Make the syntax for explicit instantiations of member templates C++ standard conforming.

git-svn-id: https://svn.dealii.org/trunk@5609 0785d39b-7218-0410-832d-ea1e28bc413d

diff --git a/deal.II/deal.II/source/dofs/dof_accessor.cc b/deal.II/deal.II/source/dofs/dof_accessor.cc
index ffc00667c1d5021b390b6aadbedeeadf6d74c802..22aade46332a9b81fc1af9d0f8aa72fbfd03f543 100644 (file)
--- a/deal.II/deal.II/source/dofs/dof_accessor.cc
+++ b/deal.II/deal.II/source/dofs/dof_accessor.cc
@@ -742,92 +742,92 @@ DoFCellAccessor<dim>::set_dof_values_by_interpolation (const Vector<number> &loc
 // for double
 template
 void
-DoFObjectAccessor<1,deal_II_dimension>::get_dof_values (const Vector<double> &,
-                                                       Vector<double>       &) const;
+DoFObjectAccessor<1,deal_II_dimension>::get_dof_values<> (const Vector<double> &,
+                                                         Vector<double>       &) const;
 
 template
 void
-DoFObjectAccessor<1,deal_II_dimension>::set_dof_values (const Vector<double> &,
-                                                       Vector<double>       &) const;
+DoFObjectAccessor<1,deal_II_dimension>::set_dof_values<> (const Vector<double> &,
+                                                         Vector<double>       &) const;
 
 
 // for float
 template
 void
-DoFObjectAccessor<1,deal_II_dimension>::get_dof_values (const Vector<float> &,
-                                                       Vector<float>       &) const;
+DoFObjectAccessor<1,deal_II_dimension>::get_dof_values<> (const Vector<float> &,
+                                                         Vector<float>       &) const;
 
 template
 void
-DoFObjectAccessor<1,deal_II_dimension>::set_dof_values (const Vector<float> &,
-                                                       Vector<float>       &) const;
+DoFObjectAccessor<1,deal_II_dimension>::set_dof_values<> (const Vector<float> &,
+                                                         Vector<float>       &) const;
 
 
 // for block vector
 template
 void
-DoFObjectAccessor<1,deal_II_dimension>::get_dof_values (const BlockVector<double> &,
-                                                       Vector<double>       &) const;
+DoFObjectAccessor<1,deal_II_dimension>::get_dof_values<> (const BlockVector<double> &,
+                                                         Vector<double>       &) const;
 
 template
 void
-DoFObjectAccessor<1,deal_II_dimension>::set_dof_values (const Vector<double>  &,
-                                                       BlockVector<double> &) const;
+DoFObjectAccessor<1,deal_II_dimension>::set_dof_values<> (const Vector<double>  &,
+                                                         BlockVector<double> &) const;
 
 template
 void
-DoFObjectAccessor<1,deal_II_dimension>::get_dof_values (const BlockVector<float> &,
-                                                       Vector<float>       &) const;
+DoFObjectAccessor<1,deal_II_dimension>::get_dof_values<> (const BlockVector<float> &,
+                                                         Vector<float>       &) const;
 
 template
 void
-DoFObjectAccessor<1,deal_II_dimension>::set_dof_values (const Vector<float>  &,
-                                                       BlockVector<float> &) const;
+DoFObjectAccessor<1,deal_II_dimension>::set_dof_values<> (const Vector<float>  &,
+                                                         BlockVector<float> &) const;
 
 #if deal_II_dimension >= 2
 // for double
 template
 void
-DoFObjectAccessor<2,deal_II_dimension>::get_dof_values (const Vector<double> &,
-                                                       Vector<double>       &) const;
+DoFObjectAccessor<2,deal_II_dimension>::get_dof_values<> (const Vector<double> &,
+                                                         Vector<double>       &) const;
 
 template
 void
-DoFObjectAccessor<2,deal_II_dimension>::set_dof_values (const Vector<double> &,
-                                                       Vector<double>       &) const;
+DoFObjectAccessor<2,deal_II_dimension>::set_dof_values<> (const Vector<double> &,
+                                                         Vector<double>       &) const;
 
 // for float
 template
 void
-DoFObjectAccessor<2,deal_II_dimension>::get_dof_values (const Vector<float> &,
-                                                       Vector<float>       &) const;
+DoFObjectAccessor<2,deal_II_dimension>::get_dof_values<> (const Vector<float> &,
+                                                         Vector<float>       &) const;
 
 template
 void
-DoFObjectAccessor<2,deal_II_dimension>::set_dof_values (const Vector<float> &,
-                                                       Vector<float>       &) const;
+DoFObjectAccessor<2,deal_II_dimension>::set_dof_values<> (const Vector<float> &,
+                                                         Vector<float>       &) const;
 
 
 // for block vector
 template
 void
-DoFObjectAccessor<2,deal_II_dimension>::get_dof_values (const BlockVector<double> &,
-                                                       Vector<double>       &) const;
+DoFObjectAccessor<2,deal_II_dimension>::get_dof_values<> (const BlockVector<double> &,
+                                                         Vector<double>       &) const;
 
 template
 void
-DoFObjectAccessor<2,deal_II_dimension>::set_dof_values (const Vector<double>  &,
-                                                       BlockVector<double> &) const;
+DoFObjectAccessor<2,deal_II_dimension>::set_dof_values<> (const Vector<double>  &,
+                                                         BlockVector<double> &) const;
 
 template
 void
-DoFObjectAccessor<2,deal_II_dimension>::get_dof_values (const BlockVector<float> &,
-                                                       Vector<float>       &) const;
+DoFObjectAccessor<2,deal_II_dimension>::get_dof_values<> (const BlockVector<float> &,
+                                                         Vector<float>       &) const;
 
 template
 void
-DoFObjectAccessor<2,deal_II_dimension>::set_dof_values (const Vector<float>  &,
-                                                       BlockVector<float> &) const;
+DoFObjectAccessor<2,deal_II_dimension>::set_dof_values<> (const Vector<float>  &,
+                                                         BlockVector<float> &) const;
 
 
 #endif
@@ -837,44 +837,44 @@ DoFObjectAccessor<2,deal_II_dimension>::set_dof_values (const Vector<float>  &,
 // for double
 template
 void
-DoFObjectAccessor<3,deal_II_dimension>::get_dof_values (const Vector<double> &,
-                                                       Vector<double>       &) const;
+DoFObjectAccessor<3,deal_II_dimension>::get_dof_values<> (const Vector<double> &,
+                                                         Vector<double>       &) const;
 
 template
 void
-DoFObjectAccessor<3,deal_II_dimension>::set_dof_values (const Vector<double> &,
-                                                       Vector<double>       &) const;
+DoFObjectAccessor<3,deal_II_dimension>::set_dof_values<> (const Vector<double> &,
+                                                         Vector<double>       &) const;
 
 // for float
 template
 void
-DoFObjectAccessor<3,deal_II_dimension>::get_dof_values (const Vector<float> &,
-                                                       Vector<float>       &) const;
+DoFObjectAccessor<3,deal_II_dimension>::get_dof_values<> (const Vector<float> &,
+                                                         Vector<float>       &) const;
 
 template
 void
-DoFObjectAccessor<3,deal_II_dimension>::set_dof_values (const Vector<float> &,
-                                                       Vector<float>       &) const;
+DoFObjectAccessor<3,deal_II_dimension>::set_dof_values<> (const Vector<float> &,
+                                                         Vector<float>       &) const;
 
 
 
 // for block vector
 template
 void
-DoFObjectAccessor<3,deal_II_dimension>::get_dof_values (const BlockVector<double> &,
-                                                       Vector<double>       &) const;
+DoFObjectAccessor<3,deal_II_dimension>::get_dof_values<> (const BlockVector<double> &,
+                                                         Vector<double>       &) const;
 template
 void
-DoFObjectAccessor<3,deal_II_dimension>::set_dof_values (const Vector<double>  &,
-                                                       BlockVector<double> &) const;
+DoFObjectAccessor<3,deal_II_dimension>::set_dof_values<> (const Vector<double>  &,
+                                                         BlockVector<double> &) const;
 template
 void
-DoFObjectAccessor<3,deal_II_dimension>::get_dof_values (const BlockVector<float> &,
-                                                       Vector<float>       &) const;
+DoFObjectAccessor<3,deal_II_dimension>::get_dof_values<> (const BlockVector<float> &,
+                                                         Vector<float>       &) const;
 template
 void
-DoFObjectAccessor<3,deal_II_dimension>::set_dof_values (const Vector<float>  &,
-                                                       BlockVector<float> &) const;
+DoFObjectAccessor<3,deal_II_dimension>::set_dof_values<> (const Vector<float>  &,
+                                                         BlockVector<float> &) const;
 
 
 #endif
@@ -884,52 +884,52 @@ DoFObjectAccessor<3,deal_II_dimension>::set_dof_values (const Vector<float>  &,
 template
 void
 DoFCellAccessor<deal_II_dimension>::
-get_interpolated_dof_values (const Vector<double> &,
-                            Vector<double>       &) const;
+get_interpolated_dof_values<> (const Vector<double> &,
+                              Vector<double>       &) const;
 
 template
 void
 DoFCellAccessor<deal_II_dimension>::
-set_dof_values_by_interpolation(const Vector<double> &,
-                               Vector<double>       &) const;
+set_dof_values_by_interpolation<>(const Vector<double> &,
+                                 Vector<double>       &) const;
 
 
 template
 void
 DoFCellAccessor<deal_II_dimension>::
-get_interpolated_dof_values (const Vector<float> &,
-                            Vector<float>       &) const;
+get_interpolated_dof_values<> (const Vector<float> &,
+                              Vector<float>       &) const;
 
 template
 void
 DoFCellAccessor<deal_II_dimension>::
-set_dof_values_by_interpolation(const Vector<float> &,
-                               Vector<float>       &) const;
+set_dof_values_by_interpolation<>(const Vector<float> &,
+                                 Vector<float>       &) const;
 
 
 template
 void
 DoFCellAccessor<deal_II_dimension>::
-get_interpolated_dof_values (const BlockVector<double> &,
-                            Vector<double>       &) const;
+get_interpolated_dof_values<> (const BlockVector<double> &,
+                              Vector<double>       &) const;
 
 template
 void
 DoFCellAccessor<deal_II_dimension>::
-set_dof_values_by_interpolation(const Vector<double> &,
-                               BlockVector<double> &) const;
+set_dof_values_by_interpolation<>(const Vector<double> &,
+                                 BlockVector<double> &) const;
 
 template
 void
 DoFCellAccessor<deal_II_dimension>::
-get_interpolated_dof_values (const BlockVector<float> &,
-                            Vector<float>       &) const;
+get_interpolated_dof_values<> (const BlockVector<float> &,
+                              Vector<float>       &) const;
 
 template
 void
 DoFCellAccessor<deal_II_dimension>::
-set_dof_values_by_interpolation(const Vector<float> &,
-                               BlockVector<float> &) const;
+set_dof_values_by_interpolation<>(const Vector<float> &,
+                                 BlockVector<float> &) const;
 
 
 template class DoFAccessor<deal_II_dimension>;

diff --git a/deal.II/deal.II/source/dofs/dof_constraints.cc b/deal.II/deal.II/source/dofs/dof_constraints.cc
index 2f69f6d93bbe79e2e2ce0b24aebde906a0875389..e713eee747e942f1fead9793941d2fdca691de54 100644 (file)
--- a/deal.II/deal.II/source/dofs/dof_constraints.cc
+++ b/deal.II/deal.II/source/dofs/dof_constraints.cc
@@ -1202,21 +1202,21 @@ ConstraintMatrix::memory_consumption () const
 // syntax...
 
 #define vector_functions \
-  template void ConstraintMatrix::condense(const VectorType &uncondensed,\
-                                          VectorType       &condensed) const;\
-  template void ConstraintMatrix::condense(VectorType &vec) const;\
-  template void ConstraintMatrix::set_zero(VectorType &vec) const;\
-  template void ConstraintMatrix::distribute(const VectorType &condensed,\
-                                            VectorType       &uncondensed) const;\
-  template void ConstraintMatrix::distribute(VectorType &vec) const;
+  template void ConstraintMatrix::condense<>(const VectorType &uncondensed,\
+                                            VectorType       &condensed) const;\
+  template void ConstraintMatrix::condense<>(VectorType &vec) const;\
+  template void ConstraintMatrix::set_zero<>(VectorType &vec) const;\
+  template void ConstraintMatrix::distribute<>(const VectorType &condensed,\
+                                              VectorType       &uncondensed) const;\
+  template void ConstraintMatrix::distribute<>(VectorType &vec) const;
 
 
 
 #define matrix_functions_1 \
-  template void ConstraintMatrix::condense(const MatrixType &uncondensed,\
-                                          MatrixType       &condensed) const;
+  template void ConstraintMatrix::condense<>(const MatrixType &uncondensed,\
+                                            MatrixType       &condensed) const;
 #define matrix_functions_2 \
-  template void ConstraintMatrix::condense(MatrixType &uncondensed) const;
+  template void ConstraintMatrix::condense<>(MatrixType &uncondensed) const;
 
 
 

diff --git a/deal.II/deal.II/source/dofs/dof_renumbering.cc b/deal.II/deal.II/source/dofs/dof_renumbering.cc
index ceb2a225a281b15ffeb910d00beca9b5b7868b1a..f14d7b6aa3feb5fecfef1363d7d6d9e82cbd641d 100644 (file)
--- a/deal.II/deal.II/source/dofs/dof_renumbering.cc
+++ b/deal.II/deal.II/source/dofs/dof_renumbering.cc
@@ -863,50 +863,50 @@ DoFRenumbering::random (DoFHandler<dim> &dof_handler)
 
 // explicit instantiations
 template
-void DoFRenumbering::Cuthill_McKee (DoFHandler<deal_II_dimension>&,
-                                   const bool,
-                                   const bool,
-                                   const std::vector<unsigned int>&);
+void DoFRenumbering::Cuthill_McKee<> (DoFHandler<deal_II_dimension>&,
+                                     const bool,
+                                     const bool,
+                                     const std::vector<unsigned int>&);
 
 template
-void DoFRenumbering::component_wise (DoFHandler<deal_II_dimension>&,
-                                    const std::vector<unsigned int>&);
+void DoFRenumbering::component_wise<> (DoFHandler<deal_II_dimension>&,
+                                      const std::vector<unsigned int>&);
 
 template
-void DoFRenumbering::component_wise (MGDoFHandler<deal_II_dimension>&,
-                                    unsigned int,
-                                    const std::vector<unsigned int>&);
+void DoFRenumbering::component_wise<> (MGDoFHandler<deal_II_dimension>&,
+                                      unsigned int,
+                                      const std::vector<unsigned int>&);
 
 
 template
-void DoFRenumbering::cell_wise_dg (DoFHandler<deal_II_dimension>&,
-                                  const std::vector<DoFHandler<deal_II_dimension>::cell_iterator>&);
+void DoFRenumbering::cell_wise_dg<> (DoFHandler<deal_II_dimension>&,
+                                    const std::vector<DoFHandler<deal_II_dimension>::cell_iterator>&);
 
 template
-void DoFRenumbering::downstream_dg (DoFHandler<deal_II_dimension>&,
-                                   const Point<deal_II_dimension>&);
+void DoFRenumbering::downstream_dg<> (DoFHandler<deal_II_dimension>&,
+                                     const Point<deal_II_dimension>&);
 
 template
-void DoFRenumbering::sort_selected_dofs_back (DoFHandler<deal_II_dimension> &,
-                                             const std::vector<bool> &);
+void DoFRenumbering::sort_selected_dofs_back<> (DoFHandler<deal_II_dimension> &,
+                                               const std::vector<bool> &);
 
 template
-void DoFRenumbering::random (DoFHandler<deal_II_dimension> &);
+void DoFRenumbering::random<> (DoFHandler<deal_II_dimension> &);
 
 #ifdef ENABLE_MULTIGRID
 template
-void DoFRenumbering::Cuthill_McKee (MGDoFHandler<deal_II_dimension>&,
-                                   const unsigned int,
-                                   const bool,
-                                   const std::vector<unsigned int>&);
+void DoFRenumbering::Cuthill_McKee<> (MGDoFHandler<deal_II_dimension>&,
+                                     const unsigned int,
+                                     const bool,
+                                     const std::vector<unsigned int>&);
 template
-void DoFRenumbering::cell_wise_dg (MGDoFHandler<deal_II_dimension>&,
-                                  const unsigned int,
-                                  const std::vector<MGDoFHandler<deal_II_dimension>::cell_iterator>&);
+void DoFRenumbering::cell_wise_dg<> (MGDoFHandler<deal_II_dimension>&,
+                                    const unsigned int,
+                                    const std::vector<MGDoFHandler<deal_II_dimension>::cell_iterator>&);
 
 template
-void DoFRenumbering::downstream_dg (MGDoFHandler<deal_II_dimension>&,
-                                   const unsigned int,
-                                   const Point<deal_II_dimension>&);
+void DoFRenumbering::downstream_dg<> (MGDoFHandler<deal_II_dimension>&,
+                                     const unsigned int,
+                                     const Point<deal_II_dimension>&);
 
 #endif

diff --git a/deal.II/deal.II/source/dofs/dof_tools.cc b/deal.II/deal.II/source/dofs/dof_tools.cc
index 85809786b0abc20593db879c9f60b8ec6cea0152..73684c83b34c83271e8d5890192f7a1ca9e87c2f 100644 (file)
--- a/deal.II/deal.II/source/dofs/dof_tools.cc
+++ b/deal.II/deal.II/source/dofs/dof_tools.cc
@@ -2342,183 +2342,183 @@ DoFTools::map_dofs_to_support_points (const Mapping<dim>       &mapping,
 
 // explicit instantiations
 template void
-DoFTools::make_flux_sparsity_pattern (const DoFHandler<deal_II_dimension>& dof,
-                                     SparsityPattern    &sparsity);
+DoFTools::make_flux_sparsity_pattern<> (const DoFHandler<deal_II_dimension>& dof,
+                                       SparsityPattern    &sparsity);
 #if deal_II_dimension > 1
 template void
-DoFTools::make_flux_sparsity_pattern (const DoFHandler<deal_II_dimension>& dof,
-                                     SparsityPattern    &,
-                                     const FullMatrix<double>&,
-                                     const FullMatrix<double>&);
+DoFTools::make_flux_sparsity_pattern<> (const DoFHandler<deal_II_dimension>& dof,
+                                       SparsityPattern    &,
+                                       const FullMatrix<double>&,
+                                       const FullMatrix<double>&);
 template void
-DoFTools::make_flux_sparsity_pattern (const DoFHandler<deal_II_dimension>& dof,
-                                     CompressedSparsityPattern    &sparsity);
+DoFTools::make_flux_sparsity_pattern<> (const DoFHandler<deal_II_dimension>& dof,
+                                       CompressedSparsityPattern    &sparsity);
 template void
-DoFTools::make_flux_sparsity_pattern (const DoFHandler<deal_II_dimension>& dof,
-                                     CompressedSparsityPattern    &,
-                                     const FullMatrix<double>&,
-                                     const FullMatrix<double>&);
+DoFTools::make_flux_sparsity_pattern<> (const DoFHandler<deal_II_dimension>& dof,
+                                       CompressedSparsityPattern    &,
+                                       const FullMatrix<double>&,
+                                       const FullMatrix<double>&);
 template void
-DoFTools::make_flux_sparsity_pattern (const DoFHandler<deal_II_dimension>& dof,
-                                     BlockSparsityPattern    &sparsity);
+DoFTools::make_flux_sparsity_pattern<> (const DoFHandler<deal_II_dimension>& dof,
+                                       BlockSparsityPattern    &sparsity);
 template void
-DoFTools::make_flux_sparsity_pattern (const DoFHandler<deal_II_dimension>& dof,
-                                     BlockSparsityPattern    &,
-                                     const FullMatrix<double>&,
-                                     const FullMatrix<double>&);
+DoFTools::make_flux_sparsity_pattern<> (const DoFHandler<deal_II_dimension>& dof,
+                                       BlockSparsityPattern    &,
+                                       const FullMatrix<double>&,
+                                       const FullMatrix<double>&);
 template void
-DoFTools::make_flux_sparsity_pattern (const DoFHandler<deal_II_dimension>& dof,
-                                     CompressedBlockSparsityPattern    &sparsity);
+DoFTools::make_flux_sparsity_pattern<> (const DoFHandler<deal_II_dimension>& dof,
+                                       CompressedBlockSparsityPattern    &sparsity);
 template void
-DoFTools::make_flux_sparsity_pattern (const DoFHandler<deal_II_dimension>& dof,
-                                     CompressedBlockSparsityPattern    &,
-                                     const FullMatrix<double>&,
-                                     const FullMatrix<double>&);
+DoFTools::make_flux_sparsity_pattern<> (const DoFHandler<deal_II_dimension>& dof,
+                                       CompressedBlockSparsityPattern    &,
+                                       const FullMatrix<double>&,
+                                       const FullMatrix<double>&);
 #endif
 
 template void
-DoFTools::make_boundary_sparsity_pattern (const DoFHandler<deal_II_dimension>& dof,
-                                         const std::vector<unsigned int>  &,
-                                         SparsityPattern    &);
+DoFTools::make_boundary_sparsity_pattern<> (const DoFHandler<deal_II_dimension>& dof,
+                                           const std::vector<unsigned int>  &,
+                                           SparsityPattern    &);
 template void
-DoFTools::make_boundary_sparsity_pattern (const DoFHandler<deal_II_dimension>& dof,
-                                         const std::vector<unsigned int>  &,
-                                         CompressedSparsityPattern    &);
+DoFTools::make_boundary_sparsity_pattern<> (const DoFHandler<deal_II_dimension>& dof,
+                                           const std::vector<unsigned int>  &,
+                                           CompressedSparsityPattern    &);
 template void
-DoFTools::make_boundary_sparsity_pattern (const DoFHandler<deal_II_dimension>& dof,
-                                         const std::vector<unsigned int>  &,
-                                         BlockSparsityPattern    &);
+DoFTools::make_boundary_sparsity_pattern<> (const DoFHandler<deal_II_dimension>& dof,
+                                           const std::vector<unsigned int>  &,
+                                           BlockSparsityPattern    &);
 template void
-DoFTools::make_boundary_sparsity_pattern (const DoFHandler<deal_II_dimension>& dof,
-                                         const std::vector<unsigned int>  &,
-                                         CompressedBlockSparsityPattern    &);
+DoFTools::make_boundary_sparsity_pattern<> (const DoFHandler<deal_II_dimension>& dof,
+                                           const std::vector<unsigned int>  &,
+                                           CompressedBlockSparsityPattern    &);
 
 
 template void
-DoFTools::make_boundary_sparsity_pattern (const DoFHandler<deal_II_dimension>& dof,
-                                         const FunctionMap<deal_II_dimension>::type  &boundary_indicators,
-                                         const std::vector<unsigned int>  &dof_to_boundary_mapping,
-                                         SparsityPattern    &sparsity);
+DoFTools::make_boundary_sparsity_pattern<> (const DoFHandler<deal_II_dimension>& dof,
+                                           const FunctionMap<deal_II_dimension>::type  &boundary_indicators,
+                                           const std::vector<unsigned int>  &dof_to_boundary_mapping,
+                                           SparsityPattern    &sparsity);
 template void
-DoFTools::make_boundary_sparsity_pattern (const DoFHandler<deal_II_dimension>& dof,
-                                         const FunctionMap<deal_II_dimension>::type  &boundary_indicators,
-                                         const std::vector<unsigned int>  &dof_to_boundary_mapping,
-                                         CompressedSparsityPattern    &sparsity);
+DoFTools::make_boundary_sparsity_pattern<> (const DoFHandler<deal_II_dimension>& dof,
+                                           const FunctionMap<deal_II_dimension>::type  &boundary_indicators,
+                                           const std::vector<unsigned int>  &dof_to_boundary_mapping,
+                                           CompressedSparsityPattern    &sparsity);
 template void
-DoFTools::make_boundary_sparsity_pattern (const DoFHandler<deal_II_dimension>& dof,
-                                         const FunctionMap<deal_II_dimension>::type  &boundary_indicators,
-                                         const std::vector<unsigned int>  &dof_to_boundary_mapping,
-                                         BlockSparsityPattern    &sparsity);
+DoFTools::make_boundary_sparsity_pattern<> (const DoFHandler<deal_II_dimension>& dof,
+                                           const FunctionMap<deal_II_dimension>::type  &boundary_indicators,
+                                           const std::vector<unsigned int>  &dof_to_boundary_mapping,
+                                           BlockSparsityPattern    &sparsity);
 template void
-DoFTools::make_boundary_sparsity_pattern (const DoFHandler<deal_II_dimension>& dof,
-                                         const FunctionMap<deal_II_dimension>::type  &boundary_indicators,
-                                         const std::vector<unsigned int>  &dof_to_boundary_mapping,
-                                         CompressedBlockSparsityPattern    &sparsity);
+DoFTools::make_boundary_sparsity_pattern<> (const DoFHandler<deal_II_dimension>& dof,
+                                           const FunctionMap<deal_II_dimension>::type  &boundary_indicators,
+                                           const std::vector<unsigned int>  &dof_to_boundary_mapping,
+                                           CompressedBlockSparsityPattern    &sparsity);
 
 
 
 template void
-DoFTools::make_sparsity_pattern (const DoFHandler<deal_II_dimension> &dof,
-                                SparsityPattern    &sparsity);
+DoFTools::make_sparsity_pattern<> (const DoFHandler<deal_II_dimension> &dof,
+                                  SparsityPattern    &sparsity);
 
 template void
-DoFTools::make_sparsity_pattern (const DoFHandler<deal_II_dimension> &dof,
-                                CompressedSparsityPattern    &sparsity);
+DoFTools::make_sparsity_pattern<> (const DoFHandler<deal_II_dimension> &dof,
+                                  CompressedSparsityPattern    &sparsity);
 
 template void
-DoFTools::make_sparsity_pattern (const DoFHandler<deal_II_dimension> &dof,
-                                BlockSparsityPattern                &sparsity);
+DoFTools::make_sparsity_pattern<> (const DoFHandler<deal_II_dimension> &dof,
+                                  BlockSparsityPattern                &sparsity);
 template void
-DoFTools::make_sparsity_pattern (const DoFHandler<deal_II_dimension> &dof,
-                                CompressedBlockSparsityPattern      &sparsity);
+DoFTools::make_sparsity_pattern<> (const DoFHandler<deal_II_dimension> &dof,
+                                  CompressedBlockSparsityPattern      &sparsity);
 
 
 template void 
-DoFTools::make_sparsity_pattern (const DoFHandler<deal_II_dimension> &dof,
-                                const std::vector<std::vector<bool> > &mask,
-                                SparsityPattern             &sparsity);
+DoFTools::make_sparsity_pattern<> (const DoFHandler<deal_II_dimension> &dof,
+                                  const std::vector<std::vector<bool> > &mask,
+                                  SparsityPattern             &sparsity);
 
 template void 
-DoFTools::make_sparsity_pattern (const DoFHandler<deal_II_dimension> &dof,
-                                const std::vector<std::vector<bool> > &mask,
-                                CompressedSparsityPattern             &sparsity);
+DoFTools::make_sparsity_pattern<> (const DoFHandler<deal_II_dimension> &dof,
+                                  const std::vector<std::vector<bool> > &mask,
+                                  CompressedSparsityPattern             &sparsity);
 
 template void 
-DoFTools::make_sparsity_pattern (const DoFHandler<deal_II_dimension> &dof,
-                                const std::vector<std::vector<bool> > &mask,
-                                BlockSparsityPattern        &sparsity);
+DoFTools::make_sparsity_pattern<> (const DoFHandler<deal_II_dimension> &dof,
+                                  const std::vector<std::vector<bool> > &mask,
+                                  BlockSparsityPattern        &sparsity);
 
 template void 
-DoFTools::make_sparsity_pattern (const DoFHandler<deal_II_dimension> &dof,
-                                const std::vector<std::vector<bool> > &mask,
-                                CompressedBlockSparsityPattern        &sparsity);
+DoFTools::make_sparsity_pattern<> (const DoFHandler<deal_II_dimension> &dof,
+                                  const std::vector<std::vector<bool> > &mask,
+                                  CompressedBlockSparsityPattern        &sparsity);
 
 
 
 template
 void
-DoFTools::distribute_cell_to_dof_vector (const DoFHandler<deal_II_dimension> &dof_handler,
-                                        const Vector<float>  &cell_data,
-                                        Vector<double>       &dof_data,
-                                        const unsigned int    component);
+DoFTools::distribute_cell_to_dof_vector<> (const DoFHandler<deal_II_dimension> &dof_handler,
+                                          const Vector<float>  &cell_data,
+                                          Vector<double>       &dof_data,
+                                          const unsigned int    component);
 
 template
 void
-DoFTools::distribute_cell_to_dof_vector (const DoFHandler<deal_II_dimension> &dof_handler,
-                                        const Vector<double> &cell_data,
-                                        Vector<double>       &dof_data,
-                                        const unsigned int    component);
+DoFTools::distribute_cell_to_dof_vector<> (const DoFHandler<deal_II_dimension> &dof_handler,
+                                          const Vector<double> &cell_data,
+                                          Vector<double>       &dof_data,
+                                          const unsigned int    component);
 
 
-template void DoFTools::extract_dofs(const DoFHandler<deal_II_dimension>& dof,
-                                    const std::vector<bool>& component_select,
-                                    std::vector<bool>& selected_dofs);
+template void DoFTools::extract_dofs<>(const DoFHandler<deal_II_dimension>& dof,
+                                      const std::vector<bool>& component_select,
+                                      std::vector<bool>& selected_dofs);
 
 #ifdef ENABLE_MULTIGRID
-template void DoFTools::extract_level_dofs(const unsigned int level,
-                                          const MGDoFHandler<deal_II_dimension>& dof,
-                                          const std::vector<bool>& component_select,
-                                          std::vector<bool>& selected_dofs);
+template void DoFTools::extract_level_dofs<>(const unsigned int level,
+                                            const MGDoFHandler<deal_II_dimension>& dof,
+                                            const std::vector<bool>& component_select,
+                                            std::vector<bool>& selected_dofs);
 #endif
 
 #if deal_II_dimension != 1
 template
 void
-DoFTools::extract_boundary_dofs (const DoFHandler<deal_II_dimension> &,
-                                const std::vector<bool>                  &,
-                                std::vector<bool>                        &,
-                                const std::set<unsigned char> &);
+DoFTools::extract_boundary_dofs<> (const DoFHandler<deal_II_dimension> &,
+                                  const std::vector<bool>                  &,
+                                  std::vector<bool>                        &,
+                                  const std::set<unsigned char> &);
 #endif 
 
 template
 void
-DoFTools::extract_subdomain_dofs (const DoFHandler<deal_II_dimension> &dof_handler,
-                                 const unsigned int     subdomain_id,
-                                 std::vector<bool>     &selected_dofs);
+DoFTools::extract_subdomain_dofs<> (const DoFHandler<deal_II_dimension> &dof_handler,
+                                   const unsigned int     subdomain_id,
+                                   std::vector<bool>     &selected_dofs);
 
   
 template
 void
-DoFTools::count_dofs_per_component (const DoFHandler<deal_II_dimension> &dof_handler,
-                                   std::vector<unsigned int>           &dofs_per_component);
+DoFTools::count_dofs_per_component<> (const DoFHandler<deal_II_dimension> &dof_handler,
+                                     std::vector<unsigned int>           &dofs_per_component);
 
 
 template
 void
-DoFTools::compute_intergrid_constraints (const DoFHandler<deal_II_dimension> &,
-                                        const unsigned int                   ,
-                                        const DoFHandler<deal_II_dimension> &,
-                                        const unsigned int                   ,
-                                        const InterGridMap<DoFHandler,deal_II_dimension> &,
-                                        ConstraintMatrix                    &);
+DoFTools::compute_intergrid_constraints<> (const DoFHandler<deal_II_dimension> &,
+                                          const unsigned int                   ,
+                                          const DoFHandler<deal_II_dimension> &,
+                                          const unsigned int                   ,
+                                          const InterGridMap<DoFHandler,deal_II_dimension> &,
+                                          ConstraintMatrix                    &);
 template
 void
-DoFTools::compute_intergrid_transfer_representation (const DoFHandler<deal_II_dimension> &,
-                                                    const unsigned int                   ,
-                                                    const DoFHandler<deal_II_dimension> &,
-                                                    const unsigned int                   ,
-                                                    const InterGridMap<DoFHandler,deal_II_dimension> &,
-                                                    std::vector<std::map<unsigned int, float> > &);
+DoFTools::compute_intergrid_transfer_representation<> (const DoFHandler<deal_II_dimension> &,
+                                                      const unsigned int                   ,
+                                                      const DoFHandler<deal_II_dimension> &,
+                                                      const unsigned int                   ,
+                                                      const InterGridMap<DoFHandler,deal_II_dimension> &,
+                                                      std::vector<std::map<unsigned int, float> > &);
 
 
 
@@ -2526,14 +2526,14 @@ DoFTools::compute_intergrid_transfer_representation (const DoFHandler<deal_II_di
 
 template
 void
-DoFTools::map_dof_to_boundary_indices (const DoFHandler<deal_II_dimension> &,
-                                      std::vector<unsigned int> &);
+DoFTools::map_dof_to_boundary_indices<> (const DoFHandler<deal_II_dimension> &,
+                                        std::vector<unsigned int> &);
 
 template
 void
-DoFTools::map_dof_to_boundary_indices (const DoFHandler<deal_II_dimension> &,
-                                      const std::set<unsigned char> &,
-                                      std::vector<unsigned int> &);
+DoFTools::map_dof_to_boundary_indices<> (const DoFHandler<deal_II_dimension> &,
+                                        const std::set<unsigned char> &,
+                                        std::vector<unsigned int> &);
 
 #endif 
 
@@ -2541,6 +2541,6 @@ DoFTools::map_dof_to_boundary_indices (const DoFHandler<deal_II_dimension> &,
 
 template
 void
-DoFTools::map_dofs_to_support_points (const Mapping<deal_II_dimension>       &mapping,
-                                     const DoFHandler<deal_II_dimension>    &dof_handler,
-                                     std::vector<Point<deal_II_dimension> > &support_points);
+DoFTools::map_dofs_to_support_points<> (const Mapping<deal_II_dimension>       &mapping,
+                                       const DoFHandler<deal_II_dimension>    &dof_handler,
+                                       std::vector<Point<deal_II_dimension> > &support_points);

diff --git a/deal.II/deal.II/source/fe/fe_tools.cc b/deal.II/deal.II/source/fe/fe_tools.cc
index ed5c3bb823463ea6c0c2d0dbde215881925695d7..8074e15806a3b58756eb2387ab5c958011057db8 100644 (file)
--- a/deal.II/deal.II/source/fe/fe_tools.cc
+++ b/deal.II/deal.II/source/fe/fe_tools.cc
@@ -711,79 +711,79 @@ FETools::lexicographic_to_hierarchic_numbering (const FE_Q<dim>           &fe,
 /*-------------- Explicit Instantiations -------------------------------*/
 
 template
-void FETools::get_interpolation_matrix(const FiniteElement<deal_II_dimension> &,
-                                      const FiniteElement<deal_II_dimension> &,
-                                      FullMatrix<double> &);
+void FETools::get_interpolation_matrix<>(const FiniteElement<deal_II_dimension> &,
+                                        const FiniteElement<deal_II_dimension> &,
+                                        FullMatrix<double> &);
 template
-void FETools::get_back_interpolation_matrix(const FiniteElement<deal_II_dimension> &,
-                                           const FiniteElement<deal_II_dimension> &,
-                                           FullMatrix<double> &);
+void FETools::get_back_interpolation_matrix<>(const FiniteElement<deal_II_dimension> &,
+                                             const FiniteElement<deal_II_dimension> &,
+                                             FullMatrix<double> &);
 template
-void FETools::get_interpolation_difference_matrix(const FiniteElement<deal_II_dimension> &,
-                                                 const FiniteElement<deal_II_dimension> &,
-                                                 FullMatrix<double> &);
+void FETools::get_interpolation_difference_matrix<>(const FiniteElement<deal_II_dimension> &,
+                                                   const FiniteElement<deal_II_dimension> &,
+                                                   FullMatrix<double> &);
 template
-void FETools::interpolate(const DoFHandler<deal_II_dimension> &,
-                         const Vector<double> &,
-                         const DoFHandler<deal_II_dimension> &,
-                         Vector<double> &);
+void FETools::interpolate<>(const DoFHandler<deal_II_dimension> &,
+                           const Vector<double> &,
+                           const DoFHandler<deal_II_dimension> &,
+                           Vector<double> &);
 template
-void FETools::back_interpolate(const DoFHandler<deal_II_dimension> &,
-                              const Vector<double> &,
-                              const FiniteElement<deal_II_dimension> &,
-                              Vector<double> &);
+void FETools::back_interpolate<>(const DoFHandler<deal_II_dimension> &,
+                                const Vector<double> &,
+                                const FiniteElement<deal_II_dimension> &,
+                                Vector<double> &);
 template
-void FETools::interpolation_difference(const DoFHandler<deal_II_dimension> &,
-                                      const Vector<double> &,
-                                      const FiniteElement<deal_II_dimension> &,
-                                      Vector<double> &);
+void FETools::interpolation_difference<>(const DoFHandler<deal_II_dimension> &,
+                                        const Vector<double> &,
+                                        const FiniteElement<deal_II_dimension> &,
+                                        Vector<double> &);
 template
-void FETools::extrapolate(const DoFHandler<deal_II_dimension> &,
-                         const Vector<double> &,
-                         const DoFHandler<deal_II_dimension> &,
-                         Vector<double> &);
+void FETools::extrapolate<>(const DoFHandler<deal_II_dimension> &,
+                           const Vector<double> &,
+                           const DoFHandler<deal_II_dimension> &,
+                           Vector<double> &);
 
 
 template
-void FETools::get_interpolation_matrix(const FiniteElement<deal_II_dimension> &,
-                                      const FiniteElement<deal_II_dimension> &,
-                                      FullMatrix<float> &);
+void FETools::get_interpolation_matrix<>(const FiniteElement<deal_II_dimension> &,
+                                        const FiniteElement<deal_II_dimension> &,
+                                        FullMatrix<float> &);
 template
-void FETools::get_back_interpolation_matrix(const FiniteElement<deal_II_dimension> &,
-                                           const FiniteElement<deal_II_dimension> &,
-                                           FullMatrix<float> &);
+void FETools::get_back_interpolation_matrix<>(const FiniteElement<deal_II_dimension> &,
+                                             const FiniteElement<deal_II_dimension> &,
+                                             FullMatrix<float> &);
 template
-void FETools::get_interpolation_difference_matrix(const FiniteElement<deal_II_dimension> &,
-                                                 const FiniteElement<deal_II_dimension> &,
-                                                 FullMatrix<float> &);
+void FETools::get_interpolation_difference_matrix<>(const FiniteElement<deal_II_dimension> &,
+                                                   const FiniteElement<deal_II_dimension> &,
+                                                   FullMatrix<float> &);
 template
-void FETools::interpolate(const DoFHandler<deal_II_dimension> &,
-                         const Vector<float> &,
-                         const DoFHandler<deal_II_dimension> &,
-                         Vector<float> &);
+void FETools::interpolate<>(const DoFHandler<deal_II_dimension> &,
+                           const Vector<float> &,
+                           const DoFHandler<deal_II_dimension> &,
+                           Vector<float> &);
 template
-void FETools::back_interpolate(const DoFHandler<deal_II_dimension> &,
-                              const Vector<float> &,
-                              const FiniteElement<deal_II_dimension> &,
-                              Vector<float> &);
+void FETools::back_interpolate<>(const DoFHandler<deal_II_dimension> &,
+                                const Vector<float> &,
+                                const FiniteElement<deal_II_dimension> &,
+                                Vector<float> &);
 template
-void FETools::interpolation_difference(const DoFHandler<deal_II_dimension> &,
-                                      const Vector<float> &,
-                                      const FiniteElement<deal_II_dimension> &,
-                                      Vector<float> &);
+void FETools::interpolation_difference<>(const DoFHandler<deal_II_dimension> &,
+                                        const Vector<float> &,
+                                        const FiniteElement<deal_II_dimension> &,
+                                        Vector<float> &);
 template
-void FETools::extrapolate(const DoFHandler<deal_II_dimension> &,
-                         const Vector<float> &,
-                         const DoFHandler<deal_II_dimension> &,
-                         Vector<float> &);
+void FETools::extrapolate<>(const DoFHandler<deal_II_dimension> &,
+                           const Vector<float> &,
+                           const DoFHandler<deal_II_dimension> &,
+                           Vector<float> &);
 template
 void
-FETools::hierarchic_to_lexicographic_numbering (const FE_Q<deal_II_dimension> &fe,
-                                               std::vector<unsigned int>     &h2l);
+FETools::hierarchic_to_lexicographic_numbering<> (const FE_Q<deal_II_dimension> &fe,
+                                                 std::vector<unsigned int>     &h2l);
 template
 void
-FETools::lexicographic_to_hierarchic_numbering (const FE_Q<deal_II_dimension> &fe,
-                                               std::vector<unsigned int>     &h2l);
+FETools::lexicographic_to_hierarchic_numbering<> (const FE_Q<deal_II_dimension> &fe,
+                                                 std::vector<unsigned int>     &h2l);
 
 
 /*----------------------------   fe_tools.cc     ---------------------------*/

diff --git a/deal.II/deal.II/source/fe/fe_values.cc b/deal.II/deal.II/source/fe/fe_values.cc
index 90e56ec6efdea938f05c0f41e4c030d9be9a8931..47709dccee6d6e3e43d6adfb921fd38658c8ac0c 100644 (file)
--- a/deal.II/deal.II/source/fe/fe_values.cc
+++ b/deal.II/deal.II/source/fe/fe_values.cc
@@ -835,88 +835,88 @@ template class FESubfaceValues<deal_II_dimension>;
 //-----------------------------------------------------------------------------
 
 template
-void FEValuesBase<deal_II_dimension>::get_function_values (const Vector<double>&,
-                                                          std::vector<double>&) const;
+void FEValuesBase<deal_II_dimension>::get_function_values<> (const Vector<double>&,
+                                                            std::vector<double>&) const;
 template
-void FEValuesBase<deal_II_dimension>::get_function_values (const Vector<float>&,
-                                                          std::vector<double>&) const;
+void FEValuesBase<deal_II_dimension>::get_function_values<> (const Vector<float>&,
+                                                            std::vector<double>&) const;
 template
-void FEValuesBase<deal_II_dimension>::get_function_values (const Vector<float>&,
-                                                          std::vector<float>&) const;
+void FEValuesBase<deal_II_dimension>::get_function_values<> (const Vector<float>&,
+                                                            std::vector<float>&) const;
 template
-void FEValuesBase<deal_II_dimension>::get_function_values (const BlockVector<double>&,
-                                                          std::vector<double>&) const;
+void FEValuesBase<deal_II_dimension>::get_function_values<> (const BlockVector<double>&,
+                                                            std::vector<double>&) const;
 template
-void FEValuesBase<deal_II_dimension>::get_function_values (const BlockVector<float>&,
-                                                          std::vector<double>&) const;
+void FEValuesBase<deal_II_dimension>::get_function_values<> (const BlockVector<float>&,
+                                                            std::vector<double>&) const;
 template
-void FEValuesBase<deal_II_dimension>::get_function_values (const BlockVector<float>&,
-                                                          std::vector<float>&) const;
+void FEValuesBase<deal_II_dimension>::get_function_values<> (const BlockVector<float>&,
+                                                            std::vector<float>&) const;
 
 //-----------------------------------------------------------------------------
 
 template
-void FEValuesBase<deal_II_dimension>::get_function_values (const Vector<double> &,
-                                                          std::vector<Vector<double> > &) const;
+void FEValuesBase<deal_II_dimension>::get_function_values<> (const Vector<double> &,
+                                                            std::vector<Vector<double> > &) const;
 template
-void FEValuesBase<deal_II_dimension>::get_function_values (const Vector<float> &,
-                                                          std::vector<Vector<double> > &) const;
+void FEValuesBase<deal_II_dimension>::get_function_values<> (const Vector<float> &,
+                                                            std::vector<Vector<double> > &) const;
 template
-void FEValuesBase<deal_II_dimension>::get_function_values (const Vector<float> &,
-                                                          std::vector<Vector<float> > &) const;
+void FEValuesBase<deal_II_dimension>::get_function_values<> (const Vector<float> &,
+                                                            std::vector<Vector<float> > &) const;
 template
-void FEValuesBase<deal_II_dimension>::get_function_values (const BlockVector<double> &,
-                                                          std::vector<Vector<double> >     &) const;
+void FEValuesBase<deal_II_dimension>::get_function_values<> (const BlockVector<double> &,
+                                                            std::vector<Vector<double> >     &) const;
 template
-void FEValuesBase<deal_II_dimension>::get_function_values (const BlockVector<float> &,
-                                                          std::vector<Vector<double> >     &) const;
+void FEValuesBase<deal_II_dimension>::get_function_values<> (const BlockVector<float> &,
+                                                            std::vector<Vector<double> >     &) const;
 
 //-----------------------------------------------------------------------------
 
 template
-void FEValuesBase<deal_II_dimension>::get_function_grads (const Vector<double> &,
-                                                         std::vector<Tensor<1,deal_II_dimension> > &) const;
+void FEValuesBase<deal_II_dimension>::get_function_grads<> (const Vector<double> &,
+                                                           std::vector<Tensor<1,deal_II_dimension> > &) const;
 template
-void FEValuesBase<deal_II_dimension>::get_function_grads (const Vector<float> &,
-                                                         std::vector<Tensor<1,deal_II_dimension> > &) const;
+void FEValuesBase<deal_II_dimension>::get_function_grads<> (const Vector<float> &,
+                                                           std::vector<Tensor<1,deal_II_dimension> > &) const;
 template
-void FEValuesBase<deal_II_dimension>::get_function_grads (const BlockVector<double> &,
-                                                         std::vector<Tensor<1,deal_II_dimension> > &) const;
+void FEValuesBase<deal_II_dimension>::get_function_grads<> (const BlockVector<double> &,
+                                                           std::vector<Tensor<1,deal_II_dimension> > &) const;
 
 //-----------------------------------------------------------------------------
 
 template
-void FEValuesBase<deal_II_dimension>::get_function_grads (const Vector<double> &,
-                                                         std::vector<std::vector<Tensor<1,deal_II_dimension> > > &) const;
+void FEValuesBase<deal_II_dimension>::get_function_grads<> (const Vector<double> &,
+                                                           std::vector<std::vector<Tensor<1,deal_II_dimension> > > &) const;
 template
-void FEValuesBase<deal_II_dimension>::get_function_grads (const Vector<float> &,
-                                                         std::vector<std::vector<Tensor<1,deal_II_dimension> > > &) const;
+void FEValuesBase<deal_II_dimension>::get_function_grads<> (const Vector<float> &,
+                                                           std::vector<std::vector<Tensor<1,deal_II_dimension> > > &) const;
 template
-void FEValuesBase<deal_II_dimension>::get_function_grads (const BlockVector<double> &,
-                                                         std::vector<std::vector<Tensor<1,deal_II_dimension> > > &) const;
+void FEValuesBase<deal_II_dimension>::get_function_grads<> (const BlockVector<double> &,
+                                                           std::vector<std::vector<Tensor<1,deal_II_dimension> > > &) const;
 template
-void FEValuesBase<deal_II_dimension>::get_function_grads (const BlockVector<float> &,
-                                                         std::vector<std::vector<Tensor<1,deal_II_dimension> > > &) const;
+void FEValuesBase<deal_II_dimension>::get_function_grads<> (const BlockVector<float> &,
+                                                           std::vector<std::vector<Tensor<1,deal_II_dimension> > > &) const;
 
 //-----------------------------------------------------------------------------
 
 template
-void FEValuesBase<deal_II_dimension>::get_function_2nd_derivatives (const Vector<double> &,
-                                                                   std::vector<Tensor<2,deal_II_dimension> > &) const;
+void FEValuesBase<deal_II_dimension>::get_function_2nd_derivatives<> (const Vector<double> &,
+                                                                     std::vector<Tensor<2,deal_II_dimension> > &) const;
 template
-void FEValuesBase<deal_II_dimension>::get_function_2nd_derivatives (const Vector<float> &,
-                                                                   std::vector<Tensor<2,deal_II_dimension> > &) const;
+void FEValuesBase<deal_II_dimension>::get_function_2nd_derivatives<> (const Vector<float> &,
+                                                                     std::vector<Tensor<2,deal_II_dimension> > &) const;
 template
-void FEValuesBase<deal_II_dimension>::get_function_2nd_derivatives (const BlockVector<double> &,
-                                                                   std::vector<Tensor<2,deal_II_dimension> > &) const;
+void FEValuesBase<deal_II_dimension>::get_function_2nd_derivatives<> (const BlockVector<double> &,
+                                                                     std::vector<Tensor<2,deal_II_dimension> > &) const;
 //-----------------------------------------------------------------------------
 
 template
-void FEValuesBase<deal_II_dimension>::get_function_2nd_derivatives (const Vector<double> &,
-                                                                   std::vector<std::vector<Tensor<2,deal_II_dimension> > > &) const;
+void FEValuesBase<deal_II_dimension>::get_function_2nd_derivatives<> (const Vector<double> &,
+                                                                     std::vector<std::vector<Tensor<2,deal_II_dimension> > > &) const;
 template
-void FEValuesBase<deal_II_dimension>::get_function_2nd_derivatives (const Vector<float> &,
-                                                                   std::vector<std::vector<Tensor<2,deal_II_dimension> > > &) const;
+void FEValuesBase<deal_II_dimension>::get_function_2nd_derivatives<> (const Vector<float> &,
+                                                                     std::vector<std::vector<Tensor<2,deal_II_dimension> > > &) const;
 template
-void FEValuesBase<deal_II_dimension>::get_function_2nd_derivatives (const BlockVector<double> &,
-                                                                   std::vector<std::vector<Tensor<2,deal_II_dimension> > > &) const;
+void FEValuesBase<deal_II_dimension>::get_function_2nd_derivatives<> (const BlockVector<double> &,
+                                                                     std::vector<std::vector<Tensor<2,deal_II_dimension> > > &) const;

diff --git a/deal.II/deal.II/source/fe/mapping_cartesian.cc b/deal.II/deal.II/source/fe/mapping_cartesian.cc
index 805453f2e9c9fda600b8887d30810f9b338b80f3..fa7813c8da5f03177e094c1b31e777c581cfc549 100644 (file)
--- a/deal.II/deal.II/source/fe/mapping_cartesian.cc
+++ b/deal.II/deal.II/source/fe/mapping_cartesian.cc
@@ -625,25 +625,25 @@ covariant_transformation (typename std::vector<tensor_>       &dst,
 
 template class MappingCartesian<deal_II_dimension>;
 
-template void MappingCartesian<deal_II_dimension>::contravariant_transformation (
+template void MappingCartesian<deal_II_dimension>::contravariant_transformation<> (
   std::vector<Tensor<1,deal_II_dimension> >       &dst,
   const std::vector<Tensor<1,deal_II_dimension> > &src,
   const Mapping<deal_II_dimension>::InternalDataBase& internal,
   const unsigned int src_offset) const;
 
-template void MappingCartesian<deal_II_dimension>::contravariant_transformation (
+template void MappingCartesian<deal_II_dimension>::contravariant_transformation<> (
   std::vector<Point<deal_II_dimension> >       &dst,
   const std::vector<Point<deal_II_dimension> > &src,
   const Mapping<deal_II_dimension>::InternalDataBase& internal,
   const unsigned int src_offset) const;
 
-template void MappingCartesian<deal_II_dimension>::covariant_transformation (
+template void MappingCartesian<deal_II_dimension>::covariant_transformation<> (
   std::vector<Tensor<1,deal_II_dimension> >       &dst,
   const std::vector<Tensor<1,deal_II_dimension> > &src,
   const Mapping<deal_II_dimension>::InternalDataBase& internal,
   const unsigned int src_offset) const;
 
-template void MappingCartesian<deal_II_dimension>::covariant_transformation (
+template void MappingCartesian<deal_II_dimension>::covariant_transformation<> (
   std::vector<Point<deal_II_dimension> >       &dst,
   const std::vector<Point<deal_II_dimension> > &src,
   const Mapping<deal_II_dimension>::InternalDataBase& internal,

diff --git a/deal.II/deal.II/source/fe/mapping_q1.cc b/deal.II/deal.II/source/fe/mapping_q1.cc
index bd83e01d0fd72e0392780e79126ccff80579c0c0..01d908122ffb3f7c348691ffefdeb9c6d912e456 100644 (file)
--- a/deal.II/deal.II/source/fe/mapping_q1.cc
+++ b/deal.II/deal.II/source/fe/mapping_q1.cc
@@ -1037,25 +1037,25 @@ MappingQ1<dim>::covariant_transformation (std::vector<tensor_>       &dst,
 
 template class MappingQ1<deal_II_dimension>;
 
-template void MappingQ1<deal_II_dimension>::contravariant_transformation (
+template void MappingQ1<deal_II_dimension>::contravariant_transformation<> (
   std::vector<Tensor<1,deal_II_dimension> >       &dst,
   const std::vector<Tensor<1,deal_II_dimension> > &src,
   const Mapping<deal_II_dimension>::InternalDataBase& internal,
   const unsigned int src_offset) const;
 
-template void MappingQ1<deal_II_dimension>::contravariant_transformation (
+template void MappingQ1<deal_II_dimension>::contravariant_transformation<> (
   std::vector<Point<deal_II_dimension> >       &dst,
   const std::vector<Point<deal_II_dimension> > &src,
   const Mapping<deal_II_dimension>::InternalDataBase& internal,
   const unsigned int src_offset) const;
 
-template void MappingQ1<deal_II_dimension>::covariant_transformation (
+template void MappingQ1<deal_II_dimension>::covariant_transformation<> (
   std::vector<Tensor<1,deal_II_dimension> >       &dst,
   const std::vector<Tensor<1,deal_II_dimension> > &src,
   const Mapping<deal_II_dimension>::InternalDataBase& internal,
   const unsigned int src_offset) const;
 
-template void MappingQ1<deal_II_dimension>::covariant_transformation (
+template void MappingQ1<deal_II_dimension>::covariant_transformation<> (
   std::vector<Point<deal_II_dimension> >       &dst,
   const std::vector<Point<deal_II_dimension> > &src,
   const Mapping<deal_II_dimension>::InternalDataBase& internal,

diff --git a/deal.II/deal.II/source/grid/grid_generator.cc b/deal.II/deal.II/source/grid/grid_generator.cc
index 92c4dfc4a44251a2a77adb21a4585ea89d614568..1ac36b52ad34cb056646852d61f303d242b934dd 100644 (file)
--- a/deal.II/deal.II/source/grid/grid_generator.cc
+++ b/deal.II/deal.II/source/grid/grid_generator.cc
@@ -958,18 +958,18 @@ void GridGenerator::laplace_solve (const SparseMatrix<double> &S,
 
 // explicit instantiations
 template void
-GridGenerator::hyper_rectangle (Triangulation<deal_II_dimension> &,
-                               const Point<deal_II_dimension>&,
-                               const Point<deal_II_dimension>&,
-                               const bool);
+GridGenerator::hyper_rectangle<> (Triangulation<deal_II_dimension> &,
+                                 const Point<deal_II_dimension>&,
+                                 const Point<deal_II_dimension>&,
+                                 const bool);
 template void
-GridGenerator::hyper_cube (Triangulation<deal_II_dimension> &,
-                          const double,
-                          const double);
+GridGenerator::hyper_cube<> (Triangulation<deal_II_dimension> &,
+                            const double,
+                            const double);
 
 #if deal_II_dimension != 1
 template void
-GridGenerator::laplace_transformation (Triangulation<deal_II_dimension> &,
-                                      const std::map<unsigned int,Point<deal_II_dimension> > &);
+GridGenerator::laplace_transformation<> (Triangulation<deal_II_dimension> &,
+                                        const std::map<unsigned int,Point<deal_II_dimension> > &);
 
 #endif

diff --git a/deal.II/deal.II/source/grid/grid_out.cc b/deal.II/deal.II/source/grid/grid_out.cc
index 85b8906af06c7c2199bf6ae4f41c619a41440be4..69290cc098c6f28f5f80e5a3e640c1666c78007c 100644 (file)
--- a/deal.II/deal.II/source/grid/grid_out.cc
+++ b/deal.II/deal.II/source/grid/grid_out.cc
@@ -839,17 +839,17 @@ void GridOut::write (const Triangulation<dim> &tria,
 
 
 // explicit instantiations
-template void GridOut::write_ucd (const Triangulation<deal_II_dimension> &,
-                                 std::ostream &);
+template void GridOut::write_ucd<> (const Triangulation<deal_II_dimension> &,
+                                   std::ostream &);
 #if deal_II_dimension != 1
-template void GridOut::write_gnuplot (const Triangulation<deal_II_dimension> &,
-                                     std::ostream &,
-                                     const Mapping<deal_II_dimension> *);
-template void GridOut::write_eps (const Triangulation<deal_II_dimension> &,
-                                 std::ostream &,
-                                 const Mapping<deal_II_dimension> *);
+template void GridOut::write_gnuplot<> (const Triangulation<deal_II_dimension> &,
+                                       std::ostream &,
+                                       const Mapping<deal_II_dimension> *);
+template void GridOut::write_eps<> (const Triangulation<deal_II_dimension> &,
+                                   std::ostream &,
+                                   const Mapping<deal_II_dimension> *);
 #endif
-template void GridOut::write (const Triangulation<deal_II_dimension> &,
-                             std::ostream &,
-                             const OutputFormat,
-                             const Mapping<deal_II_dimension> *);
+template void GridOut::write<> (const Triangulation<deal_II_dimension> &,
+                               std::ostream &,
+                               const OutputFormat,
+                               const Mapping<deal_II_dimension> *);

diff --git a/deal.II/deal.II/source/grid/grid_refinement.cc b/deal.II/deal.II/source/grid/grid_refinement.cc
index f273660f085fc082b5fc13f824d8ec64f2e41340..14c369f3b87031be2619cab1e7aaa517d910e440 100644 (file)
--- a/deal.II/deal.II/source/grid/grid_refinement.cc
+++ b/deal.II/deal.II/source/grid/grid_refinement.cc
@@ -319,46 +319,46 @@ GridRefinement::refine_and_coarsen_optimize (Triangulation<dim>   &tria,
 
 // explicit instantiations
 template void GridRefinement
-::refine (Triangulation<deal_II_dimension> &, const Vector<float> &, const double);
+::refine<> (Triangulation<deal_II_dimension> &, const Vector<float> &, const double);
 
 template void GridRefinement
-::refine (Triangulation<deal_II_dimension> &, const Vector<double> &, const double);
+::refine<> (Triangulation<deal_II_dimension> &, const Vector<double> &, const double);
 
 template void GridRefinement
-::coarsen (Triangulation<deal_II_dimension> &, const Vector<float> &, const double);
+::coarsen<> (Triangulation<deal_II_dimension> &, const Vector<float> &, const double);
 
 template void GridRefinement
-::coarsen (Triangulation<deal_II_dimension> &, const Vector<double> &, const double);
+::coarsen<> (Triangulation<deal_II_dimension> &, const Vector<double> &, const double);
 
 
 template void GridRefinement
-::refine_and_coarsen_fixed_number (Triangulation<deal_II_dimension> &,
-                                  const Vector<double> &,
-                                  const double         top_fraction,
-                                  const double         bottom_fraction);
-
-template void GridRefinement
-::refine_and_coarsen_fixed_number (Triangulation<deal_II_dimension> &,
-                                  const Vector<float> &criteria,
-                                  const double         top_fraction,
-                                  const double         bottom_fraction);
-
-template void GridRefinement
-::refine_and_coarsen_fixed_fraction (Triangulation<deal_II_dimension> &,
-                                    const Vector<double> &criteria,
+::refine_and_coarsen_fixed_number<> (Triangulation<deal_II_dimension> &,
+                                    const Vector<double> &,
                                     const double         top_fraction,
                                     const double         bottom_fraction);
 
 template void GridRefinement
-::refine_and_coarsen_fixed_fraction (Triangulation<deal_II_dimension> &,
+::refine_and_coarsen_fixed_number<> (Triangulation<deal_II_dimension> &,
                                     const Vector<float> &criteria,
                                     const double         top_fraction,
                                     const double         bottom_fraction);
 
 template void GridRefinement
-::refine_and_coarsen_optimize (Triangulation<deal_II_dimension> &,
-                              const Vector<float> &criteria);
+::refine_and_coarsen_fixed_fraction<> (Triangulation<deal_II_dimension> &,
+                                      const Vector<double> &criteria,
+                                      const double         top_fraction,
+                                      const double         bottom_fraction);
+
+template void GridRefinement
+::refine_and_coarsen_fixed_fraction<> (Triangulation<deal_II_dimension> &,
+                                      const Vector<float> &criteria,
+                                      const double         top_fraction,
+                                      const double         bottom_fraction);
+
+template void GridRefinement
+::refine_and_coarsen_optimize<> (Triangulation<deal_II_dimension> &,
+                                const Vector<float> &criteria);
 
 template void GridRefinement
-::refine_and_coarsen_optimize (Triangulation<deal_II_dimension> &,
-                              const Vector<double> &criteria);
+::refine_and_coarsen_optimize<> (Triangulation<deal_II_dimension> &,
+                                const Vector<double> &criteria);

diff --git a/deal.II/deal.II/source/grid/grid_reordering.cc b/deal.II/deal.II/source/grid/grid_reordering.cc
index cae5e0725626325cbad5d1e9595c695e293cc409..b109843468f33825ecef2ad172a360207608650e 100644 (file)
--- a/deal.II/deal.II/source/grid/grid_reordering.cc
+++ b/deal.II/deal.II/source/grid/grid_reordering.cc
@@ -1314,5 +1314,5 @@ void GridReordering<1>::reorder_cells (std::vector<CellData<1> > &)
 template
 void
 GridReordering<deal_II_dimension>::
-reorder_cells (std::vector<CellData<deal_II_dimension> > &);
+reorder_cells<> (std::vector<CellData<deal_II_dimension> > &);
 #endif

diff --git a/deal.II/deal.II/source/grid/grid_tools.cc b/deal.II/deal.II/source/grid/grid_tools.cc
index bdd93bb805c4f2aa0d660b675cd425af2fd860a4..d50e6cd6fc06beaaab403394abf476084a30ade4 100644 (file)
--- a/deal.II/deal.II/source/grid/grid_tools.cc
+++ b/deal.II/deal.II/source/grid/grid_tools.cc
@@ -96,5 +96,5 @@ GridTools::diameter (const Triangulation<1> &tria)
 #if deal_II_dimension != 1
 template
 double
-GridTools::diameter (const Triangulation<deal_II_dimension> &);
+GridTools::diameter<> (const Triangulation<deal_II_dimension> &);
 #endif

diff --git a/deal.II/deal.II/source/multigrid/mg_dof_tools.cc b/deal.II/deal.II/source/multigrid/mg_dof_tools.cc
index db372b5ffdccebe17e25cd4c2c4cdd143b5b7e7e..f1886de104849fa06945bb465cd2311e574a8cb1 100644 (file)
--- a/deal.II/deal.II/source/multigrid/mg_dof_tools.cc
+++ b/deal.II/deal.II/source/multigrid/mg_dof_tools.cc
@@ -403,152 +403,152 @@ MGTools::reinit_vector (const MGDoFHandler<dim>& mg_dof,
 
 // explicit instantiations
 template void
-MGTools::make_sparsity_pattern (const MGDoFHandler<deal_II_dimension> &,
-                               SparsityPattern &,
-                               const unsigned int);
+MGTools::make_sparsity_pattern<> (const MGDoFHandler<deal_II_dimension> &,
+                                 SparsityPattern &,
+                                 const unsigned int);
 
 template void
-MGTools::make_flux_sparsity_pattern (const MGDoFHandler<deal_II_dimension> &,
-                                    SparsityPattern &,
-                                    const unsigned int);
+MGTools::make_flux_sparsity_pattern<> (const MGDoFHandler<deal_II_dimension> &,
+                                      SparsityPattern &,
+                                      const unsigned int);
 
 template void
-MGTools::make_flux_sparsity_pattern_edge (const MGDoFHandler<deal_II_dimension> &,
-                                         SparsityPattern &,
-                                         const unsigned int);
+MGTools::make_flux_sparsity_pattern_edge<> (const MGDoFHandler<deal_II_dimension> &,
+                                           SparsityPattern &,
+                                           const unsigned int);
 
 template void
-MGTools::make_sparsity_pattern (const MGDoFHandler<deal_II_dimension> &,
-                               CompressedSparsityPattern &,
-                               const unsigned int);
+MGTools::make_sparsity_pattern<> (const MGDoFHandler<deal_II_dimension> &,
+                                 CompressedSparsityPattern &,
+                                 const unsigned int);
 
 template void
-MGTools::make_flux_sparsity_pattern (const MGDoFHandler<deal_II_dimension> &,
-                                    CompressedSparsityPattern &,
-                                    const unsigned int);
+MGTools::make_flux_sparsity_pattern<> (const MGDoFHandler<deal_II_dimension> &,
+                                      CompressedSparsityPattern &,
+                                      const unsigned int);
 
 template void
-MGTools::make_flux_sparsity_pattern_edge (const MGDoFHandler<deal_II_dimension> &,
-                                         CompressedSparsityPattern &,
-                                         const unsigned int);
+MGTools::make_flux_sparsity_pattern_edge<> (const MGDoFHandler<deal_II_dimension> &,
+                                           CompressedSparsityPattern &,
+                                           const unsigned int);
 
 template void
-MGTools::make_sparsity_pattern (const MGDoFHandler<deal_II_dimension> &,
-                               BlockSparsityPattern &,
-                               const unsigned int);
+MGTools::make_sparsity_pattern<> (const MGDoFHandler<deal_II_dimension> &,
+                                 BlockSparsityPattern &,
+                                 const unsigned int);
 template void
-MGTools::make_flux_sparsity_pattern (const MGDoFHandler<deal_II_dimension> &,
-                                    BlockSparsityPattern &,
-                                    const unsigned int);
+MGTools::make_flux_sparsity_pattern<> (const MGDoFHandler<deal_II_dimension> &,
+                                      BlockSparsityPattern &,
+                                      const unsigned int);
 
 template void
-MGTools::make_flux_sparsity_pattern_edge (const MGDoFHandler<deal_II_dimension> &,
-                                         BlockSparsityPattern &,
-                                         const unsigned int);
+MGTools::make_flux_sparsity_pattern_edge<> (const MGDoFHandler<deal_II_dimension> &,
+                                           BlockSparsityPattern &,
+                                           const unsigned int);
 
 template void
-MGTools::make_sparsity_pattern (const MGDoFHandler<deal_II_dimension> &,
-                               CompressedBlockSparsityPattern &,
-                               const unsigned int);
+MGTools::make_sparsity_pattern<> (const MGDoFHandler<deal_II_dimension> &,
+                                 CompressedBlockSparsityPattern &,
+                                 const unsigned int);
 
 template void
-MGTools::make_flux_sparsity_pattern (const MGDoFHandler<deal_II_dimension> &,
-                                    CompressedBlockSparsityPattern &,
-                                    const unsigned int);
+MGTools::make_flux_sparsity_pattern<> (const MGDoFHandler<deal_II_dimension> &,
+                                      CompressedBlockSparsityPattern &,
+                                      const unsigned int);
 
 template void
-MGTools::make_flux_sparsity_pattern_edge (const MGDoFHandler<deal_II_dimension> &,
-                                         CompressedBlockSparsityPattern &,
-                                         const unsigned int);
+MGTools::make_flux_sparsity_pattern_edge<> (const MGDoFHandler<deal_II_dimension> &,
+                                           CompressedBlockSparsityPattern &,
+                                           const unsigned int);
 
 #if deal_II_dimension > 1
 template void
-MGTools::make_flux_sparsity_pattern (const MGDoFHandler<deal_II_dimension> &,
-                                    SparsityPattern &,
-                                    const unsigned int,
-                                    const FullMatrix<double>&,
-                                    const FullMatrix<double>&);
+MGTools::make_flux_sparsity_pattern<> (const MGDoFHandler<deal_II_dimension> &,
+                                      SparsityPattern &,
+                                      const unsigned int,
+                                      const FullMatrix<double>&,
+                                      const FullMatrix<double>&);
 
 template void
-MGTools::make_flux_sparsity_pattern (const MGDoFHandler<deal_II_dimension> &,
-                                    CompressedSparsityPattern &,
-                                    const unsigned int,
-                                    const FullMatrix<double>&,
-                                    const FullMatrix<double>&);
+MGTools::make_flux_sparsity_pattern<> (const MGDoFHandler<deal_II_dimension> &,
+                                      CompressedSparsityPattern &,
+                                      const unsigned int,
+                                      const FullMatrix<double>&,
+                                      const FullMatrix<double>&);
 
 template void
-MGTools::make_flux_sparsity_pattern (const MGDoFHandler<deal_II_dimension> &,
-                                    BlockSparsityPattern &,
-                                    const unsigned int,
-                                    const FullMatrix<double>&,
-                                    const FullMatrix<double>&);
+MGTools::make_flux_sparsity_pattern<> (const MGDoFHandler<deal_II_dimension> &,
+                                      BlockSparsityPattern &,
+                                      const unsigned int,
+                                      const FullMatrix<double>&,
+                                      const FullMatrix<double>&);
 
 template void
-MGTools::make_flux_sparsity_pattern (const MGDoFHandler<deal_II_dimension> &,
-                                    CompressedBlockSparsityPattern &,
-                                    const unsigned int,
-                                    const FullMatrix<double>&,
-                                    const FullMatrix<double>&);
+MGTools::make_flux_sparsity_pattern<> (const MGDoFHandler<deal_II_dimension> &,
+                                      CompressedBlockSparsityPattern &,
+                                      const unsigned int,
+                                      const FullMatrix<double>&,
+                                      const FullMatrix<double>&);
 
 #endif
 
-template void MGTools::reinit_vector (const MGDoFHandler<deal_II_dimension>&,
-                                     MGLevelObject<Vector<double> >&);
-template void MGTools::reinit_vector (const MGDoFHandler<deal_II_dimension>&,
-                                     MGLevelObject<Vector<float> >&);
+template void MGTools::reinit_vector<> (const MGDoFHandler<deal_II_dimension>&,
+                                       MGLevelObject<Vector<double> >&);
+template void MGTools::reinit_vector<> (const MGDoFHandler<deal_II_dimension>&,
+                                       MGLevelObject<Vector<float> >&);
 
 
-//  template void MGTools::copy_to_mg (const MGDoFHandler<deal_II_dimension>&,
+//  template void MGTools::copy_to_mg<> (const MGDoFHandler<deal_II_dimension>&,
 //                                const MGTransferBase<Vector<double> >&,
 //                                MGLevelObject<Vector<double> >&,
 //                                const Vector<double>&);
 
-//  template void MGTools::copy_from_mg(const MGDoFHandler<deal_II_dimension>&,
+//  template void MGTools::copy_from_mg<>(const MGDoFHandler<deal_II_dimension>&,
 //                                 Vector<double>&,
 //                                 const MGLevelObject<Vector<double> >&);
 
-//  template void MGTools::copy_from_mg_add(const MGDoFHandler<deal_II_dimension>&,
+//  template void MGTools::copy_from_mg_add<>(const MGDoFHandler<deal_II_dimension>&,
 //                                     Vector<double>&,
 //                                     const MGLevelObject<Vector<double> >&);
 
-//  template void MGTools::copy_to_mg (const MGDoFHandler<deal_II_dimension>&,
+//  template void MGTools::copy_to_mg<> (const MGDoFHandler<deal_II_dimension>&,
 //                                const MGTransferBase<Vector<double> >&,
 //                                MGLevelObject<Vector<double> >&,
 //                                const Vector<float>&);
 
-//  template void MGTools::copy_from_mg(const MGDoFHandler<deal_II_dimension>&,
+//  template void MGTools::copy_from_mg<>(const MGDoFHandler<deal_II_dimension>&,
 //                                 Vector<double>&,
 //                                 const MGLevelObject<Vector<float> >&);
 
-//  template void MGTools::copy_from_mg_add(const MGDoFHandler<deal_II_dimension>&,
+//  template void MGTools::copy_from_mg_add<>(const MGDoFHandler<deal_II_dimension>&,
 //                                     Vector<double>&,
 //                                     const MGLevelObject<Vector<float> >&);
 
-//  template void MGTools::copy_to_mg (const MGDoFHandler<deal_II_dimension>&,
+//  template void MGTools::copy_to_mg<> (const MGDoFHandler<deal_II_dimension>&,
 //                                const MGTransferBase<Vector<double> >&,
 //                                MGLevelObject<Vector<double> >&,
 //                                const BlockVector<double>&);
 
-//  template void MGTools::copy_from_mg(const MGDoFHandler<deal_II_dimension>&,
+//  template void MGTools::copy_from_mg<>(const MGDoFHandler<deal_II_dimension>&,
 //                                 BlockVector<double>&,
 //                                 const MGLevelObject<Vector<double> >&);
 
-//  template void MGTools::copy_from_mg_add(const MGDoFHandler<deal_II_dimension>&,
+//  template void MGTools::copy_from_mg_add<>(const MGDoFHandler<deal_II_dimension>&,
 //                                     BlockVector<double>&,
 //                                     const MGLevelObject<Vector<double> >&);
 
-//  template void MGTools::copy_to_mg (const MGDoFHandler<deal_II_dimension>&,
+//  template void MGTools::copy_to_mg<> (const MGDoFHandler<deal_II_dimension>&,
 //                                const MGTransferBase<Vector<double> >&,
 //                                MGLevelObject<Vector<double> >&,
 //                                const BlockVector<float>&);
 
-//  template void MGTools::copy_from_mg(const MGDoFHandler<deal_II_dimension>&,
+//  template void MGTools::copy_from_mg<>(const MGDoFHandler<deal_II_dimension>&,
 //                                 BlockVector<double>&,
 //                                 const MGLevelObject<Vector<float> >&);
 
-//  template void MGTools::copy_from_mg_add(const MGDoFHandler<deal_II_dimension>&,
+//  template void MGTools::copy_from_mg_add<>(const MGDoFHandler<deal_II_dimension>&,
 //                                     BlockVector<double>&,
 //                                     const MGLevelObject<Vector<float> >&);
 
-template void MGTools::count_dofs_per_component (const MGDoFHandler<deal_II_dimension>&,
-                                                std::vector<std::vector<unsigned int> >&);
+template void MGTools::count_dofs_per_component<> (const MGDoFHandler<deal_II_dimension>&,
+                                                  std::vector<std::vector<unsigned int> >&);

diff --git a/deal.II/deal.II/source/multigrid/mg_smoother.cc b/deal.II/deal.II/source/multigrid/mg_smoother.cc
index 85bfd978bc69aa01ed8577d69282b667f16689f5..d0b822535d49b1282375411eb044b40f5453d0c0 100644 (file)
--- a/deal.II/deal.II/source/multigrid/mg_smoother.cc
+++ b/deal.II/deal.II/source/multigrid/mg_smoother.cc
@@ -36,7 +36,7 @@
 #if deal_II_dimension == 1
 
 MGSmootherContinuous::MGSmootherContinuous (const MGDoFHandler<1> &/*mg_dof*/,
-                                           unsigned int steps)
+                                           const unsigned int steps)
                :
                steps(steps)
 {
@@ -50,7 +50,7 @@ MGSmootherContinuous::MGSmootherContinuous (const MGDoFHandler<1> &/*mg_dof*/,
 
 template <int dim>
 MGSmootherContinuous::MGSmootherContinuous (const MGDoFHandler<dim> &mg_dof,
-                                           unsigned int steps)
+                                           const unsigned int steps)
                :
                steps(steps)
 {
@@ -133,24 +133,25 @@ MGSmootherContinuous::set_zero_interior_boundary (const unsigned int level,
 // don't do the following instantiation in 1d, since there is a specialized
 // function there
 #if deal_II_dimension > 1
-template MGSmootherContinuous::MGSmootherContinuous (const MGDoFHandler<deal_II_dimension>&, unsigned int);
+template MGSmootherContinuous::MGSmootherContinuous (const MGDoFHandler<deal_II_dimension>&,
+                                                    const unsigned int);
 #endif
 
 template
-void MGSmootherContinuous::set_zero_interior_boundary (const unsigned int,
-                                            Vector<double>&) const;
+void MGSmootherContinuous::set_zero_interior_boundary<> (const unsigned int,
+                                                        Vector<double>&) const;
 
 template
-void MGSmootherContinuous::set_zero_interior_boundary (const unsigned int,
-                                            Vector<float>&) const;
+void MGSmootherContinuous::set_zero_interior_boundary<> (const unsigned int,
+                                                        Vector<float>&) const;
 
 template
-void MGSmootherContinuous::set_zero_interior_boundary (const unsigned int,
-                                            BlockVector<double>&) const;
+void MGSmootherContinuous::set_zero_interior_boundary<> (const unsigned int,
+                                                        BlockVector<double>&) const;
 
 template
-void MGSmootherContinuous::set_zero_interior_boundary (const unsigned int,
-                                            BlockVector<float>&) const;
+void MGSmootherContinuous::set_zero_interior_boundary<> (const unsigned int,
+                                                        BlockVector<float>&) const;
 
 
   

diff --git a/deal.II/deal.II/source/multigrid/multigrid.cc b/deal.II/deal.II/source/multigrid/multigrid.cc
index f00b190617a5919e9a115ee12e44b5751f7c34e3..cc65bc9e1c41532f71bffdf6fc8620d9e587223f 100644 (file)
--- a/deal.II/deal.II/source/multigrid/multigrid.cc
+++ b/deal.II/deal.II/source/multigrid/multigrid.cc
@@ -331,12 +331,12 @@ void MGTransferSelect::build_matrices (const MGDoFHandler<dim> &mg_dof,
 // explicit instatations
 
 template
-void MGTransferPrebuilt::build_matrices (const MGDoFHandler<deal_II_dimension> &mg_dof);
+void MGTransferPrebuilt::build_matrices<> (const MGDoFHandler<deal_II_dimension> &mg_dof);
 
 template
-void MGTransferBlock::build_matrices (const MGDoFHandler<deal_II_dimension> &mg_dof,
-                                     std::vector<bool>);
+void MGTransferBlock::build_matrices<> (const MGDoFHandler<deal_II_dimension> &mg_dof,
+                                       std::vector<bool>);
 
 template
-void MGTransferSelect::build_matrices (const MGDoFHandler<deal_II_dimension> &mg_dof,
-                                      unsigned int);
+void MGTransferSelect::build_matrices<> (const MGDoFHandler<deal_II_dimension> &mg_dof,
+                                        unsigned int);

diff --git a/deal.II/deal.II/source/numerics/data_out.cc b/deal.II/deal.II/source/numerics/data_out.cc
index b000032938046dd2c088a4856208fe1184613231..790e31e676e60ea8112895278d3fd0a965f35edd 100644 (file)
--- a/deal.II/deal.II/source/numerics/data_out.cc
+++ b/deal.II/deal.II/source/numerics/data_out.cc
@@ -643,44 +643,44 @@ DataOut<dim>::next_cell (const typename DoFHandler<dim>::cell_iterator &cell)
 // explicit instantiations
 template class DataOut_DoFData<deal_II_dimension,deal_II_dimension>;
 template void
-DataOut_DoFData<deal_II_dimension,deal_II_dimension>::add_data_vector (
+DataOut_DoFData<deal_II_dimension,deal_II_dimension>::add_data_vector<> (
   const Vector<double> &vec,
   const std::vector<std::string>    &name,
   const DataVectorType  type);
 template void
-DataOut_DoFData<deal_II_dimension,deal_II_dimension>::add_data_vector (
+DataOut_DoFData<deal_II_dimension,deal_II_dimension>::add_data_vector<> (
   const BlockVector<double> &vec,
   const std::vector<std::string>    &name,
   const DataVectorType  type);
 template void
-DataOut_DoFData<deal_II_dimension,deal_II_dimension>::add_data_vector (
+DataOut_DoFData<deal_II_dimension,deal_II_dimension>::add_data_vector<> (
   const Vector<double> &vec,
   const std::string    &name,
   const DataVectorType  type);
 template void
-DataOut_DoFData<deal_II_dimension,deal_II_dimension>::add_data_vector (
+DataOut_DoFData<deal_II_dimension,deal_II_dimension>::add_data_vector<> (
   const BlockVector<double> &vec,
   const std::string    &name,
   const DataVectorType  type);
 
 template class DataOut_DoFData<deal_II_dimension,deal_II_dimension+1>;
 template void
-DataOut_DoFData<deal_II_dimension,deal_II_dimension+1>::add_data_vector (
+DataOut_DoFData<deal_II_dimension,deal_II_dimension+1>::add_data_vector<> (
   const Vector<double> &vec,
   const std::vector<std::string>    &name,
   const DataVectorType  type);
 template void
-DataOut_DoFData<deal_II_dimension,deal_II_dimension+1>::add_data_vector (
+DataOut_DoFData<deal_II_dimension,deal_II_dimension+1>::add_data_vector<> (
   const BlockVector<double> &vec,
   const std::vector<std::string>    &name,
   const DataVectorType  type);
 template void
-DataOut_DoFData<deal_II_dimension,deal_II_dimension+1>::add_data_vector (
+DataOut_DoFData<deal_II_dimension,deal_II_dimension+1>::add_data_vector<> (
   const Vector<double> &vec,
   const std::string    &name,
   const DataVectorType  type);
 template void
-DataOut_DoFData<deal_II_dimension,deal_II_dimension+1>::add_data_vector (
+DataOut_DoFData<deal_II_dimension,deal_II_dimension+1>::add_data_vector<> (
   const BlockVector<double> &vec,
   const std::string    &name,
   const DataVectorType  type);
@@ -693,22 +693,22 @@ template class DataOut<deal_II_dimension>;
 #if deal_II_dimension >= 2
 template class DataOut_DoFData<deal_II_dimension,deal_II_dimension-1,deal_II_dimension>;
 template void
-DataOut_DoFData<deal_II_dimension,deal_II_dimension-1,deal_II_dimension>::add_data_vector (
+DataOut_DoFData<deal_II_dimension,deal_II_dimension-1,deal_II_dimension>::add_data_vector<> (
   const Vector<double> &vec,
   const std::vector<std::string>    &name,
   const DataVectorType  type);
 template void
-DataOut_DoFData<deal_II_dimension,deal_II_dimension-1,deal_II_dimension>::add_data_vector (
+DataOut_DoFData<deal_II_dimension,deal_II_dimension-1,deal_II_dimension>::add_data_vector<> (
   const BlockVector<double> &vec,
   const std::vector<std::string>    &name,
   const DataVectorType  type);
 template void
-DataOut_DoFData<deal_II_dimension,deal_II_dimension-1,deal_II_dimension>::add_data_vector (
+DataOut_DoFData<deal_II_dimension,deal_II_dimension-1,deal_II_dimension>::add_data_vector<> (
   const Vector<double> &vec,
   const std::string    &name,
   const DataVectorType  type);
 template void
-DataOut_DoFData<deal_II_dimension,deal_II_dimension-1,deal_II_dimension>::add_data_vector (
+DataOut_DoFData<deal_II_dimension,deal_II_dimension-1,deal_II_dimension>::add_data_vector<> (
   const BlockVector<double> &vec,
   const std::string    &name,
   const DataVectorType  type);

diff --git a/deal.II/deal.II/source/numerics/data_out_stack.cc b/deal.II/deal.II/source/numerics/data_out_stack.cc
index b5a3359e096dd0de9d598a3bb9d77a3f6ab799c9..9803737990bbe1fbc750c7fe0500648e3feff3b1 100644 (file)
--- a/deal.II/deal.II/source/numerics/data_out_stack.cc
+++ b/deal.II/deal.II/source/numerics/data_out_stack.cc
@@ -380,7 +380,7 @@ std::vector<std::string> DataOutStack<dim>::get_dataset_names () const
 
 // explicit instantiations
 template class DataOutStack<deal_II_dimension>;
-template void DataOutStack<deal_II_dimension>::add_data_vector (const Vector<double> &vec,
-                                                               const std::string    &name);
-template void DataOutStack<deal_II_dimension>::add_data_vector (const Vector<float>  &vec,
-                                                               const std::string    &name);
+template void DataOutStack<deal_II_dimension>::add_data_vector<> (const Vector<double> &vec,
+                                                                 const std::string    &name);
+template void DataOutStack<deal_II_dimension>::add_data_vector<> (const Vector<float>  &vec,
+                                                                 const std::string    &name);

diff --git a/deal.II/deal.II/source/numerics/derivative_approximation.cc b/deal.II/deal.II/source/numerics/derivative_approximation.cc
index bc6707914ebb694e5ebdf69343ae32a4ee6c15eb..3467d67424482a51d387292efb46fc5c0d8a934c 100644 (file)
--- a/deal.II/deal.II/source/numerics/derivative_approximation.cc
+++ b/deal.II/deal.II/source/numerics/derivative_approximation.cc
@@ -713,31 +713,31 @@ DerivativeApproximation::approximate (const Mapping<dim>    &mapping,
 template
 void 
 DerivativeApproximation::
-approximate_gradient (const Mapping<deal_II_dimension> &mapping,
-                     const DoFHandler<deal_II_dimension> &dof_handler,
-                     const Vector<double>  &solution,
-                     Vector<float>         &derivative_norm,
-                     const unsigned int     component);
+approximate_gradient<> (const Mapping<deal_II_dimension> &mapping,
+                       const DoFHandler<deal_II_dimension> &dof_handler,
+                       const Vector<double>  &solution,
+                       Vector<float>         &derivative_norm,
+                       const unsigned int     component);
 template
 void 
 DerivativeApproximation::
-approximate_gradient (const DoFHandler<deal_II_dimension> &dof_handler,
-                     const Vector<double>  &solution,
-                     Vector<float>         &derivative_norm,
-                     const unsigned int     component);
+approximate_gradient<> (const DoFHandler<deal_II_dimension> &dof_handler,
+                       const Vector<double>  &solution,
+                       Vector<float>         &derivative_norm,
+                       const unsigned int     component);
 
 template
 void 
 DerivativeApproximation::
-approximate_second_derivative (const Mapping<deal_II_dimension>    &mapping,
-                              const DoFHandler<deal_II_dimension> &dof_handler,
-                              const Vector<double>  &solution,
-                              Vector<float>         &derivative_norm,
-                              const unsigned int     component);
+approximate_second_derivative<> (const Mapping<deal_II_dimension>    &mapping,
+                                const DoFHandler<deal_II_dimension> &dof_handler,
+                                const Vector<double>  &solution,
+                                Vector<float>         &derivative_norm,
+                                const unsigned int     component);
 template
 void 
 DerivativeApproximation::
-approximate_second_derivative (const DoFHandler<deal_II_dimension> &dof_handler,
-                              const Vector<double>  &solution,
-                              Vector<float>         &derivative_norm,
-                              const unsigned int     component);
+approximate_second_derivative<> (const DoFHandler<deal_II_dimension> &dof_handler,
+                                const Vector<double>  &solution,
+                                Vector<float>         &derivative_norm,
+                                const unsigned int     component);

diff --git a/deal.II/deal.II/source/numerics/histogram.cc b/deal.II/deal.II/source/numerics/histogram.cc
index 8c5638d12003e18fbcf9b0c838ebdac7471cf0c9..cc75cd980e8beea2c34c4e65687748bfad787f0c 100644 (file)
--- a/deal.II/deal.II/source/numerics/histogram.cc
+++ b/deal.II/deal.II/source/numerics/histogram.cc
@@ -329,23 +329,23 @@ Histogram::memory_consumption () const
 
 // explicit instantiations for float
 template
-void Histogram::evaluate (const std::vector<Vector<float> > &values,
-                         const std::vector<double>                  &y_values, 
-                         const unsigned int                          n_intervals,
-                         const IntervalSpacing                       interval_spacing);
+void Histogram::evaluate<> (const std::vector<Vector<float> > &values,
+                           const std::vector<double>                  &y_values, 
+                           const unsigned int                          n_intervals,
+                           const IntervalSpacing                       interval_spacing);
 template
-void Histogram::evaluate (const Vector<float>   &values,
-                         const unsigned int     n_intervals,
-                         const IntervalSpacing  interval_spacing);
+void Histogram::evaluate<> (const Vector<float>   &values,
+                           const unsigned int     n_intervals,
+                           const IntervalSpacing  interval_spacing);
 
 
 // explicit instantiations for double
 template
-void Histogram::evaluate (const std::vector<Vector<double> >  &values,
-                         const std::vector<double>                    &y_values, 
-                         const unsigned int                            n_intervals,
-                         const IntervalSpacing                         interval_spacing);
+void Histogram::evaluate<> (const std::vector<Vector<double> >  &values,
+                           const std::vector<double>                    &y_values, 
+                           const unsigned int                            n_intervals,
+                           const IntervalSpacing                         interval_spacing);
 template
-void Histogram::evaluate (const Vector<double>   &values,
-                         const unsigned int      n_intervals,
-                         const IntervalSpacing   interval_spacing);
+void Histogram::evaluate<> (const Vector<double>   &values,
+                           const unsigned int      n_intervals,
+                           const IntervalSpacing   interval_spacing);

diff --git a/deal.II/deal.II/source/numerics/matrices.all_dimensions.cc b/deal.II/deal.II/source/numerics/matrices.all_dimensions.cc
index 540cb00c950730184d9e1819e5fee4c158176174..307da1e91c45499e69db9578b1af5d45bb4035ef 100644 (file)
--- a/deal.II/deal.II/source/numerics/matrices.all_dimensions.cc
+++ b/deal.II/deal.II/source/numerics/matrices.all_dimensions.cc
@@ -511,15 +511,15 @@ MatrixTools::apply_boundary_values (const std::map<unsigned int,double> &boundar
 
 template
 void
-MatrixTools::apply_boundary_values (const std::map<unsigned int,double> &boundary_values,
-                                   SparseMatrix<double>  &matrix,
-                                   Vector<double>   &solution,
-                                   Vector<double>   &right_hand_side,
-                                   const bool        preserve_symmetry);
+MatrixTools::apply_boundary_values<> (const std::map<unsigned int,double> &boundary_values,
+                                     SparseMatrix<double>  &matrix,
+                                     Vector<double>   &solution,
+                                     Vector<double>   &right_hand_side,
+                                     const bool        preserve_symmetry);
 template
 void
-MatrixTools::apply_boundary_values (const std::map<unsigned int,double> &boundary_values,
-                                   SparseMatrix<float>  &matrix,
-                                   Vector<float>   &solution,
-                                   Vector<float>   &right_hand_side,
-                                   const bool        preserve_symmetry);
+MatrixTools::apply_boundary_values<> (const std::map<unsigned int,double> &boundary_values,
+                                     SparseMatrix<float>  &matrix,
+                                     Vector<float>   &solution,
+                                     Vector<float>   &right_hand_side,
+                                     const bool        preserve_symmetry);

diff --git a/deal.II/deal.II/source/numerics/matrices.cc b/deal.II/deal.II/source/numerics/matrices.cc
index 2980d77c681ab8a037c596e94c070062b849e945..5a72b0dfd819e612ef1af96cdb4f8c72eb2dbbbc 100644 (file)
--- a/deal.II/deal.II/source/numerics/matrices.cc
+++ b/deal.II/deal.II/source/numerics/matrices.cc
@@ -1228,77 +1228,77 @@ void MatrixCreator::create_laplace_matrix (const DoFHandler<dim>    &dof,
 // explicit instantiations
 
 template
-void MatrixCreator::create_mass_matrix (const Mapping<deal_II_dimension>       &mapping,
-                                       const DoFHandler<deal_II_dimension>    &dof,
-                                       const Quadrature<deal_II_dimension>    &q,
-                                       SparseMatrix<double>     &matrix,
-                                       const Function<deal_II_dimension> * const coefficient);
+void MatrixCreator::create_mass_matrix<> (const Mapping<deal_II_dimension>       &mapping,
+                                         const DoFHandler<deal_II_dimension>    &dof,
+                                         const Quadrature<deal_II_dimension>    &q,
+                                         SparseMatrix<double>     &matrix,
+                                         const Function<deal_II_dimension> * const coefficient);
 template
-void MatrixCreator::create_mass_matrix (const DoFHandler<deal_II_dimension>    &dof,
-                                       const Quadrature<deal_II_dimension>    &q,
-                                       SparseMatrix<double>     &matrix,
-                                       const Function<deal_II_dimension> * const coefficient);
+void MatrixCreator::create_mass_matrix<> (const DoFHandler<deal_II_dimension>    &dof,
+                                         const Quadrature<deal_II_dimension>    &q,
+                                         SparseMatrix<double>     &matrix,
+                                         const Function<deal_II_dimension> * const coefficient);
 template
-void MatrixCreator::create_mass_matrix (const Mapping<deal_II_dimension>       &mapping,
-                                       const DoFHandler<deal_II_dimension>    &dof,
-                                       const Quadrature<deal_II_dimension>    &q,
-                                       SparseMatrix<double>     &matrix,
-                                       const Function<deal_II_dimension>      &rhs,
-                                       Vector<double>           &rhs_vector,
-                                       const Function<deal_II_dimension> * const coefficient);
+void MatrixCreator::create_mass_matrix<> (const Mapping<deal_II_dimension>       &mapping,
+                                         const DoFHandler<deal_II_dimension>    &dof,
+                                         const Quadrature<deal_II_dimension>    &q,
+                                         SparseMatrix<double>     &matrix,
+                                         const Function<deal_II_dimension>      &rhs,
+                                         Vector<double>           &rhs_vector,
+                                         const Function<deal_II_dimension> * const coefficient);
 template
-void MatrixCreator::create_mass_matrix (const DoFHandler<deal_II_dimension>    &dof,
-                                       const Quadrature<deal_II_dimension>    &q,
-                                       SparseMatrix<double>     &matrix,
-                                       const Function<deal_II_dimension>      &rhs,
-                                       Vector<double>           &rhs_vector,
-                                       const Function<deal_II_dimension> * const coefficient);
+void MatrixCreator::create_mass_matrix<> (const DoFHandler<deal_II_dimension>    &dof,
+                                         const Quadrature<deal_II_dimension>    &q,
+                                         SparseMatrix<double>     &matrix,
+                                         const Function<deal_II_dimension>      &rhs,
+                                         Vector<double>           &rhs_vector,
+                                         const Function<deal_II_dimension> * const coefficient);
 
 #if deal_II_dimension != 1
 template
 void
-MatrixCreator::create_boundary_mass_matrix (const Mapping<deal_II_dimension>        &mapping,
-                                           const DoFHandler<deal_II_dimension>     &dof,
-                                           const Quadrature<deal_II_dimension-1>   &q,
-                                           SparseMatrix<double>      &matrix,
-                                           const FunctionMap<deal_II_dimension>::type         &boundary_functions,
-                                           Vector<double>            &rhs_vector,
-                                           std::vector<unsigned int> &dof_to_boundary_mapping,
-                                           const Function<deal_II_dimension> * const a);
+MatrixCreator::create_boundary_mass_matrix<> (const Mapping<deal_II_dimension>        &mapping,
+                                             const DoFHandler<deal_II_dimension>     &dof,
+                                             const Quadrature<deal_II_dimension-1>   &q,
+                                             SparseMatrix<double>      &matrix,
+                                             const FunctionMap<deal_II_dimension>::type         &boundary_functions,
+                                             Vector<double>            &rhs_vector,
+                                             std::vector<unsigned int> &dof_to_boundary_mapping,
+                                             const Function<deal_II_dimension> * const a);
 #endif
 
 template
-void MatrixCreator::create_boundary_mass_matrix (const DoFHandler<deal_II_dimension>     &dof,
-                                                const Quadrature<deal_II_dimension-1>   &q,
-                                                SparseMatrix<double>      &matrix,
-                                                const FunctionMap<deal_II_dimension>::type &rhs,
-                                                Vector<double>            &rhs_vector,
-                                                std::vector<unsigned int> &dof_to_boundary_mapping,
-                                                const Function<deal_II_dimension> * const a);
+void MatrixCreator::create_boundary_mass_matrix<> (const DoFHandler<deal_II_dimension>     &dof,
+                                                  const Quadrature<deal_II_dimension-1>   &q,
+                                                  SparseMatrix<double>      &matrix,
+                                                  const FunctionMap<deal_II_dimension>::type &rhs,
+                                                  Vector<double>            &rhs_vector,
+                                                  std::vector<unsigned int> &dof_to_boundary_mapping,
+                                                  const Function<deal_II_dimension> * const a);
 template
-void MatrixCreator::create_laplace_matrix (const DoFHandler<deal_II_dimension>    &dof,
-                                          const Quadrature<deal_II_dimension>    &q,
-                                          SparseMatrix<double>     &matrix,
-                                          const Function<deal_II_dimension> * const coefficient);
+void MatrixCreator::create_laplace_matrix<> (const DoFHandler<deal_II_dimension>    &dof,
+                                            const Quadrature<deal_II_dimension>    &q,
+                                            SparseMatrix<double>     &matrix,
+                                            const Function<deal_II_dimension> * const coefficient);
 
 template
-void MatrixCreator::create_laplace_matrix (const Mapping<deal_II_dimension>       &mapping,
-                                          const DoFHandler<deal_II_dimension>    &dof,
-                                          const Quadrature<deal_II_dimension>    &q,
-                                          SparseMatrix<double>     &matrix,
-                                          const Function<deal_II_dimension> * const coefficient);
+void MatrixCreator::create_laplace_matrix<> (const Mapping<deal_II_dimension>       &mapping,
+                                            const DoFHandler<deal_II_dimension>    &dof,
+                                            const Quadrature<deal_II_dimension>    &q,
+                                            SparseMatrix<double>     &matrix,
+                                            const Function<deal_II_dimension> * const coefficient);
 template
-void MatrixCreator::create_laplace_matrix (const Mapping<deal_II_dimension>       &mapping,
-                                          const DoFHandler<deal_II_dimension>    &dof,
-                                          const Quadrature<deal_II_dimension>    &q,
-                                          SparseMatrix<double>     &matrix,
-                                          const Function<deal_II_dimension>      &rhs,
-                                          Vector<double>           &rhs_vector,
-                                          const Function<deal_II_dimension> * const coefficient);
+void MatrixCreator::create_laplace_matrix<> (const Mapping<deal_II_dimension>       &mapping,
+                                            const DoFHandler<deal_II_dimension>    &dof,
+                                            const Quadrature<deal_II_dimension>    &q,
+                                            SparseMatrix<double>     &matrix,
+                                            const Function<deal_II_dimension>      &rhs,
+                                            Vector<double>           &rhs_vector,
+                                            const Function<deal_II_dimension> * const coefficient);
 template
-void MatrixCreator::create_laplace_matrix (const DoFHandler<deal_II_dimension>    &dof,
-                                          const Quadrature<deal_II_dimension>    &q,
-                                          SparseMatrix<double>     &matrix,
-                                          const Function<deal_II_dimension>      &rhs,
-                                          Vector<double>           &rhs_vector,
-                                          const Function<deal_II_dimension> * const coefficient);
+void MatrixCreator::create_laplace_matrix<> (const DoFHandler<deal_II_dimension>    &dof,
+                                            const Quadrature<deal_II_dimension>    &q,
+                                            SparseMatrix<double>     &matrix,
+                                            const Function<deal_II_dimension>      &rhs,
+                                            Vector<double>           &rhs_vector,
+                                            const Function<deal_II_dimension> * const coefficient);

diff --git a/deal.II/deal.II/source/numerics/solution_transfer.cc b/deal.II/deal.II/source/numerics/solution_transfer.cc
index 210b0b3609f6bfef74a4a4a97ac181a3d57f130f..120a56b6b6e5e5f2b66194eb9eb567ae8be09c14 100644 (file)
--- a/deal.II/deal.II/source/numerics/solution_transfer.cc
+++ b/deal.II/deal.II/source/numerics/solution_transfer.cc
@@ -401,4 +401,4 @@ SolutionTransfer<dim, number>::Pointerstruct::memory_consumption () const
 template class SolutionTransfer<deal_II_dimension, float>;
 template class SolutionTransfer<deal_II_dimension, double>;
 
-/*----------------------------   solutiontransfer.cc     ----------------------*/
+/*----------------------------   solution_transfer.cc     ----------------------*/

diff --git a/deal.II/deal.II/source/numerics/vectors.cc b/deal.II/deal.II/source/numerics/vectors.cc
index cf522ea2bb5bd82d096bb7beb1b323dfea9973ba..b0228abe0642c1dddc63cb36bab5809d0610a17f 100644 (file)
--- a/deal.II/deal.II/source/numerics/vectors.cc
+++ b/deal.II/deal.II/source/numerics/vectors.cc
@@ -1460,298 +1460,298 @@ VectorTools::compute_mean_value (const DoFHandler<dim> &dof,
 
 // explicit instantiations
 template
-void VectorTools::interpolate (const Mapping<deal_II_dimension>&,
-                              const DoFHandler<deal_II_dimension>&,
-                              const Function<deal_II_dimension>&,
-                              Vector<double>&);
+void VectorTools::interpolate<> (const Mapping<deal_II_dimension>&,
+                                const DoFHandler<deal_II_dimension>&,
+                                const Function<deal_II_dimension>&,
+                                Vector<double>&);
 template
-void VectorTools::interpolate (const DoFHandler<deal_II_dimension>&,
-                              const Function<deal_II_dimension>&,
-                              Vector<double>&);
+void VectorTools::interpolate<> (const DoFHandler<deal_II_dimension>&,
+                                const Function<deal_II_dimension>&,
+                                Vector<double>&);
 template
-void VectorTools::interpolate (const Mapping<deal_II_dimension>&,
-                              const DoFHandler<deal_II_dimension>&,
-                              const Function<deal_II_dimension>&,
-                              Vector<float>&);
+void VectorTools::interpolate<> (const Mapping<deal_II_dimension>&,
+                                const DoFHandler<deal_II_dimension>&,
+                                const Function<deal_II_dimension>&,
+                                Vector<float>&);
 template
-void VectorTools::interpolate (const DoFHandler<deal_II_dimension>&,
-                              const Function<deal_II_dimension>&,
-                              Vector<float>&);
+void VectorTools::interpolate<> (const DoFHandler<deal_II_dimension>&,
+                                const Function<deal_II_dimension>&,
+                                Vector<float>&);
 template
-void VectorTools::interpolate (const Mapping<deal_II_dimension>&,
-                              const DoFHandler<deal_II_dimension>&,
-                              const Function<deal_II_dimension>&,
-                              BlockVector<double>&);
+void VectorTools::interpolate<> (const Mapping<deal_II_dimension>&,
+                                const DoFHandler<deal_II_dimension>&,
+                                const Function<deal_II_dimension>&,
+                                BlockVector<double>&);
 template
-void VectorTools::interpolate (const DoFHandler<deal_II_dimension>&,
-                              const Function<deal_II_dimension>&,
-                              BlockVector<double>&);
+void VectorTools::interpolate<> (const DoFHandler<deal_II_dimension>&,
+                                const Function<deal_II_dimension>&,
+                                BlockVector<double>&);
 template
-void VectorTools::interpolate (const Mapping<deal_II_dimension>&,
-                              const DoFHandler<deal_II_dimension>&,
-                              const Function<deal_II_dimension>&,
-                              BlockVector<float>&);
+void VectorTools::interpolate<> (const Mapping<deal_II_dimension>&,
+                                const DoFHandler<deal_II_dimension>&,
+                                const Function<deal_II_dimension>&,
+                                BlockVector<float>&);
 template
-void VectorTools::interpolate (const DoFHandler<deal_II_dimension>&,
-                              const Function<deal_II_dimension>&,
-                              BlockVector<float>&);
+void VectorTools::interpolate<> (const DoFHandler<deal_II_dimension>&,
+                                const Function<deal_II_dimension>&,
+                                BlockVector<float>&);
 
 template
-void VectorTools::interpolate(const DoFHandler<deal_II_dimension>&,
-                             const DoFHandler<deal_II_dimension>&,
-                             const FullMatrix<double>&,
-                             const Vector<double>&,
-                             Vector<double>&);
+void VectorTools::interpolate<>(const DoFHandler<deal_II_dimension>&,
+                               const DoFHandler<deal_II_dimension>&,
+                               const FullMatrix<double>&,
+                               const Vector<double>&,
+                               Vector<double>&);
 template
-void VectorTools::interpolate(const DoFHandler<deal_II_dimension>&,
-                             const DoFHandler<deal_II_dimension>&,
-                             const FullMatrix<double>&,
-                             const BlockVector<double>&,
-                             BlockVector<double>&);
+void VectorTools::interpolate<>(const DoFHandler<deal_II_dimension>&,
+                               const DoFHandler<deal_II_dimension>&,
+                               const FullMatrix<double>&,
+                               const BlockVector<double>&,
+                               BlockVector<double>&);
 
 template
-void VectorTools::project (const DoFHandler<deal_II_dimension>   &,
-                          const ConstraintMatrix                &,
-                          const Quadrature<deal_II_dimension>   &,
-                          const Function<deal_II_dimension>     &,
-                          Vector<double>                        &,
-                          const bool,
-                          const Quadrature<deal_II_dimension-1> &,
-                          const bool);
+void VectorTools::project<> (const DoFHandler<deal_II_dimension>   &,
+                            const ConstraintMatrix                &,
+                            const Quadrature<deal_II_dimension>   &,
+                            const Function<deal_II_dimension>     &,
+                            Vector<double>                        &,
+                            const bool,
+                            const Quadrature<deal_II_dimension-1> &,
+                            const bool);
 template
-void VectorTools::create_right_hand_side (const Mapping<deal_II_dimension>    &,
-                                         const DoFHandler<deal_II_dimension> &,
-                                         const Quadrature<deal_II_dimension> &,
-                                         const Function<deal_II_dimension>   &,
-                                         Vector<double>                      &);
+void VectorTools::create_right_hand_side<> (const Mapping<deal_II_dimension>    &,
+                                           const DoFHandler<deal_II_dimension> &,
+                                           const Quadrature<deal_II_dimension> &,
+                                           const Function<deal_II_dimension>   &,
+                                           Vector<double>                      &);
 template
-void VectorTools::create_right_hand_side (const DoFHandler<deal_II_dimension> &,
-                                         const Quadrature<deal_II_dimension> &,
-                                         const Function<deal_II_dimension>   &,
-                                         Vector<double>                      &);
+void VectorTools::create_right_hand_side<> (const DoFHandler<deal_II_dimension> &,
+                                           const Quadrature<deal_II_dimension> &,
+                                           const Function<deal_II_dimension>   &,
+                                           Vector<double>                      &);
 
 #if deal_II_dimension != 1
 template
 void
-VectorTools::create_boundary_right_hand_side (const Mapping<deal_II_dimension>    &,
-                                             const DoFHandler<deal_II_dimension> &,
-                                             const Quadrature<deal_II_dimension-1> &,
-                                             const Function<deal_II_dimension>   &,
-                                             Vector<double>                      &,
-                                             const std::set<unsigned char> &);
+VectorTools::create_boundary_right_hand_side<> (const Mapping<deal_II_dimension>    &,
+                                               const DoFHandler<deal_II_dimension> &,
+                                               const Quadrature<deal_II_dimension-1> &,
+                                               const Function<deal_II_dimension>   &,
+                                               Vector<double>                      &,
+                                               const std::set<unsigned char> &);
 #endif
 
 template
 void
-VectorTools::create_boundary_right_hand_side (const DoFHandler<deal_II_dimension> &,
-                                             const Quadrature<deal_II_dimension-1> &,
-                                             const Function<deal_II_dimension>   &,
-                                             Vector<double>                      &,
-                                             const std::set<unsigned char> &);
+VectorTools::create_boundary_right_hand_side<> (const DoFHandler<deal_II_dimension> &,
+                                               const Quadrature<deal_II_dimension-1> &,
+                                               const Function<deal_II_dimension>   &,
+                                               Vector<double>                      &,
+                                               const std::set<unsigned char> &);
 template
-void VectorTools::interpolate_boundary_values (const DoFHandler<deal_II_dimension> &,
-                                              const unsigned char,
-                                              const Function<deal_II_dimension>   &,
-                                              std::map<unsigned int,double>       &,
-                                              const std::vector<bool>    &);
+void VectorTools::interpolate_boundary_values<> (const DoFHandler<deal_II_dimension> &,
+                                                const unsigned char,
+                                                const Function<deal_II_dimension>   &,
+                                                std::map<unsigned int,double>       &,
+                                                const std::vector<bool>    &);
 template
-void VectorTools::integrate_difference (const Mapping<deal_II_dimension>    &,
-                                       const DoFHandler<deal_II_dimension> &,
-                                       const Vector<double>                &,
-                                       const Function<deal_II_dimension>   &,
-                                       Vector<float>                       &,
-                                       const Quadrature<deal_II_dimension> &,
-                                       const NormType                      &,
-                                       const Function<deal_II_dimension>   *);
+void VectorTools::integrate_difference<> (const Mapping<deal_II_dimension>    &,
+                                         const DoFHandler<deal_II_dimension> &,
+                                         const Vector<double>                &,
+                                         const Function<deal_II_dimension>   &,
+                                         Vector<float>                       &,
+                                         const Quadrature<deal_II_dimension> &,
+                                         const NormType                      &,
+                                         const Function<deal_II_dimension>   *);
 template
-void VectorTools::integrate_difference (const DoFHandler<deal_II_dimension> &,
-                                       const Vector<double>                &,
-                                       const Function<deal_II_dimension>   &,
-                                       Vector<float>                       &,
-                                       const Quadrature<deal_II_dimension> &,
-                                       const NormType                      &,
-                                       const Function<deal_II_dimension>   *);
+void VectorTools::integrate_difference<> (const DoFHandler<deal_II_dimension> &,
+                                         const Vector<double>                &,
+                                         const Function<deal_II_dimension>   &,
+                                         Vector<float>                       &,
+                                         const Quadrature<deal_II_dimension> &,
+                                         const NormType                      &,
+                                         const Function<deal_II_dimension>   *);
 template
-void VectorTools::integrate_difference (const Mapping<deal_II_dimension>    &,
-                                       const DoFHandler<deal_II_dimension> &,
-                                       const Vector<double>                &,
-                                       const Function<deal_II_dimension>   &,
-                                       Vector<double>                      &,
-                                       const Quadrature<deal_II_dimension> &,
-                                       const NormType                      &,
-                                       const Function<deal_II_dimension>   *);
+void VectorTools::integrate_difference<> (const Mapping<deal_II_dimension>    &,
+                                         const DoFHandler<deal_II_dimension> &,
+                                         const Vector<double>                &,
+                                         const Function<deal_II_dimension>   &,
+                                         Vector<double>                      &,
+                                         const Quadrature<deal_II_dimension> &,
+                                         const NormType                      &,
+                                         const Function<deal_II_dimension>   *);
 template
-void VectorTools::integrate_difference (const DoFHandler<deal_II_dimension> &,
-                                       const Vector<double>                &,
-                                       const Function<deal_II_dimension>   &,
-                                       Vector<double>                      &,
-                                       const Quadrature<deal_II_dimension> &,
-                                       const NormType                      &,
-                                       const Function<deal_II_dimension>   *);
+void VectorTools::integrate_difference<> (const DoFHandler<deal_II_dimension> &,
+                                         const Vector<double>                &,
+                                         const Function<deal_II_dimension>   &,
+                                         Vector<double>                      &,
+                                         const Quadrature<deal_II_dimension> &,
+                                         const NormType                      &,
+                                         const Function<deal_II_dimension>   *);
 template
-void VectorTools::integrate_difference (const Mapping<deal_II_dimension>    &,
-                                       const DoFHandler<deal_II_dimension> &,
-                                       const Vector<float>                 &,
-                                       const Function<deal_II_dimension>   &,
-                                       Vector<float>                       &,
-                                       const Quadrature<deal_II_dimension> &,
-                                       const NormType                      &,
-                                       const Function<deal_II_dimension>   *);
+void VectorTools::integrate_difference<> (const Mapping<deal_II_dimension>    &,
+                                         const DoFHandler<deal_II_dimension> &,
+                                         const Vector<float>                 &,
+                                         const Function<deal_II_dimension>   &,
+                                         Vector<float>                       &,
+                                         const Quadrature<deal_II_dimension> &,
+                                         const NormType                      &,
+                                         const Function<deal_II_dimension>   *);
 template
-void VectorTools::integrate_difference (const DoFHandler<deal_II_dimension> &,
-                                       const Vector<float>                 &,
-                                       const Function<deal_II_dimension>   &,
-                                       Vector<float>                       &,
-                                       const Quadrature<deal_II_dimension> &,
-                                       const NormType                      &,
-                                       const Function<deal_II_dimension>   *);
+void VectorTools::integrate_difference<> (const DoFHandler<deal_II_dimension> &,
+                                         const Vector<float>                 &,
+                                         const Function<deal_II_dimension>   &,
+                                         Vector<float>                       &,
+                                         const Quadrature<deal_II_dimension> &,
+                                         const NormType                      &,
+                                         const Function<deal_II_dimension>   *);
 template
-void VectorTools::integrate_difference (const Mapping<deal_II_dimension>    &,
-                                       const DoFHandler<deal_II_dimension> &,
-                                       const Vector<float>                 &,
-                                       const Function<deal_II_dimension>   &,
-                                       Vector<double>                      &,
-                                       const Quadrature<deal_II_dimension> &,
-                                       const NormType                      &,
-                                       const Function<deal_II_dimension>   *);
+void VectorTools::integrate_difference<> (const Mapping<deal_II_dimension>    &,
+                                         const DoFHandler<deal_II_dimension> &,
+                                         const Vector<float>                 &,
+                                         const Function<deal_II_dimension>   &,
+                                         Vector<double>                      &,
+                                         const Quadrature<deal_II_dimension> &,
+                                         const NormType                      &,
+                                         const Function<deal_II_dimension>   *);
 template
-void VectorTools::integrate_difference (const DoFHandler<deal_II_dimension> &,
-                                       const Vector<float>                 &,
-                                       const Function<deal_II_dimension>   &,
-                                       Vector<double>                      &,
-                                       const Quadrature<deal_II_dimension> &,
-                                       const NormType                      &,
-                                       const Function<deal_II_dimension>   *);
+void VectorTools::integrate_difference<> (const DoFHandler<deal_II_dimension> &,
+                                         const Vector<float>                 &,
+                                         const Function<deal_II_dimension>   &,
+                                         Vector<double>                      &,
+                                         const Quadrature<deal_II_dimension> &,
+                                         const NormType                      &,
+                                         const Function<deal_II_dimension>   *);
 template
-void VectorTools::integrate_difference (const Mapping<deal_II_dimension>    &,
-                                       const DoFHandler<deal_II_dimension> &,
-                                       const BlockVector<double>                &,
-                                       const Function<deal_II_dimension>   &,
-                                       Vector<float>                       &,
-                                       const Quadrature<deal_II_dimension> &,
-                                       const NormType                      &,
-                                       const Function<deal_II_dimension>   *);
+void VectorTools::integrate_difference<> (const Mapping<deal_II_dimension>    &,
+                                         const DoFHandler<deal_II_dimension> &,
+                                         const BlockVector<double>                &,
+                                         const Function<deal_II_dimension>   &,
+                                         Vector<float>                       &,
+                                         const Quadrature<deal_II_dimension> &,
+                                         const NormType                      &,
+                                         const Function<deal_II_dimension>   *);
 template
-void VectorTools::integrate_difference (const DoFHandler<deal_II_dimension> &,
-                                       const BlockVector<double>                &,
-                                       const Function<deal_II_dimension>   &,
-                                       Vector<float>                       &,
-                                       const Quadrature<deal_II_dimension> &,
-                                       const NormType                      &,
-                                       const Function<deal_II_dimension>   *);
+void VectorTools::integrate_difference<> (const DoFHandler<deal_II_dimension> &,
+                                         const BlockVector<double>                &,
+                                         const Function<deal_II_dimension>   &,
+                                         Vector<float>                       &,
+                                         const Quadrature<deal_II_dimension> &,
+                                         const NormType                      &,
+                                         const Function<deal_II_dimension>   *);
 template
-void VectorTools::integrate_difference (const Mapping<deal_II_dimension>    &,
-                                       const DoFHandler<deal_II_dimension> &,
-                                       const BlockVector<double>                &,
-                                       const Function<deal_II_dimension>   &,
-                                       Vector<double>                      &,
-                                       const Quadrature<deal_II_dimension> &,
-                                       const NormType                      &,
-                                       const Function<deal_II_dimension>   *);
+void VectorTools::integrate_difference<> (const Mapping<deal_II_dimension>    &,
+                                         const DoFHandler<deal_II_dimension> &,
+                                         const BlockVector<double>                &,
+                                         const Function<deal_II_dimension>   &,
+                                         Vector<double>                      &,
+                                         const Quadrature<deal_II_dimension> &,
+                                         const NormType                      &,
+                                         const Function<deal_II_dimension>   *);
 template
-void VectorTools::integrate_difference (const DoFHandler<deal_II_dimension> &,
-                                       const BlockVector<double>                &,
-                                       const Function<deal_II_dimension>   &,
-                                       Vector<double>                      &,
-                                       const Quadrature<deal_II_dimension> &,
-                                       const NormType                      &,
-                                       const Function<deal_II_dimension>   *);
+void VectorTools::integrate_difference<> (const DoFHandler<deal_II_dimension> &,
+                                         const BlockVector<double>                &,
+                                         const Function<deal_II_dimension>   &,
+                                         Vector<double>                      &,
+                                         const Quadrature<deal_II_dimension> &,
+                                         const NormType                      &,
+                                         const Function<deal_II_dimension>   *);
 template
-void VectorTools::integrate_difference (const Mapping<deal_II_dimension>    &,
-                                       const DoFHandler<deal_II_dimension> &,
-                                       const BlockVector<float>                 &,
-                                       const Function<deal_II_dimension>   &,
-                                       Vector<float>                       &,
-                                       const Quadrature<deal_II_dimension> &,
-                                       const NormType                      &,
-                                       const Function<deal_II_dimension>   *);
+void VectorTools::integrate_difference<> (const Mapping<deal_II_dimension>    &,
+                                         const DoFHandler<deal_II_dimension> &,
+                                         const BlockVector<float>                 &,
+                                         const Function<deal_II_dimension>   &,
+                                         Vector<float>                       &,
+                                         const Quadrature<deal_II_dimension> &,
+                                         const NormType                      &,
+                                         const Function<deal_II_dimension>   *);
 template
-void VectorTools::integrate_difference (const DoFHandler<deal_II_dimension> &,
-                                       const BlockVector<float>                 &,
-                                       const Function<deal_II_dimension>   &,
-                                       Vector<float>                       &,
-                                       const Quadrature<deal_II_dimension> &,
-                                       const NormType                      &,
-                                       const Function<deal_II_dimension>   *);
+void VectorTools::integrate_difference<> (const DoFHandler<deal_II_dimension> &,
+                                         const BlockVector<float>                 &,
+                                         const Function<deal_II_dimension>   &,
+                                         Vector<float>                       &,
+                                         const Quadrature<deal_II_dimension> &,
+                                         const NormType                      &,
+                                         const Function<deal_II_dimension>   *);
 template
-void VectorTools::integrate_difference (const Mapping<deal_II_dimension>    &,
-                                       const DoFHandler<deal_II_dimension> &,
-                                       const BlockVector<float>                 &,
-                                       const Function<deal_II_dimension>   &,
-                                       Vector<double>                      &,
-                                       const Quadrature<deal_II_dimension> &,
-                                       const NormType                      &,
-                                       const Function<deal_II_dimension>   *);
+void VectorTools::integrate_difference<> (const Mapping<deal_II_dimension>    &,
+                                         const DoFHandler<deal_II_dimension> &,
+                                         const BlockVector<float>                 &,
+                                         const Function<deal_II_dimension>   &,
+                                         Vector<double>                      &,
+                                         const Quadrature<deal_II_dimension> &,
+                                         const NormType                      &,
+                                         const Function<deal_II_dimension>   *);
 template
-void VectorTools::integrate_difference (const DoFHandler<deal_II_dimension> &,
-                                       const BlockVector<float>                 &,
-                                       const Function<deal_II_dimension>   &,
-                                       Vector<double>                      &,
-                                       const Quadrature<deal_II_dimension> &,
-                                       const NormType                      &,
-                                       const Function<deal_II_dimension>   *);
+void VectorTools::integrate_difference<> (const DoFHandler<deal_II_dimension> &,
+                                         const BlockVector<float>                 &,
+                                         const Function<deal_II_dimension>   &,
+                                         Vector<double>                      &,
+                                         const Quadrature<deal_II_dimension> &,
+                                         const NormType                      &,
+                                         const Function<deal_II_dimension>   *);
 #if deal_II_dimension != 1
 template
-void VectorTools::project_boundary_values (const Mapping<deal_II_dimension>     &,
-                                          const DoFHandler<deal_II_dimension>  &,
-                                          const FunctionMap<deal_II_dimension>::type &,
-                                          const Quadrature<deal_II_dimension-1>&,
-                                          std::map<unsigned int,double>        &);
+void VectorTools::project_boundary_values<> (const Mapping<deal_II_dimension>     &,
+                                            const DoFHandler<deal_II_dimension>  &,
+                                            const FunctionMap<deal_II_dimension>::type &,
+                                            const Quadrature<deal_II_dimension-1>&,
+                                            std::map<unsigned int,double>        &);
 #endif
 
 template
-void VectorTools::project_boundary_values (const DoFHandler<deal_II_dimension>  &,
-                                          const FunctionMap<deal_II_dimension>::type &,
-                                          const Quadrature<deal_II_dimension-1>&,
-                                          std::map<unsigned int,double>        &);
+void VectorTools::project_boundary_values<> (const DoFHandler<deal_II_dimension>  &,
+                                            const FunctionMap<deal_II_dimension>::type &,
+                                            const Quadrature<deal_II_dimension-1>&,
+                                            std::map<unsigned int,double>        &);
 
 template
-double VectorTools::compute_mean_value (const Mapping<deal_II_dimension>&,
-                                       const DoFHandler<deal_II_dimension>&,
-                                       const Quadrature<deal_II_dimension>&,
-                                       const Vector<double>&,
-                                       const unsigned int);
+double VectorTools::compute_mean_value<> (const Mapping<deal_II_dimension>&,
+                                         const DoFHandler<deal_II_dimension>&,
+                                         const Quadrature<deal_II_dimension>&,
+                                         const Vector<double>&,
+                                         const unsigned int);
 template
-double VectorTools::compute_mean_value (const DoFHandler<deal_II_dimension>&,
-                                       const Quadrature<deal_II_dimension>&,
-                                       const Vector<double>&,
-                                       const unsigned int);
+double VectorTools::compute_mean_value<> (const DoFHandler<deal_II_dimension>&,
+                                         const Quadrature<deal_II_dimension>&,
+                                         const Vector<double>&,
+                                         const unsigned int);
 
 template
-double VectorTools::compute_mean_value (const Mapping<deal_II_dimension>&,
-                                       const DoFHandler<deal_II_dimension>&,
-                                       const Quadrature<deal_II_dimension>&,
-                                       const BlockVector<double>&,
-                                       const unsigned int);
+double VectorTools::compute_mean_value<> (const Mapping<deal_II_dimension>&,
+                                         const DoFHandler<deal_II_dimension>&,
+                                         const Quadrature<deal_II_dimension>&,
+                                         const BlockVector<double>&,
+                                         const unsigned int);
 template
-double VectorTools::compute_mean_value (const DoFHandler<deal_II_dimension>&,
-                                       const Quadrature<deal_II_dimension>&,
-                                       const BlockVector<double>&,
-                                       const unsigned int);
+double VectorTools::compute_mean_value<> (const DoFHandler<deal_II_dimension>&,
+                                         const Quadrature<deal_II_dimension>&,
+                                         const BlockVector<double>&,
+                                         const unsigned int);
 
 template
-double VectorTools::compute_mean_value (const Mapping<deal_II_dimension>&,
-                                       const DoFHandler<deal_II_dimension>&,
-                                       const Quadrature<deal_II_dimension>&,
-                                       const Vector<float>&,
-                                       const unsigned int);
+double VectorTools::compute_mean_value<> (const Mapping<deal_II_dimension>&,
+                                         const DoFHandler<deal_II_dimension>&,
+                                         const Quadrature<deal_II_dimension>&,
+                                         const Vector<float>&,
+                                         const unsigned int);
 template
-double VectorTools::compute_mean_value (const DoFHandler<deal_II_dimension>&,
-                                       const Quadrature<deal_II_dimension>&,
-                                       const Vector<float>&,
-                                       const unsigned int);
+double VectorTools::compute_mean_value<> (const DoFHandler<deal_II_dimension>&,
+                                         const Quadrature<deal_II_dimension>&,
+                                         const Vector<float>&,
+                                         const unsigned int);
 
 template
-double VectorTools::compute_mean_value (const Mapping<deal_II_dimension>&,
-                                       const DoFHandler<deal_II_dimension>&,
-                                       const Quadrature<deal_II_dimension>&,
-                                       const BlockVector<float>&,
-                                       const unsigned int);
+double VectorTools::compute_mean_value<> (const Mapping<deal_II_dimension>&,
+                                         const DoFHandler<deal_II_dimension>&,
+                                         const Quadrature<deal_II_dimension>&,
+                                         const BlockVector<float>&,
+                                         const unsigned int);
 template
-double VectorTools::compute_mean_value (const DoFHandler<deal_II_dimension>&,
-                                       const Quadrature<deal_II_dimension>&,
-                                       const BlockVector<float>&,
-                                       const unsigned int);
+double VectorTools::compute_mean_value<> (const DoFHandler<deal_II_dimension>&,
+                                         const Quadrature<deal_II_dimension>&,
+                                         const BlockVector<float>&,
+                                         const unsigned int);
 
 
 
@@ -1759,20 +1759,20 @@ double VectorTools::compute_mean_value (const DoFHandler<deal_II_dimension>&,
 // and thus need no explicit instantiation
 #if deal_II_dimension > 1
 template
-void VectorTools::interpolate_boundary_values (const Mapping<deal_II_dimension>    &,
-                                              const DoFHandler<deal_II_dimension> &,
-                                              const unsigned char,
-                                              const Function<deal_II_dimension>   &,
-                                              std::map<unsigned int,double>       &,
-                                              const std::vector<bool>    &);
+void VectorTools::interpolate_boundary_values<> (const Mapping<deal_II_dimension>    &,
+                                                const DoFHandler<deal_II_dimension> &,
+                                                const unsigned char,
+                                                const Function<deal_II_dimension>   &,
+                                                std::map<unsigned int,double>       &,
+                                                const std::vector<bool>    &);
 template
-void VectorTools::project (const Mapping<deal_II_dimension>      &,
-                          const DoFHandler<deal_II_dimension>   &,
-                          const ConstraintMatrix                &,
-                          const Quadrature<deal_II_dimension>   &,
-                          const Function<deal_II_dimension>     &,
-                          Vector<double>                        &,
-                          const bool,
-                          const Quadrature<deal_II_dimension-1> &,
-                          const bool);
+void VectorTools::project<> (const Mapping<deal_II_dimension>      &,
+                            const DoFHandler<deal_II_dimension>   &,
+                            const ConstraintMatrix                &,
+                            const Quadrature<deal_II_dimension>   &,
+                            const Function<deal_II_dimension>     &,
+                            Vector<double>                        &,
+                            const bool,
+                            const Quadrature<deal_II_dimension-1> &,
+                            const bool);
 #endif

diff --git a/deal.II/doc/news/2002/c-3-3.html b/deal.II/doc/news/2002/c-3-3.html
index 4bbaba98a8ec15a884ff1ac983f76df2f73157d9..65704b91698d55728251690b6d93631c1f75f99d 100644 (file)
--- a/deal.II/doc/news/2002/c-3-3.html
+++ b/deal.II/doc/news/2002/c-3-3.html
@@ -33,6 +33,15 @@ contributor's names are abbreviated by WB (Wolfgang Bangerth), GK
 <h3>General</h3>
 
 <ol>
+  <li> <p> 
+       Fixed: Explicit specializations of member templates are now
+       conforming to the C++ standard. While most compilers accepted
+       the previous form, Sun's Forte compiler wants a strictly
+       conforming one.
+       <br>
+       (WB 2002/03/25)
+       </p>
+
   <li> <p> 
        Fixed: For gcc versions that used <code
        class="class">ostrstream</code> instead of <code

diff --git a/deal.II/lac/source/block_vector.cc b/deal.II/lac/source/block_vector.cc
index 0a5315a49919805341f302a395ca067212419911..3565c6c0a9f20b0e1852e5e006a18fc233a2697e 100644 (file)
--- a/deal.II/lac/source/block_vector.cc
+++ b/deal.II/lac/source/block_vector.cc
@@ -15,20 +15,20 @@
 
 // explicit instantiations
 template class BlockVector<double>;
-template BlockVector<double>& BlockVector<double>::operator=(
+template BlockVector<double>& BlockVector<double>::template operator=<>(
   const BlockVector<float>&);
-template void BlockVector<double>::reinit(const BlockVector<double>&, const bool);
-template void BlockVector<double>::reinit(const BlockVector<float>&, const bool);
-template void BlockVector<double>::equ(const double, const BlockVector<double>&);
-template void BlockVector<double>::equ(const double, const BlockVector<float>&);
+template void BlockVector<double>::reinit<>(const BlockVector<double>&, const bool);
+template void BlockVector<double>::reinit<>(const BlockVector<float>&, const bool);
+template void BlockVector<double>::equ<>(const double, const BlockVector<double>&);
+template void BlockVector<double>::equ<>(const double, const BlockVector<float>&);
 
 template class BlockVector<float>;
-template BlockVector<float>& BlockVector<float>::operator=(
+template BlockVector<float>& BlockVector<float>::template operator=<>(
   const BlockVector<double>&);
-template void BlockVector<float>::reinit(const BlockVector<double>&, const bool);
-template void BlockVector<float>::reinit(const BlockVector<float>&, const bool);
-template void BlockVector<float>::equ(const float, const BlockVector<double>&);
-template void BlockVector<float>::equ(const float, const BlockVector<float>&);
+template void BlockVector<float>::reinit<>(const BlockVector<double>&, const bool);
+template void BlockVector<float>::reinit<>(const BlockVector<float>&, const bool);
+template void BlockVector<float>::equ<>(const float, const BlockVector<double>&);
+template void BlockVector<float>::equ<>(const float, const BlockVector<float>&);
 
 namespace BlockVectorIterators
 {

diff --git a/deal.II/lac/source/full_matrix.double.cc b/deal.II/lac/source/full_matrix.double.cc
index 940b5a5f3aa56d5856f86a72fc48e9a2b48302f2..fbae87cb73d3f0a95d62519b4ad80cfabb93e51e 100644 (file)
--- a/deal.II/lac/source/full_matrix.double.cc
+++ b/deal.II/lac/source/full_matrix.double.cc
@@ -22,62 +22,62 @@ template class FullMatrix<TYPEMAT>;
 #define TYPEMAT2 double
 
 //template FullMatrix<TYPEMAT>& FullMatrix<TYPEMAT>::operator =(const FullMatrix<TYPEMAT2>&);
-template void FullMatrix<TYPEMAT>::fill (const FullMatrix<TYPEMAT2>&, const unsigned, const unsigned);
-template void FullMatrix<TYPEMAT>::add (const TYPEMAT, const FullMatrix<TYPEMAT2>&);
-template void FullMatrix<TYPEMAT>::Tadd (const TYPEMAT, const FullMatrix<TYPEMAT2>&);
-template void FullMatrix<TYPEMAT>::mmult (FullMatrix<TYPEMAT2>&, const FullMatrix<TYPEMAT2>&, const bool) const;
-template void FullMatrix<TYPEMAT>::Tmmult (FullMatrix<TYPEMAT2>&, const FullMatrix<TYPEMAT2>&, const bool) const;
-template void FullMatrix<TYPEMAT>::add_diag (const TYPEMAT, const FullMatrix<TYPEMAT2>&);
-template void FullMatrix<TYPEMAT>::invert (const FullMatrix<TYPEMAT2>&);
+template void FullMatrix<TYPEMAT>::fill<> (const FullMatrix<TYPEMAT2>&, const unsigned, const unsigned);
+template void FullMatrix<TYPEMAT>::add<> (const TYPEMAT, const FullMatrix<TYPEMAT2>&);
+template void FullMatrix<TYPEMAT>::Tadd<> (const TYPEMAT, const FullMatrix<TYPEMAT2>&);
+template void FullMatrix<TYPEMAT>::mmult<> (FullMatrix<TYPEMAT2>&, const FullMatrix<TYPEMAT2>&, const bool) const;
+template void FullMatrix<TYPEMAT>::Tmmult<> (FullMatrix<TYPEMAT2>&, const FullMatrix<TYPEMAT2>&, const bool) const;
+template void FullMatrix<TYPEMAT>::add_diag<> (const TYPEMAT, const FullMatrix<TYPEMAT2>&);
+template void FullMatrix<TYPEMAT>::invert<> (const FullMatrix<TYPEMAT2>&);
 
 
 #define TYPEVEC double
 #define TYPERES double
 
-template void FullMatrix<TYPEMAT>::fill_permutation (const FullMatrix<TYPEVEC>&,
-                                                    const std::vector<unsigned int>&,
-                                                    const std::vector<unsigned int>&);
-template void FullMatrix<TYPEMAT>::vmult(Vector<TYPEVEC>&, const Vector<TYPEVEC>&, const bool) const;
-template void FullMatrix<TYPEMAT>::Tvmult(Vector<TYPEVEC>&, const Vector<TYPEVEC>&, const bool) const;
-template double FullMatrix<TYPEMAT>::residual(Vector<TYPEVEC>&, const Vector<TYPEVEC>&, const Vector<TYPERES>&) const;
-template TYPEVEC FullMatrix<TYPEMAT>::matrix_norm_square (const Vector<TYPEVEC> &) const;
-template TYPEVEC FullMatrix<TYPEMAT>::matrix_scalar_product(const Vector<TYPEVEC>&, const Vector<TYPEVEC>&) const;
-template void FullMatrix<TYPEMAT>::forward(Vector<TYPEVEC>&, const Vector<TYPEVEC>&) const;
-template void FullMatrix<TYPEMAT>::backward(Vector<TYPEVEC>&, const Vector<TYPEVEC>&) const;
-template void FullMatrix<TYPEMAT>::householder(Vector<TYPEVEC>&);
-template double FullMatrix<TYPEMAT>::least_squares(Vector<TYPEVEC>&, Vector<TYPEVEC>&);
+template void FullMatrix<TYPEMAT>::fill_permutation<> (const FullMatrix<TYPEVEC>&,
+                                                      const std::vector<unsigned int>&,
+                                                      const std::vector<unsigned int>&);
+template void FullMatrix<TYPEMAT>::vmult<>(Vector<TYPEVEC>&, const Vector<TYPEVEC>&, const bool) const;
+template void FullMatrix<TYPEMAT>::Tvmult<>(Vector<TYPEVEC>&, const Vector<TYPEVEC>&, const bool) const;
+template double FullMatrix<TYPEMAT>::residual<>(Vector<TYPEVEC>&, const Vector<TYPEVEC>&, const Vector<TYPERES>&) const;
+template TYPEVEC FullMatrix<TYPEMAT>::matrix_norm_square<> (const Vector<TYPEVEC> &) const;
+template TYPEVEC FullMatrix<TYPEMAT>::matrix_scalar_product<>(const Vector<TYPEVEC>&, const Vector<TYPEVEC>&) const;
+template void FullMatrix<TYPEMAT>::forward<>(Vector<TYPEVEC>&, const Vector<TYPEVEC>&) const;
+template void FullMatrix<TYPEMAT>::backward<>(Vector<TYPEVEC>&, const Vector<TYPEVEC>&) const;
+template void FullMatrix<TYPEMAT>::householder<>(Vector<TYPEVEC>&);
+template double FullMatrix<TYPEMAT>::least_squares<>(Vector<TYPEVEC>&, Vector<TYPEVEC>&);
 
 template
-void FullMatrix<TYPEMAT>::precondition_Jacobi (Vector<TYPEVEC> &,
-                                              const Vector<TYPEVEC> &,
-                                              const TYPEMAT) const;
+void FullMatrix<TYPEMAT>::precondition_Jacobi<> (Vector<TYPEVEC> &,
+                                                const Vector<TYPEVEC> &,
+                                                const TYPEMAT) const;
 
 
 #undef TYPEVEC
 #define TYPEVEC float
 
-template void FullMatrix<TYPEMAT>::fill_permutation (const FullMatrix<TYPEVEC>&,
-                                                    const std::vector<unsigned int>&,
-                                                    const std::vector<unsigned int>&);
-template void FullMatrix<TYPEMAT>::vmult(Vector<TYPEVEC>&, const Vector<TYPEVEC>&, const bool) const;
-template void FullMatrix<TYPEMAT>::Tvmult(Vector<TYPEVEC>&, const Vector<TYPEVEC>&, const bool) const;
-template double FullMatrix<TYPEMAT>::residual(Vector<TYPEVEC>&, const Vector<TYPEVEC>&, const Vector<TYPERES>&) const;
-template TYPEVEC FullMatrix<TYPEMAT>::matrix_norm_square (const Vector<TYPEVEC> &) const;
-template TYPEVEC FullMatrix<TYPEMAT>::matrix_scalar_product(const Vector<TYPEVEC>&, const Vector<TYPEVEC>&) const;
-template void FullMatrix<TYPEMAT>::forward(Vector<TYPEVEC>&, const Vector<TYPEVEC>&) const;
-template void FullMatrix<TYPEMAT>::backward(Vector<TYPEVEC>&, const Vector<TYPEVEC>&) const;
-template void FullMatrix<TYPEMAT>::householder(Vector<TYPEVEC>&);
-template double FullMatrix<TYPEMAT>::least_squares(Vector<TYPEVEC>&, Vector<TYPEVEC>&);
+template void FullMatrix<TYPEMAT>::fill_permutation<> (const FullMatrix<TYPEVEC>&,
+                                                      const std::vector<unsigned int>&,
+                                                      const std::vector<unsigned int>&);
+template void FullMatrix<TYPEMAT>::vmult<>(Vector<TYPEVEC>&, const Vector<TYPEVEC>&, const bool) const;
+template void FullMatrix<TYPEMAT>::Tvmult<>(Vector<TYPEVEC>&, const Vector<TYPEVEC>&, const bool) const;
+template double FullMatrix<TYPEMAT>::residual<>(Vector<TYPEVEC>&, const Vector<TYPEVEC>&, const Vector<TYPERES>&) const;
+template TYPEVEC FullMatrix<TYPEMAT>::matrix_norm_square<> (const Vector<TYPEVEC> &) const;
+template TYPEVEC FullMatrix<TYPEMAT>::matrix_scalar_product<>(const Vector<TYPEVEC>&, const Vector<TYPEVEC>&) const;
+template void FullMatrix<TYPEMAT>::forward<>(Vector<TYPEVEC>&, const Vector<TYPEVEC>&) const;
+template void FullMatrix<TYPEMAT>::backward<>(Vector<TYPEVEC>&, const Vector<TYPEVEC>&) const;
+template void FullMatrix<TYPEMAT>::householder<>(Vector<TYPEVEC>&);
+template double FullMatrix<TYPEMAT>::least_squares<>(Vector<TYPEVEC>&, Vector<TYPEVEC>&);
 
 template
-void FullMatrix<TYPEMAT>::precondition_Jacobi (Vector<TYPEVEC> &,
-                                              const Vector<TYPEVEC> &,
-                                              const TYPEMAT) const;
+void FullMatrix<TYPEMAT>::precondition_Jacobi<> (Vector<TYPEVEC> &,
+                                                const Vector<TYPEVEC> &,
+                                                const TYPEMAT) const;
 
 #undef TYPERES
 #define TYPERES float
 
-template double FullMatrix<TYPEMAT>::residual(Vector<TYPEVEC>&, const Vector<TYPEVEC>&, const Vector<TYPERES>&) const;
+template double FullMatrix<TYPEMAT>::residual<>(Vector<TYPEVEC>&, const Vector<TYPEVEC>&, const Vector<TYPERES>&) const;
 
 // Experimental code
 

diff --git a/deal.II/lac/source/full_matrix.float.cc b/deal.II/lac/source/full_matrix.float.cc
index b8a2128031be287037209037999f5af2756bfe10..b33d53547849cb37afe00758fa63b749f35c4878 100644 (file)
--- a/deal.II/lac/source/full_matrix.float.cc
+++ b/deal.II/lac/source/full_matrix.float.cc
@@ -20,57 +20,57 @@ template class FullMatrix<TYPEMAT>;
 
 #define TYPEMAT2 float
 
-//template FullMatrix<TYPEMAT>& FullMatrix<TYPEMAT>::operator =(const FullMatrix<TYPEMAT2>&);
-template void FullMatrix<TYPEMAT>::fill (const FullMatrix<TYPEMAT2>&, const unsigned, const unsigned);
-template void FullMatrix<TYPEMAT>::add (const TYPEMAT, const FullMatrix<TYPEMAT2>&);
-template void FullMatrix<TYPEMAT>::Tadd (const TYPEMAT, const FullMatrix<TYPEMAT2>&);
-template void FullMatrix<TYPEMAT>::mmult (FullMatrix<TYPEMAT2>&, const FullMatrix<TYPEMAT2>&, const bool) const;
-template void FullMatrix<TYPEMAT>::Tmmult (FullMatrix<TYPEMAT2>&, const FullMatrix<TYPEMAT2>&, const bool) const;
-template void FullMatrix<TYPEMAT>::add_diag (const TYPEMAT, const FullMatrix<TYPEMAT2>&);
-template void FullMatrix<TYPEMAT>::invert (const FullMatrix<TYPEMAT2>&);
+//template FullMatrix<TYPEMAT>& FullMatrix<TYPEMAT>::operator =<>(const FullMatrix<TYPEMAT2>&);
+template void FullMatrix<TYPEMAT>::fill<> (const FullMatrix<TYPEMAT2>&, const unsigned, const unsigned);
+template void FullMatrix<TYPEMAT>::add<> (const TYPEMAT, const FullMatrix<TYPEMAT2>&);
+template void FullMatrix<TYPEMAT>::Tadd<> (const TYPEMAT, const FullMatrix<TYPEMAT2>&);
+template void FullMatrix<TYPEMAT>::mmult<> (FullMatrix<TYPEMAT2>&, const FullMatrix<TYPEMAT2>&, const bool) const;
+template void FullMatrix<TYPEMAT>::Tmmult<> (FullMatrix<TYPEMAT2>&, const FullMatrix<TYPEMAT2>&, const bool) const;
+template void FullMatrix<TYPEMAT>::add_diag<> (const TYPEMAT, const FullMatrix<TYPEMAT2>&);
+template void FullMatrix<TYPEMAT>::invert<> (const FullMatrix<TYPEMAT2>&);
 
 #define TYPEVEC double
 #define TYPERES double
 
-template void FullMatrix<TYPEMAT>::fill_permutation (const FullMatrix<TYPEVEC>&,
-                                                    const std::vector<unsigned int>&,
-                                                    const std::vector<unsigned int>&);
-template void FullMatrix<TYPEMAT>::vmult(Vector<TYPEVEC>&, const Vector<TYPEVEC>&, const bool) const;
-template void FullMatrix<TYPEMAT>::Tvmult(Vector<TYPEVEC>&, const Vector<TYPEVEC>&, const bool) const;
-template double FullMatrix<TYPEMAT>::residual(Vector<TYPEVEC>&, const Vector<TYPEVEC>&, const Vector<TYPERES>&) const;
-template TYPEVEC FullMatrix<TYPEMAT>::matrix_norm_square (const Vector<TYPEVEC> &) const;
-template TYPEVEC FullMatrix<TYPEMAT>::matrix_scalar_product(const Vector<TYPEVEC>&, const Vector<TYPEVEC>&) const;
-template void FullMatrix<TYPEMAT>::forward(Vector<TYPEVEC>&, const Vector<TYPEVEC>&) const;
-template void FullMatrix<TYPEMAT>::backward(Vector<TYPEVEC>&, const Vector<TYPEVEC>&) const;
-template void FullMatrix<TYPEMAT>::householder(Vector<TYPEVEC>&);
-template double FullMatrix<TYPEMAT>::least_squares(Vector<TYPEVEC>&, Vector<TYPEVEC>&);
+template void FullMatrix<TYPEMAT>::fill_permutation<> (const FullMatrix<TYPEVEC>&,
+                                                      const std::vector<unsigned int>&,
+                                                      const std::vector<unsigned int>&);
+template void FullMatrix<TYPEMAT>::vmult<>(Vector<TYPEVEC>&, const Vector<TYPEVEC>&, const bool) const;
+template void FullMatrix<TYPEMAT>::Tvmult<>(Vector<TYPEVEC>&, const Vector<TYPEVEC>&, const bool) const;
+template double FullMatrix<TYPEMAT>::residual<>(Vector<TYPEVEC>&, const Vector<TYPEVEC>&, const Vector<TYPERES>&) const;
+template TYPEVEC FullMatrix<TYPEMAT>::matrix_norm_square<> (const Vector<TYPEVEC> &) const;
+template TYPEVEC FullMatrix<TYPEMAT>::matrix_scalar_product<>(const Vector<TYPEVEC>&, const Vector<TYPEVEC>&) const;
+template void FullMatrix<TYPEMAT>::forward<>(Vector<TYPEVEC>&, const Vector<TYPEVEC>&) const;
+template void FullMatrix<TYPEMAT>::backward<>(Vector<TYPEVEC>&, const Vector<TYPEVEC>&) const;
+template void FullMatrix<TYPEMAT>::householder<>(Vector<TYPEVEC>&);
+template double FullMatrix<TYPEMAT>::least_squares<>(Vector<TYPEVEC>&, Vector<TYPEVEC>&);
 template
-void FullMatrix<TYPEMAT>::precondition_Jacobi (Vector<TYPEVEC> &,
-                                              const Vector<TYPEVEC> &,
-                                              const TYPEMAT) const;
+void FullMatrix<TYPEMAT>::precondition_Jacobi<> (Vector<TYPEVEC> &,
+                                                const Vector<TYPEVEC> &,
+                                                const TYPEMAT) const;
 
 #undef TYPEVEC
 #define TYPEVEC float
 
-template void FullMatrix<TYPEMAT>::fill_permutation (const FullMatrix<TYPEVEC>&,
-                                                    const std::vector<unsigned int>&,
-                                                    const std::vector<unsigned int>&);
-template void FullMatrix<TYPEMAT>::vmult(Vector<TYPEVEC>&, const Vector<TYPEVEC>&, const bool) const;
-template void FullMatrix<TYPEMAT>::Tvmult(Vector<TYPEVEC>&, const Vector<TYPEVEC>&, const bool) const;
-template double FullMatrix<TYPEMAT>::residual(Vector<TYPEVEC>&, const Vector<TYPEVEC>&, const Vector<TYPERES>&) const;
-template TYPEVEC FullMatrix<TYPEMAT>::matrix_norm_square (const Vector<TYPEVEC> &) const;
-template TYPEVEC FullMatrix<TYPEMAT>::matrix_scalar_product(const Vector<TYPEVEC>&, const Vector<TYPEVEC>&) const;
-template void FullMatrix<TYPEMAT>::forward(Vector<TYPEVEC>&, const Vector<TYPEVEC>&) const;
-template void FullMatrix<TYPEMAT>::backward(Vector<TYPEVEC>&, const Vector<TYPEVEC>&) const;
-template void FullMatrix<TYPEMAT>::householder(Vector<TYPEVEC>&);
-template double FullMatrix<TYPEMAT>::least_squares(Vector<TYPEVEC>&, Vector<TYPEVEC>&);
+template void FullMatrix<TYPEMAT>::fill_permutation<> (const FullMatrix<TYPEVEC>&,
+                                                      const std::vector<unsigned int>&,
+                                                      const std::vector<unsigned int>&);
+template void FullMatrix<TYPEMAT>::vmult<>(Vector<TYPEVEC>&, const Vector<TYPEVEC>&, const bool) const;
+template void FullMatrix<TYPEMAT>::Tvmult<>(Vector<TYPEVEC>&, const Vector<TYPEVEC>&, const bool) const;
+template double FullMatrix<TYPEMAT>::residual<>(Vector<TYPEVEC>&, const Vector<TYPEVEC>&, const Vector<TYPERES>&) const;
+template TYPEVEC FullMatrix<TYPEMAT>::matrix_norm_square<> (const Vector<TYPEVEC> &) const;
+template TYPEVEC FullMatrix<TYPEMAT>::matrix_scalar_product<>(const Vector<TYPEVEC>&, const Vector<TYPEVEC>&) const;
+template void FullMatrix<TYPEMAT>::forward<>(Vector<TYPEVEC>&, const Vector<TYPEVEC>&) const;
+template void FullMatrix<TYPEMAT>::backward<>(Vector<TYPEVEC>&, const Vector<TYPEVEC>&) const;
+template void FullMatrix<TYPEMAT>::householder<>(Vector<TYPEVEC>&);
+template double FullMatrix<TYPEMAT>::least_squares<>(Vector<TYPEVEC>&, Vector<TYPEVEC>&);
 template
-void FullMatrix<TYPEMAT>::precondition_Jacobi (Vector<TYPEVEC> &,
-                                              const Vector<TYPEVEC> &,
-                                              const TYPEMAT) const;
+void FullMatrix<TYPEMAT>::precondition_Jacobi<> (Vector<TYPEVEC> &,
+                                                const Vector<TYPEVEC> &,
+                                                const TYPEMAT) const;
 
 
 #undef TYPERES
 #define TYPERES float
 
-template double FullMatrix<TYPEMAT>::residual(Vector<TYPEVEC>&, const Vector<TYPEVEC>&, const Vector<TYPERES>&) const;
+template double FullMatrix<TYPEMAT>::residual<>(Vector<TYPEVEC>&, const Vector<TYPEVEC>&, const Vector<TYPERES>&) const;

diff --git a/deal.II/lac/source/precondition_block.cc b/deal.II/lac/source/precondition_block.cc
index 8c2d45f619eede1e5d1912d8f07ff43334e79f23..626a75b22db0ed7452e092298a6e696b6f9953c4 100644 (file)
--- a/deal.II/lac/source/precondition_block.cc
+++ b/deal.II/lac/source/precondition_block.cc
@@ -35,59 +35,59 @@ template class PreconditionBlock<double, double>;
 // explicit instantiations for "float" PreconditionBlock
 template class PreconditionBlockJacobi<float, float>;
 
-template void PreconditionBlockJacobi<float, float>::vmult
+template void PreconditionBlockJacobi<float, float>::vmult<>
 (Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockJacobi<float, float>::vmult
+template void PreconditionBlockJacobi<float, float>::vmult<>
 (Vector<double> &, const Vector<double> &) const;
-template void PreconditionBlockJacobi<float, float>::Tvmult
+template void PreconditionBlockJacobi<float, float>::Tvmult<>
 (Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockJacobi<float, float>::Tvmult
+template void PreconditionBlockJacobi<float, float>::Tvmult<>
 (Vector<double> &, const Vector<double> &) const;
-template void PreconditionBlockJacobi<float, float>::vmult_add
+template void PreconditionBlockJacobi<float, float>::vmult_add<>
 (Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockJacobi<float, float>::vmult_add
+template void PreconditionBlockJacobi<float, float>::vmult_add<>
 (Vector<double> &, const Vector<double> &) const;
-template void PreconditionBlockJacobi<float, float>::Tvmult_add
+template void PreconditionBlockJacobi<float, float>::Tvmult_add<>
 (Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockJacobi<float, float>::Tvmult_add
+template void PreconditionBlockJacobi<float, float>::Tvmult_add<>
 (Vector<double> &, const Vector<double> &) const;
 
 template class PreconditionBlockJacobi<double, float>;
 
-template void PreconditionBlockJacobi<double, float>::vmult
+template void PreconditionBlockJacobi<double, float>::vmult<>
 (Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockJacobi<double, float>::vmult
+template void PreconditionBlockJacobi<double, float>::vmult<>
 (Vector<double> &, const Vector<double> &) const;
-template void PreconditionBlockJacobi<double, float>::Tvmult
+template void PreconditionBlockJacobi<double, float>::Tvmult<>
 (Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockJacobi<double, float>::Tvmult
+template void PreconditionBlockJacobi<double, float>::Tvmult<>
 (Vector<double> &, const Vector<double> &) const;
-template void PreconditionBlockJacobi<double, float>::vmult_add
+template void PreconditionBlockJacobi<double, float>::vmult_add<>
 (Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockJacobi<double, float>::vmult_add
+template void PreconditionBlockJacobi<double, float>::vmult_add<>
 (Vector<double> &, const Vector<double> &) const;
-template void PreconditionBlockJacobi<double, float>::Tvmult_add
+template void PreconditionBlockJacobi<double, float>::Tvmult_add<>
 (Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockJacobi<double, float>::Tvmult_add
+template void PreconditionBlockJacobi<double, float>::Tvmult_add<>
 (Vector<double> &, const Vector<double> &) const;
 
 template class PreconditionBlockJacobi<double, double>;
 
-template void PreconditionBlockJacobi<double, double>::vmult
+template void PreconditionBlockJacobi<double, double>::vmult<>
 (Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockJacobi<double, double>::vmult
+template void PreconditionBlockJacobi<double, double>::vmult<>
 (Vector<double> &, const Vector<double> &) const;
-template void PreconditionBlockJacobi<double, double>::Tvmult
+template void PreconditionBlockJacobi<double, double>::Tvmult<>
 (Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockJacobi<double, double>::Tvmult
+template void PreconditionBlockJacobi<double, double>::Tvmult<>
 (Vector<double> &, const Vector<double> &) const;
-template void PreconditionBlockJacobi<double, double>::vmult_add
+template void PreconditionBlockJacobi<double, double>::vmult_add<>
 (Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockJacobi<double, double>::vmult_add
+template void PreconditionBlockJacobi<double, double>::vmult_add<>
 (Vector<double> &, const Vector<double> &) const;
-template void PreconditionBlockJacobi<double, double>::Tvmult_add
+template void PreconditionBlockJacobi<double, double>::Tvmult_add<>
 (Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockJacobi<double, double>::Tvmult_add
+template void PreconditionBlockJacobi<double, double>::Tvmult_add<>
 (Vector<double> &, const Vector<double> &) const;
 
 /*--------------------- PreconditionBlockGaussSeidel -----------------------*/
@@ -96,13 +96,13 @@ template void PreconditionBlockJacobi<double, double>::Tvmult_add
 // explicit instantiations for "float" PreconditionBlock
 template class PreconditionBlockSOR<float, float>;
 
-template void PreconditionBlockSOR<float, float>::vmult (
+template void PreconditionBlockSOR<float, float>::vmult<> (
   Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockSOR<float, float>::vmult (
+template void PreconditionBlockSOR<float, float>::vmult<> (
   Vector<double> &, const Vector<double> &) const;
-template void PreconditionBlockSOR<float, float>::Tvmult (
+template void PreconditionBlockSOR<float, float>::Tvmult<> (
   Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockSOR<float, float>::Tvmult (
+template void PreconditionBlockSOR<float, float>::Tvmult<> (
   Vector<double> &, const Vector<double> &) const;
 
 
@@ -115,24 +115,24 @@ template void PreconditionBlockSOR<float, float>::Tvmult (
 template class PreconditionBlockSOR<double, float>;
 
 
-template void PreconditionBlockSOR<double, float>::vmult (
+template void PreconditionBlockSOR<double, float>::vmult<> (
   Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockSOR<double, float>::vmult (
+template void PreconditionBlockSOR<double, float>::vmult<> (
   Vector<double> &, const Vector<double> &) const;
-template void PreconditionBlockSOR<double, float>::Tvmult (
+template void PreconditionBlockSOR<double, float>::Tvmult<> (
   Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockSOR<double, float>::Tvmult (
+template void PreconditionBlockSOR<double, float>::Tvmult<> (
   Vector<double> &, const Vector<double> &) const;
 
 template class PreconditionBlockSOR<double, double>;
 
-template void PreconditionBlockSOR<double, double>::vmult (
+template void PreconditionBlockSOR<double, double>::vmult<> (
   Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockSOR<double, double>::vmult (
+template void PreconditionBlockSOR<double, double>::vmult<> (
   Vector<double> &, const Vector<double> &) const;
-template void PreconditionBlockSOR<double, double>::Tvmult (
+template void PreconditionBlockSOR<double, double>::Tvmult<> (
   Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockSOR<double, double>::Tvmult (
+template void PreconditionBlockSOR<double, double>::Tvmult<> (
   Vector<double> &, const Vector<double> &) const;
 
 
@@ -142,13 +142,13 @@ template void PreconditionBlockSOR<double, double>::Tvmult (
 // explicit instantiations for "float" PreconditionBlock
 template class PreconditionBlockSSOR<float, float>;
 
-template void PreconditionBlockSSOR<float, float>::vmult (
+template void PreconditionBlockSSOR<float, float>::vmult<> (
   Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockSSOR<float, float>::vmult (
+template void PreconditionBlockSSOR<float, float>::vmult<> (
   Vector<double> &, const Vector<double> &) const;
-template void PreconditionBlockSSOR<float, float>::Tvmult (
+template void PreconditionBlockSSOR<float, float>::Tvmult<> (
   Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockSSOR<float, float>::Tvmult (
+template void PreconditionBlockSSOR<float, float>::Tvmult<> (
   Vector<double> &, const Vector<double> &) const;
 
 
@@ -161,22 +161,22 @@ template void PreconditionBlockSSOR<float, float>::Tvmult (
 template class PreconditionBlockSSOR<double, float>;
 
 
-template void PreconditionBlockSSOR<double, float>::vmult (
+template void PreconditionBlockSSOR<double, float>::vmult<> (
   Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockSSOR<double, float>::vmult (
+template void PreconditionBlockSSOR<double, float>::vmult<> (
   Vector<double> &, const Vector<double> &) const;
-template void PreconditionBlockSSOR<double, float>::Tvmult (
+template void PreconditionBlockSSOR<double, float>::Tvmult<> (
   Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockSSOR<double, float>::Tvmult (
+template void PreconditionBlockSSOR<double, float>::Tvmult<> (
   Vector<double> &, const Vector<double> &) const;
 
 template class PreconditionBlockSSOR<double, double>;
 
-template void PreconditionBlockSSOR<double, double>::vmult (
+template void PreconditionBlockSSOR<double, double>::vmult<> (
   Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockSSOR<double, double>::vmult (
+template void PreconditionBlockSSOR<double, double>::vmult<> (
   Vector<double> &, const Vector<double> &) const;
-template void PreconditionBlockSSOR<double, double>::Tvmult (
+template void PreconditionBlockSSOR<double, double>::Tvmult<> (
   Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockSSOR<double, double>::Tvmult (
+template void PreconditionBlockSSOR<double, double>::Tvmult<> (
   Vector<double> &, const Vector<double> &) const;

diff --git a/deal.II/lac/source/sparse_ilu.cc b/deal.II/lac/source/sparse_ilu.cc
index 896dd3dfae7b417ab510d577beaee9fdc8ed0cc8..130b5994763dfbf4da681b41811e36d8017d8fb6 100644 (file)
--- a/deal.II/lac/source/sparse_ilu.cc
+++ b/deal.II/lac/source/sparse_ilu.cc
@@ -17,22 +17,22 @@
 
 // explicit instantiations
 template class SparseILU<double>;
-template void SparseILU<double>::decompose (const SparseMatrix<double> &,
-                                           const double);
-template void SparseILU<double>::apply_decomposition (Vector<double> &,
-                                                     const Vector<double> &) const;
-template void SparseILU<double>::decompose (const SparseMatrix<float> &,
-                                           const double);
-template void SparseILU<double>::apply_decomposition (Vector<float> &,
-                                                     const Vector<float> &) const;
+template void SparseILU<double>::decompose<> (const SparseMatrix<double> &,
+                                             const double);
+template void SparseILU<double>::apply_decomposition<> (Vector<double> &,
+                                                       const Vector<double> &) const;
+template void SparseILU<double>::decompose<> (const SparseMatrix<float> &,
+                                             const double);
+template void SparseILU<double>::apply_decomposition<> (Vector<float> &,
+                                                       const Vector<float> &) const;
 
 
 template class SparseILU<float>;
-template void SparseILU<float>::decompose (const SparseMatrix<double> &,
-                                          const double);
-template void SparseILU<float>::apply_decomposition (Vector<double> &,
-                                                    const Vector<double> &) const;
-template void SparseILU<float>::decompose (const SparseMatrix<float> &,
-                                          const double);
-template void SparseILU<float>::apply_decomposition (Vector<float> &,
-                                                    const Vector<float> &) const;
+template void SparseILU<float>::decompose<> (const SparseMatrix<double> &,
+                                            const double);
+template void SparseILU<float>::apply_decomposition<> (Vector<double> &,
+                                                      const Vector<double> &) const;
+template void SparseILU<float>::decompose<> (const SparseMatrix<float> &,
+                                            const double);
+template void SparseILU<float>::apply_decomposition<> (Vector<float> &,
+                                                      const Vector<float> &) const;

diff --git a/deal.II/lac/source/sparse_vanka.cc b/deal.II/lac/source/sparse_vanka.cc
index c033ec140849f8527fae3c284025c5d931a8a8c4..f844a3d36fcd26194566ad45b89b0fe9bc9f6ad0 100644 (file)
--- a/deal.II/lac/source/sparse_vanka.cc
+++ b/deal.II/lac/source/sparse_vanka.cc
@@ -19,16 +19,16 @@
 template class SparseVanka<float>;
 template class SparseVanka<double>;
 
-template void SparseVanka<double>::vmult (Vector<float>       &dst,
-                                         const Vector<float> &src) const;
-template void SparseVanka<double>::vmult (Vector<double>       &dst,
-                                         const Vector<double> &src) const;
+template void SparseVanka<double>::vmult<> (Vector<float>       &dst,
+                                           const Vector<float> &src) const;
+template void SparseVanka<double>::vmult<> (Vector<double>       &dst,
+                                           const Vector<double> &src) const;
 
 
 template class SparseBlockVanka<float>;
 template class SparseBlockVanka<double>;
 
-template void SparseBlockVanka<double>::vmult (Vector<float>       &dst,
-                                              const Vector<float> &src) const;
-template void SparseBlockVanka<double>::vmult (Vector<double>       &dst,
-                                              const Vector<double> &src) const;
+template void SparseBlockVanka<double>::vmult<> (Vector<float>       &dst,
+                                                const Vector<float> &src) const;
+template void SparseBlockVanka<double>::vmult<> (Vector<double>       &dst,
+                                                const Vector<double> &src) const;

diff --git a/deal.II/lac/source/sparsity_pattern.cc b/deal.II/lac/source/sparsity_pattern.cc
index 5edda629201d0f2b0b5b657bdee80a6b025ebbe2..eca7bc5e7d9eebb60f7bc3b73fd53966ddd3997d 100644 (file)
--- a/deal.II/lac/source/sparsity_pattern.cc
+++ b/deal.II/lac/source/sparsity_pattern.cc
@@ -786,5 +786,5 @@ SparsityPattern::memory_consumption () const
 
 
 // explicit instantiations
-template void SparsityPattern::copy_from (const FullMatrix<float> &);
-template void SparsityPattern::copy_from (const FullMatrix<double> &);
+template void SparsityPattern::copy_from<> (const FullMatrix<float> &);
+template void SparsityPattern::copy_from<> (const FullMatrix<double> &);

diff --git a/deal.II/lac/source/vector.cc b/deal.II/lac/source/vector.cc
index 8fad192863f3c73fa428b305f426f3518be10d28..a119df8f17fcc447a2bf02e40b10dfc9acf34928 100644 (file)
--- a/deal.II/lac/source/vector.cc
+++ b/deal.II/lac/source/vector.cc
@@ -16,22 +16,22 @@
 
 // explicit instantiations
 template class Vector<double>;
-template Vector<double>& Vector<double>::operator=(const Vector<float>&);
-template double Vector<double>::operator*(const Vector<float>&) const;
-template double Vector<double>::operator*(const Vector<double>&) const;
-template void Vector<double>::reinit(const Vector<double>&, const bool);
-template void Vector<double>::reinit(const Vector<float>&, const bool);
-template void Vector<double>::equ(const double, const Vector<double>&);
-template void Vector<double>::equ(const double, const Vector<float>&);
+template Vector<double>& Vector<double>::template operator=<>(const Vector<float>&);
+template double Vector<double>::template operator*<>(const Vector<float>&) const;
+template double Vector<double>::template operator*<>(const Vector<double>&) const;
+template void Vector<double>::reinit<>(const Vector<double>&, const bool);
+template void Vector<double>::reinit<>(const Vector<float>&, const bool);
+template void Vector<double>::equ<>(const double, const Vector<double>&);
+template void Vector<double>::equ<>(const double, const Vector<float>&);
 
 template class Vector<float>;
-template Vector<float>& Vector<float>::operator=(const Vector<double>&);
-template float Vector<float>::operator*(const Vector<float>&) const;
-template float Vector<float>::operator*(const Vector<double>&) const;
-template void Vector<float>::reinit(const Vector<double>&, const bool);
-template void Vector<float>::reinit(const Vector<float>&, const bool);
-template void Vector<float>::equ(const float, const Vector<double>&);
-template void Vector<float>::equ(const float, const Vector<float>&);
+template Vector<float>& Vector<float>::template operator=<>(const Vector<double>&);
+template float Vector<float>::template operator*<>(const Vector<float>&) const;
+template float Vector<float>::template operator*<>(const Vector<double>&) const;
+template void Vector<float>::reinit<>(const Vector<double>&, const bool);
+template void Vector<float>::reinit<>(const Vector<float>&, const bool);
+template void Vector<float>::equ<>(const float, const Vector<double>&);
+template void Vector<float>::equ<>(const float, const Vector<float>&);
 
 // see the .h file for why these functions are disabled.
 // template Vector<float>::Vector (const Vector<double>& v);

diff --git a/deal.II/lac/source/vector.long_double.cc b/deal.II/lac/source/vector.long_double.cc
index 3567be18838de4b298a38e4965c1eee5e330c496..be7edf17b42410f9566535831894dcb8c2c904c5 100644 (file)
--- a/deal.II/lac/source/vector.long_double.cc
+++ b/deal.II/lac/source/vector.long_double.cc
@@ -17,27 +17,27 @@
 // explicit instantiations
 template class Vector<long double>;
 
-template Vector<long double>& Vector<long double>::operator=(const Vector<double>&);
-template Vector<long double>& Vector<long double>::operator=(const Vector<float>&);
-template long double Vector<long double>::operator * (const Vector<long double> &) const;
-template long double Vector<long double>::operator * (const Vector<double> &) const;
-template long double Vector<long double>::operator * (const Vector<float> &) const;
-template void Vector<long double>::reinit(const Vector<long double>&, const bool);
-template void Vector<long double>::reinit(const Vector<double>&, const bool);
-template void Vector<long double>::reinit(const Vector<float>&, const bool);
-template void Vector<long double>::equ(const long double, const Vector<long double>&);
-template void Vector<long double>::equ(const long double, const Vector<double>&);
-template void Vector<long double>::equ(const long double, const Vector<float>&);
+template Vector<long double>& Vector<long double>::template operator=<>(const Vector<double>&);
+template Vector<long double>& Vector<long double>::template operator=<>(const Vector<float>&);
+template long double Vector<long double>::template operator *<> (const Vector<long double> &) const;
+template long double Vector<long double>::template operator *<> (const Vector<double> &) const;
+template long double Vector<long double>::template operator *<> (const Vector<float> &) const;
+template void Vector<long double>::reinit<>(const Vector<long double>&, const bool);
+template void Vector<long double>::reinit<>(const Vector<double>&, const bool);
+template void Vector<long double>::reinit<>(const Vector<float>&, const bool);
+template void Vector<long double>::equ<>(const long double, const Vector<long double>&);
+template void Vector<long double>::equ<>(const long double, const Vector<double>&);
+template void Vector<long double>::equ<>(const long double, const Vector<float>&);
 
-template Vector<double>& Vector<double>::operator=(const Vector<long double>&);
-template double Vector<double>::operator * (const Vector<long double> &) const;
-template void Vector<double>::reinit(const Vector<long double>&, const bool);
-template void Vector<double>::equ(const double, const Vector<long double>&);
+template Vector<double>& Vector<double>::template operator=<>(const Vector<long double>&);
+template double Vector<double>::template operator *<> (const Vector<long double> &) const;
+template void Vector<double>::reinit<>(const Vector<long double>&, const bool);
+template void Vector<double>::equ<>(const double, const Vector<long double>&);
 
-template Vector<float>& Vector<float>::operator=(const Vector<long double>&);
-template float Vector<float>::operator * (const Vector<long double> &) const;
-template void Vector<float>::reinit(const Vector<long double>&, const bool);
-template void Vector<float>::equ(const float, const Vector<long double>&);
+template Vector<float>& Vector<float>::template operator=<>(const Vector<long double>&);
+template float Vector<float>::template operator *<> (const Vector<long double> &) const;
+template void Vector<float>::reinit<>(const Vector<long double>&, const bool);
+template void Vector<float>::equ<>(const float, const Vector<long double>&);
 
 // see the .h file for why these functions are disabled.
 // template Vector<float>::Vector (const Vector<double>& v);