Intels ICC compiler wants that in explicit instantiations of member templates the...

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

diff --git a/deal.II/deal.II/include/dofs/dof_levels.h b/deal.II/deal.II/include/dofs/dof_levels.h
index 21e96b8f0f170669ad37afc2c2aeb687af92220d..6189ef3daf1e938df0f0c01037f7dd919748645d 100644 (file)
--- a/deal.II/deal.II/include/dofs/dof_levels.h
+++ b/deal.II/deal.II/include/dofs/dof_levels.h
@@ -31,15 +31,17 @@ class DoFLevel
 {
   private:
                                     /**
-                                     * Make the constructor private to avoid
-                                     * that someone uses this class.
+                                     * Make the constructor private
+                                     * to avoid that someone uses
+                                     * this class.
                                      */
     DoFLevel ();
 };
 
 
 /**
- * Store the indices of the degrees of freedom which are located on the lines.
+ * Store the indices of the degrees of freedom which are located on
+ * the lines.
  *
  * @sect3{Information for all @ref{DoFLevel} classes}
  *
@@ -65,21 +67,24 @@ class DoFLevel
  * is then
  * to be understood as a block matrix.
  *
- * The storage format of the degrees of freedom indices (short: DoF indices) is
- * somewhat like a mirror of the data structures of the triangulation classes.
- * There is a hierarchy of @ref{DoFLevel}@p{<dim>} classes for the different dimensions
- * which have objects named @p{line_dofs}, @p{quad_dofs} and so on, in which the
- * indices of DoFs located on lines and quads, respectively, are stored. The
- * indices are stored levelwise. The layout in
- * these arrays is as follows: if for a selected finite element (use
- * @ref{DoFHandler}@p{::distribute_dofs()} to select a finite element) the number of
- * DoFs on each line (without those in the vertices) is @p{N}, then the length
- * of the @p{line_dofs} array is @p{N} times the number of lines on this level. The
- * DoF indices for the @p{i}th line are at the positions @p{N*i...(N+1)*i-1}.
+ * The storage format of the degrees of freedom indices (short: DoF
+ * indices) is somewhat like a mirror of the data structures of the
+ * triangulation classes.  There is a hierarchy of
+ * @ref{DoFLevel}@p{<dim>} classes for the different dimensions which
+ * have objects named @p{line_dofs}, @p{quad_dofs} and so on, in which
+ * the indices of DoFs located on lines and quads, respectively, are
+ * stored. The indices are stored levelwise. The layout in these
+ * arrays is as follows: if for a selected finite element (use
+ * @ref{DoFHandler}@p{::distribute_dofs()} to select a finite element)
+ * the number of DoFs on each line (without those in the vertices) is
+ * @p{N}, then the length of the @p{line_dofs} array is @p{N} times
+ * the number of lines on this level. The DoF indices for the @p{i}th
+ * line are at the positions @p{N*i...(N+1)*i-1}.
  *
- * The DoF indices for vertices are not stored this way, since they need
- * different treatment in multigrid environments. If no multigrid is used, the
- * indices are stored in the @p{vertex_dofs} array of the @ref{DoFHandler} class.
+ * The DoF indices for vertices are not stored this way, since they
+ * need different treatment in multigrid environments. If no multigrid
+ * is used, the indices are stored in the @p{vertex_dofs} array of the
+ * @ref{DoFHandler} class.
  *
  * @author Wolfgang Bangerth, 1998
  */
@@ -88,9 +93,10 @@ class DoFLevel<1>
 {
   public:
                                     /**
-                                     * Store the global indices of the degrees
-                                     * of freedom. See @ref{DoFLevel} for
-                                     * detailed information.
+                                     * Store the global indices of
+                                     * the degrees of freedom. See
+                                     * @ref{DoFLevel} for detailed
+                                     * information.
                                      */
     std::vector<unsigned int> line_dofs;
 
@@ -105,8 +111,8 @@ class DoFLevel<1>
 
 
 /**
- * Store the indices of the degrees of freedom which are located on quads.
- * See @ref{DoFLevel<1>} for more information.
+ * Store the indices of the degrees of freedom which are located on
+ * quads.  See @ref{DoFLevel<1>} for more information.
  *
  * @author Wolfgang Bangerth, 1998
  */
@@ -115,9 +121,10 @@ class DoFLevel<2> : public DoFLevel<1>
 {
   public:
                                     /**
-                                     * Store the global indices of the degrees
-                                     * of freedom. See @ref{DoFLevel} for
-                                     * detailed information.
+                                     * Store the global indices of
+                                     * the degrees of freedom. See
+                                     * @ref{DoFLevel} for detailed
+                                     * information.
                                      */
     std::vector<unsigned int> quad_dofs;
 
@@ -132,8 +139,8 @@ class DoFLevel<2> : public DoFLevel<1>
 
 
 /**
- * Store the indices of the degrees of freedom which are located on hexhedra.
- * See @ref{DoFLevel<1>} for more information.
+ * Store the indices of the degrees of freedom which are located on
+ * hexhedra.  See @ref{DoFLevel<1>} for more information.
  *
  * @author Wolfgang Bangerth, 1998
  */
@@ -142,9 +149,10 @@ class DoFLevel<3> : public DoFLevel<2>
 {
   public:
                                     /**
-                                     * Store the global indices of the degrees
-                                     * of freedom. See @ref{DoFLevel} for
-                                     * detailed information.
+                                     * Store the global indices of
+                                     * the degrees of freedom. See
+                                     * @ref{DoFLevel} for detailed
+                                     * information.
                                      */
     std::vector<unsigned int> hex_dofs;
 

diff --git a/deal.II/deal.II/source/dofs/dof_accessor.cc b/deal.II/deal.II/source/dofs/dof_accessor.cc
index 22aade46332a9b81fc1af9d0f8aa72fbfd03f543..3aea88fcf677c2467859b35c2aacbbaa05ab4a04 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,108 @@ 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<Vector<double>,double>
+(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<Vector<double>,double>
+(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<Vector<float>,float>
+(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<Vector<float>,float>
+(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<BlockVector<double>,double>
+(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<BlockVector<double>,double>
+(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<BlockVector<float>,float>
+(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<BlockVector<float>,float>
+(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<Vector<double>,double>
+(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<Vector<double>,double>
+(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<Vector<float>,float>
+(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<Vector<float>,float>
+(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<BlockVector<double>,double>
+(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<BlockVector<double>,double>
+(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<BlockVector<float>,float>
+(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<BlockVector<float>,float>
+(const Vector<float>  &,
+ BlockVector<float> &) const;
 
 
 #endif
@@ -837,44 +853,52 @@ 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<Vector<double>,double>
+(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<Vector<double>,double>
+(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<Vector<float>,float>
+(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<Vector<float>,float>
+(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<BlockVector<double>,double>
+(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<BlockVector<double>,double>
+(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<BlockVector<float>,float>
+(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<BlockVector<float>,float>
+(const Vector<float>  &,
+ BlockVector<float> &) const;
 
 
 #endif
@@ -884,52 +908,60 @@ 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<Vector<double>,double>
+(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<Vector<double>,double>
+(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<Vector<float>,float>
+(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<Vector<float>,float>
+(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<BlockVector<double>,double>
+(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<BlockVector<double>,double>
+(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<BlockVector<float>,float>
+(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<BlockVector<float>,float>
+(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 f5cc6b33fe70b160084107759cd53b57030678c6..e7b6b898efe426af8180c66d10deee709616c08b 100644 (file)
--- a/deal.II/deal.II/source/dofs/dof_constraints.cc
+++ b/deal.II/deal.II/source/dofs/dof_constraints.cc
@@ -1203,12 +1203,12 @@ ConstraintMatrix::memory_consumption () const
 
 #define vector_functions \
   template void ConstraintMatrix::condense<VectorType>(const VectorType &uncondensed,\
-                                            VectorType       &condensed) const;\
+                                                      VectorType       &condensed) const;\
   template void ConstraintMatrix::condense<VectorType>(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::set_zero<VectorType>(VectorType &vec) const;\
+  template void ConstraintMatrix::distribute<VectorType>(const VectorType &condensed,\
+                                                        VectorType       &uncondensed) const;\
+  template void ConstraintMatrix::distribute<VectorType>(VectorType &vec) const;
 
 
 

diff --git a/deal.II/deal.II/source/dofs/dof_renumbering.cc b/deal.II/deal.II/source/dofs/dof_renumbering.cc
index f14d7b6aa3feb5fecfef1363d7d6d9e82cbd641d..a1964b0b237f3cb68187ef56343fa5cfc8c8bfa8 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,60 @@ 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<deal_II_dimension>
+(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<deal_II_dimension>
+(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<deal_II_dimension>
+(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<deal_II_dimension>
+(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<deal_II_dimension>
+(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<deal_II_dimension>
+(DoFHandler<deal_II_dimension> &,
+ const std::vector<bool> &);
 
 template
-void DoFRenumbering::random<> (DoFHandler<deal_II_dimension> &);
+void DoFRenumbering::random<deal_II_dimension>
+(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<deal_II_dimension>
+(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<deal_II_dimension>
+(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<deal_II_dimension>
+(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 73684c83b34c83271e8d5890192f7a1ca9e87c2f..85c9d652a865543207246820edcc46ab4ad8af39 100644 (file)
--- a/deal.II/deal.II/source/dofs/dof_tools.cc
+++ b/deal.II/deal.II/source/dofs/dof_tools.cc
@@ -293,7 +293,7 @@ void DoFTools::make_boundary_sparsity_pattern (const DoFHandler<dim>& dof,
 
 
 
-template<int dim, class SparsityPattern>
+template <int dim, class SparsityPattern>
 void
 DoFTools::make_flux_sparsity_pattern (const DoFHandler<dim> &dof,
                                      SparsityPattern       &sparsity)
@@ -436,12 +436,12 @@ DoFTools::make_flux_sparsity_pattern (const DoFHandler<1> &dof,
 #endif
 
 
-template<int dim, class SparsityPattern>
+template <int dim, class SparsityPattern>
 void
 DoFTools::make_flux_sparsity_pattern (const DoFHandler<dim> &dof,
                                      SparsityPattern       &sparsity,
-                                     const FullMatrix<double>& int_mask,
-                                     const FullMatrix<double>& flux_mask)
+                                     const FullMatrix<double> &int_mask,
+                                     const FullMatrix<double> &flux_mask)
 {
   const unsigned int n_dofs = dof.n_dofs();
   const FiniteElement<dim>& fe = dof.get_fe();
@@ -1157,7 +1157,7 @@ DoFTools::extract_hanging_node_dofs (const DoFHandler<1> &dof_handler,
   Assert(selected_dofs.size() == dof_handler.n_dofs(),
         ExcDimensionMismatch(selected_dofs.size(), dof_handler.n_dofs()));
                                   // preset all values by false
-  fill_n (selected_dofs.begin(), dof_handler.n_dofs(), false);
+  std::fill_n (selected_dofs.begin(), dof_handler.n_dofs(), false);
 
                                   // there are no hanging nodes in 1d
 };
@@ -2342,183 +2342,284 @@ 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_sparsity_pattern<deal_II_dimension,SparsityPattern>
+(const DoFHandler<deal_II_dimension> &dof,
+ SparsityPattern    &sparsity);
+
+template void
+DoFTools::make_sparsity_pattern<deal_II_dimension,CompressedSparsityPattern>
+(const DoFHandler<deal_II_dimension> &dof,
+ CompressedSparsityPattern    &sparsity);
+
+template void
+DoFTools::make_sparsity_pattern<deal_II_dimension,BlockSparsityPattern>
+(const DoFHandler<deal_II_dimension> &dof,
+ BlockSparsityPattern                &sparsity);
+template void
+DoFTools::make_sparsity_pattern<deal_II_dimension,CompressedBlockSparsityPattern>
+(const DoFHandler<deal_II_dimension> &dof,
+ CompressedBlockSparsityPattern      &sparsity);
+
+
+template void 
+DoFTools::make_sparsity_pattern<deal_II_dimension,SparsityPattern>
+(const DoFHandler<deal_II_dimension> &dof,
+ const std::vector<std::vector<bool> > &mask,
+ SparsityPattern             &sparsity);
+
+template void 
+DoFTools::make_sparsity_pattern<deal_II_dimension,CompressedSparsityPattern>
+(const DoFHandler<deal_II_dimension> &dof,
+ const std::vector<std::vector<bool> > &mask,
+ CompressedSparsityPattern             &sparsity);
+
+template void 
+DoFTools::make_sparsity_pattern<deal_II_dimension,BlockSparsityPattern>
+(const DoFHandler<deal_II_dimension> &dof,
+ const std::vector<std::vector<bool> > &mask,
+ BlockSparsityPattern        &sparsity);
+
+template void 
+DoFTools::make_sparsity_pattern<deal_II_dimension,CompressedBlockSparsityPattern>
+(const DoFHandler<deal_II_dimension> &dof,
+ const std::vector<std::vector<bool> > &mask,
+ CompressedBlockSparsityPattern        &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_boundary_sparsity_pattern<deal_II_dimension,SparsityPattern>
+(const DoFHandler<deal_II_dimension>& dof,
+ const std::vector<unsigned int>  &,
+ SparsityPattern    &);
+template void
+DoFTools::make_boundary_sparsity_pattern<deal_II_dimension,CompressedSparsityPattern>
+(const DoFHandler<deal_II_dimension>& dof,
+ const std::vector<unsigned int>  &,
+ CompressedSparsityPattern    &);
 template void
-DoFTools::make_flux_sparsity_pattern<> (const DoFHandler<deal_II_dimension>& dof,
-                                       CompressedSparsityPattern    &sparsity);
+DoFTools::make_boundary_sparsity_pattern<deal_II_dimension,BlockSparsityPattern>
+(const DoFHandler<deal_II_dimension>& dof,
+ const std::vector<unsigned int>  &,
+ BlockSparsityPattern    &);
 template void
-DoFTools::make_flux_sparsity_pattern<> (const DoFHandler<deal_II_dimension>& dof,
-                                       CompressedSparsityPattern    &,
-                                       const FullMatrix<double>&,
-                                       const FullMatrix<double>&);
+DoFTools::make_boundary_sparsity_pattern<deal_II_dimension,CompressedBlockSparsityPattern>
+(const DoFHandler<deal_II_dimension>& dof,
+ const std::vector<unsigned int>  &,
+ CompressedBlockSparsityPattern    &);
+
 template void
-DoFTools::make_flux_sparsity_pattern<> (const DoFHandler<deal_II_dimension>& dof,
-                                       BlockSparsityPattern    &sparsity);
+DoFTools::make_boundary_sparsity_pattern<deal_II_dimension,SparsityPattern>
+(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_flux_sparsity_pattern<> (const DoFHandler<deal_II_dimension>& dof,
-                                       BlockSparsityPattern    &,
-                                       const FullMatrix<double>&,
-                                       const FullMatrix<double>&);
+DoFTools::make_boundary_sparsity_pattern<deal_II_dimension,CompressedSparsityPattern>
+(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_flux_sparsity_pattern<> (const DoFHandler<deal_II_dimension>& dof,
-                                       CompressedBlockSparsityPattern    &sparsity);
+DoFTools::make_boundary_sparsity_pattern<deal_II_dimension,BlockSparsityPattern>
+(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_flux_sparsity_pattern<> (const DoFHandler<deal_II_dimension>& dof,
-                                       CompressedBlockSparsityPattern    &,
-                                       const FullMatrix<double>&,
-                                       const FullMatrix<double>&);
+DoFTools::make_boundary_sparsity_pattern<deal_II_dimension,CompressedBlockSparsityPattern>
+(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);
 #endif
 
+#if deal_II_dimension == 1
 template void
-DoFTools::make_boundary_sparsity_pattern<> (const DoFHandler<deal_II_dimension>& dof,
-                                           const std::vector<unsigned int>  &,
-                                           SparsityPattern    &);
+DoFTools::make_boundary_sparsity_pattern<SparsityPattern>
+(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<CompressedSparsityPattern>
+(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<BlockSparsityPattern>
+(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<CompressedBlockSparsityPattern>
+(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<SparsityPattern>
+(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<CompressedSparsityPattern>
+(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<BlockSparsityPattern>
+(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<CompressedBlockSparsityPattern>
+(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);
+#endif
 
 
+#if deal_II_dimension > 1
 template void
-DoFTools::make_sparsity_pattern<> (const DoFHandler<deal_II_dimension> &dof,
-                                  SparsityPattern    &sparsity);
-
+DoFTools::make_flux_sparsity_pattern<deal_II_dimension,SparsityPattern>
+(const DoFHandler<deal_II_dimension>& dof,
+ SparsityPattern    &sparsity);
 template void
-DoFTools::make_sparsity_pattern<> (const DoFHandler<deal_II_dimension> &dof,
-                                  CompressedSparsityPattern    &sparsity);
-
+DoFTools::make_flux_sparsity_pattern<deal_II_dimension,CompressedSparsityPattern>
+(const DoFHandler<deal_II_dimension>& dof,
+ CompressedSparsityPattern    &sparsity);
 template void
-DoFTools::make_sparsity_pattern<> (const DoFHandler<deal_II_dimension> &dof,
-                                  BlockSparsityPattern                &sparsity);
+DoFTools::make_flux_sparsity_pattern<deal_II_dimension,BlockSparsityPattern>
+(const DoFHandler<deal_II_dimension>& dof,
+ BlockSparsityPattern    &sparsity);
 template void
-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);
-
-template void 
-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_flux_sparsity_pattern<deal_II_dimension,CompressedBlockSparsityPattern>
+(const DoFHandler<deal_II_dimension>& dof,
+ CompressedBlockSparsityPattern    &sparsity);
+#else
+template void
+DoFTools::make_flux_sparsity_pattern<SparsityPattern>
+(const DoFHandler<1>& dof,
+ SparsityPattern    &sparsity);
+template void
+DoFTools::make_flux_sparsity_pattern<CompressedSparsityPattern>
+(const DoFHandler<1>& dof,
+ CompressedSparsityPattern    &sparsity);
+template void
+DoFTools::make_flux_sparsity_pattern<BlockSparsityPattern>
+(const DoFHandler<1>& dof,
+ BlockSparsityPattern    &sparsity);
+template void
+DoFTools::make_flux_sparsity_pattern<CompressedBlockSparsityPattern>
+(const DoFHandler<1>& dof,
+ CompressedBlockSparsityPattern    &sparsity);
+#endif
 
-template void 
-DoFTools::make_sparsity_pattern<> (const DoFHandler<deal_II_dimension> &dof,
-                                  const std::vector<std::vector<bool> > &mask,
-                                  CompressedBlockSparsityPattern        &sparsity);
+#if deal_II_dimension > 1
+template void
+DoFTools::make_flux_sparsity_pattern<deal_II_dimension,SparsityPattern>
+(const DoFHandler<deal_II_dimension>& dof,
+ SparsityPattern    &,
+ const FullMatrix<double>&,
+ const FullMatrix<double>&);
+template void
+DoFTools::make_flux_sparsity_pattern<deal_II_dimension,CompressedSparsityPattern>
+(const DoFHandler<deal_II_dimension>& dof,
+ CompressedSparsityPattern    &,
+ const FullMatrix<double>&,
+ const FullMatrix<double>&);
+template void
+DoFTools::make_flux_sparsity_pattern<deal_II_dimension,BlockSparsityPattern>
+(const DoFHandler<deal_II_dimension>& dof,
+ BlockSparsityPattern    &,
+ const FullMatrix<double>&,
+ const FullMatrix<double>&);
+template void
+DoFTools::make_flux_sparsity_pattern<deal_II_dimension,CompressedBlockSparsityPattern>
+(const DoFHandler<deal_II_dimension>& dof,
+ CompressedBlockSparsityPattern    &,
+ const FullMatrix<double>&,
+ const FullMatrix<double>&);
+#endif
 
 
 
 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<deal_II_dimension>
+(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<deal_II_dimension>
+(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<deal_II_dimension>
+(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<deal_II_dimension>
+(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<deal_II_dimension>
+(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<deal_II_dimension>
+(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<deal_II_dimension>
+(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<deal_II_dimension>
+(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<deal_II_dimension>
+(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 +2627,16 @@ DoFTools::compute_intergrid_transfer_representation<> (const DoFHandler<deal_II_
 
 template
 void
-DoFTools::map_dof_to_boundary_indices<> (const DoFHandler<deal_II_dimension> &,
-                                        std::vector<unsigned int> &);
+DoFTools::map_dof_to_boundary_indices<deal_II_dimension>
+(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<deal_II_dimension>
+(const DoFHandler<deal_II_dimension> &,
+ const std::set<unsigned char> &,
+ std::vector<unsigned int> &);
 
 #endif 
 
@@ -2541,6 +2644,7 @@ 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<deal_II_dimension>
+(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 8074e15806a3b58756eb2387ab5c958011057db8..e02a3db5093e68fa49a5e6f01d05c8ed8fc4fb20 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,95 @@ 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<deal_II_dimension>
+(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<deal_II_dimension>
+(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<deal_II_dimension>
+(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<deal_II_dimension>
+(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<deal_II_dimension>
+(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<deal_II_dimension>
+(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<deal_II_dimension>
+(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<deal_II_dimension>
+(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<deal_II_dimension>
+(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<deal_II_dimension>
+(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<deal_II_dimension>
+(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<deal_II_dimension>
+(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<deal_II_dimension>
+(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<deal_II_dimension>
+(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<deal_II_dimension>
+(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<deal_II_dimension>
+(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 47709dccee6d6e3e43d6adfb921fd38658c8ac0c..a4c2edab9ccf03a059a5a655a7a5c62d72a8068a 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,112 @@ 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<Vector<double> >
+(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<Vector<float> >
+(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<Vector<float> >
+(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<BlockVector<double> >
+(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<BlockVector<float> >
+(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<BlockVector<float> >
+(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<Vector<double> >
+(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<Vector<float> >
+(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<Vector<float> >
+(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<BlockVector<double> >
+(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<BlockVector<float> >
+(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<Vector<double> >
+(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<Vector<float> >
+(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<BlockVector<double> >
+(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<Vector<double> >
+(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<Vector<float> >
+(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<BlockVector<double> >
+(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<BlockVector<float> >
+(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<Vector<double> >
+(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<Vector<float> >
+(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<BlockVector<double> >
+(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<Vector<double> >
+(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<Vector<float> >
+(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<BlockVector<double> >
+(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 fa7813c8da5f03177e094c1b31e777c581cfc549..6c08421476aeca7be8b75e9fe729456ff07c5db7 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,29 @@ 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<Tensor<1,deal_II_dimension> > (
   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<Point<deal_II_dimension> > (
   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<Tensor<1,deal_II_dimension> > (
   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<Point<deal_II_dimension> > (
   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 01d908122ffb3f7c348691ffefdeb9c6d912e456..4fa0fbf3ec69a08c4755ea84ad6e79bab195f4c0 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,29 @@ 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<Tensor<1,deal_II_dimension> > (
   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<Point<deal_II_dimension> > (
   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<Tensor<1,deal_II_dimension> > (
   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<Point<deal_II_dimension> > (
   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 1ac36b52ad34cb056646852d61f303d242b934dd..8b6334ecd75b9213ceab3a474e3f696450d06119 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,19 @@ 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<deal_II_dimension> (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<deal_II_dimension> (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<deal_II_dimension> (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 69290cc098c6f28f5f80e5a3e640c1666c78007c..d353603b12607d5f518e496a8e4ad2a07badfb03 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,21 @@ 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<deal_II_dimension>
+(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<deal_II_dimension>
+(const Triangulation<deal_II_dimension> &,
+ std::ostream &,
+ const Mapping<deal_II_dimension> *);
+template void GridOut::write_eps<deal_II_dimension>
+(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<deal_II_dimension>
+(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 14c369f3b87031be2619cab1e7aaa517d910e440..9956ea00d2e9695bd4a8920c36ee955a67c0d549 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,54 @@ GridRefinement::refine_and_coarsen_optimize (Triangulation<dim>   &tria,
 
 // explicit instantiations
 template void GridRefinement
-::refine<> (Triangulation<deal_II_dimension> &, const Vector<float> &, const double);
+::refine<deal_II_dimension> (Triangulation<deal_II_dimension> &,
+                            const Vector<float> &,
+                            const double);
 
 template void GridRefinement
-::refine<> (Triangulation<deal_II_dimension> &, const Vector<double> &, const double);
+::refine<deal_II_dimension> (Triangulation<deal_II_dimension> &,
+                            const Vector<double> &,
+                            const double);
 
 template void GridRefinement
-::coarsen<> (Triangulation<deal_II_dimension> &, const Vector<float> &, const double);
+::coarsen<deal_II_dimension> (Triangulation<deal_II_dimension> &,
+                             const Vector<float> &,
+                             const double);
 
 template void GridRefinement
-::coarsen<> (Triangulation<deal_II_dimension> &, const Vector<double> &, const double);
+::coarsen<deal_II_dimension> (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);
+::refine_and_coarsen_fixed_number<deal_II_dimension> (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);
+::refine_and_coarsen_fixed_number<deal_II_dimension> (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,
-                                      const double         top_fraction,
-                                      const double         bottom_fraction);
+::refine_and_coarsen_fixed_fraction<deal_II_dimension> (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);
+::refine_and_coarsen_fixed_fraction<deal_II_dimension> (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_optimize<deal_II_dimension> (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<deal_II_dimension> (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 b109843468f33825ecef2ad172a360207608650e..cae5e0725626325cbad5d1e9595c695e293cc409 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 d50e6cd6fc06beaaab403394abf476084a30ade4..d8ee977a568aa95cd080c9ed849e6f47658203cc 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<deal_II_dimension> (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 f1886de104849fa06945bb465cd2311e574a8cb1..1781bb1176380e0ceb82daa36addb9cbc20dcb27 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,88 +403,88 @@ MGTools::reinit_vector (const MGDoFHandler<dim>& mg_dof,
 
 // explicit instantiations
 template void
-MGTools::make_sparsity_pattern<> (const MGDoFHandler<deal_II_dimension> &,
+MGTools::make_sparsity_pattern<deal_II_dimension> (const MGDoFHandler<deal_II_dimension> &,
                                  SparsityPattern &,
                                  const unsigned int);
 
 template void
-MGTools::make_flux_sparsity_pattern<> (const MGDoFHandler<deal_II_dimension> &,
+MGTools::make_flux_sparsity_pattern<deal_II_dimension> (const MGDoFHandler<deal_II_dimension> &,
                                       SparsityPattern &,
                                       const unsigned int);
 
 template void
-MGTools::make_flux_sparsity_pattern_edge<> (const MGDoFHandler<deal_II_dimension> &,
+MGTools::make_flux_sparsity_pattern_edge<deal_II_dimension> (const MGDoFHandler<deal_II_dimension> &,
                                            SparsityPattern &,
                                            const unsigned int);
 
 template void
-MGTools::make_sparsity_pattern<> (const MGDoFHandler<deal_II_dimension> &,
+MGTools::make_sparsity_pattern<deal_II_dimension> (const MGDoFHandler<deal_II_dimension> &,
                                  CompressedSparsityPattern &,
                                  const unsigned int);
 
 template void
-MGTools::make_flux_sparsity_pattern<> (const MGDoFHandler<deal_II_dimension> &,
+MGTools::make_flux_sparsity_pattern<deal_II_dimension> (const MGDoFHandler<deal_II_dimension> &,
                                       CompressedSparsityPattern &,
                                       const unsigned int);
 
 template void
-MGTools::make_flux_sparsity_pattern_edge<> (const MGDoFHandler<deal_II_dimension> &,
+MGTools::make_flux_sparsity_pattern_edge<deal_II_dimension> (const MGDoFHandler<deal_II_dimension> &,
                                            CompressedSparsityPattern &,
                                            const unsigned int);
 
 template void
-MGTools::make_sparsity_pattern<> (const MGDoFHandler<deal_II_dimension> &,
+MGTools::make_sparsity_pattern<deal_II_dimension> (const MGDoFHandler<deal_II_dimension> &,
                                  BlockSparsityPattern &,
                                  const unsigned int);
 template void
-MGTools::make_flux_sparsity_pattern<> (const MGDoFHandler<deal_II_dimension> &,
+MGTools::make_flux_sparsity_pattern<deal_II_dimension> (const MGDoFHandler<deal_II_dimension> &,
                                       BlockSparsityPattern &,
                                       const unsigned int);
 
 template void
-MGTools::make_flux_sparsity_pattern_edge<> (const MGDoFHandler<deal_II_dimension> &,
+MGTools::make_flux_sparsity_pattern_edge<deal_II_dimension> (const MGDoFHandler<deal_II_dimension> &,
                                            BlockSparsityPattern &,
                                            const unsigned int);
 
 template void
-MGTools::make_sparsity_pattern<> (const MGDoFHandler<deal_II_dimension> &,
+MGTools::make_sparsity_pattern<deal_II_dimension> (const MGDoFHandler<deal_II_dimension> &,
                                  CompressedBlockSparsityPattern &,
                                  const unsigned int);
 
 template void
-MGTools::make_flux_sparsity_pattern<> (const MGDoFHandler<deal_II_dimension> &,
+MGTools::make_flux_sparsity_pattern<deal_II_dimension> (const MGDoFHandler<deal_II_dimension> &,
                                       CompressedBlockSparsityPattern &,
                                       const unsigned int);
 
 template void
-MGTools::make_flux_sparsity_pattern_edge<> (const MGDoFHandler<deal_II_dimension> &,
+MGTools::make_flux_sparsity_pattern_edge<deal_II_dimension> (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> &,
+MGTools::make_flux_sparsity_pattern<deal_II_dimension> (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> &,
+MGTools::make_flux_sparsity_pattern<deal_II_dimension> (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> &,
+MGTools::make_flux_sparsity_pattern<deal_II_dimension> (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> &,
+MGTools::make_flux_sparsity_pattern<deal_II_dimension> (const MGDoFHandler<deal_II_dimension> &,
                                       CompressedBlockSparsityPattern &,
                                       const unsigned int,
                                       const FullMatrix<double>&,
@@ -492,63 +492,63 @@ MGTools::make_flux_sparsity_pattern<> (const MGDoFHandler<deal_II_dimension> &,
 
 #endif
 
-template void MGTools::reinit_vector<> (const MGDoFHandler<deal_II_dimension>&,
+template void MGTools::reinit_vector<deal_II_dimension> (const MGDoFHandler<deal_II_dimension>&,
                                        MGLevelObject<Vector<double> >&);
-template void MGTools::reinit_vector<> (const MGDoFHandler<deal_II_dimension>&,
+template void MGTools::reinit_vector<deal_II_dimension> (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<deal_II_dimension> (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<deal_II_dimension>(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<deal_II_dimension>(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<deal_II_dimension> (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<deal_II_dimension>(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<deal_II_dimension>(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<deal_II_dimension> (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<deal_II_dimension>(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<deal_II_dimension>(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<deal_II_dimension> (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<deal_II_dimension>(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<deal_II_dimension>(const MGDoFHandler<deal_II_dimension>&,
 //                                     BlockVector<double>&,
 //                                     const MGLevelObject<Vector<float> >&);
 
-template void MGTools::count_dofs_per_component<> (const MGDoFHandler<deal_II_dimension>&,
+template void MGTools::count_dofs_per_component<deal_II_dimension> (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 d0b822535d49b1282375411eb044b40f5453d0c0..827b0b16729d5133504e26e9422c5e455cd3ece0 100644 (file)
--- a/deal.II/deal.II/source/multigrid/mg_smoother.cc
+++ b/deal.II/deal.II/source/multigrid/mg_smoother.cc
@@ -138,19 +138,19 @@ template MGSmootherContinuous::MGSmootherContinuous (const MGDoFHandler<deal_II_
 #endif
 
 template
-void MGSmootherContinuous::set_zero_interior_boundary<> (const unsigned int,
+void MGSmootherContinuous::set_zero_interior_boundary<Vector<double> > (const unsigned int,
                                                         Vector<double>&) const;
 
 template
-void MGSmootherContinuous::set_zero_interior_boundary<> (const unsigned int,
+void MGSmootherContinuous::set_zero_interior_boundary<Vector<float> > (const unsigned int,
                                                         Vector<float>&) const;
 
 template
-void MGSmootherContinuous::set_zero_interior_boundary<> (const unsigned int,
+void MGSmootherContinuous::set_zero_interior_boundary<BlockVector<double> > (const unsigned int,
                                                         BlockVector<double>&) const;
 
 template
-void MGSmootherContinuous::set_zero_interior_boundary<> (const unsigned int,
+void MGSmootherContinuous::set_zero_interior_boundary<BlockVector<float> > (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 f7781ad8706a07108fafb1be0f73b175999d68ae..0314ee90b962e195750d6db67bab98c70733e556 100644 (file)
--- a/deal.II/deal.II/source/multigrid/multigrid.cc
+++ b/deal.II/deal.II/source/multigrid/multigrid.cc
@@ -333,12 +333,15 @@ 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<deal_II_dimension>
+(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<deal_II_dimension>
+(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<deal_II_dimension>
+(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 790e31e676e60ea8112895278d3fd0a965f35edd..0838dd1cd3f9a909f76084e9b482f3501cfbfb4b 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,52 @@ 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<Vector<double> > (
   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<BlockVector<double> > (
   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<Vector<double> > (
   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<BlockVector<double> > (
   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<Vector<double> > (
   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<BlockVector<double> > (
   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<Vector<double> > (
   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<BlockVector<double> > (
   const BlockVector<double> &vec,
   const std::string    &name,
   const DataVectorType  type);
@@ -693,22 +701,26 @@ 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<Vector<double> > (
   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<BlockVector<double> > (
   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<Vector<double> > (
   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<BlockVector<double> > (
   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 9803737990bbe1fbc750c7fe0500648e3feff3b1..ba1b5f0a0b52b19750e2a6d0908baf4ed2b41997 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,9 @@ 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<double> (const Vector<double> &vec,
+                        const std::string    &name);
+template void DataOutStack<deal_II_dimension>::
+add_data_vector<float> (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 3467d67424482a51d387292efb46fc5c0d8a934c..72b8c8dbeff74c91a0f19f780cd5eddb81252b00 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,35 @@ 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<deal_II_dimension>
+(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<deal_II_dimension>
+(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<deal_II_dimension>
+(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<deal_II_dimension>
+(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 cc75cd980e8beea2c34c4e65687748bfad787f0c..1003659a59710c1096ed663e357c24c7faf08f38 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<float> (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<float> (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<double> (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<double> (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 307da1e91c45499e69db9578b1af5d45bb4035ef..df2171766f7cca84864be5fc5f6834b14a612b07 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<double> (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<float> (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 5a72b0dfd819e612ef1af96cdb4f8c72eb2dbbbc..0d56e2c90096e53b1e0b8a0799690c5e768c988c 100644 (file)
--- a/deal.II/deal.II/source/numerics/matrices.cc
+++ b/deal.II/deal.II/source/numerics/matrices.cc
@@ -1228,77 +1228,87 @@ 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<deal_II_dimension>
+(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<deal_II_dimension>
+(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<deal_II_dimension>
+(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<deal_II_dimension>
+(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<deal_II_dimension>
+(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<deal_II_dimension>
+(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<deal_II_dimension>
+(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<deal_II_dimension>
+(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<deal_II_dimension>
+(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<deal_II_dimension>
+(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/vectors.cc b/deal.II/deal.II/source/numerics/vectors.cc
index b0228abe0642c1dddc63cb36bab5809d0610a17f..0d7a2ae07d2b9ddf39bd64bbbab82c8b58d81984 100644 (file)
--- a/deal.II/deal.II/source/numerics/vectors.cc
+++ b/deal.II/deal.II/source/numerics/vectors.cc
@@ -1460,298 +1460,340 @@ 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<deal_II_dimension>
+(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<deal_II_dimension>
+(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<deal_II_dimension>
+(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<deal_II_dimension>
+(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<deal_II_dimension>
+(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<deal_II_dimension>
+(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<deal_II_dimension>
+(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<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 DoFHandler<deal_II_dimension>&,
-                               const FullMatrix<double>&,
-                               const Vector<double>&,
-                               Vector<double>&);
+void VectorTools::interpolate<deal_II_dimension>
+(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<deal_II_dimension>
+(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<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);
 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<deal_II_dimension>
+(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<deal_II_dimension>
+(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<deal_II_dimension>
+(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<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> &);
 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<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::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<deal_II_dimension>
+
+(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<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 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<deal_II_dimension>
+(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<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 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<deal_II_dimension>
+(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<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 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<deal_II_dimension>
+(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<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 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<deal_II_dimension>
+(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<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 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<deal_II_dimension>
+(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<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 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<deal_II_dimension>
+(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<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 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<deal_II_dimension>
+(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<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>   *);
 #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<deal_II_dimension>
+(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<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>        &);
 
 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<deal_II_dimension>
+(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<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 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<deal_II_dimension>
+(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<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 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<deal_II_dimension>
+(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<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 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<deal_II_dimension>
+(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<deal_II_dimension>
+(const DoFHandler<deal_II_dimension>&,
+ const Quadrature<deal_II_dimension>&,
+ const BlockVector<float>&,
+ const unsigned int);
 
 
 
@@ -1759,20 +1801,22 @@ 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<deal_II_dimension>
+(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<deal_II_dimension>
+(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/lac/include/lac/block_vector.h b/deal.II/lac/include/lac/block_vector.h
index fe42c8c2fd4e1ffbcc85d248e5f072b4c708b832..448fb4963e475e995adf1a491229d450e320f1aa 100644 (file)
--- a/deal.II/lac/include/lac/block_vector.h
+++ b/deal.II/lac/include/lac/block_vector.h
@@ -854,7 +854,7 @@ class BlockVector
                                      */
     template<typename Number2>
     BlockVector<Number> &
-    operator= (const BlockVector< Number2>& V);
+    operator= (const BlockVector<Number2>& V);
     
                                     /**
                                      * $U = U * V$: scalar product.

diff --git a/deal.II/lac/include/lac/sparse_matrix.2.templates b/deal.II/lac/include/lac/sparse_matrix.2.templates
index e1b053c4fcd264e3d4f3b62f9c4aa30ea2445412..a68e1bea80cdc9f08d9fa28fbcaa0e44a2f49b05 100644 (file)
--- a/deal.II/lac/include/lac/sparse_matrix.2.templates
+++ b/deal.II/lac/include/lac/sparse_matrix.2.templates
@@ -18,55 +18,63 @@
 // TYPEMAT and TYPE2 are defined in sparsematrix?.cc
 
 template SparseMatrix<TYPEMAT> &
-SparseMatrix<TYPEMAT>::copy_from<> (const SparseMatrix<TYPE2> &);
+SparseMatrix<TYPEMAT>::copy_from<TYPE2> (const SparseMatrix<TYPE2> &);
 
 template 
-void SparseMatrix<TYPEMAT>::copy_from<> (const FullMatrix<TYPE2> &);
-
-template void SparseMatrix<TYPEMAT>::add_scaled<> (const TYPEMAT,
-                                                  const SparseMatrix<TYPE2> &);
-
-template void SparseMatrix<TYPEMAT>::vmult<> (Vector<TYPE2> &,
-                                             const Vector<TYPE2> &) const;
-template void SparseMatrix<TYPEMAT>::Tvmult<> (Vector<TYPE2> &,
-                                              const Vector<TYPE2> &) const;
-template void SparseMatrix<TYPEMAT>::vmult_add<> (Vector<TYPE2> &,
-                                                 const Vector<TYPE2> &) const;
-template void SparseMatrix<TYPEMAT>::Tvmult_add<> (Vector<TYPE2> &,
+void SparseMatrix<TYPEMAT>::copy_from<TYPE2> (const FullMatrix<TYPE2> &);
+
+template void SparseMatrix<TYPEMAT>::add_scaled<TYPE2> (const TYPEMAT,
+                                                       const SparseMatrix<TYPE2> &);
+
+template void SparseMatrix<TYPEMAT>::vmult<TYPE2> (Vector<TYPE2> &,
                                                   const Vector<TYPE2> &) const;
+template void SparseMatrix<TYPEMAT>::Tvmult<TYPE2> (Vector<TYPE2> &,
+                                                   const Vector<TYPE2> &) const;
+template void SparseMatrix<TYPEMAT>::vmult_add<TYPE2> (Vector<TYPE2> &,
+                                                      const Vector<TYPE2> &) const;
+template void SparseMatrix<TYPEMAT>::Tvmult_add<TYPE2> (Vector<TYPE2> &,
+                                                       const Vector<TYPE2> &) const;
 
 template TYPE2
-SparseMatrix<TYPEMAT>::matrix_norm_square<> (const Vector<TYPE2> &) const;
+SparseMatrix<TYPEMAT>::matrix_norm_square<TYPE2> (const Vector<TYPE2> &) const;
 
 template TYPE2
-SparseMatrix<TYPEMAT>::matrix_scalar_product<> (const Vector<TYPE2> &,
-                                               const Vector<TYPE2> &) const;
+SparseMatrix<TYPEMAT>::matrix_scalar_product<TYPE2> (const Vector<TYPE2> &,
+                                                    const Vector<TYPE2> &) const;
 
-template TYPE2 SparseMatrix<TYPEMAT>::residual<> (Vector<TYPE2> &,
-                                                 const Vector<TYPE2> &,
-                                                 const Vector<TYPE2> &) const;
+template TYPE2 SparseMatrix<TYPEMAT>::residual<TYPE2> (Vector<TYPE2> &,
+                                                      const Vector<TYPE2> &,
+                                                      const Vector<TYPE2> &) const;
 
-template void SparseMatrix<TYPEMAT>::precondition_SSOR<> (Vector<TYPE2> &,
-                                                         const Vector<TYPE2> &,
-                                                         const TYPEMAT) const;
+template void SparseMatrix<TYPEMAT>::precondition_SSOR<TYPE2> (Vector<TYPE2> &,
+                                                              const Vector<TYPE2> &,
+                                                              const TYPEMAT) const;
 
-template void SparseMatrix<TYPEMAT>::precondition_SOR<> (Vector<TYPE2> &,
-                                                        const Vector<TYPE2> &,
-                                                        const TYPEMAT) const;
+template void SparseMatrix<TYPEMAT>::precondition_SOR<TYPE2> (Vector<TYPE2> &,
+                                                             const Vector<TYPE2> &,
+                                                             const TYPEMAT) const;
 
-template void SparseMatrix<TYPEMAT>::precondition_TSOR<> (Vector<TYPE2> &,
+template void SparseMatrix<TYPEMAT>::precondition_TSOR<TYPE2> (Vector<TYPE2> &,
                                                          const Vector<TYPE2> &,
                                                          const TYPEMAT) const;
 
-template void SparseMatrix<TYPEMAT>::precondition_Jacobi<> (Vector<TYPE2> &,
+template void SparseMatrix<TYPEMAT>::precondition_Jacobi<TYPE2> (Vector<TYPE2> &,
                                                            const Vector<TYPE2> &,
                                                            const TYPEMAT) const;
 
-template void SparseMatrix<TYPEMAT>::SOR<> (Vector<TYPE2> &, const TYPEMAT) const;
-template void SparseMatrix<TYPEMAT>::TSOR<> (Vector<TYPE2> &, const TYPEMAT) const;
-template void SparseMatrix<TYPEMAT>::SSOR<> (Vector<TYPE2> &, const TYPEMAT) const;
-template void SparseMatrix<TYPEMAT>::SOR_step<> (Vector<TYPE2> &, const Vector<TYPE2> &, const TYPEMAT) const;
-template void SparseMatrix<TYPEMAT>::TSOR_step<> (Vector<TYPE2> &, const Vector<TYPE2> &, const TYPEMAT) const;
-template void SparseMatrix<TYPEMAT>::SSOR_step<> (Vector<TYPE2> &, const Vector<TYPE2> &, const TYPEMAT) const;
+template void SparseMatrix<TYPEMAT>::SOR<TYPE2> (Vector<TYPE2> &,
+                                                const TYPEMAT) const;
+template void SparseMatrix<TYPEMAT>::TSOR<TYPE2> (Vector<TYPE2> &,
+                                                 const TYPEMAT) const;
+template void SparseMatrix<TYPEMAT>::SSOR<TYPE2> (Vector<TYPE2> &,
+                                                 const TYPEMAT) const;
+template void SparseMatrix<TYPEMAT>::SOR_step<TYPE2> (Vector<TYPE2> &, const Vector<TYPE2> &,
+                                                     const TYPEMAT) const;
+template void SparseMatrix<TYPEMAT>::TSOR_step<TYPE2> (Vector<TYPE2> &,
+                                                      const Vector<TYPE2> &,
+                                                      const TYPEMAT) const;
+template void SparseMatrix<TYPEMAT>::SSOR_step<TYPE2> (Vector<TYPE2> &,
+                                                      const Vector<TYPE2> &, 
+                                                      const TYPEMAT) const;
 
 

diff --git a/deal.II/lac/source/block_vector.cc b/deal.II/lac/source/block_vector.cc
index 7cfb9143dd7f19f8504f44b58229e0702951415f..9af154837cd81ea44e921413dba0488de7dcd6cb 100644 (file)
--- a/deal.II/lac/source/block_vector.cc
+++ b/deal.II/lac/source/block_vector.cc
@@ -15,20 +15,28 @@
 
 // explicit instantiations
 template class BlockVector<double>;
-template BlockVector<double>& BlockVector<double>::DEAL_II_MEMBER_OP_TEMPLATE_INST operator=<>(
+template BlockVector<double>& BlockVector<double>::DEAL_II_MEMBER_OP_TEMPLATE_INST operator=<float>(
   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<double>(const BlockVector<double>&,
+                                                 const bool);
+template void BlockVector<double>::reinit<float>(const BlockVector<float>&,
+                                                const bool);
+template void BlockVector<double>::equ<double>(const double,
+                                              const BlockVector<double>&);
+template void BlockVector<double>::equ<float>(const double,
+                                             const BlockVector<float>&);
 
 template class BlockVector<float>;
-template BlockVector<float>& BlockVector<float>::DEAL_II_MEMBER_OP_TEMPLATE_INST operator=<>(
+template BlockVector<float>& BlockVector<float>::DEAL_II_MEMBER_OP_TEMPLATE_INST operator=<double>(
   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<double>(const BlockVector<double>&,
+                                                const bool);
+template void BlockVector<float>::reinit<float>(const BlockVector<float>&,
+                                               const bool);
+template void BlockVector<float>::equ<double>(const float,
+                                             const BlockVector<double>&);
+template void BlockVector<float>::equ<float>(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 fbae87cb73d3f0a95d62519b4ad80cfabb93e51e..1b215de1c26cf3e9f147c5ac3b349cc616dc924c 100644 (file)
--- a/deal.II/lac/source/full_matrix.double.cc
+++ b/deal.II/lac/source/full_matrix.double.cc
@@ -22,33 +22,43 @@ 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<TYPEMAT2> (const FullMatrix<TYPEMAT2>&, const unsigned, const unsigned);
+template void FullMatrix<TYPEMAT>::add<TYPEMAT2> (const TYPEMAT, const FullMatrix<TYPEMAT2>&);
+template void FullMatrix<TYPEMAT>::Tadd<TYPEMAT2> (const TYPEMAT, const FullMatrix<TYPEMAT2>&);
+template void FullMatrix<TYPEMAT>::mmult<TYPEMAT2> (FullMatrix<TYPEMAT2>&, const FullMatrix<TYPEMAT2>&, const bool) const;
+template void FullMatrix<TYPEMAT>::Tmmult<TYPEMAT2> (FullMatrix<TYPEMAT2>&, const FullMatrix<TYPEMAT2>&, const bool) const;
+template void FullMatrix<TYPEMAT>::add_diag<TYPEMAT2> (const TYPEMAT, const FullMatrix<TYPEMAT2>&);
+template void FullMatrix<TYPEMAT>::invert<TYPEMAT2> (const FullMatrix<TYPEMAT2>&);
 
 
 #define TYPEVEC double
 #define TYPERES double
 
-template void FullMatrix<TYPEMAT>::fill_permutation<> (const FullMatrix<TYPEVEC>&,
+template void FullMatrix<TYPEMAT>::fill_permutation<TYPEVEC> (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>::vmult<TYPEVEC>(Vector<TYPEVEC>&,
+                                          const Vector<TYPEVEC>&,
+                                          const bool) const;
+template void FullMatrix<TYPEMAT>::Tvmult<TYPEVEC>(Vector<TYPEVEC>&,
+                                           const Vector<TYPEVEC>&,
+
+                                           const bool) const;
+template double FullMatrix<TYPEMAT>::residual<TYPEVEC>(Vector<TYPEVEC>&, const Vector<TYPEVEC>&,
+                                               const Vector<TYPERES>&) const;
+template TYPEVEC FullMatrix<TYPEMAT>::matrix_norm_square<TYPEVEC> (const Vector<TYPEVEC> &) const;
+template TYPEVEC FullMatrix<TYPEMAT>::matrix_scalar_product<TYPEVEC>(const Vector<TYPEVEC>&,
+                                                             const Vector<TYPEVEC>&) const;
+template void FullMatrix<TYPEMAT>::forward<TYPEVEC>(Vector<TYPEVEC>&,
+                                            const Vector<TYPEVEC>&) const;
+template void FullMatrix<TYPEMAT>::backward<TYPEVEC>(Vector<TYPEVEC>&,
+                                             const Vector<TYPEVEC>&) const;
+template void FullMatrix<TYPEMAT>::householder<TYPEVEC>(Vector<TYPEVEC>&);
+template double FullMatrix<TYPEMAT>::least_squares<TYPEVEC>(Vector<TYPEVEC>&,
+                                                    Vector<TYPEVEC>&);
 
 template
-void FullMatrix<TYPEMAT>::precondition_Jacobi<> (Vector<TYPEVEC> &,
+void FullMatrix<TYPEMAT>::precondition_Jacobi<TYPEVEC> (Vector<TYPEVEC> &,
                                                 const Vector<TYPEVEC> &,
                                                 const TYPEMAT) const;
 
@@ -56,28 +66,43 @@ void FullMatrix<TYPEMAT>::precondition_Jacobi<> (Vector<TYPEVEC> &,
 #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<TYPEVEC> (const FullMatrix<TYPEVEC>&,
+                                                             const std::vector<unsigned int>&,
+                                                             const std::vector<unsigned int>&);
+template void FullMatrix<TYPEMAT>::vmult<TYPEVEC>(Vector<TYPEVEC>&,
+                                                 const Vector<TYPEVEC>&,
+                                                 const bool) const;
+template void FullMatrix<TYPEMAT>::Tvmult<TYPEVEC>(Vector<TYPEVEC>&,
+                                                  const Vector<TYPEVEC>&,
+                                                  const bool) const;
+template double FullMatrix<TYPEMAT>::residual<TYPEVEC>(Vector<TYPEVEC>&,
+                                                      const Vector<TYPEVEC>&,
+                                                      const Vector<TYPERES>&) const;
+template TYPEVEC FullMatrix<TYPEMAT>::matrix_norm_square<TYPEVEC> (const Vector<TYPEVEC> &) const;
+template TYPEVEC FullMatrix<TYPEMAT>::matrix_scalar_product<TYPEVEC>(const Vector<TYPEVEC>&,
+                                                                    const Vector<TYPEVEC>&) const;
+template void FullMatrix<TYPEMAT>::forward<TYPEVEC>(Vector<TYPEVEC>&,
+                                                   const Vector<TYPEVEC>&) const;
+template void FullMatrix<TYPEMAT>::backward<TYPEVEC>(Vector<TYPEVEC>&,
+                                                    const Vector<TYPEVEC>&) const;
+template void FullMatrix<TYPEMAT>::householder<TYPEVEC>(Vector<TYPEVEC>&);
+template double FullMatrix<TYPEMAT>::least_squares<TYPEVEC>(Vector<TYPEVEC>&,
+                                                           Vector<TYPEVEC>&);
 
 template
-void FullMatrix<TYPEMAT>::precondition_Jacobi<> (Vector<TYPEVEC> &,
-                                                const Vector<TYPEVEC> &,
-                                                const TYPEMAT) const;
+void
+FullMatrix<TYPEMAT>::precondition_Jacobi<TYPEVEC> (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<TYPEVEC,TYPERES>(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 b33d53547849cb37afe00758fa63b749f35c4878..319cfeb1fe5baff01cf7420054daced96b7cb18f 100644 (file)
--- a/deal.II/lac/source/full_matrix.float.cc
+++ b/deal.II/lac/source/full_matrix.float.cc
@@ -21,51 +21,51 @@ 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 void FullMatrix<TYPEMAT>::fill<TYPEMAT2> (const FullMatrix<TYPEMAT2>&, const unsigned, const unsigned);
+template void FullMatrix<TYPEMAT>::add<TYPEMAT2> (const TYPEMAT, const FullMatrix<TYPEMAT2>&);
+template void FullMatrix<TYPEMAT>::Tadd<TYPEMAT2> (const TYPEMAT, const FullMatrix<TYPEMAT2>&);
+template void FullMatrix<TYPEMAT>::mmult<TYPEMAT2> (FullMatrix<TYPEMAT2>&, const FullMatrix<TYPEMAT2>&, const bool) const;
+template void FullMatrix<TYPEMAT>::Tmmult<TYPEMAT2> (FullMatrix<TYPEMAT2>&, const FullMatrix<TYPEMAT2>&, const bool) const;
+template void FullMatrix<TYPEMAT>::add_diag<TYPEMAT2> (const TYPEMAT, const FullMatrix<TYPEMAT2>&);
+template void FullMatrix<TYPEMAT>::invert<TYPEMAT2> (const FullMatrix<TYPEMAT2>&);
 
 #define TYPEVEC double
 #define TYPERES double
 
-template void FullMatrix<TYPEMAT>::fill_permutation<> (const FullMatrix<TYPEVEC>&,
+template void FullMatrix<TYPEMAT>::fill_permutation<TYPEVEC> (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>::vmult<TYPEVEC>(Vector<TYPEVEC>&, const Vector<TYPEVEC>&, const bool) const;
+template void FullMatrix<TYPEMAT>::Tvmult<TYPEVEC>(Vector<TYPEVEC>&, const Vector<TYPEVEC>&, const bool) const;
+template double FullMatrix<TYPEMAT>::residual<TYPEVEC>(Vector<TYPEVEC>&, const Vector<TYPEVEC>&, const Vector<TYPERES>&) const;
+template TYPEVEC FullMatrix<TYPEMAT>::matrix_norm_square<TYPEVEC> (const Vector<TYPEVEC> &) const;
+template TYPEVEC FullMatrix<TYPEMAT>::matrix_scalar_product<TYPEVEC>(const Vector<TYPEVEC>&, const Vector<TYPEVEC>&) const;
+template void FullMatrix<TYPEMAT>::forward<TYPEVEC>(Vector<TYPEVEC>&, const Vector<TYPEVEC>&) const;
+template void FullMatrix<TYPEMAT>::backward<TYPEVEC>(Vector<TYPEVEC>&, const Vector<TYPEVEC>&) const;
+template void FullMatrix<TYPEMAT>::householder<TYPEVEC>(Vector<TYPEVEC>&);
+template double FullMatrix<TYPEMAT>::least_squares<TYPEVEC>(Vector<TYPEVEC>&, Vector<TYPEVEC>&);
 template
-void FullMatrix<TYPEMAT>::precondition_Jacobi<> (Vector<TYPEVEC> &,
+void FullMatrix<TYPEMAT>::precondition_Jacobi<TYPEVEC> (Vector<TYPEVEC> &,
                                                 const Vector<TYPEVEC> &,
                                                 const TYPEMAT) const;
 
 #undef TYPEVEC
 #define TYPEVEC float
 
-template void FullMatrix<TYPEMAT>::fill_permutation<> (const FullMatrix<TYPEVEC>&,
+template void FullMatrix<TYPEMAT>::fill_permutation<TYPEVEC> (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>::vmult<TYPEVEC>(Vector<TYPEVEC>&, const Vector<TYPEVEC>&, const bool) const;
+template void FullMatrix<TYPEMAT>::Tvmult<TYPEVEC>(Vector<TYPEVEC>&, const Vector<TYPEVEC>&, const bool) const;
+template double FullMatrix<TYPEMAT>::residual<TYPEVEC>(Vector<TYPEVEC>&, const Vector<TYPEVEC>&, const Vector<TYPERES>&) const;
+template TYPEVEC FullMatrix<TYPEMAT>::matrix_norm_square<TYPEVEC> (const Vector<TYPEVEC> &) const;
+template TYPEVEC FullMatrix<TYPEMAT>::matrix_scalar_product<TYPEVEC>(const Vector<TYPEVEC>&, const Vector<TYPEVEC>&) const;
+template void FullMatrix<TYPEMAT>::forward<TYPEVEC>(Vector<TYPEVEC>&, const Vector<TYPEVEC>&) const;
+template void FullMatrix<TYPEMAT>::backward<TYPEVEC>(Vector<TYPEVEC>&, const Vector<TYPEVEC>&) const;
+template void FullMatrix<TYPEMAT>::householder<TYPEVEC>(Vector<TYPEVEC>&);
+template double FullMatrix<TYPEMAT>::least_squares<TYPEVEC>(Vector<TYPEVEC>&, Vector<TYPEVEC>&);
 template
-void FullMatrix<TYPEMAT>::precondition_Jacobi<> (Vector<TYPEVEC> &,
+void FullMatrix<TYPEMAT>::precondition_Jacobi<TYPEVEC> (Vector<TYPEVEC> &,
                                                 const Vector<TYPEVEC> &,
                                                 const TYPEMAT) const;
 
@@ -73,4 +73,4 @@ void FullMatrix<TYPEMAT>::precondition_Jacobi<> (Vector<TYPEVEC> &,
 #undef TYPERES
 #define TYPERES float
 
-template double FullMatrix<TYPEMAT>::residual<>(Vector<TYPEVEC>&, const Vector<TYPEVEC>&, const Vector<TYPERES>&) const;
+template double FullMatrix<TYPEMAT>::residual<TYPEVEC,TYPERES>(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 626a75b22db0ed7452e092298a6e696b6f9953c4..3c5a66587199739c826dd757a3292610ca25ee19 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<float>
 (Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockJacobi<float, float>::vmult<>
+template void PreconditionBlockJacobi<float, float>::vmult<double>
 (Vector<double> &, const Vector<double> &) const;
-template void PreconditionBlockJacobi<float, float>::Tvmult<>
+template void PreconditionBlockJacobi<float, float>::Tvmult<float>
 (Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockJacobi<float, float>::Tvmult<>
+template void PreconditionBlockJacobi<float, float>::Tvmult<double>
 (Vector<double> &, const Vector<double> &) const;
-template void PreconditionBlockJacobi<float, float>::vmult_add<>
+template void PreconditionBlockJacobi<float, float>::vmult_add<float>
 (Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockJacobi<float, float>::vmult_add<>
+template void PreconditionBlockJacobi<float, float>::vmult_add<double>
 (Vector<double> &, const Vector<double> &) const;
-template void PreconditionBlockJacobi<float, float>::Tvmult_add<>
+template void PreconditionBlockJacobi<float, float>::Tvmult_add<float>
 (Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockJacobi<float, float>::Tvmult_add<>
+template void PreconditionBlockJacobi<float, float>::Tvmult_add<double>
 (Vector<double> &, const Vector<double> &) const;
 
 template class PreconditionBlockJacobi<double, float>;
 
-template void PreconditionBlockJacobi<double, float>::vmult<>
+template void PreconditionBlockJacobi<double, float>::vmult<float>
 (Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockJacobi<double, float>::vmult<>
+template void PreconditionBlockJacobi<double, float>::vmult<double>
 (Vector<double> &, const Vector<double> &) const;
-template void PreconditionBlockJacobi<double, float>::Tvmult<>
+template void PreconditionBlockJacobi<double, float>::Tvmult<float>
 (Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockJacobi<double, float>::Tvmult<>
+template void PreconditionBlockJacobi<double, float>::Tvmult<double>
 (Vector<double> &, const Vector<double> &) const;
-template void PreconditionBlockJacobi<double, float>::vmult_add<>
+template void PreconditionBlockJacobi<double, float>::vmult_add<float>
 (Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockJacobi<double, float>::vmult_add<>
+template void PreconditionBlockJacobi<double, float>::vmult_add<double>
 (Vector<double> &, const Vector<double> &) const;
-template void PreconditionBlockJacobi<double, float>::Tvmult_add<>
+template void PreconditionBlockJacobi<double, float>::Tvmult_add<float>
 (Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockJacobi<double, float>::Tvmult_add<>
+template void PreconditionBlockJacobi<double, float>::Tvmult_add<double>
 (Vector<double> &, const Vector<double> &) const;
 
 template class PreconditionBlockJacobi<double, double>;
 
-template void PreconditionBlockJacobi<double, double>::vmult<>
+template void PreconditionBlockJacobi<double, double>::vmult<float>
 (Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockJacobi<double, double>::vmult<>
+template void PreconditionBlockJacobi<double, double>::vmult<double>
 (Vector<double> &, const Vector<double> &) const;
-template void PreconditionBlockJacobi<double, double>::Tvmult<>
+template void PreconditionBlockJacobi<double, double>::Tvmult<float>
 (Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockJacobi<double, double>::Tvmult<>
+template void PreconditionBlockJacobi<double, double>::Tvmult<double>
 (Vector<double> &, const Vector<double> &) const;
-template void PreconditionBlockJacobi<double, double>::vmult_add<>
+template void PreconditionBlockJacobi<double, double>::vmult_add<float>
 (Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockJacobi<double, double>::vmult_add<>
+template void PreconditionBlockJacobi<double, double>::vmult_add<double>
 (Vector<double> &, const Vector<double> &) const;
-template void PreconditionBlockJacobi<double, double>::Tvmult_add<>
+template void PreconditionBlockJacobi<double, double>::Tvmult_add<float>
 (Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockJacobi<double, double>::Tvmult_add<>
+template void PreconditionBlockJacobi<double, double>::Tvmult_add<double>
 (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<float> (
   Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockSOR<float, float>::vmult<> (
+template void PreconditionBlockSOR<float, float>::vmult<double> (
   Vector<double> &, const Vector<double> &) const;
-template void PreconditionBlockSOR<float, float>::Tvmult<> (
+template void PreconditionBlockSOR<float, float>::Tvmult<float> (
   Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockSOR<float, float>::Tvmult<> (
+template void PreconditionBlockSOR<float, float>::Tvmult<double> (
   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<float> (
   Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockSOR<double, float>::vmult<> (
+template void PreconditionBlockSOR<double, float>::vmult<double> (
   Vector<double> &, const Vector<double> &) const;
-template void PreconditionBlockSOR<double, float>::Tvmult<> (
+template void PreconditionBlockSOR<double, float>::Tvmult<float> (
   Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockSOR<double, float>::Tvmult<> (
+template void PreconditionBlockSOR<double, float>::Tvmult<double> (
   Vector<double> &, const Vector<double> &) const;
 
 template class PreconditionBlockSOR<double, double>;
 
-template void PreconditionBlockSOR<double, double>::vmult<> (
+template void PreconditionBlockSOR<double, double>::vmult<float> (
   Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockSOR<double, double>::vmult<> (
+template void PreconditionBlockSOR<double, double>::vmult<double> (
   Vector<double> &, const Vector<double> &) const;
-template void PreconditionBlockSOR<double, double>::Tvmult<> (
+template void PreconditionBlockSOR<double, double>::Tvmult<float> (
   Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockSOR<double, double>::Tvmult<> (
+template void PreconditionBlockSOR<double, double>::Tvmult<double> (
   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<float> (
   Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockSSOR<float, float>::vmult<> (
+template void PreconditionBlockSSOR<float, float>::vmult<double> (
   Vector<double> &, const Vector<double> &) const;
-template void PreconditionBlockSSOR<float, float>::Tvmult<> (
+template void PreconditionBlockSSOR<float, float>::Tvmult<float> (
   Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockSSOR<float, float>::Tvmult<> (
+template void PreconditionBlockSSOR<float, float>::Tvmult<double> (
   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<float> (
   Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockSSOR<double, float>::vmult<> (
+template void PreconditionBlockSSOR<double, float>::vmult<double> (
   Vector<double> &, const Vector<double> &) const;
-template void PreconditionBlockSSOR<double, float>::Tvmult<> (
+template void PreconditionBlockSSOR<double, float>::Tvmult<float> (
   Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockSSOR<double, float>::Tvmult<> (
+template void PreconditionBlockSSOR<double, float>::Tvmult<double> (
   Vector<double> &, const Vector<double> &) const;
 
 template class PreconditionBlockSSOR<double, double>;
 
-template void PreconditionBlockSSOR<double, double>::vmult<> (
+template void PreconditionBlockSSOR<double, double>::vmult<float> (
   Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockSSOR<double, double>::vmult<> (
+template void PreconditionBlockSSOR<double, double>::vmult<double> (
   Vector<double> &, const Vector<double> &) const;
-template void PreconditionBlockSSOR<double, double>::Tvmult<> (
+template void PreconditionBlockSSOR<double, double>::Tvmult<float> (
   Vector<float> &, const Vector<float> &) const;
-template void PreconditionBlockSSOR<double, double>::Tvmult<> (
+template void PreconditionBlockSSOR<double, double>::Tvmult<double> (
   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 130b5994763dfbf4da681b41811e36d8017d8fb6..771c729e57b25d8cf79b434e11284b1e8e285f4b 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<double> (const SparseMatrix<double> &,
+                                                   const double);
+template void SparseILU<double>::apply_decomposition<double> (Vector<double> &,
+                                                             const Vector<double> &) const;
+template void SparseILU<double>::decompose<float> (const SparseMatrix<float> &,
+                                                  const double);
+template void SparseILU<double>::apply_decomposition<float> (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<double> (const SparseMatrix<double> &,
+                                                  const double);
+template void SparseILU<float>::apply_decomposition<double> (Vector<double> &,
+                                                            const Vector<double> &) const;
+template void SparseILU<float>::decompose<float> (const SparseMatrix<float> &,
+                                                 const double);
+template void SparseILU<float>::apply_decomposition<float> (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 f844a3d36fcd26194566ad45b89b0fe9bc9f6ad0..5799d42c14fd5b764b18448d410edc5d6c51fe20 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<float> (Vector<float>       &dst,
+                                                const Vector<float> &src) const;
+template void SparseVanka<double>::vmult<double> (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<float> (Vector<float>       &dst,
+                                                     const Vector<float> &src) const;
+template void SparseBlockVanka<double>::vmult<double> (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 eca7bc5e7d9eebb60f7bc3b73fd53966ddd3997d..37911fbbe65fec066a0ada24bbfdb3f63610d4e1 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<float> (const FullMatrix<float> &);
+template void SparsityPattern::copy_from<double> (const FullMatrix<double> &);

diff --git a/deal.II/lac/source/vector.cc b/deal.II/lac/source/vector.cc
index 3f56b0a68e898496299ad065ac418d781ce3e2f2..0dfa53a884b96dfc1ce08fbe474236a7d323b896 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>::DEAL_II_MEMBER_OP_TEMPLATE_INST operator=<>(const Vector<float>&);
-template double Vector<double>::DEAL_II_MEMBER_OP_TEMPLATE_INST operator*<>(const Vector<float>&) const;
-template double Vector<double>::DEAL_II_MEMBER_OP_TEMPLATE_INST 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>::DEAL_II_MEMBER_OP_TEMPLATE_INST operator=<float>(const Vector<float>&);
+template double Vector<double>::DEAL_II_MEMBER_OP_TEMPLATE_INST operator*<float>(const Vector<float>&) const;
+template double Vector<double>::DEAL_II_MEMBER_OP_TEMPLATE_INST operator*<double>(const Vector<double>&) const;
+template void Vector<double>::reinit<double>(const Vector<double>&, const bool);
+template void Vector<double>::reinit<float>(const Vector<float>&, const bool);
+template void Vector<double>::equ<double>(const double, const Vector<double>&);
+template void Vector<double>::equ<float>(const double, const Vector<float>&);
 
 template class Vector<float>;
-template Vector<float>& Vector<float>::DEAL_II_MEMBER_OP_TEMPLATE_INST operator=<>(const Vector<double>&);
-template float Vector<float>::DEAL_II_MEMBER_OP_TEMPLATE_INST operator*<>(const Vector<float>&) const;
-template float Vector<float>::DEAL_II_MEMBER_OP_TEMPLATE_INST 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>::DEAL_II_MEMBER_OP_TEMPLATE_INST operator=<double>(const Vector<double>&);
+template float Vector<float>::DEAL_II_MEMBER_OP_TEMPLATE_INST operator*<float>(const Vector<float>&) const;
+template float Vector<float>::DEAL_II_MEMBER_OP_TEMPLATE_INST operator*<double>(const Vector<double>&) const;
+template void Vector<float>::reinit<double>(const Vector<double>&, const bool);
+template void Vector<float>::reinit<float>(const Vector<float>&, const bool);
+template void Vector<float>::equ<double>(const float, const Vector<double>&);
+template void Vector<float>::equ<float>(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 a226706de06f49215befbed4bda486e8d535f66f..4b0110771416b3830915f261fb92dae45b028de9 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>::DEAL_II_MEMBER_OP_TEMPLATE_INST operator=<>(const Vector<double>&);
-template Vector<long double>& Vector<long double>::DEAL_II_MEMBER_OP_TEMPLATE_INST operator=<>(const Vector<float>&);
-template long double Vector<long double>::DEAL_II_MEMBER_OP_TEMPLATE_INST operator *<> (const Vector<long double> &) const;
-template long double Vector<long double>::DEAL_II_MEMBER_OP_TEMPLATE_INST operator *<> (const Vector<double> &) const;
-template long double Vector<long double>::DEAL_II_MEMBER_OP_TEMPLATE_INST 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>::DEAL_II_MEMBER_OP_TEMPLATE_INST operator=<double>(const Vector<double>&);
+template Vector<long double>& Vector<long double>::DEAL_II_MEMBER_OP_TEMPLATE_INST operator=<float>(const Vector<float>&);
+template long double Vector<long double>::DEAL_II_MEMBER_OP_TEMPLATE_INST operator *<long double> (const Vector<long double> &) const;
+template long double Vector<long double>::DEAL_II_MEMBER_OP_TEMPLATE_INST operator *<double> (const Vector<double> &) const;
+template long double Vector<long double>::DEAL_II_MEMBER_OP_TEMPLATE_INST operator *<float> (const Vector<float> &) const;
+template void Vector<long double>::reinit<long double>(const Vector<long double>&, const bool);
+template void Vector<long double>::reinit<double>(const Vector<double>&, const bool);
+template void Vector<long double>::reinit<float>(const Vector<float>&, const bool);
+template void Vector<long double>::equ<long double>(const long double, const Vector<long double>&);
+template void Vector<long double>::equ<double>(const long double, const Vector<double>&);
+template void Vector<long double>::equ<float>(const long double, const Vector<float>&);
 
-template Vector<double>& Vector<double>::DEAL_II_MEMBER_OP_TEMPLATE_INST operator=<>(const Vector<long double>&);
-template double Vector<double>::DEAL_II_MEMBER_OP_TEMPLATE_INST 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>::DEAL_II_MEMBER_OP_TEMPLATE_INST operator=<long double>(const Vector<long double>&);
+template double Vector<double>::DEAL_II_MEMBER_OP_TEMPLATE_INST operator *<long double> (const Vector<long double> &) const;
+template void Vector<double>::reinit<long double>(const Vector<long double>&, const bool);
+template void Vector<double>::equ<long double>(const double, const Vector<long double>&);
 
-template Vector<float>& Vector<float>::DEAL_II_MEMBER_OP_TEMPLATE_INST operator=<>(const Vector<long double>&);
-template float Vector<float>::DEAL_II_MEMBER_OP_TEMPLATE_INST 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>::DEAL_II_MEMBER_OP_TEMPLATE_INST operator=<long double>(const Vector<long double>&);
+template float Vector<float>::DEAL_II_MEMBER_OP_TEMPLATE_INST operator *<long double> (const Vector<long double> &) const;
+template void Vector<float>::reinit<long double>(const Vector<long double>&, const bool);
+template void Vector<float>::equ<long double>(const float, const Vector<long double>&);
 
 // see the .h file for why these functions are disabled.
 // template Vector<float>::Vector (const Vector<double>& v);