]> https://gitweb.dealii.org/ - dealii-svn.git/commitdiff
Added template to function, and made GridOut::write work also in codimension one.
authorheltai <heltai@0785d39b-7218-0410-832d-ea1e28bc413d>
Fri, 18 Jul 2014 15:59:55 +0000 (15:59 +0000)
committerheltai <heltai@0785d39b-7218-0410-832d-ea1e28bc413d>
Fri, 18 Jul 2014 15:59:55 +0000 (15:59 +0000)
git-svn-id: https://svn.dealii.org/trunk@33197 0785d39b-7218-0410-832d-ea1e28bc413d

16 files changed:
deal.II/doc/news/changes.h
deal.II/include/deal.II/base/function.h
deal.II/include/deal.II/base/function_time.h
deal.II/include/deal.II/base/tensor_function.h
deal.II/include/deal.II/dofs/dof_tools.h
deal.II/include/deal.II/dofs/function_map.h
deal.II/include/deal.II/grid/grid_out.h
deal.II/include/deal.II/grid/grid_tools.h
deal.II/include/deal.II/multigrid/mg_constrained_dofs.h
deal.II/include/deal.II/numerics/matrix_tools.h
deal.II/include/deal.II/numerics/vector_tools.h
deal.II/source/base/function.cc
deal.II/source/base/function_time.cc
deal.II/source/base/tensor_function.cc
deal.II/source/grid/grid_out.cc
deal.II/source/grid/grid_out.inst.in

index d9020e8a12c3a90b4eaf96abc933584d40b2948a..4969a345292bbb8fd3689caf2d00d66815606e74 100644 (file)
@@ -190,6 +190,20 @@ inconvenience this causes.
 <h3>Specific improvements</h3>
 
 <ol>
+  <li> New: The function GridOut::write, can now be used also in 
+  the codimension one case. 
+  <br>
+  (Luca Heltai, 2014/07/18)
+  </li>
+
+  <li> New: The Function classes, now take an additional optional
+  template argument, specifying the type of number to use, which defaults
+  to double. 
+  <br>
+  (Luca Heltai, 2014/07/18)
+  </li>
+
+
   <li> New: The GridReordering::reorder_cells() function used a
   numbering format for the vertices in a cell that was last used in
   deal.II version 5.2. This format is still used internally, but
index a48f4637d481bb0445691ba7a9bf432a3c6ba8ef..ace10a1c2259be4a01383a809ca6b35fef43e137 100644 (file)
@@ -32,7 +32,7 @@ DEAL_II_NAMESPACE_OPEN
 
 
 template <typename number> class Vector;
-template <int rank, int dim> class TensorFunction;
+template <int rank, int dim, typename Number> class TensorFunction;
 
 /**
  * This class is a model for a general function that, given a point at which
@@ -52,11 +52,11 @@ template <int rank, int dim> class TensorFunction;
  * methods:
  * @code
  *                 // access to one component at one point
- *   double value        (const Point<dim>   &p,
+ *   double value        (const Point<dim, Number>   &p,
  *                        const unsigned int  component = 0) const;
  *
  *                 // return all components at one point
- *   void   vector_value (const Point<dim>   &p,
+ *   void   vector_value (const Point<dim, Number>   &p,
  *                        Vector<double>     &value) const;
  * @endcode
  *
@@ -64,12 +64,12 @@ template <int rank, int dim> class TensorFunction;
  * components at a list of points at once:
  * @code
  *                 // access to one component at several points
- *   void   value_list (const std::vector<Point<dim> >  &point_list,
+ *   void   value_list (const std::vector<Point<dim, Number> >  &point_list,
  *                      std::vector<double>             &value_list,
  *                      const unsigned int  component = 0) const;
  *
  *                 // return all components at several points
- *   void   vector_value_list (const std::vector<Point<dim> >    &point_list,
+ *   void   vector_value_list (const std::vector<Point<dim, Number> >    &point_list,
  *                             std::vector<Vector<double> >      &value_list) const;
  * @endcode
  *
@@ -111,11 +111,11 @@ template <int rank, int dim> class TensorFunction;
  * class to convert the former to the latter.
  *
  * @ingroup functions
- * @author Wolfgang Bangerth, 1998, 1999
+ * @author Wolfgang Bangerth, 1998, 1999, Luca Heltai 2014
  */
-template <int dim>
-class Function : public FunctionTime,
-  public Subscriptor
+template <int dim, typename Number=double>
+class Function : public FunctionTime<Number>,
+                public Subscriptor
 {
 public:
   /**
@@ -135,7 +135,7 @@ public:
    * variable, which defaults to zero.
    */
   Function (const unsigned int n_components = 1,
-            const double       initial_time = 0.0);
+            const Number       initial_time = 0.0);
 
   /**
    * Virtual destructor; absolutely necessary in this case.
@@ -175,7 +175,7 @@ public:
    * component you want to have evaluated; it defaults to zero, i.e. the
    * first component.
    */
-  virtual double value (const Point<dim>   &p,
+  virtual Number value (const Point<dim, Number>   &p,
                         const unsigned int  component = 0) const;
 
   /**
@@ -186,8 +186,8 @@ public:
    *
    * The default implementation will call value() for each component.
    */
-  virtual void vector_value (const Point<dim>   &p,
-                             Vector<double>     &values) const;
+  virtual void vector_value (const Point<dim, Number>   &p,
+                             Vector<Number>     &values) const;
 
   /**
    * Set <tt>values</tt> to the point values of the specified component of
@@ -198,8 +198,8 @@ public:
    * By default, this function repeatedly calls value() for each point
    * separately, to fill the output array.
    */
-  virtual void value_list (const std::vector<Point<dim> > &points,
-                           std::vector<double>            &values,
+  virtual void value_list (const std::vector<Point<dim, Number> > &points,
+                           std::vector<Number>            &values,
                            const unsigned int              component = 0) const;
 
   /**
@@ -212,8 +212,8 @@ public:
    * By default, this function repeatedly calls vector_value() for each
    * point separately, to fill the output array.
    */
-  virtual void vector_value_list (const std::vector<Point<dim> > &points,
-                                  std::vector<Vector<double> >   &values) const;
+  virtual void vector_value_list (const std::vector<Point<dim, Number> > &points,
+                                  std::vector<Vector<Number> >   &values) const;
 
   /**
    * For each component of the function, fill a vector of values, one for
@@ -223,22 +223,22 @@ public:
    * value_list() for each component. In order to improve performance, this
    * can be reimplemented in derived classes to speed up performance.
    */
-  virtual void vector_values (const std::vector<Point<dim> > &points,
-                              std::vector<std::vector<double> > &values) const;
+  virtual void vector_values (const std::vector<Point<dim, Number> > &points,
+                              std::vector<std::vector<Number> > &values) const;
 
   /**
    * Return the gradient of the specified component of the function at the
    * given point.
    */
-  virtual Tensor<1,dim> gradient (const Point<dim>   &p,
+  virtual Tensor<1,dim, Number> gradient (const Point<dim, Number>   &p,
                                   const unsigned int  component = 0) const;
 
   /**
    * Return the gradient of all components of the function at the given
    * point.
    */
-  virtual void vector_gradient (const Point<dim>            &p,
-                                std::vector<Tensor<1,dim> > &gradients) const;
+  virtual void vector_gradient (const Point<dim, Number>            &p,
+                                std::vector<Tensor<1,dim, Number> > &gradients) const;
 
   /**
    * Set <tt>gradients</tt> to the gradients of the specified component of
@@ -246,8 +246,8 @@ public:
    * <tt>gradients</tt> already has the right size, i.e.  the same size as
    * the <tt>points</tt> array.
    */
-  virtual void gradient_list (const std::vector<Point<dim> > &points,
-                              std::vector<Tensor<1,dim> >    &gradients,
+  virtual void gradient_list (const std::vector<Point<dim, Number> > &points,
+                              std::vector<Tensor<1,dim, Number> >    &gradients,
                               const unsigned int              component = 0) const;
 
   /**
@@ -258,8 +258,8 @@ public:
    * value_list() for each component. In order to improve performance, this
    * can be reimplemented in derived classes to speed up performance.
    */
-  virtual void vector_gradients (const std::vector<Point<dim> >            &points,
-                                 std::vector<std::vector<Tensor<1,dim> > > &gradients) const;
+  virtual void vector_gradients (const std::vector<Point<dim, Number> >            &points,
+                                 std::vector<std::vector<Tensor<1,dim, Number> > > &gradients) const;
 
   /**
    * Set <tt>gradients</tt> to the gradients of the function at the
@@ -270,34 +270,34 @@ public:
    * The outer loop over <tt>gradients</tt> is over the points in the list,
    * the inner loop over the different components of the function.
    */
-  virtual void vector_gradient_list (const std::vector<Point<dim> >            &points,
-                                     std::vector<std::vector<Tensor<1,dim> > > &gradients) const;
+  virtual void vector_gradient_list (const std::vector<Point<dim, Number> >            &points,
+                                     std::vector<std::vector<Tensor<1,dim, Number> > > &gradients) const;
 
   /**
    * Compute the Laplacian of a given component at point <tt>p</tt>.
    */
-  virtual double laplacian (const Point<dim>   &p,
+  virtual Number laplacian (const Point<dim, Number>   &p,
                             const unsigned int  component = 0) const;
 
   /**
    * Compute the Laplacian of all components at point <tt>p</tt> and store
    * them in <tt>values</tt>.
    */
-  virtual void vector_laplacian (const Point<dim>   &p,
-                                 Vector<double>     &values) const;
+  virtual void vector_laplacian (const Point<dim, Number>   &p,
+                                 Vector<Number>     &values) const;
 
   /**
    * Compute the Laplacian of one component at a set of points.
    */
-  virtual void laplacian_list (const std::vector<Point<dim> > &points,
-                               std::vector<double>            &values,
+  virtual void laplacian_list (const std::vector<Point<dim, Number> > &points,
+                               std::vector<Number>            &values,
                                const unsigned int              component = 0) const;
 
   /**
    * Compute the Laplacians of all components at a set of points.
    */
-  virtual void vector_laplacian_list (const std::vector<Point<dim> > &points,
-                                      std::vector<Vector<double> >   &values) const;
+  virtual void vector_laplacian_list (const std::vector<Point<dim, Number> > &points,
+                                      std::vector<Vector<Number> >   &values) const;
 
   /**
    * Determine an estimate for the memory consumption (in bytes) of this
@@ -324,8 +324,8 @@ public:
  * @ingroup functions
  * @author Wolfgang Bangerth, 1998, 1999
  */
-template <int dim>
-class ZeroFunction : public Function<dim>
+template <int dim, typename Number=double>
+class ZeroFunction : public Function<dim, Number>
 {
 public:
   /**
@@ -339,31 +339,31 @@ public:
    */
   virtual ~ZeroFunction ();
 
-  virtual double value (const Point<dim>   &p,
+  virtual Number value (const Point<dim, Number>   &p,
                         const unsigned int  component) const;
 
-  virtual void vector_value (const Point<dim> &p,
-                             Vector<double>   &return_value) const;
+  virtual void vector_value (const Point<dim, Number> &p,
+                             Vector<Number>   &return_value) const;
 
-  virtual void value_list (const std::vector<Point<dim> > &points,
-                           std::vector<double>            &values,
+  virtual void value_list (const std::vector<Point<dim, Number> > &points,
+                           std::vector<Number>            &values,
                            const unsigned int              component = 0) const;
 
-  virtual void vector_value_list (const std::vector<Point<dim> > &points,
-                                  std::vector<Vector<double> >   &values) const;
+  virtual void vector_value_list (const std::vector<Point<dim, Number> > &points,
+                                  std::vector<Vector<Number> >   &values) const;
 
-  virtual Tensor<1,dim> gradient (const Point<dim> &p,
+  virtual Tensor<1,dim, Number> gradient (const Point<dim, Number> &p,
                                   const unsigned int component = 0) const;
 
-  virtual void vector_gradient (const Point<dim>            &p,
-                                std::vector<Tensor<1,dim> > &gradients) const;
+  virtual void vector_gradient (const Point<dim, Number>            &p,
+                                std::vector<Tensor<1,dim, Number> > &gradients) const;
 
-  virtual void gradient_list (const std::vector<Point<dim> > &points,
-                              std::vector<Tensor<1,dim> >    &gradients,
+  virtual void gradient_list (const std::vector<Point<dim, Number> > &points,
+                              std::vector<Tensor<1,dim, Number> >    &gradients,
                               const unsigned int              component = 0) const;
 
-  virtual void vector_gradient_list (const std::vector<Point<dim> >            &points,
-                                     std::vector<std::vector<Tensor<1,dim> > > &gradients) const;
+  virtual void vector_gradient_list (const std::vector<Point<dim, Number> >            &points,
+                                     std::vector<std::vector<Tensor<1,dim, Number> > > &gradients) const;
 };
 
 
@@ -391,15 +391,15 @@ public:
  * @ingroup functions
  * @author Wolfgang Bangerth, 1998, 1999
  */
-template <int dim>
-class ConstantFunction : public ZeroFunction<dim>
+template <int dim, typename Number=double>
+class ConstantFunction : public ZeroFunction<dim, Number>
 {
 public:
   /**
    * Constructor; takes the constant function value as an argument. The
    * number of components is preset to one.
    */
-  ConstantFunction (const double       value,
+  ConstantFunction (const Number       value,
                     const unsigned int n_components = 1);
 
   /**
@@ -407,18 +407,18 @@ public:
    */
   virtual ~ConstantFunction ();
 
-  virtual double value (const Point<dim>   &p,
+  virtual Number value (const Point<dim, Number>   &p,
                         const unsigned int  component) const;
 
-  virtual void   vector_value (const Point<dim> &p,
-                               Vector<double>   &return_value) const;
+  virtual void   vector_value (const Point<dim, Number> &p,
+                               Vector<Number>   &return_value) const;
 
-  virtual void value_list (const std::vector<Point<dim> > &points,
-                           std::vector<double>            &values,
+  virtual void value_list (const std::vector<Point<dim, Number> > &points,
+                           std::vector<Number>            &values,
                            const unsigned int              component = 0) const;
 
-  virtual void vector_value_list (const std::vector<Point<dim> > &points,
-                                  std::vector<Vector<double> >   &values) const;
+  virtual void vector_value_list (const std::vector<Point<dim, Number> > &points,
+                                  std::vector<Vector<Number> >   &values) const;
 
   std::size_t memory_consumption () const;
 
@@ -426,7 +426,7 @@ protected:
   /**
    * Store the constant function value.
    */
-  const double function_value;
+  const Number function_value;
 };
 
 
@@ -445,8 +445,8 @@ protected:
  * @ingroup functions
  * @author Guido Kanschat, 2000, Wolfgang Bangerth 2006
  */
-template <int dim>
-class ComponentSelectFunction : public ConstantFunction<dim>
+template <int dim, typename Number=double>
+class ComponentSelectFunction : public ConstantFunction<dim, Number>
 {
 public:
   /**
@@ -455,7 +455,7 @@ public:
    * total number of vector components.
    */
   ComponentSelectFunction (const unsigned int selected,
-                           const double       value,
+                           const Number       value,
                            const unsigned int n_components);
 
   /**
@@ -479,8 +479,8 @@ public:
    * Return the value of the function at the given point for all
    * components.
    */
-  virtual void   vector_value (const Point<dim> &p,
-                               Vector<double>   &return_value) const;
+  virtual void   vector_value (const Point<dim, Number> &p,
+                               Vector<Number>   &return_value) const;
 
   /**
    * Set <tt>values</tt> to the point values of the function at the
@@ -488,8 +488,8 @@ public:
    * <tt>values</tt> already has the right size, i.e. the same size as the
    * <tt>points</tt> array.
    */
-  virtual void vector_value_list (const std::vector<Point<dim> > &points,
-                                  std::vector<Vector<double> >   &values) const;
+  virtual void vector_value_list (const std::vector<Point<dim, Number> > &points,
+                                  std::vector<Vector<Number> >   &values) const;
 
   /**
    * Determine an estimate for the memory consumption (in bytes) of this
@@ -512,7 +512,7 @@ protected:
 /**
  * This class provides a way to convert a scalar function of the kind
  * @code
- *   double foo (const Point<dim> &);
+ *   Number foo (const Point<dim, Number> &);
  * @endcode
  * into an object of type Function@<dim@>. Since the argument returns a
  * scalar, the result is clearly a Function object for which
@@ -537,10 +537,10 @@ protected:
  * argument. For example, if you need a Function object that returns the
  * norm of a point, you could write it like so:
  * @code
- *   template <int dim>
- *   class Norm : public Function<dim> {
+ *   template <int dim, typename Number>
+ *   class Norm : public Function<dim, Number> {
  *     public:
- *       virtual double value (const Point<dim> &p,
+ *       virtual Number value (const Point<dim, Number> &p,
  *                             const unsigned int component) const {
  *         Assert (component == 0, ExcMessage ("This object is scalar!"));
  *         return p.norm();
@@ -552,23 +552,23 @@ protected:
  * and then pass the <code>my_norm_object</code> around, or you could write
  * it like so:
  * @code
- *   ScalarFunctionFromFunctionObject<dim> my_norm_object (&Point<dim>::norm);
+ *   ScalarFunctionFromFunctionObject<dim, Number> my_norm_object (&Point<dim, Number>::norm);
  * @endcode
  *
  * Similarly, to generate an object that computes the distance to a point
  * <code>q</code>, we could do this:
  * @code
- *   template <int dim>
- *   class DistanceTo : public Function<dim> {
+ *   template <int dim, typename Number>
+ *   class DistanceTo : public Function<dim, Number> {
  *     public:
- *       DistanceTo (const Point<dim> &q) : q(q) {}
- *       virtual double value (const Point<dim> &p,
+ *       DistanceTo (const Point<dim, Number> &q) : q(q) {}
+ *       virtual Number value (const Point<dim, Number> &p,
  *                             const unsigned int component) const {
  *         Assert (component == 0, ExcMessage ("This object is scalar!"));
  *         return q.distance(p);
  *       }
  *     private:
- *       const Point<dim> q;
+ *       const Point<dim, Number> q;
  *    };
  *
  *    Point<2> q (2,3);
@@ -576,8 +576,8 @@ protected:
  * @endcode
  * or we could write it like so:
  * @code
- *    ScalarFunctionFromFunctionObject<dim>
- *      my_distance_object (std_cxx1x::bind (&Point<dim>::distance,
+ *    ScalarFunctionFromFunctionObject<dim, Number>
+ *      my_distance_object (std_cxx1x::bind (&Point<dim, Number>::distance,
  *                                           q,
  *                                           std_cxx1x::_1));
  * @endcode
@@ -585,21 +585,21 @@ protected:
  *
  * @author Wolfgang Bangerth, 2011
  */
-template <int dim>
-class ScalarFunctionFromFunctionObject : public Function<dim>
+template <int dim, typename Number=double>
+class ScalarFunctionFromFunctionObject : public Function<dim, Number>
 {
 public:
   /**
-   * Given a function object that takes a Point and returns a double value,
-   * convert this into an object that matches the Function<dim> interface.
+   * Given a function object that takes a Point and returns a Number value,
+   * convert this into an object that matches the Function<dim, Number> interface.
    */
-  ScalarFunctionFromFunctionObject (const std_cxx1x::function<double (const Point<dim> &)> &function_object);
+  ScalarFunctionFromFunctionObject (const std_cxx1x::function<Number (const Point<dim, Number> &)> &function_object);
 
   /**
    * Return the value of the function at the given point. Returns the value
    * the function given to the constructor produces for this point.
    */
-  virtual double value (const Point<dim>   &p,
+  virtual Number value (const Point<dim, Number>   &p,
                         const unsigned int  component = 0) const;
 
 private:
@@ -607,7 +607,7 @@ private:
    * The function object which we call when this class's value() or
    * value_list() functions are called.
    **/
-  const std_cxx1x::function<double (const Point<dim> &)> function_object;
+  const std_cxx1x::function<Number (const Point<dim, Number> &)> function_object;
 };
 
 
@@ -633,7 +633,7 @@ private:
  *
  * To be more concrete, let us consider the following example:
  * @code
- *   double one (const Point<2> &p) { return 1; }
+ *   Number one (const Point<2> &p) { return 1; }
  *   VectorFunctionFromScalarFunctionObject<2>
  *      component_mask (&one, 1, 3);
  * @endcode
@@ -646,12 +646,12 @@ private:
  *
  * @author Wolfgang Bangerth, 2011
  */
-template <int dim>
-class VectorFunctionFromScalarFunctionObject : public Function<dim>
+template <int dim, typename Number=double>
+class VectorFunctionFromScalarFunctionObject : public Function<dim, Number>
 {
 public:
   /**
-   * Given a function object that takes a Point and returns a double
+   * Given a function object that takes a Point and returns a Number
    * value, convert this into an object that matches the Function@<dim@>
    * interface.
    *
@@ -662,7 +662,7 @@ public:
    * @param selected_component The single component that should be
    *     filled by the first argument.
    **/
-  VectorFunctionFromScalarFunctionObject (const std_cxx1x::function<double (const Point<dim> &)> &function_object,
+  VectorFunctionFromScalarFunctionObject (const std_cxx1x::function<Number (const Point<dim, Number> &)> &function_object,
                                           const unsigned int selected_component,
                                           const unsigned int n_components);
 
@@ -670,7 +670,7 @@ public:
    * Return the value of the function at the given point. Returns the value
    * the function given to the constructor produces for this point.
    */
-  virtual double value (const Point<dim>   &p,
+  virtual Number value (const Point<dim, Number>   &p,
                         const unsigned int  component = 0) const;
 
   /**
@@ -679,15 +679,15 @@ public:
    * <tt>values</tt> shall have the right size beforehand, i.e.
    * #n_components.
    */
-  virtual void vector_value (const Point<dim>   &p,
-                             Vector<double>     &values) const;
+  virtual void vector_value (const Point<dim, Number>   &p,
+                             Vector<Number>     &values) const;
 
 private:
   /**
    * The function object which we call when this class's value() or
    * value_list() functions are called.
    **/
-  const std_cxx1x::function<double (const Point<dim> &)> function_object;
+  const std_cxx1x::function<Number (const Point<dim, Number> &)> function_object;
 
   /**
    * The vector component whose value is to be filled by the given scalar
@@ -698,7 +698,7 @@ private:
 
 
 /**
- * This class is built as a means of translating the <code>Tensor<1,dim>
+ * This class is built as a means of translating the <code>Tensor<1,dim, Number>
  * </code> values produced by objects of type TensorFunction and returning
  * them as a multiple component version of the same thing as a Vector for
  * use in, for example, the VectorTools::interpolate or the many other
@@ -709,11 +709,11 @@ private:
  *
  *  For example: Say you created a class called
  *  @code
- *    class RightHandSide : public TensorFunction<rank,dim>
+ *    class RightHandSide : public TensorFunction<rank,dim, Number>
  *  @endcode
  *  which extends the TensorFunction class and you have an object
  *  @code
- *    RightHandSide<1,dim> rhs;
+ *    RightHandSide<1,dim, Number> rhs;
  *  @endcode
  *  of that class which you want to interpolate onto your mesh using the
  *  VectorTools::interpolate function, but the finite element you use for
@@ -723,21 +723,21 @@ private:
  *  that has 3*dim vector components. Creating such an object from the
  *  existing <code>rhs</code> object is done using this piece of code:
  *  @code
- *      RighHandSide<1,dim> rhs;
- *      VectorFunctionFromTensorFunction<dim> rhs_vector_function (rhs, 0, 3*dim);
+ *      RighHandSide<1,dim, Number> rhs;
+ *      VectorFunctionFromTensorFunction<dim, Number> rhs_vector_function (rhs, 0, 3*dim);
  *  @endcode
  *  where the <code>dim</code> components of the tensor function are placed into
  *  the first <code>dim</code> components of the function object.
  *
  * @author Spencer Patty, 2013
  */
-template <int dim>
-class VectorFunctionFromTensorFunction : public Function<dim>
+template <int dim, typename Number=double>
+class VectorFunctionFromTensorFunction : public Function<dim, Number>
 {
 public:
   /**
    * Given a TensorFunction object that takes a <tt>Point</tt> and returns
-   * a <tt>Tensor<1,dim></tt> value, convert this into an object that
+   * a <tt>Tensor<1,dim, Number></tt> value, convert this into an object that
    * matches the Function@<dim@> interface.
    *
    * By default, create a Vector object of the same size as
@@ -752,7 +752,7 @@ public:
    *     tensor_function fits inside the <tt>n_component</tt> length return
    *     vector.
    */
-  VectorFunctionFromTensorFunction (const TensorFunction<1,dim> &tensor_function,
+  VectorFunctionFromTensorFunction (const TensorFunction<1,dim, Number> &tensor_function,
                                     const unsigned int selected_component=0,
                                     const unsigned int n_components=dim);
 
@@ -766,7 +766,7 @@ public:
    * Return a single component of a vector-valued function at a given
    * point.
    */
-  virtual double value (const Point<dim> &p,
+  virtual Number value (const Point<dim, Number> &p,
                         const unsigned int component = 0) const;
 
   /**
@@ -775,8 +775,8 @@ public:
    * <tt>values</tt> shall have the right size beforehand, i.e.
    * #n_components.
    */
-  virtual void vector_value (const Point<dim> &p,
-                             Vector<double>   &values) const;
+  virtual void vector_value (const Point<dim, Number> &p,
+                             Vector<Number>   &values) const;
 
   /**
    * Return all components of a vector-valued function at a list of points.
@@ -785,21 +785,21 @@ public:
    * element of the vector will be passed to vector_value() to evaluate the
    * function
    */
-  virtual void vector_value_list (const std::vector<Point<dim> > &points,
-                                  std::vector<Vector<double> >   &value_list) const;
+  virtual void vector_value_list (const std::vector<Point<dim, Number> > &points,
+                                  std::vector<Vector<Number> >   &value_list) const;
 
 private:
   /**
    * The TensorFunction object which we call when this class's
    * vector_value() or vector_value_list() functions are called.
    **/
-  const TensorFunction<1,dim> &tensor_function;
+  const TensorFunction<1,dim,Number> &tensor_function;
 
   /**
    * The first vector component whose value is to be filled by the given
    * TensorFunction.  The values will be placed in components
    * selected_component to selected_component+dim-1 for a
-   * <tt>TensorFunction<1,dim></tt> object.
+   * <tt>TensorFunction<1,dim, Number></tt> object.
    */
   const unsigned int selected_component;
 };
index 3615f51f73a30042aec1c31a20d3dec39c4824aa..4b8109be72edb04b47ca16b48e40741d14c328e6 100644 (file)
@@ -64,6 +64,7 @@ DEAL_II_NAMESPACE_OPEN
  *  @ingroup functions
  *  @author Wolfgang Bangerth, Guido Kanschat, 1998, 1999
  */
+template <typename Number=double>
 class FunctionTime
 {
 public:
@@ -72,7 +73,7 @@ public:
    * for the time variable, which defaults
    * to zero.
    */
-  FunctionTime (const double initial_time = 0.0);
+  FunctionTime (const Number initial_time = Number(0.0));
 
   /**
    * Virtual destructor.
@@ -82,25 +83,25 @@ public:
   /**
    * Return the value of the time variable/
    */
-  double get_time () const;
+  Number get_time () const;
 
   /**
    * Set the time to <tt>new_time</tt>, overwriting
    * the old value.
    */
-  virtual void set_time (const double new_time);
+  virtual void set_time (const Number new_time);
 
   /**
    * Advance the time by the given
    * time step <tt>delta_t</tt>.
    */
-  virtual void advance_time (const double delta_t);
+  virtual void advance_time (const Number delta_t);
 
 private:
   /**
    * Store the present time.
    */
-  double time;
+  Number time;
 };
 
 
@@ -109,8 +110,9 @@ private:
 
 #ifndef DOXYGEN
 
-inline double
-FunctionTime::get_time () const
+template<typename Number>
+inline Number
+FunctionTime<Number>::get_time () const
 {
   return time;
 }
index c6da7af3aaf8f0a52236ac377dcbfadd74c22d28..d61290e0b5bafee9224eaaf5c69511c29693cbd5 100644 (file)
@@ -56,23 +56,23 @@ DEAL_II_NAMESPACE_OPEN
  *  @ingroup functions
  *  @author Guido Kanschat, 1999
  */
-template <int rank, int dim>
-class TensorFunction : public FunctionTime,
+template <int rank, int dim, typename Number=double>
+class TensorFunction : public FunctionTime<Number>,
   public Subscriptor
 {
 public:
   /**
    * Define typedefs for the return types of the <tt>value</tt> functions.
    */
-  typedef Tensor<rank,dim> value_type;
+  typedef Tensor<rank,dim,Number> value_type;
 
-  typedef Tensor<rank+1,dim> gradient_type;
+  typedef Tensor<rank+1,dim,Number> gradient_type;
 
   /**
    * Constructor. May take an initial value for the time variable, which
    * defaults to zero.
    */
-  TensorFunction (const double initial_time = 0.0);
+  TensorFunction (const Number initial_time = Number(0.0));
 
   /**
    * Virtual destructor; absolutely necessary in this case, as classes are
@@ -84,27 +84,27 @@ public:
   /**
    * Return the value of the function at the given point.
    */
-  virtual value_type value (const Point<dim> &p) const;
+  virtual value_type value (const Point<dim, Number> &p) const;
 
   /**
    * Set <tt>values</tt> to the point values of the function at the
    * <tt>points</tt>.  It is assumed that <tt>values</tt> already has the
    * right size, i.e.  the same size as the <tt>points</tt> array.
    */
-  virtual void value_list (const std::vector<Point<dim> > &points,
+  virtual void value_list (const std::vector<Point<dim, Number> > &points,
                            std::vector<value_type> &values) const;
 
   /**
    * Return the gradient of the function at the given point.
    */
-  virtual gradient_type gradient (const Point<dim> &p) const;
+  virtual gradient_type gradient (const Point<dim, Number> &p) const;
 
   /**
    * Set <tt>gradients</tt> to the gradients of the function at the
    * <tt>points</tt>.  It is assumed that <tt>values</tt> already has the
    * right size, i.e.  the same size as the <tt>points</tt> array.
    */
-  virtual void gradient_list (const std::vector<Point<dim> >   &points,
+  virtual void gradient_list (const std::vector<Point<dim, Number> >   &points,
                               std::vector<gradient_type> &gradients) const;
 
   /**
@@ -130,8 +130,8 @@ public:
  * @ingroup functions
  * @author Matthias Maier, 2013
  */
-template <int rank, int dim>
-class ConstantTensorFunction : public TensorFunction<rank, dim>
+template <int rank, int dim, typename Number=double>
+class ConstantTensorFunction : public TensorFunction<rank, dim, Number>
 {
 public:
   /**
@@ -141,23 +141,23 @@ public:
    * An initial value for the time variable may be specified, otherwise it
    * defaults to zero.
    */
-  ConstantTensorFunction (const dealii::Tensor<rank, dim> &value,
-                          const double initial_time = 0.0);
+  ConstantTensorFunction (const dealii::Tensor<rank, dim, Number> &value,
+                          const Number initial_time = 0.0);
 
   virtual ~ConstantTensorFunction ();
 
-  virtual typename dealii::TensorFunction<rank, dim>::value_type value (const Point<dim> &p) const;
+  virtual typename dealii::TensorFunction<rank, dim, Number>::value_type value (const Point<dim, Number> &p) const;
 
-  virtual void value_list (const std::vector<Point<dim> > &points,
-                           std::vector<typename dealii::TensorFunction<rank, dim>::value_type> &values) const;
+  virtual void value_list (const std::vector<Point<dim, Number> > &points,
+                           std::vector<typename dealii::TensorFunction<rank, dim, Number>::value_type> &values) const;
 
-  virtual typename dealii::TensorFunction<rank, dim>::gradient_type gradient (const Point<dim> &p) const;
+  virtual typename dealii::TensorFunction<rank, dim, Number>::gradient_type gradient (const Point<dim, Number> &p) const;
 
-  virtual void gradient_list (const std::vector<Point<dim> > &points,
-                              std::vector<typename dealii::TensorFunction<rank, dim>::gradient_type> &gradients) const;
+  virtual void gradient_list (const std::vector<Point<dim, Number> > &points,
+                              std::vector<typename dealii::TensorFunction<rank, dim, Number>::gradient_type> &gradients) const;
 
 private:
-  const dealii::Tensor<rank, dim> _value;
+  const dealii::Tensor<rank, dim, Number> _value;
 };
 
 
@@ -169,8 +169,8 @@ private:
  * @ingroup functions
  * @author Matthias Maier, 2013
  */
-template <int rank, int dim>
-class ZeroTensorFunction : public ConstantTensorFunction<rank, dim>
+template <int rank, int dim, typename Number=double>
+class ZeroTensorFunction : public ConstantTensorFunction<rank, dim, Number>
 {
 public:
   /**
@@ -179,7 +179,7 @@ public:
    * An initial value for the time variable may be specified, otherwise it
    * defaults to zero.
    */
-  ZeroTensorFunction (const double initial_time = 0.0);
+  ZeroTensorFunction (const Number initial_time = 0.0);
 };
 
 
index 45f72ff92dc2b4b963483118c9e28f78eb589fba..72a3791bfef943bdc44c5c48f364f7bb11b4f1dd 100644 (file)
@@ -40,7 +40,7 @@ DEAL_II_NAMESPACE_OPEN
 template<int dim, class T> class Table;
 class SparsityPattern;
 template <typename number> class Vector;
-template <int dim> class Function;
+template <int dim, typename Number> class Function;
 template <int dim, int spacedim> class FiniteElement;
 template <int dim, int spacedim> class DoFHandler;
 namespace hp
index 52e3495a0daa7fb652f72db01a269218f5855534..a436e0eea4fe3f450b51335241d79e01d7e0dba1 100644 (file)
@@ -22,7 +22,7 @@
 
 DEAL_II_NAMESPACE_OPEN
 
-template <int spacedim> class Function;
+template <int spacedim, typename Number> class Function;
 
 
 
@@ -65,7 +65,7 @@ template <int spacedim> class Function;
  * @ingroup functions
  * @author Wolfgang Bangerth, Ralf Hartmann, 2001
  */
-template<int dim>
+template<int dim,typename Number=double>
 struct FunctionMap
 {
   /**
@@ -77,7 +77,7 @@ struct FunctionMap
    * name it in the fashion of the
    * STL local typedefs.
    */
-  typedef std::map<types::boundary_id, const Function<dim>*> type;
+  typedef std::map<types::boundary_id, const Function<dim,Number>*> type;
 };
 
 DEAL_II_NAMESPACE_CLOSE
index 308df13c5e5c8c5b9afd71438fdb1a2c4f069b92..55b48caa5833b6b5c65e0cc982396c53a22b2dae 100644 (file)
@@ -895,8 +895,8 @@ public:
    * Not implemented for the
    * codimension one case.
    */
-  template <int dim>
-  void write_dx (const Triangulation<dim> &tria,
+  template <int dim, int spacedim>
+  void write_dx (const Triangulation<dim,spacedim> &tria,
                  std::ostream             &out) const;
 
   /**
@@ -1044,10 +1044,10 @@ public:
    *
    * Not implemented for the codimension one case.
    */
-  template <int dim>
-  void write_eps (const Triangulation<dim> &tria,
+  template <int dim, int spacedim>
+  void write_eps (const Triangulation<dim, spacedim> &tria,
                   std::ostream             &out,
-                  const Mapping<dim>       *mapping=0) const;
+                  const Mapping<dim, spacedim>       *mapping=0) const;
 
   /**
    * Write two-dimensional XFig-file.
@@ -1067,10 +1067,10 @@ public:
    *
    * Not implemented for the codimension one case.
    */
-  template <int dim>
-  void write_xfig (const Triangulation<dim> &tria,
+  template <int dim, int spacedim>
+  void write_xfig (const Triangulation<dim, spacedim> &tria,
                    std::ostream              &out,
-                   const Mapping<dim>        *mapping=0) const;
+                   const Mapping<dim, spacedim>        *mapping=0) const;
 
   /**
    * Write the triangulation in the SVG format.
@@ -1122,8 +1122,8 @@ public:
    *
    * @note Not implemented for the codimension one case.
    */
-  template <int dim>
-  void write_mathgl (const Triangulation<dim> &tria,
+  template <int dim, int spacedim>
+  void write_mathgl (const Triangulation<dim, spacedim> &tria,
                      std::ostream             &out) const;
 
   /**
index 8a6b6c6747e237a6f2086d865798d08d98aab4b7..fb5eff8e654aa015db8feb21f055d88f33508b07 100644 (file)
@@ -312,7 +312,7 @@ namespace GridTools
   template <int dim>
   void laplace_transform (const std::map<unsigned int,Point<dim> > &new_points,
                           Triangulation<dim> &tria,
-                          const Function<dim> *coefficient = 0);
+                          const Function<dim,double> *coefficient = 0);
 
   /**
    * Scale the entire triangulation
index e30bfa3ae4a4a14cc39b71957a12edf2e0d0162e..0547380d321612e16e891a9254819a70c3d81eb5 100644 (file)
@@ -28,7 +28,7 @@
 DEAL_II_NAMESPACE_OPEN
 
 template <int dim, int spacedim> class DoFHandler;
-template <int dim> struct FunctionMap;
+template <int dim, typename Number> struct FunctionMap;
 
 
 /**
index 3d90ebe0fad488c38cb4f2534d39a27d8395f37f..ab4b762277889acb9286a4046c7bdfb4e5610ab0 100644 (file)
@@ -19,6 +19,7 @@
 
 
 #include <deal.II/base/config.h>
+#include <deal.II/base/function.h>
 #include <deal.II/base/exceptions.h>
 #include <deal.II/base/thread_management.h>
 #include <deal.II/lac/constraint_matrix.h>
index 59c74cfccc4e4d268139b4971de935298e2ad28f..0f15f4c9788c958cde81205e6171e72acac7869f 100644 (file)
@@ -32,8 +32,8 @@
 
 DEAL_II_NAMESPACE_OPEN
 
-template <int dim> class Function;
-template <int dim> struct FunctionMap;
+template <int dim, typename Number> class Function;
+template <int dim, typename Number> struct FunctionMap;
 template <int dim> class Quadrature;
 template <int dim> class QGauss;
 
@@ -454,7 +454,7 @@ namespace VectorTools
   template <class VECTOR, int dim, int spacedim, template <int,int> class DH>
   void interpolate (const Mapping<dim,spacedim>    &mapping,
                     const DH<dim,spacedim>         &dof,
-                    const Function<spacedim>       &function,
+                    const Function<spacedim,double>       &function,
                     VECTOR                         &vec);
 
   /**
@@ -464,7 +464,7 @@ namespace VectorTools
    */
   template <class VECTOR, class DH>
   void interpolate (const DH              &dof,
-                    const Function<DH::space_dimension>   &function,
+                    const Function<DH::space_dimension,double>   &function,
                     VECTOR                &vec);
 
   /**
@@ -565,7 +565,7 @@ namespace VectorTools
   void
   interpolate_based_on_material_id(const Mapping<DH::dimension, DH::space_dimension>&                          mapping,
                                    const DH&                                                                   dof_handler,
-                                   const std::map< types::material_id, const Function<DH::space_dimension>* >& function_map,
+                                   const std::map< types::material_id, const Function<DH::space_dimension,double>* >& function_map,
                                    VECTOR&                                                                     dst,
                                    const ComponentMask&                                                        component_mask = ComponentMask());
 
@@ -715,7 +715,7 @@ namespace VectorTools
                 const DoFHandler<dim,spacedim>    &dof,
                 const ConstraintMatrix   &constraints,
                 const Quadrature<dim>    &quadrature,
-                const Function<spacedim>      &function,
+                const Function<spacedim,double>      &function,
                 VECTOR                   &vec,
                 const bool                enforce_zero_boundary = false,
                 const Quadrature<dim-1>  &q_boundary = (dim > 1 ?
@@ -732,7 +732,7 @@ namespace VectorTools
   void project (const DoFHandler<dim,spacedim>    &dof,
                 const ConstraintMatrix   &constraints,
                 const Quadrature<dim>    &quadrature,
-                const Function<spacedim>      &function,
+                const Function<spacedim,double>      &function,
                 VECTOR                   &vec,
                 const bool                enforce_zero_boundary = false,
                 const Quadrature<dim-1>  &q_boundary = (dim > 1 ?
@@ -749,7 +749,7 @@ namespace VectorTools
                 const hp::DoFHandler<dim,spacedim>    &dof,
                 const ConstraintMatrix   &constraints,
                 const hp::QCollection<dim>    &quadrature,
-                const Function<spacedim>      &function,
+                const Function<spacedim,double>      &function,
                 VECTOR                   &vec,
                 const bool                enforce_zero_boundary = false,
                 const hp::QCollection<dim-1>  &q_boundary = hp::QCollection<dim-1>(dim > 1 ?
@@ -766,7 +766,7 @@ namespace VectorTools
   void project (const hp::DoFHandler<dim,spacedim>    &dof,
                 const ConstraintMatrix   &constraints,
                 const hp::QCollection<dim>    &quadrature,
-                const Function<spacedim>      &function,
+                const Function<spacedim,double>      &function,
                 VECTOR                   &vec,
                 const bool                enforce_zero_boundary = false,
                 const hp::QCollection<dim-1>  &q_boundary = hp::QCollection<dim-1>(dim > 1 ?
@@ -895,7 +895,7 @@ namespace VectorTools
   interpolate_boundary_values (const Mapping<DH::dimension,DH::space_dimension>            &mapping,
                                const DH                 &dof,
                                const types::boundary_id            boundary_component,
-                               const Function<DH::space_dimension>           &boundary_function,
+                               const Function<DH::space_dimension,double>           &boundary_function,
                                std::map<types::global_dof_index,double> &boundary_values,
                                const ComponentMask       &component_mask = ComponentMask());
 
@@ -914,7 +914,7 @@ namespace VectorTools
   void
   interpolate_boundary_values (const DH        &dof,
                                const types::boundary_id            boundary_component,
-                               const Function<DH::space_dimension>           &boundary_function,
+                               const Function<DH::space_dimension,double>           &boundary_function,
                                std::map<types::global_dof_index,double> &boundary_values,
                                const ComponentMask       &component_mask = ComponentMask());
 
@@ -1057,7 +1057,7 @@ namespace VectorTools
   interpolate_boundary_values (const Mapping<DH::dimension,DH::space_dimension> &mapping,
                                const DH                            &dof,
                                const types::boundary_id                  boundary_component,
-                               const Function<DH::space_dimension> &boundary_function,
+                               const Function<DH::space_dimension,double> &boundary_function,
                                ConstraintMatrix                    &constraints,
                                const ComponentMask             &component_mask = ComponentMask());
 
@@ -1078,7 +1078,7 @@ namespace VectorTools
   void
   interpolate_boundary_values (const DH                            &dof,
                                const types::boundary_id                  boundary_component,
-                               const Function<DH::space_dimension> &boundary_function,
+                               const Function<DH::space_dimension,double> &boundary_function,
                                ConstraintMatrix                    &constraints,
                                const ComponentMask             &component_mask = ComponentMask());
 
@@ -1359,7 +1359,7 @@ namespace VectorTools
   template <int dim>
   void project_boundary_values_curl_conforming (const DoFHandler<dim> &dof_handler,
                                                 const unsigned int first_vector_component,
-                                                const Function<dim> &boundary_function,
+                                                const Function<dim,double> &boundary_function,
                                                 const types::boundary_id boundary_component,
                                                 ConstraintMatrix &constraints,
                                                 const Mapping<dim> &mapping = StaticMappingQ1<dim>::mapping);
@@ -1374,7 +1374,7 @@ namespace VectorTools
   template <int dim>
   void project_boundary_values_curl_conforming (const hp::DoFHandler<dim> &dof_handler,
                                                 const unsigned int first_vector_component,
-                                                const Function<dim> &boundary_function,
+                                                const Function<dim,double> &boundary_function,
                                                 const types::boundary_id boundary_component,
                                                 ConstraintMatrix &constraints,
                                                 const hp::MappingCollection<dim, dim> &mapping_collection = hp::StaticMappingQ1<dim>::mapping_collection);
@@ -1449,7 +1449,7 @@ namespace VectorTools
   template<int dim>
   void project_boundary_values_div_conforming (const DoFHandler<dim> &dof_handler,
                                                const unsigned int first_vector_component,
-                                               const Function<dim> &boundary_function,
+                                               const Function<dim,double> &boundary_function,
                                                const types::boundary_id boundary_component,
                                                ConstraintMatrix &constraints,
                                                const Mapping<dim> &mapping = StaticMappingQ1<dim>::mapping);
@@ -1464,7 +1464,7 @@ namespace VectorTools
   template<int dim>
   void project_boundary_values_div_conforming (const hp::DoFHandler<dim> &dof_handler,
                                                const unsigned int first_vector_component,
-                                               const Function<dim> &boundary_function,
+                                               const Function<dim,double> &boundary_function,
                                                const types::boundary_id boundary_component,
                                                ConstraintMatrix &constraints,
                                                const hp::MappingCollection<dim, dim> &mapping_collection = hp::StaticMappingQ1<dim>::mapping_collection);
@@ -1752,7 +1752,7 @@ namespace VectorTools
   void create_right_hand_side (const Mapping<dim, spacedim>    &mapping,
                                const DoFHandler<dim,spacedim> &dof,
                                const Quadrature<dim> &q,
-                               const Function<spacedim>   &rhs,
+                               const Function<spacedim,double>   &rhs,
                                Vector<double>        &rhs_vector);
 
   /**
@@ -1763,7 +1763,7 @@ namespace VectorTools
   template <int dim, int spacedim>
   void create_right_hand_side (const DoFHandler<dim,spacedim> &dof,
                                const Quadrature<dim> &q,
-                               const Function<spacedim>   &rhs,
+                               const Function<spacedim,double>   &rhs,
                                Vector<double>        &rhs_vector);
 
   /**
@@ -1774,7 +1774,7 @@ namespace VectorTools
   void create_right_hand_side (const hp::MappingCollection<dim,spacedim>    &mapping,
                                const hp::DoFHandler<dim,spacedim> &dof,
                                const hp::QCollection<dim> &q,
-                               const Function<spacedim>   &rhs,
+                               const Function<spacedim,double>   &rhs,
                                Vector<double>        &rhs_vector);
 
   /**
@@ -1784,7 +1784,7 @@ namespace VectorTools
   template <int dim, int spacedim>
   void create_right_hand_side (const hp::DoFHandler<dim,spacedim> &dof,
                                const hp::QCollection<dim> &q,
-                               const Function<spacedim>   &rhs,
+                               const Function<spacedim,double>   &rhs,
                                Vector<double>        &rhs_vector);
 
   /**
@@ -1913,7 +1913,7 @@ namespace VectorTools
   void create_boundary_right_hand_side (const Mapping<dim,spacedim>      &mapping,
                                         const DoFHandler<dim,spacedim>   &dof,
                                         const Quadrature<dim-1> &q,
-                                        const Function<spacedim>     &rhs,
+                                        const Function<spacedim,double>     &rhs,
                                         Vector<double>          &rhs_vector,
                                         const std::set<types::boundary_id> &boundary_indicators = std::set<types::boundary_id>());
 
@@ -1928,7 +1928,7 @@ namespace VectorTools
   template <int dim, int spacedim>
   void create_boundary_right_hand_side (const DoFHandler<dim,spacedim>   &dof,
                                         const Quadrature<dim-1> &q,
-                                        const Function<spacedim>     &rhs,
+                                        const Function<spacedim,double>     &rhs,
                                         Vector<double>          &rhs_vector,
                                         const std::set<types::boundary_id> &boundary_indicators = std::set<types::boundary_id>());
 
@@ -1942,7 +1942,7 @@ namespace VectorTools
   void create_boundary_right_hand_side (const hp::MappingCollection<dim,spacedim>      &mapping,
                                         const hp::DoFHandler<dim,spacedim>   &dof,
                                         const hp::QCollection<dim-1> &q,
-                                        const Function<spacedim>     &rhs,
+                                        const Function<spacedim,double>     &rhs,
                                         Vector<double>          &rhs_vector,
                                         const std::set<types::boundary_id> &boundary_indicators = std::set<types::boundary_id>());
 
@@ -1961,7 +1961,7 @@ namespace VectorTools
   template <int dim, int spacedim>
   void create_boundary_right_hand_side (const hp::DoFHandler<dim,spacedim>   &dof,
                                         const hp::QCollection<dim-1> &q,
-                                        const Function<spacedim>     &rhs,
+                                        const Function<spacedim,double>     &rhs,
                                         Vector<double>          &rhs_vector,
                                         const std::set<types::boundary_id> &boundary_indicators = std::set<types::boundary_id>());
 
@@ -2085,11 +2085,11 @@ namespace VectorTools
   void integrate_difference (const Mapping<dim,spacedim>    &mapping,
                              const DoFHandler<dim,spacedim> &dof,
                              const InVector                 &fe_function,
-                             const Function<spacedim>       &exact_solution,
+                             const Function<spacedim,double>       &exact_solution,
                              OutVector                      &difference,
                              const Quadrature<dim>          &q,
                              const NormType                 &norm,
-                             const Function<spacedim>       *weight = 0,
+                             const Function<spacedim,double>       *weight = 0,
                              const double exponent = 2.);
 
   /**
@@ -2100,11 +2100,11 @@ namespace VectorTools
   template <int dim, class InVector, class OutVector, int spacedim>
   void integrate_difference (const DoFHandler<dim,spacedim> &dof,
                              const InVector                 &fe_function,
-                             const Function<spacedim>       &exact_solution,
+                             const Function<spacedim,double>       &exact_solution,
                              OutVector                      &difference,
                              const Quadrature<dim>          &q,
                              const NormType                 &norm,
-                             const Function<spacedim>       *weight = 0,
+                             const Function<spacedim,double>       *weight = 0,
                              const double exponent = 2.);
 
   /**
@@ -2114,11 +2114,11 @@ namespace VectorTools
   void integrate_difference (const hp::MappingCollection<dim,spacedim> &mapping,
                              const hp::DoFHandler<dim,spacedim>        &dof,
                              const InVector                            &fe_function,
-                             const Function<spacedim>                  &exact_solution,
+                             const Function<spacedim,double>                  &exact_solution,
                              OutVector                                 &difference,
                              const hp::QCollection<dim>                &q,
                              const NormType                            &norm,
-                             const Function<spacedim>                  *weight = 0,
+                             const Function<spacedim,double>                  *weight = 0,
                              const double exponent = 2.);
 
   /**
@@ -2129,11 +2129,11 @@ namespace VectorTools
   template <int dim, class InVector, class OutVector, int spacedim>
   void integrate_difference (const hp::DoFHandler<dim,spacedim> &dof,
                              const InVector                     &fe_function,
-                             const Function<spacedim>           &exact_solution,
+                             const Function<spacedim,double>           &exact_solution,
                              OutVector                          &difference,
                              const hp::QCollection<dim>         &q,
                              const NormType                     &norm,
-                             const Function<spacedim>           *weight = 0,
+                             const Function<spacedim,double>           *weight = 0,
                              const double exponent = 2.);
 
   /**
@@ -2160,7 +2160,7 @@ namespace VectorTools
   template <int dim, class InVector, int spacedim>
   void point_difference (const DoFHandler<dim,spacedim> &dof,
                          const InVector                 &fe_function,
-                         const Function<spacedim>       &exact_solution,
+                         const Function<spacedim,double>       &exact_solution,
                          Vector<double>                 &difference,
                          const Point<spacedim>          &point);
 
@@ -2190,7 +2190,7 @@ namespace VectorTools
   void point_difference (const Mapping<dim, spacedim>   &mapping,
                          const DoFHandler<dim,spacedim> &dof,
                          const InVector                 &fe_function,
-                         const Function<spacedim>       &exact_solution,
+                         const Function<spacedim,double>       &exact_solution,
                          Vector<double>                 &difference,
                          const Point<spacedim>          &point);
 
index 40c7f30af2f2c6421c08b1dbfe113205fb6852db..ce7fba508f6c3473ae57ace741303c7818f959ed 100644 (file)
 DEAL_II_NAMESPACE_OPEN
 
 
-template <int dim>
-const unsigned int Function<dim>::dimension;
+template <int dim, typename Number>
+const unsigned int Function<dim, Number>::dimension;
 
 
-template <int dim>
-Function<dim>::Function (const unsigned int n_components,
-                         const double       initial_time)
+template <int dim, typename Number>
+Function<dim, Number>::Function (const unsigned int n_components,
+                                const Number       initial_time)
   :
-  FunctionTime(initial_time),
+  FunctionTime<Number>(initial_time),
   n_components(n_components)
 {
   // avoid the construction of function
@@ -45,22 +45,22 @@ Function<dim>::Function (const unsigned int n_components,
 }
 
 
-template <int dim>
-Function<dim>::~Function ()
+template <int dim, typename Number>
+Function<dim, Number>::~Function ()
 {}
 
 
 
-template <int dim>
-Function<dim> &Function<dim>::operator= (const Function &f)
+template <int dim, typename Number>
+Function<dim, Number> &Function<dim, Number>::operator= (const Function &f)
 {
   AssertDimension (n_components, f.n_components);
   return *this;
 }
 
 
-template <int dim>
-double Function<dim>::value (const Point<dim> &,
+template <int dim, typename Number>
+Number Function<dim, Number>::value (const Point<dim, Number> &,
                              const unsigned int) const
 {
   Assert (false, ExcPureFunctionCalled());
@@ -68,9 +68,9 @@ double Function<dim>::value (const Point<dim> &,
 }
 
 
-template <int dim>
-void Function<dim>::vector_value (const Point<dim> &p,
-                                  Vector<double> &v) const
+template <int dim, typename Number>
+void Function<dim, Number>::vector_value (const Point<dim, Number> &p,
+                                  Vector<Number> &v) const
 {
   AssertDimension(v.size(), this->n_components);
   for (unsigned int i=0; i<this->n_components; ++i)
@@ -78,9 +78,9 @@ void Function<dim>::vector_value (const Point<dim> &p,
 }
 
 
-template <int dim>
-void Function<dim>::value_list (const std::vector<Point<dim> > &points,
-                                std::vector<double>                     &values,
+template <int dim, typename Number>
+void Function<dim, Number>::value_list (const std::vector<Point<dim, Number> > &points,
+                                std::vector<Number>                     &values,
                                 const unsigned int                       component) const
 {
   // check whether component is in
@@ -94,9 +94,9 @@ void Function<dim>::value_list (const std::vector<Point<dim> > &points,
 }
 
 
-template <int dim>
-void Function<dim>::vector_value_list (const std::vector<Point<dim> > &points,
-                                       std::vector<Vector<double> >   &values) const
+template <int dim, typename Number>
+void Function<dim, Number>::vector_value_list (const std::vector<Point<dim, Number> > &points,
+                                       std::vector<Vector<Number> >   &values) const
 {
   // check whether component is in
   // the valid range is up to the
@@ -109,10 +109,10 @@ void Function<dim>::vector_value_list (const std::vector<Point<dim> > &points,
 }
 
 
-template <int dim>
-void Function<dim>::vector_values (
-  const std::vector<Point<dim> > &points,
-  std::vector<std::vector<double> > &values) const
+template <int dim, typename Number>
+void Function<dim, Number>::vector_values (
+  const std::vector<Point<dim, Number> > &points,
+  std::vector<std::vector<Number> > &values) const
 {
   const unsigned int n = this->n_components;
   AssertDimension (values.size(), n);
@@ -121,19 +121,19 @@ void Function<dim>::vector_values (
 }
 
 
-template <int dim>
-Tensor<1,dim> Function<dim>::gradient (const Point<dim> &,
-                                       const unsigned int) const
+template <int dim, typename Number>
+Tensor<1,dim,Number> Function<dim, Number>::gradient (const Point<dim, Number> &,
+                                              const unsigned int) const
 {
   Assert (false, ExcPureFunctionCalled());
-  return Point<dim>();
+  return Point<dim, Number>();
 }
 
 
-template <int dim>
-void Function<dim>::vector_gradient (
-  const Point<dim> &p,
-  std::vector<Tensor<1,dim> > &v) const
+template <int dim, typename Number>
+void Function<dim, Number>::vector_gradient (
+  const Point<dim, Number> &p,
+  std::vector<Tensor<1,dim,Number> > &v) const
 {
   AssertDimension(v.size(), this->n_components);
   for (unsigned int i=0; i<this->n_components; ++i)
@@ -141,10 +141,10 @@ void Function<dim>::vector_gradient (
 }
 
 
-template <int dim>
-void Function<dim>::gradient_list (const std::vector<Point<dim> > &points,
-                                   std::vector<Tensor<1,dim> >    &gradients,
-                                   const unsigned int              component) const
+template <int dim, typename Number>
+void Function<dim, Number>::gradient_list (const std::vector<Point<dim, Number> > &points,
+                                          std::vector<Tensor<1,dim,Number> >    &gradients,
+                                          const unsigned int              component) const
 {
   Assert (gradients.size() == points.size(),
           ExcDimensionMismatch(gradients.size(), points.size()));
@@ -154,9 +154,9 @@ void Function<dim>::gradient_list (const std::vector<Point<dim> > &points,
 }
 
 
-template <int dim>
-void Function<dim>::vector_gradient_list (const std::vector<Point<dim> >            &points,
-                                          std::vector<std::vector<Tensor<1,dim> > > &gradients) const
+template <int dim, typename Number>
+void Function<dim, Number>::vector_gradient_list (const std::vector<Point<dim, Number> >            &points,
+                                                 std::vector<std::vector<Tensor<1,dim,Number> > > &gradients) const
 {
   Assert (gradients.size() == points.size(),
           ExcDimensionMismatch(gradients.size(), points.size()));
@@ -170,10 +170,10 @@ void Function<dim>::vector_gradient_list (const std::vector<Point<dim> >
 }
 
 
-template <int dim>
-void Function<dim>::vector_gradients (
-  const std::vector<Point<dim> > &points,
-  std::vector<std::vector<Tensor<1,dim> > > &values) const
+template <int dim, typename Number>
+void Function<dim, Number>::vector_gradients (
+  const std::vector<Point<dim, Number> > &points,
+  std::vector<std::vector<Tensor<1,dim,Number> > > &values) const
 {
   const unsigned int n = this->n_components;
   AssertDimension (values.size(), n);
@@ -183,8 +183,8 @@ void Function<dim>::vector_gradients (
 
 
 
-template <int dim>
-double Function<dim>::laplacian (const Point<dim> &,
+template <int dim, typename Number>
+Number Function<dim, Number>::laplacian (const Point<dim, Number> &,
                                  const unsigned int) const
 {
   Assert (false, ExcPureFunctionCalled());
@@ -192,18 +192,18 @@ double Function<dim>::laplacian (const Point<dim> &,
 }
 
 
-template <int dim>
-void Function<dim>::vector_laplacian (const Point<dim> &,
-                                      Vector<double> &) const
+template <int dim, typename Number>
+void Function<dim, Number>::vector_laplacian (const Point<dim, Number> &,
+                                      Vector<Number> &) const
 {
   Assert (false, ExcPureFunctionCalled());
 }
 
 
 
-template <int dim>
-void Function<dim>::laplacian_list (const std::vector<Point<dim> > &points,
-                                    std::vector<double>            &laplacians,
+template <int dim, typename Number>
+void Function<dim, Number>::laplacian_list (const std::vector<Point<dim, Number> > &points,
+                                    std::vector<Number>            &laplacians,
                                     const unsigned int              component) const
 {
   // check whether component is in
@@ -217,9 +217,9 @@ void Function<dim>::laplacian_list (const std::vector<Point<dim> > &points,
 }
 
 
-template <int dim>
-void Function<dim>::vector_laplacian_list (const std::vector<Point<dim> > &points,
-                                           std::vector<Vector<double> >   &laplacians) const
+template <int dim, typename Number>
+void Function<dim, Number>::vector_laplacian_list (const std::vector<Point<dim, Number> > &points,
+                                           std::vector<Vector<Number> >   &laplacians) const
 {
   // check whether component is in
   // the valid range is up to the
@@ -233,9 +233,9 @@ void Function<dim>::vector_laplacian_list (const std::vector<Point<dim> > &point
 
 
 
-template <int dim>
+template <int dim, typename Number>
 std::size_t
-Function<dim>::memory_consumption () const
+Function<dim, Number>::memory_consumption () const
 {
   // only simple data elements, so
   // use sizeof operator
@@ -245,29 +245,29 @@ Function<dim>::memory_consumption () const
 
 //---------------------------------------------------------------------------
 
-template <int dim>
-ZeroFunction<dim>::ZeroFunction (const unsigned int n_components)
+template <int dim, typename Number>
+ZeroFunction<dim, Number>::ZeroFunction (const unsigned int n_components)
   :
-  Function<dim> (n_components)
+  Function<dim, Number> (n_components)
 {}
 
 
-template <int dim>
-ZeroFunction<dim>::~ZeroFunction ()
+template <int dim, typename Number>
+ZeroFunction<dim, Number>::~ZeroFunction ()
 {}
 
 
-template <int dim>
-double ZeroFunction<dim>::value (const Point<dim> &,
+template <int dim, typename Number>
+Number ZeroFunction<dim, Number>::value (const Point<dim, Number> &,
                                  const unsigned int) const
 {
   return 0.;
 }
 
 
-template <int dim>
-void ZeroFunction<dim>::vector_value (const Point<dim> &,
-                                      Vector<double>   &return_value) const
+template <int dim, typename Number>
+void ZeroFunction<dim, Number>::vector_value (const Point<dim, Number> &,
+                                      Vector<Number>   &return_value) const
 {
   Assert (return_value.size() == this->n_components,
           ExcDimensionMismatch (return_value.size(), this->n_components));
@@ -276,9 +276,9 @@ void ZeroFunction<dim>::vector_value (const Point<dim> &,
 }
 
 
-template <int dim>
-void ZeroFunction<dim>::value_list (const std::vector<Point<dim> > &points,
-                                    std::vector<double>            &values,
+template <int dim, typename Number>
+void ZeroFunction<dim, Number>::value_list (const std::vector<Point<dim, Number> > &points,
+                                    std::vector<Number>            &values,
                                     const unsigned int         /*component*/) const
 {
   Assert (values.size() == points.size(),
@@ -288,9 +288,9 @@ void ZeroFunction<dim>::value_list (const std::vector<Point<dim> > &points,
 }
 
 
-template <int dim>
-void ZeroFunction<dim>::vector_value_list (const std::vector<Point<dim> > &points,
-                                           std::vector<Vector<double> >   &values) const
+template <int dim, typename Number>
+void ZeroFunction<dim, Number>::vector_value_list (const std::vector<Point<dim, Number> > &points,
+                                           std::vector<Vector<Number> >   &values) const
 {
   Assert (values.size() == points.size(),
           ExcDimensionMismatch(values.size(), points.size()));
@@ -304,17 +304,17 @@ void ZeroFunction<dim>::vector_value_list (const std::vector<Point<dim> > &point
 }
 
 
-template <int dim>
-Tensor<1,dim> ZeroFunction<dim>::gradient (const Point<dim> &,
+template <int dim, typename Number>
+Tensor<1,dim,Number> ZeroFunction<dim, Number>::gradient (const Point<dim, Number> &,
                                            const unsigned int) const
 {
-  return Tensor<1,dim>();
+  return Tensor<1,dim,Number>();
 }
 
 
-template <int dim>
-void ZeroFunction<dim>::vector_gradient (const Point<dim> &,
-                                         std::vector<Tensor<1,dim> > &gradients) const
+template <int dim, typename Number>
+void ZeroFunction<dim, Number>::vector_gradient (const Point<dim, Number> &,
+                                         std::vector<Tensor<1,dim,Number> > &gradients) const
 {
   Assert (gradients.size() == this->n_components,
           ExcDimensionMismatch(gradients.size(), this->n_components));
@@ -324,9 +324,9 @@ void ZeroFunction<dim>::vector_gradient (const Point<dim> &,
 }
 
 
-template <int dim>
-void ZeroFunction<dim>::gradient_list (const std::vector<Point<dim> > &points,
-                                       std::vector<Tensor<1,dim> >    &gradients,
+template <int dim, typename Number>
+void ZeroFunction<dim, Number>::gradient_list (const std::vector<Point<dim, Number> > &points,
+                                       std::vector<Tensor<1,dim,Number> >    &gradients,
                                        const unsigned int              /*component*/) const
 {
   Assert (gradients.size() == points.size(),
@@ -337,9 +337,9 @@ void ZeroFunction<dim>::gradient_list (const std::vector<Point<dim> > &points,
 }
 
 
-template <int dim>
-void ZeroFunction<dim>::vector_gradient_list (const std::vector<Point<dim> >            &points,
-                                              std::vector<std::vector<Tensor<1,dim> > > &gradients) const
+template <int dim, typename Number>
+void ZeroFunction<dim, Number>::vector_gradient_list (const std::vector<Point<dim, Number> >            &points,
+                                              std::vector<std::vector<Tensor<1,dim,Number> > > &gradients) const
 {
   Assert (gradients.size() == points.size(),
           ExcDimensionMismatch(gradients.size(), points.size()));
@@ -355,23 +355,23 @@ void ZeroFunction<dim>::vector_gradient_list (const std::vector<Point<dim> >
 //---------------------------------------------------------------------------
 
 
-template <int dim>
-ConstantFunction<dim>::ConstantFunction (const double value,
+template <int dim, typename Number>
+ConstantFunction<dim, Number>::ConstantFunction (const Number value,
                                          const unsigned int n_components)
   :
-  ZeroFunction<dim> (n_components),
+  ZeroFunction<dim, Number> (n_components),
   function_value    (value)
 {}
 
 
 
-template <int dim>
-ConstantFunction<dim>::~ConstantFunction () {}
+template <int dim, typename Number>
+ConstantFunction<dim, Number>::~ConstantFunction () {}
 
 
 
-template <int dim>
-double ConstantFunction<dim>::value (const Point<dim> &,
+template <int dim, typename Number>
+Number ConstantFunction<dim, Number>::value (const Point<dim, Number> &,
                                      const unsigned int component) const
 {
   Assert (component < this->n_components,
@@ -381,9 +381,9 @@ double ConstantFunction<dim>::value (const Point<dim> &,
 
 
 
-template <int dim>
-void ConstantFunction<dim>::vector_value (const Point<dim> &,
-                                          Vector<double>   &return_value) const
+template <int dim, typename Number>
+void ConstantFunction<dim, Number>::vector_value (const Point<dim, Number> &,
+                                          Vector<Number>   &return_value) const
 {
   Assert (return_value.size() == this->n_components,
           ExcDimensionMismatch (return_value.size(), this->n_components));
@@ -393,9 +393,9 @@ void ConstantFunction<dim>::vector_value (const Point<dim> &,
 
 
 
-template <int dim>
-void ConstantFunction<dim>::value_list (const std::vector<Point<dim> > &points,
-                                        std::vector<double>            &values,
+template <int dim, typename Number>
+void ConstantFunction<dim, Number>::value_list (const std::vector<Point<dim, Number> > &points,
+                                        std::vector<Number>            &values,
                                         const unsigned int              component) const
 {
   Assert (component < this->n_components,
@@ -408,9 +408,9 @@ void ConstantFunction<dim>::value_list (const std::vector<Point<dim> > &points,
 
 
 
-template <int dim>
-void ConstantFunction<dim>::vector_value_list (const std::vector<Point<dim> > &points,
-                                               std::vector<Vector<double> >   &values) const
+template <int dim, typename Number>
+void ConstantFunction<dim, Number>::vector_value_list (const std::vector<Point<dim, Number> > &points,
+                                               std::vector<Vector<Number> >   &values) const
 {
   Assert (values.size() == points.size(),
           ExcDimensionMismatch(values.size(), points.size()));
@@ -425,9 +425,9 @@ void ConstantFunction<dim>::vector_value_list (const std::vector<Point<dim> > &p
 
 
 
-template <int dim>
+template <int dim, typename Number>
 std::size_t
-ConstantFunction<dim>::memory_consumption () const
+ConstantFunction<dim, Number>::memory_consumption () const
 {
   // only simple data elements, so
   // use sizeof operator
@@ -436,24 +436,24 @@ ConstantFunction<dim>::memory_consumption () const
 
 //---------------------------------------------------------------------------
 
-template <int dim>
-ComponentSelectFunction<dim>::
+template <int dim, typename Number>
+ComponentSelectFunction<dim, Number>::
 ComponentSelectFunction (const unsigned int selected,
-                         const double value,
+                         const Number value,
                          const unsigned int n_components)
   :
-  ConstantFunction<dim> (value, n_components),
+  ConstantFunction<dim, Number> (value, n_components),
   selected_components(std::make_pair(selected,selected+1))
 {}
 
 
 
-template <int dim>
-ComponentSelectFunction<dim>::
+template <int dim, typename Number>
+ComponentSelectFunction<dim, Number>::
 ComponentSelectFunction (const unsigned int selected,
                          const unsigned int n_components)
   :
-  ConstantFunction<dim> (1., n_components),
+  ConstantFunction<dim, Number> (1., n_components),
   selected_components(std::make_pair(selected,selected+1))
 {
   Assert (selected < n_components,
@@ -462,12 +462,12 @@ ComponentSelectFunction (const unsigned int selected,
 
 
 
-template <int dim>
-ComponentSelectFunction<dim>::
+template <int dim, typename Number>
+ComponentSelectFunction<dim, Number>::
 ComponentSelectFunction (const std::pair<unsigned int,unsigned int> &selected,
                          const unsigned int n_components)
   :
-  ConstantFunction<dim> (1., n_components),
+  ConstantFunction<dim, Number> (1., n_components),
   selected_components(selected)
 {
   Assert (selected_components.first < selected_components.second,
@@ -480,9 +480,9 @@ ComponentSelectFunction (const std::pair<unsigned int,unsigned int> &selected,
 
 
 
-template <int dim>
-void ComponentSelectFunction<dim>::vector_value (const Point<dim> &,
-                                                 Vector<double>   &return_value) const
+template <int dim, typename Number>
+void ComponentSelectFunction<dim, Number>::vector_value (const Point<dim, Number> &,
+                                                 Vector<Number>   &return_value) const
 {
   Assert (return_value.size() == this->n_components,
           ExcDimensionMismatch (return_value.size(), this->n_components));
@@ -495,23 +495,23 @@ void ComponentSelectFunction<dim>::vector_value (const Point<dim> &,
 
 
 
-template <int dim>
-void ComponentSelectFunction<dim>::vector_value_list (const std::vector<Point<dim> > &points,
-                                                      std::vector<Vector<double> >   &values) const
+template <int dim, typename Number>
+void ComponentSelectFunction<dim, Number>::vector_value_list (const std::vector<Point<dim, Number> > &points,
+                                                      std::vector<Vector<Number> >   &values) const
 {
   Assert (values.size() == points.size(),
           ExcDimensionMismatch(values.size(), points.size()));
 
   for (unsigned int i=0; i<points.size(); ++i)
-    ComponentSelectFunction<dim>::vector_value (points[i],
+    ComponentSelectFunction<dim, Number>::vector_value (points[i],
                                                 values[i]);
 }
 
 
 
-template <int dim>
+template <int dim, typename Number>
 std::size_t
-ComponentSelectFunction<dim>::memory_consumption () const
+ComponentSelectFunction<dim, Number>::memory_consumption () const
 {
   // only simple data elements, so
   // use sizeof operator
@@ -519,19 +519,19 @@ ComponentSelectFunction<dim>::memory_consumption () const
 }
 
 
-template <int dim>
-ScalarFunctionFromFunctionObject<dim>::
-ScalarFunctionFromFunctionObject (const std_cxx1x::function<double (const Point<dim> &)> &function_object)
+template <int dim, typename Number>
+ScalarFunctionFromFunctionObject<dim, Number>::
+ScalarFunctionFromFunctionObject (const std_cxx1x::function<Number (const Point<dim, Number> &)> &function_object)
   :
-  Function<dim>(1),
+  Function<dim, Number>(1),
   function_object (function_object)
 {}
 
 
 
-template <int dim>
-double
-ScalarFunctionFromFunctionObject<dim>::value (const Point<dim> &p,
+template <int dim, typename Number>
+Number
+ScalarFunctionFromFunctionObject<dim, Number>::value (const Point<dim, Number> &p,
                                               const unsigned int component) const
 {
   Assert (component == 0,
@@ -541,13 +541,13 @@ ScalarFunctionFromFunctionObject<dim>::value (const Point<dim> &p,
 
 
 
-template <int dim>
-VectorFunctionFromScalarFunctionObject<dim>::
-VectorFunctionFromScalarFunctionObject (const std_cxx1x::function<double (const Point<dim> &)> &function_object,
+template <int dim, typename Number>
+VectorFunctionFromScalarFunctionObject<dim, Number>::
+VectorFunctionFromScalarFunctionObject (const std_cxx1x::function<Number (const Point<dim, Number> &)> &function_object,
                                         const unsigned int selected_component,
                                         const unsigned int n_components)
   :
-  Function<dim>(n_components),
+  Function<dim, Number>(n_components),
   function_object (function_object),
   selected_component (selected_component)
 {
@@ -557,9 +557,9 @@ VectorFunctionFromScalarFunctionObject (const std_cxx1x::function<double (const
 
 
 
-template <int dim>
-double
-VectorFunctionFromScalarFunctionObject<dim>::value (const Point<dim> &p,
+template <int dim, typename Number>
+Number
+VectorFunctionFromScalarFunctionObject<dim, Number>::value (const Point<dim, Number> &p,
                                                     const unsigned int component) const
 {
   Assert (component < this->n_components,
@@ -573,11 +573,11 @@ VectorFunctionFromScalarFunctionObject<dim>::value (const Point<dim> &p,
 
 
 
-template <int dim>
+template <int dim, typename Number>
 void
-VectorFunctionFromScalarFunctionObject<dim>::
-vector_value (const Point<dim>   &p,
-              Vector<double>     &values) const
+VectorFunctionFromScalarFunctionObject<dim, Number>::
+vector_value (const Point<dim, Number>   &p,
+              Vector<Number>     &values) const
 {
   AssertDimension(values.size(), this->n_components);
 
@@ -592,31 +592,31 @@ vector_value (const Point<dim>   &p,
  * The constructor for <tt>VectorFunctionFromTensorFunction</tt> which initiates the return vector
  * to be size <tt>n_components</tt>.
  */
-template <int dim>
-VectorFunctionFromTensorFunction<dim>::VectorFunctionFromTensorFunction (const TensorFunction<1,dim> &tensor_function,
+template <int dim, typename Number>
+VectorFunctionFromTensorFunction<dim, Number>::VectorFunctionFromTensorFunction (const TensorFunction<1,dim,Number> &tensor_function,
     const unsigned int selected_component,
     const unsigned int n_components)
   :
-  Function<dim> (n_components),
+  Function<dim, Number> (n_components),
   tensor_function (tensor_function),
   selected_component (selected_component)
 {
 
-  // Verify that the Tensor<1,dim> will fit in the given length selected_components
+  // Verify that the Tensor<1,dim,Number> will fit in the given length selected_components
   // and not hang over the end of the vector.
   Assert (selected_component + dim - 1 < this->n_components,
           ExcIndexRange (selected_component, 0, this->n_components));
 }
 
 
-template <int dim>
-VectorFunctionFromTensorFunction<dim>::~VectorFunctionFromTensorFunction ()
+template <int dim, typename Number>
+VectorFunctionFromTensorFunction<dim, Number>::~VectorFunctionFromTensorFunction ()
 {}
 
 
-template <int dim>
+template <int dim, typename Number>
 inline
-double VectorFunctionFromTensorFunction<dim>::value (const Point<dim> &p,
+Number VectorFunctionFromTensorFunction<dim, Number>::value (const Point<dim, Number> &p,
                                                      const unsigned int component) const
 {
   Assert (component<this->n_components,
@@ -632,16 +632,16 @@ double VectorFunctionFromTensorFunction<dim>::value (const Point<dim> &p,
   // otherwise retrieve the values from the <tt>tensor_function</tt> to be
   // placed at the <tt>selected_component</tt> to <tt>selected_component + dim - 1</tt>
   // elements of the <tt>Vector</tt> values and pick the correct one
-  const Tensor<1,dim> tensor_value = tensor_function.value (p);
+  const Tensor<1,dim,Number> tensor_value = tensor_function.value (p);
 
   return tensor_value[component-selected_component];
 }
 
 
-template <int dim>
+template <int dim, typename Number>
 inline
-void VectorFunctionFromTensorFunction<dim>::vector_value (const Point<dim> &p,
-                                                          Vector<double>   &values) const
+void VectorFunctionFromTensorFunction<dim, Number>::vector_value (const Point<dim, Number> &p,
+                                                          Vector<Number>   &values) const
 {
   Assert(values.size() == this->n_components,
          ExcDimensionMismatch(values.size(),this->n_components));
@@ -649,7 +649,7 @@ void VectorFunctionFromTensorFunction<dim>::vector_value (const Point<dim> &p,
   // Retrieve the values from the <tt>tensor_function</tt> to be
   // placed at the <tt>selected_component</tt> to <tt>selected_component + dim - 1</tt>
   // elements of the <tt>Vector</tt> values.
-  const Tensor<1,dim> tensor_value = tensor_function.value (p);
+  const Tensor<1,dim,Number> tensor_value = tensor_function.value (p);
 
   // First we make all elements of values = 0
   values = 0;
@@ -661,13 +661,13 @@ void VectorFunctionFromTensorFunction<dim>::vector_value (const Point<dim> &p,
 
 
 /** Member function <tt>vector_value_list </tt> is the interface for giving a list of
- * points (<code>vector<Point<dim> ></code>) of which to evaluate using the <tt>vector_value</tt>
+ * points (<code>vector<Point<dim, Number> ></code>) of which to evaluate using the <tt>vector_value</tt>
  * member function.  Again, this function is written so as to not replicate the function definition
  * but passes each point on to <tt>vector_value</tt> to be evaluated.
  */
-template <int dim>
-void VectorFunctionFromTensorFunction<dim>::vector_value_list (const std::vector<Point<dim> > &points,
-    std::vector<Vector<double> > &value_list) const
+template <int dim, typename Number>
+void VectorFunctionFromTensorFunction<dim, Number>::vector_value_list (const std::vector<Point<dim, Number> > &points,
+    std::vector<Vector<Number> > &value_list) const
 {
   Assert (value_list.size() == points.size(),
           ExcDimensionMismatch (value_list.size(), points.size()));
@@ -675,7 +675,7 @@ void VectorFunctionFromTensorFunction<dim>::vector_value_list (const std::vector
   const unsigned int n_points = points.size();
 
   for (unsigned int p=0; p<n_points; ++p)
-    VectorFunctionFromTensorFunction<dim>::vector_value (points[p], value_list[p]);
+    VectorFunctionFromTensorFunction<dim, Number>::vector_value (points[p], value_list[p]);
 }
 
 
index b726a6551e57d7281b987f92d984267c0f1ab355..2dc9fc6fbd1d1abd49c72de4f6a46145c09dc2c5 100644 (file)
 DEAL_II_NAMESPACE_OPEN
 
 
-FunctionTime::FunctionTime(const double initial_time)
+template<typename Number>
+FunctionTime<Number>::FunctionTime(const Number initial_time)
   :
   time(initial_time)
 {}
 
 
 
-FunctionTime::~FunctionTime()
+template<typename Number>
+FunctionTime<Number>::~FunctionTime()
 {}
 
 
 
+template<typename Number>
 void
-FunctionTime::set_time (const double new_time)
+FunctionTime<Number>::set_time (const Number new_time)
 {
   time = new_time;
 }
 
 
-
+template<typename Number>
 void
-FunctionTime::advance_time (const double delta_t)
+FunctionTime<Number>::advance_time (const Number delta_t)
 {
   set_time (time+delta_t);
 }
 
+// Explicit instantiation
+template class FunctionTime<double>;
+
 DEAL_II_NAMESPACE_CLOSE
+
index 93c80d0eb2dd622570bacadb0582d219fa693a61..f4b7415effd4a335bcb91cfab07d3d4c5ac6c000 100644 (file)
@@ -28,31 +28,31 @@ DEAL_II_NAMESPACE_OPEN
 // TensorFunction
 //////////////////////////////////////////////////////////////////////
 
-template <int rank, int dim>
-TensorFunction<rank, dim>::TensorFunction (const double initial_time)
+template <int rank, int dim, typename Number>
+TensorFunction<rank, dim, Number>::TensorFunction (const Number initial_time)
   :
-  FunctionTime (initial_time)
+  FunctionTime<Number> (initial_time)
 {}
 
 
 
-template <int rank, int dim>
-TensorFunction<rank, dim>::~TensorFunction ()
+template <int rank, int dim, typename Number>
+TensorFunction<rank, dim, Number>::~TensorFunction ()
 {}
 
 
-template <int rank, int dim>
-typename TensorFunction<rank, dim>::value_type
-TensorFunction<rank, dim>::value (const Point<dim> &) const
+template <int rank, int dim, typename Number>
+typename TensorFunction<rank, dim, Number>::value_type
+TensorFunction<rank, dim, Number>::value (const Point<dim,Number> &) const
 {
   Assert (false, ExcPureFunctionCalled());
   return Tensor<rank,dim>();
 }
 
 
-template <int rank, int dim>
+template <int rank, int dim, typename Number>
 void
-TensorFunction<rank, dim>::value_list (const std::vector<Point<dim> > &points,
+TensorFunction<rank, dim, Number>::value_list (const std::vector<Point<dim,Number> > &points,
                                        std::vector<value_type>        &values) const
 {
   Assert (values.size() == points.size(),
@@ -63,18 +63,18 @@ TensorFunction<rank, dim>::value_list (const std::vector<Point<dim> > &points,
 }
 
 
-template <int rank, int dim>
-typename TensorFunction<rank, dim>::gradient_type
-TensorFunction<rank, dim>::gradient (const Point<dim> &) const
+template <int rank, int dim, typename Number>
+typename TensorFunction<rank, dim, Number>::gradient_type
+TensorFunction<rank, dim, Number>::gradient (const Point<dim,Number> &) const
 {
   Assert (false, ExcPureFunctionCalled());
   return Tensor<rank+1,dim>();
 }
 
 
-template <int rank, int dim>
+template <int rank, int dim, typename Number>
 void
-TensorFunction<rank, dim>::gradient_list (const std::vector<Point<dim> >   &points,
+TensorFunction<rank, dim, Number>::gradient_list (const std::vector<Point<dim,Number> >   &points,
                                           std::vector<gradient_type> &gradients) const
 {
   Assert (gradients.size() == points.size(),
@@ -91,32 +91,32 @@ TensorFunction<rank, dim>::gradient_list (const std::vector<Point<dim> >   &poin
 //////////////////////////////////////////////////////////////////////
 
 
-template <int rank, int dim>
-ConstantTensorFunction<rank, dim>::ConstantTensorFunction (const Tensor<rank, dim> &value,
-                                                           const double initial_time)
+template <int rank, int dim, typename Number>
+ConstantTensorFunction<rank, dim, Number>::ConstantTensorFunction (const Tensor<rank, dim, Number> &value,
+                                                                  const Number initial_time)
   :
-  TensorFunction<rank, dim> (initial_time),
+  TensorFunction<rank, dim, Number> (initial_time),
   _value(value)
 {}
 
 
-template <int rank, int dim>
-ConstantTensorFunction<rank, dim>::~ConstantTensorFunction ()
+template <int rank, int dim, typename Number>
+ConstantTensorFunction<rank, dim, Number>::~ConstantTensorFunction ()
 {}
 
 
-template <int rank, int dim>
-typename TensorFunction<rank, dim>::value_type
-ConstantTensorFunction<rank, dim>::value (const Point<dim> &/*point*/) const
+template <int rank, int dim, typename Number>
+typename TensorFunction<rank, dim, Number>::value_type
+ConstantTensorFunction<rank, dim, Number>::value (const Point<dim,Number> &/*point*/) const
 {
   return _value;
 }
 
 
-template <int rank, int dim>
+template <int rank, int dim, typename Number>
 void
-ConstantTensorFunction<rank, dim>::value_list (const std::vector<Point<dim> > &points,
-                                               std::vector<typename TensorFunction<rank, dim>::value_type> &values) const
+ConstantTensorFunction<rank, dim, Number>::value_list (const std::vector<Point<dim,Number> > &points,
+                                               std::vector<typename TensorFunction<rank, dim, Number>::value_type> &values) const
 {
   Assert (values.size() == points.size(),
           ExcDimensionMismatch(values.size(), points.size()));
@@ -126,9 +126,9 @@ ConstantTensorFunction<rank, dim>::value_list (const std::vector<Point<dim> > &p
 }
 
 
-template <int rank, int dim>
-typename TensorFunction<rank, dim>::gradient_type
-ConstantTensorFunction<rank, dim>::gradient (const Point<dim> &) const
+template <int rank, int dim, typename Number>
+typename TensorFunction<rank, dim, Number>::gradient_type
+ConstantTensorFunction<rank, dim, Number>::gradient (const Point<dim,Number> &) const
 {
   static const Tensor<rank+1,dim> zero;
 
@@ -136,10 +136,10 @@ ConstantTensorFunction<rank, dim>::gradient (const Point<dim> &) const
 }
 
 
-template <int rank, int dim>
+template <int rank, int dim, typename Number>
 void
-ConstantTensorFunction<rank, dim>::gradient_list (const std::vector<Point<dim> >   &points,
-                                                  std::vector<typename TensorFunction<rank, dim>::gradient_type> &gradients) const
+ConstantTensorFunction<rank, dim, Number>::gradient_list (const std::vector<Point<dim,Number> >   &points,
+                                                  std::vector<typename TensorFunction<rank, dim, Number>::gradient_type> &gradients) const
 {
   Assert (gradients.size() == points.size(),
           ExcDimensionMismatch(gradients.size(), points.size()));
@@ -157,10 +157,10 @@ ConstantTensorFunction<rank, dim>::gradient_list (const std::vector<Point<dim> >
 //////////////////////////////////////////////////////////////////////
 
 
-template <int rank, int dim>
-ZeroTensorFunction<rank, dim>::ZeroTensorFunction (const double initial_time)
+template <int rank, int dim, typename Number>
+ZeroTensorFunction<rank, dim, Number>::ZeroTensorFunction (const Number initial_time)
   :
-  ConstantTensorFunction<rank, dim> (dealii::Tensor<rank, dim>(), initial_time)
+  ConstantTensorFunction<rank, dim, Number> (dealii::Tensor<rank, dim, Number>(), initial_time)
 {}
 
 
index afd5647f65ea62750992668cd330392eac5df7fd..6622f529ed52438e22442beb15c7402188fcc2b3 100644 (file)
@@ -689,17 +689,31 @@ void GridOut::write_dx (const Triangulation<1> &,
   Assert (false, ExcNotImplemented());
 }
 
+template <>
+void GridOut::write_dx (const Triangulation<1,2> &,
+                        std::ostream &) const
+{
+  Assert (false, ExcNotImplemented());
+}
+
+template <>
+void GridOut::write_dx (const Triangulation<1,3> &,
+                        std::ostream &) const
+{
+  Assert (false, ExcNotImplemented());
+}
+
 
 
-template <int dim>
-void GridOut::write_dx (const Triangulation<dim> &tria,
+template <int dim, int spacedim>
+void GridOut::write_dx (const Triangulation<dim, spacedim> &tria,
                         std::ostream             &out) const
 {
 //TODO:[GK] allow for boundary faces only
   Assert(dx_flags.write_all_faces, ExcNotImplemented());
   AssertThrow (out, ExcIO());
   // Copied and adapted from write_ucd
-  const std::vector<Point<dim> > &vertices    = tria.get_vertices();
+  const std::vector<Point<spacedim> > &vertices    = tria.get_vertices();
   const std::vector<bool>        &vertex_used = tria.get_used_vertices();
 
   const unsigned int n_vertices = tria.n_used_vertices();
@@ -718,8 +732,8 @@ void GridOut::write_dx (const Triangulation<dim> &tria,
       renumber[i]=new_number++;
   Assert(new_number==n_vertices, ExcInternalError());
 
-  typename Triangulation<dim>::active_cell_iterator       cell;
-  const typename Triangulation<dim>::active_cell_iterator endc=tria.end();
+  typename Triangulation<dim, spacedim>::active_cell_iterator       cell;
+  const typename Triangulation<dim, spacedim>::active_cell_iterator endc=tria.end();
 
 
   // write the vertices
@@ -809,7 +823,7 @@ void GridOut::write_dx (const Triangulation<dim> &tria,
         {
           for (unsigned int f=0; f<GeometryInfo<dim>::faces_per_cell; ++f)
             {
-              typename Triangulation<dim>::face_iterator face = cell->face(f);
+              typename Triangulation<dim, spacedim>::face_iterator face = cell->face(f);
 
               for (unsigned int v=0; v<GeometryInfo<dim>::vertices_per_face; ++v)
                 out << '\t' << renumber[face->vertex_index(GeometryInfo<dim-1>::dx_to_deal[v])];
@@ -1192,11 +1206,11 @@ void GridOut::write_ucd (const Triangulation<dim,spacedim> &tria,
 
 
 
-template <int dim>
+template <int dim, int spacedim>
 void GridOut::write_xfig (
-  const Triangulation<dim> &,
+  const Triangulation<dim, spacedim> &,
   std::ostream &,
-  const Mapping<dim> *) const
+  const Mapping<dim, spacedim> *) const
 {
   Assert (false, ExcNotImplemented());
 }
@@ -1210,6 +1224,7 @@ void GridOut::write_xfig (
   const Mapping<2> *       /*mapping*/) const
 {
   const int dim = 2;
+  const int spacedim = 2;
 
   const unsigned int nv = GeometryInfo<dim>::vertices_per_cell;
   const unsigned int nf = GeometryInfo<dim>::faces_per_cell;
@@ -1272,8 +1287,8 @@ void GridOut::write_xfig (
   // on finer levels. Level 0
   // corresponds to a depth of 900,
   // each level subtracting 1
-  Triangulation<dim>::cell_iterator cell = tria.begin();
-  const Triangulation<dim>::cell_iterator end = tria.end();
+  Triangulation<dim, spacedim>::cell_iterator cell = tria.begin();
+  const Triangulation<dim, spacedim>::cell_iterator end = tria.end();
 
   for (; cell != end; ++cell)
     {
@@ -1339,7 +1354,7 @@ void GridOut::write_xfig (
       if (xfig_flags.draw_boundary)
         for (unsigned int f=0; f<nf; ++f)
           {
-            Triangulation<dim>::face_iterator
+            Triangulation<dim, spacedim>::face_iterator
             face = cell->face(face_reorder[f]);
             const types::boundary_id bi = face->boundary_indicator();
             if (bi != numbers::internal_face_boundary_id)
@@ -2264,8 +2279,8 @@ void GridOut::write_mathgl (const Triangulation<1> &,
 }
 
 
-template <int dim>
-void GridOut::write_mathgl (const Triangulation<dim> &tria,
+template <int dim, int spacedim>
+void GridOut::write_mathgl (const Triangulation<dim, spacedim> &tria,
                             std::ostream             &out) const
 {
   AssertThrow (out, ExcIO ());
@@ -2356,7 +2371,7 @@ void GridOut::write_mathgl (const Triangulation<dim> &tria,
 
   // run over all active cells and write out a list of
   // xyz-coordinates that correspond to vertices
-  typename dealii::Triangulation<dim>::active_cell_iterator
+  typename dealii::Triangulation<dim, spacedim>::active_cell_iterator
   cell=tria.begin_active (),
   endc=tria.end ();
 
@@ -3345,12 +3360,30 @@ namespace internal
       Assert(false, ExcNotImplemented());
     }
 
+    void write_eps (const dealii::Triangulation<1,2> &,
+                    std::ostream &,
+                    const Mapping<1,2> *,
+                    const GridOutFlags::Eps<2> &,
+                    const GridOutFlags::Eps<3> &)
+    {
+      Assert(false, ExcNotImplemented());
+    }
 
+    void write_eps (const dealii::Triangulation<2,3> &,
+                    std::ostream &,
+                    const Mapping<2,3> *,
+                    const GridOutFlags::Eps<2> &,
+                    const GridOutFlags::Eps<3> &)
+    {
+      Assert(false, ExcNotImplemented());
+    }
 
-    template <int dim>
-    void write_eps (const dealii::Triangulation<dim> &tria,
+
+
+    template <int dim, int spacedim>
+    void write_eps (const dealii::Triangulation<dim, spacedim> &tria,
                     std::ostream             &out,
-                    const Mapping<dim>       *mapping,
+                    const Mapping<dim,spacedim>       *mapping,
                     const GridOutFlags::Eps<2> &eps_flags_2,
                     const GridOutFlags::Eps<3> &eps_flags_3)
     {
@@ -3394,13 +3427,13 @@ namespace internal
 
         case 2:
         {
-          for (typename dealii::Triangulation<dim>::active_cell_iterator
+          for (typename dealii::Triangulation<dim, spacedim>::active_cell_iterator
               cell=tria.begin_active();
               cell!=tria.end(); ++cell)
             for (unsigned int line_no=0;
                  line_no<GeometryInfo<dim>::lines_per_cell; ++line_no)
               {
-                typename dealii::Triangulation<dim>::line_iterator
+                typename dealii::Triangulation<dim, spacedim>::line_iterator
                 line=cell->line(line_no);
 
                 // first treat all
@@ -3467,12 +3500,12 @@ namespace internal
               // boundary faces and
               // generate the info from
               // them
-              for (typename dealii::Triangulation<dim>::active_cell_iterator
+              for (typename dealii::Triangulation<dim, spacedim>::active_cell_iterator
                   cell=tria.begin_active();
                   cell!=tria.end(); ++cell)
                 for (unsigned int face_no=0; face_no<GeometryInfo<dim>::faces_per_cell; ++face_no)
                   {
-                    const typename dealii::Triangulation<dim>::face_iterator
+                    const typename dealii::Triangulation<dim, spacedim>::face_iterator
                     face = cell->face(face_no);
 
                     if (face->at_boundary())
@@ -3517,7 +3550,7 @@ namespace internal
           // presently not supported
           Assert (mapping == 0, ExcNotImplemented());
 
-          typename dealii::Triangulation<dim>::active_cell_iterator
+          typename dealii::Triangulation<dim, spacedim>::active_cell_iterator
           cell=tria.begin_active(),
           endc=tria.end();
 
@@ -3568,7 +3601,7 @@ namespace internal
             for (unsigned int line_no=0;
                  line_no<GeometryInfo<dim>::lines_per_cell; ++line_no)
               {
-                typename dealii::Triangulation<dim>::line_iterator
+                typename dealii::Triangulation<dim, spacedim>::line_iterator
                 line=cell->line(line_no);
                 line_list.push_back (LineEntry(Point<2>(line->vertex(0) * unit_vector2,
                                                         line->vertex(0) * unit_vector1),
@@ -3734,7 +3767,7 @@ namespace internal
           out << "(Helvetica) findfont 140 scalefont setfont"
               << '\n';
 
-          typename dealii::Triangulation<dim>::active_cell_iterator
+          typename dealii::Triangulation<dim, spacedim>::active_cell_iterator
           cell = tria.begin_active (),
           endc = tria.end ();
           for (; cell!=endc; ++cell)
@@ -3765,7 +3798,7 @@ namespace internal
           // already tracked, to avoid
           // doing this multiply
           std::set<unsigned int> treated_vertices;
-          typename dealii::Triangulation<dim>::active_cell_iterator
+          typename dealii::Triangulation<dim, spacedim>::active_cell_iterator
           cell = tria.begin_active (),
           endc = tria.end ();
           for (; cell!=endc; ++cell)
@@ -3801,10 +3834,10 @@ namespace internal
 }
 
 
-template <int dim>
-void GridOut::write_eps (const Triangulation<dim> &tria,
+template <int dim, int spacedim>
+void GridOut::write_eps (const Triangulation<dim, spacedim> &tria,
                          std::ostream             &out,
-                         const Mapping<dim>       *mapping) const
+                         const Mapping<dim,spacedim>       *mapping) const
 {
   internal::write_eps (tria, out, mapping,
                        eps_flags_2, eps_flags_3);
index 160a8fd98f1d02feca236fd6867b9449507356a2..c9cbe7f4bbe153f639cfe5f32742c76edc76a38a 100644 (file)
@@ -82,6 +82,15 @@ for (deal_II_dimension : DIMENSIONS)
    template void GridOut::write_vtu
       (const Triangulation<deal_II_dimension,deal_II_dimension+1>&,
        std::ostream&) const;
+
+    template void GridOut::write<deal_II_dimension,deal_II_dimension+1>
+      (const Triangulation<deal_II_dimension,deal_II_dimension+1> &,
+       std::ostream &, const OutputFormat,
+       const Mapping<deal_II_dimension,deal_II_dimension+1> *) const;
+    template void GridOut::write<deal_II_dimension,deal_II_dimension+1>
+      (const Triangulation<deal_II_dimension,deal_II_dimension+1> &,
+       std::ostream &, const Mapping<deal_II_dimension,deal_II_dimension+1> *) const;
+
 #endif
 #if deal_II_dimension == 3
    template void GridOut::write_ucd

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.