]> https://gitweb.dealii.org/ - dealii-svn.git/commitdiff
new templates in FETools
authorguido <guido@0785d39b-7218-0410-832d-ea1e28bc413d>
Tue, 24 Sep 2002 22:31:24 +0000 (22:31 +0000)
committerguido <guido@0785d39b-7218-0410-832d-ea1e28bc413d>
Tue, 24 Sep 2002 22:31:24 +0000 (22:31 +0000)
git-svn-id: https://svn.dealii.org/trunk@6503 0785d39b-7218-0410-832d-ea1e28bc413d

deal.II/deal.II/include/fe/fe_tools.h
deal.II/deal.II/source/fe/fe_dgp_nonparametric.cc
deal.II/deal.II/source/fe/fe_tools.cc
deal.II/doc/news/2002/c-3-4.html

index 5058cb084ea238c5f8eb24224ef3f4dfa419437a..e9763d0b2746936db1569e36babe141a071afcea 100644 (file)
@@ -164,11 +164,11 @@ class FETools
                                      * your hanging node constraints
                                      * object.
                                      */
-    template <int dim, typename number>
-    static void interpolate (const DoFHandler<dim> &dof1,
-                            const Vector<number>  &u1,
-                            const DoFHandler<dim> &dof2,
-                            Vector<number>        &u2);
+    template <int dim, class InVector, class OutVector>
+    static void interpolate (const DoFHandler<dim>dof1,
+                            const InVector&        u1,
+                            const DoFHandler<dim>dof2,
+                            OutVector&             u2);
     
                                     /**
                                      * Gives the interpolation of a
@@ -203,12 +203,12 @@ class FETools
                                      * at the DoF values on the
                                      * discontinuities.
                                      */
-    template <int dim, typename number>
-    static void interpolate (const DoFHandler<dim>  &dof1,
-                            const Vector<number>   &u1,
-                            const DoFHandler<dim>  &dof2,
-                            const ConstraintMatrix &constraints,
-                            Vector<number>         &u2);
+    template <int dim, class InVector, class OutVector>
+    static void interpolate (const DoFHandler<dim>&  dof1,
+                            const InVector&         u1,
+                            const DoFHandler<dim>&  dof2,
+                            const ConstraintMatrixconstraints,
+                            OutVector&              u2);
     
 
                                     /**
@@ -237,11 +237,11 @@ class FETools
                                      * function is simply an identity
                                      * mapping.
                                      */
-    template <int dim, typename number>
-    static void back_interpolate (const DoFHandler<dim>    &dof1,
-                                 const Vector<number>     &u1,
-                                 const FiniteElement<dim> &fe2,
-                                 Vector<number>           &u1_interpolated);
+    template <int dim, class InVector, class OutVector>
+    static void back_interpolate (const DoFHandler<dim>&    dof1,
+                                 const InVector&           u1,
+                                 const FiniteElement<dim>fe2,
+                                 OutVector&                u1_interpolated);
 
                                     /**
                                      * Gives the interpolation of the
@@ -270,13 +270,13 @@ class FETools
                                      * function is simply an identity
                                      * mapping.
                                      */
-    template <int dim, typename number>
-    static void back_interpolate (const DoFHandler<dim>    &dof1,
-                                 const ConstraintMatrix   &constraints1,
-                                 const Vector<number>     &u1,
-                                 const DoFHandler<dim>    &dof2,
-                                 const ConstraintMatrix   &constraints2,
-                                 Vector<number>           &u1_interpolated);
+    template <int dim, class InVector, class OutVector>
+    static void back_interpolate (const DoFHandler<dim>&  dof1,
+                                 const ConstraintMatrixconstraints1,
+                                 const InVector&         u1,
+                                 const DoFHandler<dim>&  dof2,
+                                 const ConstraintMatrixconstraints2,
+                                 OutVector&              u1_interpolated);
 
                                     /**
                                      * Gives $(Id-I_h)z1$ for a given
@@ -294,11 +294,11 @@ class FETools
                                      * additional
                                      * @p{ConstraintMatrix} object.
                                      */
-    template <int dim, typename number>
+    template <int dim, class InVector, class OutVector>
     static void interpolation_difference(const DoFHandler<dim> &dof1,
-                                        const Vector<number> &z1,
+                                        const InVector &z1,
                                         const FiniteElement<dim> &fe2,
-                                        Vector<number> &z1_difference);    
+                                        OutVector &z1_difference);    
     
                                     /**
                                      * Gives $(Id-I_h)z1$ for a given
@@ -317,13 +317,13 @@ class FETools
                                      * nodes (locally refined grids)
                                      * are involved.
                                      */
-    template <int dim, typename number>
-    static void interpolation_difference(const DoFHandler<dim> &dof1,
-                                        const ConstraintMatrix &constraints1,
-                                        const Vector<number> &z1,
-                                        const DoFHandler<dim> &dof2,
-                                        const ConstraintMatrix &constraints2,
-                                        Vector<number> &z1_difference);    
+    template <int dim, class InVector, class OutVector>
+    static void interpolation_difference(const DoFHandler<dim>&  dof1,
+                                        const ConstraintMatrixconstraints1,
+                                        const InVector&         z1,
+                                        const DoFHandler<dim>&  dof2,
+                                        const ConstraintMatrixconstraints2,
+                                        OutVector&              z1_difference);    
 
                                     /**
                                      * Gives the patchwise
@@ -352,11 +352,11 @@ class FETools
                                      * @p{ConstraintMatrix} argument,
                                      * see below.
                                      */
-    template <int dim, typename number>
-    static void extrapolate(const DoFHandler<dim> &dof1,
-                           const Vector<number>  &z1,
-                           const DoFHandler<dim> &dof2,
-                           Vector<number>        &z2);    
+    template <int dim, class InVector, class OutVector>
+    static void extrapolate(const DoFHandler<dim>dof1,
+                           const InVector&        z1,
+                           const DoFHandler<dim>dof2,
+                           OutVector&             z2);    
 
                                     /**
                                      * Gives the patchwise
@@ -380,12 +380,12 @@ class FETools
                                      * solution to a piecewise
                                      * quadratic solution.
                                      */
-    template <int dim, typename number>
-    static void extrapolate(const DoFHandler<dim> &dof1,
-                           const Vector<number>  &z1,
-                           const DoFHandler<dim> &dof2,
-                           const ConstraintMatrix &constraints,
-                           Vector<number>        &z2);    
+    template <int dim, class InVector, class OutVector>
+    static void extrapolate(const DoFHandler<dim>&  dof1,
+                           const InVector&         z1,
+                           const DoFHandler<dim>&  dof2,
+                           const ConstraintMatrixconstraints,
+                           OutVector&              z2);    
 
                                     /**
                                      * The numbering of the degrees
index c4d79a5087dd84de7545ebfc0484de122358352c..12f9e3de8360c34aefd3c521f16a303f88d517d7 100644 (file)
@@ -207,9 +207,10 @@ FE_DGPNonparametric<dim>::update_each (const UpdateFlags flags) const
 
 template <int dim>
 typename Mapping<dim>::InternalDataBase *
-FE_DGPNonparametric<dim>::get_data (const UpdateFlags      update_flags,
-                      const Mapping<dim>    &mapping,
-                      const Quadrature<dim> &quadrature) const
+FE_DGPNonparametric<dim>::get_data (
+  const UpdateFlags      update_flags,
+  const Mapping<dim>&    mapping,
+  const Quadrature<dim>& quadrature) const
 {
                                   // generate a new data object
   InternalData* data = new InternalData;
index 6c876ce3ec573e1e065d542be663b9c4c7386448..c378ab571d4a9ffe5a508b6c1ba3be223613cb4e 100644 (file)
@@ -15,6 +15,7 @@
 #include <base/quadrature.h>
 #include <lac/full_matrix.h>
 #include <lac/vector.h>
+#include <lac/block_vector.h>
 #include <grid/tria.h>
 #include <grid/tria_iterator.h>
 #include <fe/fe_tools.h>
@@ -123,11 +124,11 @@ void FETools::get_interpolation_difference_matrix(const FiniteElement<dim> &fe1,
 }
 
 
-template <int dim, typename number>
+template <int dim, class InVector, class OutVector>
 void FETools::interpolate(const DoFHandler<dim> &dof1,
-                         const Vector<number> &u1,
+                         const InVector &u1,
                          const DoFHandler<dim> &dof2,
-                         Vector<number> &u2)
+                         OutVector &u2)
 {
   ConstraintMatrix dummy;
   dummy.close();
@@ -135,12 +136,12 @@ void FETools::interpolate(const DoFHandler<dim> &dof1,
 }
 
   
-template <int dim, typename number>
+template <int dim, class InVector, class OutVector>
 void FETools::interpolate(const DoFHandler<dim> &dof1,
-                         const Vector<number> &u1,
+                         const InVector &u1,
                          const DoFHandler<dim> &dof2,
                          const ConstraintMatrix &constraints,
-                         Vector<number> &u2)
+                         OutVector &u2)
 {
   Assert(&dof1.get_tria()==&dof2.get_tria(), ExcTriangulationMismatch());
   Assert(dof1.get_fe().n_components() == dof2.get_fe().n_components(),
@@ -161,10 +162,10 @@ void FETools::interpolate(const DoFHandler<dim> &dof1,
   const unsigned int dofs_per_cell1=dof1.get_fe().dofs_per_cell;
   const unsigned int dofs_per_cell2=dof2.get_fe().dofs_per_cell;
   
-  Vector<number> u1_local(dofs_per_cell1);
-  Vector<number> u2_local(dofs_per_cell2);
+  Vector<double> u1_local(dofs_per_cell1);
+  Vector<double> u2_local(dofs_per_cell2);
 
-  FullMatrix<number> interpolation_matrix(dofs_per_cell2,
+  FullMatrix<double> interpolation_matrix(dofs_per_cell2,
                                          dofs_per_cell1);
   FETools::get_interpolation_matrix(dof1.get_fe(), dof2.get_fe(),
                                    interpolation_matrix);
@@ -210,11 +211,11 @@ void FETools::interpolate(const DoFHandler<dim> &dof1,
 }
 
 
-template <int dim, typename number>
+template <int dim, class InVector, class OutVector>
 void FETools::back_interpolate(const DoFHandler<dim> &dof1,
-                              const Vector<number> &u1,
+                              const InVector &u1,
                               const FiniteElement<dim> &fe2,
-                              Vector<number> &u1_interpolated)
+                              OutVector &u1_interpolated)
 {
   Assert(dof1.get_fe().n_components() == fe2.n_components(),
         ExcDimensionMismatch(dof1.get_fe().n_components(), fe2.n_components()));
@@ -234,13 +235,13 @@ void FETools::back_interpolate(const DoFHandler<dim> &dof1,
 
   const unsigned int dofs_per_cell1=dof1.get_fe().dofs_per_cell;
 
-  Vector<number> u1_local(dofs_per_cell1);
-  Vector<number> u1_int_local(dofs_per_cell1);
+  Vector<double> u1_local(dofs_per_cell1);
+  Vector<double> u1_int_local(dofs_per_cell1);
   
   typename DoFHandler<dim>::active_cell_iterator cell = dof1.begin_active(),
                                                 endc = dof1.end();
 
-  FullMatrix<number> interpolation_matrix(dofs_per_cell1, dofs_per_cell1);
+  FullMatrix<double> interpolation_matrix(dofs_per_cell1, dofs_per_cell1);
   FETools::get_back_interpolation_matrix(dof1.get_fe(), fe2,
                                         interpolation_matrix);
   for (; cell!=endc; ++cell) 
@@ -259,13 +260,13 @@ void FETools::back_interpolate(const DoFHandler<dim> &dof1,
 
 
   
-template <int dim, typename number>
+template <int dim, class InVector, class OutVector>
 void FETools::back_interpolate(const DoFHandler<dim> &dof1,
                               const ConstraintMatrix &constraints1,
-                              const Vector<number> &u1,
+                              const InVector &u1,
                               const DoFHandler<dim> &dof2,
                               const ConstraintMatrix &constraints2,
-                              Vector<number> &u1_interpolated)
+                              OutVector &u1_interpolated)
 {
                                   // For discontinuous elements
                                   // without constraints take the
@@ -297,11 +298,11 @@ void FETools::back_interpolate(const DoFHandler<dim> &dof1,
 
 
   
-template <int dim, typename number>
+template <int dim, class InVector, class OutVector>
 void FETools::interpolation_difference(const DoFHandler<dim> &dof1,
-                                      const Vector<number> &u1,
+                                      const InVector &u1,
                                       const FiniteElement<dim> &fe2,
-                                      Vector<number> &u1_difference)
+                                      OutVector &u1_difference)
 {
   Assert(dof1.get_fe().n_components() == fe2.n_components(),
         ExcDimensionMismatch(dof1.get_fe().n_components(), fe2.n_components()));
@@ -321,10 +322,10 @@ void FETools::interpolation_difference(const DoFHandler<dim> &dof1,
 
   const unsigned int dofs_per_cell=dof1.get_fe().dofs_per_cell;
 
-  Vector<number> u1_local(dofs_per_cell);
-  Vector<number> u1_diff_local(dofs_per_cell);
+  Vector<double> u1_local(dofs_per_cell);
+  Vector<double> u1_diff_local(dofs_per_cell);
   
-  FullMatrix<number> difference_matrix(dofs_per_cell, dofs_per_cell);
+  FullMatrix<double> difference_matrix(dofs_per_cell, dofs_per_cell);
   FETools::get_interpolation_difference_matrix(dof1.get_fe(), fe2,
                                               difference_matrix);
   
@@ -347,13 +348,13 @@ void FETools::interpolation_difference(const DoFHandler<dim> &dof1,
 
 
 
-template <int dim, typename number>
+template <int dim, class InVector, class OutVector>
 void FETools::interpolation_difference(const DoFHandler<dim> &dof1,
                                       const ConstraintMatrix &constraints1,
-                                      const Vector<number> &u1,
+                                      const InVector &u1,
                                       const DoFHandler<dim> &dof2,
                                       const ConstraintMatrix &constraints2,
-                                      Vector<number> &u1_difference)
+                                      OutVector &u1_difference)
 {
                                   // For discontinuous elements
                                   // without constraints take the
@@ -370,11 +371,11 @@ void FETools::interpolation_difference(const DoFHandler<dim> &dof1,
 }
 
   
-template <int dim, typename number>
+template <int dim, class InVector, class OutVector>
 void FETools::extrapolate(const DoFHandler<dim> &dof1,
-                         const Vector<number> &u1,
+                         const InVector &u1,
                          const DoFHandler<dim> &dof2,
-                         Vector<number> &u2)
+                         OutVector &u2)
 {
   ConstraintMatrix dummy;
   dummy.close();
@@ -383,12 +384,12 @@ void FETools::extrapolate(const DoFHandler<dim> &dof1,
 
 
 
-template <int dim, typename number>
+template <int dim, class InVector, class OutVector>
 void FETools::extrapolate(const DoFHandler<dim> &dof1,
-                         const Vector<number> &u1,
+                         const InVector &u1,
                          const DoFHandler<dim> &dof2,
                          const ConstraintMatrix &constraints,
-                         Vector<number> &u2)
+                         OutVector &u2)
 {
   Assert(dof1.get_fe().n_components() == dof2.get_fe().n_components(),
         ExcDimensionMismatch(dof1.get_fe().n_components(), dof2.get_fe().n_components()));
@@ -396,12 +397,13 @@ void FETools::extrapolate(const DoFHandler<dim> &dof1,
   Assert(u1.size()==dof1.n_dofs(), ExcDimensionMismatch(u1.size(), dof1.n_dofs()));
   Assert(u2.size()==dof2.n_dofs(), ExcDimensionMismatch(u2.size(), dof2.n_dofs()));
 
-  Vector<number> u3(dof2.n_dofs());
+  OutVector u3;
+  u3.reinit(u2);
   interpolate(dof1, u1, dof2, constraints, u3);
 
   const unsigned int dofs_per_cell  = dof2.get_fe().dofs_per_cell;
   const Triangulation<dim> &tria=dof1.get_tria();
-  Vector<number> dof_values(dofs_per_cell);
+  Vector<double> dof_values(dofs_per_cell);
   
   for (unsigned int level=0; level<tria.n_levels()-1; ++level)
     {
@@ -854,6 +856,8 @@ FETools::lexicographic_to_hierarchic_numbering (const FE_Q<dim>           &fe,
 
 /*-------------- Explicit Instantiations -------------------------------*/
 
+//TODO:[RH] Why do the instantiations for float and double differ?
+
 template
 void FETools::get_interpolation_matrix<deal_II_dimension>
 (const FiniteElement<deal_II_dimension> &,
@@ -869,94 +873,129 @@ void FETools::get_interpolation_difference_matrix<deal_II_dimension>
 (const FiniteElement<deal_II_dimension> &,
  const FiniteElement<deal_II_dimension> &,
  FullMatrix<double> &);
+template
+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<deal_II_dimension>
+(const FiniteElement<deal_II_dimension> &,
+ const FiniteElement<deal_II_dimension> &,
+ FullMatrix<float> &);
+template
+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<deal_II_dimension>
-(const DoFHandler<deal_II_dimension> &,
- const Vector<double> &,
- const DoFHandler<deal_II_dimension> &,
- Vector<double> &);
+(const DoFHandler<deal_II_dimension> &, const Vector<double> &,
+ const DoFHandler<deal_II_dimension> &, Vector<double> &);
 template
 void FETools::interpolate<deal_II_dimension>
-(const DoFHandler<deal_II_dimension> &,
- const Vector<double> &,
- const DoFHandler<deal_II_dimension> &,
- const ConstraintMatrix &,
+(const DoFHandler<deal_II_dimension> &, const Vector<double> &,
+ const DoFHandler<deal_II_dimension> &, const ConstraintMatrix &,
  Vector<double> &);
 template
 void FETools::back_interpolate<deal_II_dimension>
-(const DoFHandler<deal_II_dimension> &,
- const Vector<double> &,
- const FiniteElement<deal_II_dimension> &,
- Vector<double> &);
+(const DoFHandler<deal_II_dimension> &, const Vector<double> &,
+ const FiniteElement<deal_II_dimension> &, Vector<double> &);
 template
 void FETools::back_interpolate<deal_II_dimension>
-(const DoFHandler<deal_II_dimension> &,
- const ConstraintMatrix &, 
+(const DoFHandler<deal_II_dimension> &, const ConstraintMatrix &,
  const Vector<double> &,
- const DoFHandler<deal_II_dimension> &,
- const ConstraintMatrix &,
+ const DoFHandler<deal_II_dimension> &, const ConstraintMatrix &,
  Vector<double> &);
 template
 void FETools::interpolation_difference<deal_II_dimension>
-(const DoFHandler<deal_II_dimension> &,
- const Vector<double> &,
- const FiniteElement<deal_II_dimension> &,
- Vector<double> &);
+(const DoFHandler<deal_II_dimension> &, const Vector<double> &,
+ const FiniteElement<deal_II_dimension> &, Vector<double> &);
 template
 void FETools::interpolation_difference<deal_II_dimension>
-(const DoFHandler<deal_II_dimension> &,
- const ConstraintMatrix &,
+(const DoFHandler<deal_II_dimension> &, const ConstraintMatrix &,
  const Vector<double> &,
- const DoFHandler<deal_II_dimension> &,
- const ConstraintMatrix &,
+ const DoFHandler<deal_II_dimension> &, const ConstraintMatrix &,
  Vector<double> &);
 template
 void FETools::extrapolate<deal_II_dimension>
-(const DoFHandler<deal_II_dimension> &,
- const Vector<double> &,
- const DoFHandler<deal_II_dimension> &,
- Vector<double> &);
+(const DoFHandler<deal_II_dimension> &, const Vector<double> &,
+ const DoFHandler<deal_II_dimension> &, Vector<double> &);
 
 
 template
-void FETools::get_interpolation_matrix<deal_II_dimension>
-(const FiniteElement<deal_II_dimension> &,
- const FiniteElement<deal_II_dimension> &,
- FullMatrix<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::get_back_interpolation_matrix<deal_II_dimension>
-(const FiniteElement<deal_II_dimension> &,
- const FiniteElement<deal_II_dimension> &,
- FullMatrix<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::get_interpolation_difference_matrix<deal_II_dimension>
-(const FiniteElement<deal_II_dimension> &,
- const FiniteElement<deal_II_dimension> &,
- FullMatrix<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<deal_II_dimension>
+(const DoFHandler<deal_II_dimension> &, const Vector<float> &,
+ const DoFHandler<deal_II_dimension> &, Vector<float> &);
+
+
+template
+void FETools::interpolate<deal_II_dimension>
+(const DoFHandler<deal_II_dimension> &, const BlockVector<double> &,
+ const DoFHandler<deal_II_dimension> &, BlockVector<double> &);
 template
 void FETools::interpolate<deal_II_dimension>
-(const DoFHandler<deal_II_dimension> &,
- const Vector<float> &,
- const DoFHandler<deal_II_dimension> &,
- Vector<float> &);
+(const DoFHandler<deal_II_dimension> &, const BlockVector<double> &,
+ const DoFHandler<deal_II_dimension> &, const ConstraintMatrix &,
+ BlockVector<double> &);
 template
 void FETools::back_interpolate<deal_II_dimension>
-(const DoFHandler<deal_II_dimension> &,
- const Vector<float> &,
- const FiniteElement<deal_II_dimension> &,
- Vector<float> &);
+(const DoFHandler<deal_II_dimension> &, const BlockVector<double> &,
+ const FiniteElement<deal_II_dimension> &, BlockVector<double> &);
+template
+void FETools::back_interpolate<deal_II_dimension>
+(const DoFHandler<deal_II_dimension> &, const ConstraintMatrix &,
+ const BlockVector<double> &,
+ const DoFHandler<deal_II_dimension> &, const ConstraintMatrix &,
+ BlockVector<double> &);
 template
 void FETools::interpolation_difference<deal_II_dimension>
-(const DoFHandler<deal_II_dimension> &,
- const Vector<float> &,
- const FiniteElement<deal_II_dimension> &,
- Vector<float> &);
+(const DoFHandler<deal_II_dimension> &, const BlockVector<double> &,
+ const FiniteElement<deal_II_dimension> &, BlockVector<double> &);
+template
+void FETools::interpolation_difference<deal_II_dimension>
+(const DoFHandler<deal_II_dimension> &, const ConstraintMatrix &,
+ const BlockVector<double> &,
+ const DoFHandler<deal_II_dimension> &, const ConstraintMatrix &,
+ BlockVector<double> &);
 template
 void FETools::extrapolate<deal_II_dimension>
-(const DoFHandler<deal_II_dimension> &,
- const Vector<float> &,
- const DoFHandler<deal_II_dimension> &,
- Vector<float> &);
+(const DoFHandler<deal_II_dimension> &, const BlockVector<double> &,
+ const DoFHandler<deal_II_dimension> &, BlockVector<double> &);
+
+
+template
+void FETools::interpolate<deal_II_dimension>
+(const DoFHandler<deal_II_dimension> &, const BlockVector<float> &,
+ const DoFHandler<deal_II_dimension> &, BlockVector<float> &);
+template
+void FETools::back_interpolate<deal_II_dimension>
+(const DoFHandler<deal_II_dimension> &, const BlockVector<float> &,
+ const FiniteElement<deal_II_dimension> &, BlockVector<float> &);
+template
+void FETools::interpolation_difference<deal_II_dimension>
+(const DoFHandler<deal_II_dimension> &, const BlockVector<float> &,
+ const FiniteElement<deal_II_dimension> &, BlockVector<float> &);
+template
+void FETools::extrapolate<deal_II_dimension>
+(const DoFHandler<deal_II_dimension> &, const BlockVector<float> &,
+ const DoFHandler<deal_II_dimension> &, BlockVector<float> &);
+
+
 template
 void
 FETools::hierarchic_to_lexicographic_numbering<deal_II_dimension>
index 0ca6b512d015837189974bdc480d1d0e740e84e7..3b3afed5c5039d1bbde30b17f94784a3cd95b4f8 100644 (file)
@@ -311,6 +311,12 @@ contributor's names are abbreviated by WB (Wolfgang Bangerth), GK
 <h3>deal.II</h3>
 
 <ol>
+  <li> <p>Improved: The different transfer functions in <code
+  class="class">FETools</code> operate on template vector arguments.
+  <br>
+  (GK 2002/09/24)
+  </p>
+
   <li> <p> New: the class <code
   class="class">FE_DGPNonparametric</code> implements finite elements
   where shape functions are polynomials of order <i>k</i> on the
@@ -318,7 +324,7 @@ contributor's names are abbreviated by WB (Wolfgang Bangerth), GK
   the mapped quadrature points. No grid transfer matrices are
   available for this class.
   <br>
-  (GK 09/19/2002)
+  (GK 2002/09/19)
   </p>
 
   <li> <p> 

In the beginning the Universe was created. This has made a lot of people very angry and has been widely regarded as a bad move.

Douglas Adams


Typeset in Trocchi and Trocchi Bold Sans Serif.