// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
*
* Still not implemented.
*/
- void evaluate_convergence_rates (const string &data_column_key,
- const string &reference_column_key,
- const RateMode rate_mode);
+ void evaluate_convergence_rates (const std::string &data_column_key,
+ const std::string &reference_column_key,
+ const RateMode rate_mode);
/**
* the @p{set_tex_supercaption (...)} function
* of the base class @p{TableHandler}.
*/
- void evaluate_convergence_rates (const string &data_column_key,
- const RateMode rate_mode);
+ void evaluate_convergence_rates (const std::string &data_column_key,
+ const RateMode rate_mode);
/**
* Omit this column @p{key}
* omitting the column from convergence
* rate evalution.
*/
- void omit_column_from_convergence_rate_evaluation(const string &key);
+ void omit_column_from_convergence_rate_evaluation(const std::string &key);
/**
* Evaluates convergence rates
* should omitted by calling the
* @p{omit_column_from_convergence_rate_evaluation(..)}.
*/
- void evaluate_all_convergence_rates(const string &reference_column_key,
- const RateMode rate_mode);
+ void evaluate_all_convergence_rates(const std::string &reference_column_key,
+ const RateMode rate_mode);
/**
* Evaluates convergence rates
* Exception
*/
DeclException1 (ExcRateColumnAlreadyExists,
- string,
+ std::string,
<< "Rate column <" << arg1 << "> does already exist.");
};
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* not be determined exactly
* (for example: what is the
* memory consumption of an
- * STL @p{map} type with a
+ * STL @p{std::map} type with a
* certain number of
* elements?), this is only
* an estimate. however often
* not be determined exactly
* (for example: what is the
* memory consumption of an
- * STL @p{map} type with a
+ * STL @p{std::map} type with a
* certain number of
* elements?), this is only
* an estimate. however often
* not be determined exactly
* (for example: what is the
* memory consumption of an
- * STL @p{map} type with a
+ * STL @p{std::map} type with a
* certain number of
* elements?), this is only
* an estimate. however often
* not be determined exactly
* (for example: what is the
* memory consumption of an
- * STL @p{map} type with a
+ * STL @p{std::map} type with a
* certain number of
* elements?), this is only
* an estimate. however often
* not be determined exactly
* (for example: what is the
* memory consumption of an
- * STL @p{map} type with a
+ * STL @p{std::map} type with a
* certain number of
* elements?), this is only
* an estimate. however often
* not be determined exactly
* (for example: what is the
* memory consumption of an
- * STL @p{map} type with a
+ * STL @p{std::map} type with a
* certain number of
* elements?), this is only
* an estimate. however often
* on the parameters.
*/
template <int dim, int spacedim>
- static void write_ucd (const vector<Patch<dim,spacedim> > &patches,
- const vector<string> &data_names,
- const UcdFlags &flags,
- ostream &out);
+ static void write_ucd (const
std::vector<Patch<dim,spacedim> > &patches,
+ const std::vector<std::string> &data_names,
+ const UcdFlags &flags,
+ std::ostream &out);
/**
* Write the given list of patches
* on the parameters.
*/
template <int dim, int spacedim>
- static void write_gnuplot (const vector<Patch<dim,spacedim> > &patches,
- const vector<string> &data_names,
- const GnuplotFlags &flags,
- ostream &out);
+ static void write_gnuplot (const
std::vector<Patch<dim,spacedim> > &patches,
+ const std::vector<std::string> &data_names,
+ const GnuplotFlags &flags,
+ std::ostream &out);
/**
* Write the given list of patches
* on the parameters.
*/
template <int dim, int spacedim>
- static void write_povray (const vector<Patch<dim,spacedim> > &patches,
- const vector<string> &data_names,
- const PovrayFlags &flags,
- ostream &out);
+ static void write_povray (const
std::vector<Patch<dim,spacedim> > &patches,
+ const std::vector<std::string> &data_names,
+ const PovrayFlags &flags,
+ std::ostream &out);
/**
* Write the given list of patches
* on the parameters.
*/
template <int dim, int spacedim>
- static void write_eps (const vector<Patch<dim,spacedim> > &patches,
- const vector<string> &data_names,
- const EpsFlags &flags,
- ostream &out);
+ static void write_eps (const
std::vector<Patch<dim,spacedim> > &patches,
+ const std::vector<std::string> &data_names,
+ const EpsFlags &flags,
+ std::ostream &out);
/**
* Write the given list of patches
* on the parameters.
*/
template <int dim, int spacedim>
- static void write_gmv (const vector<Patch<dim,spacedim> > &patches,
- const vector<string> &data_names,
- const GmvFlags &flags,
- ostream &out);
+ static void write_gmv (const
std::vector<Patch<dim,spacedim> > &patches,
+ const std::vector<std::string> &data_names,
+ const GmvFlags &flags,
+ std::ostream &out);
/**
* Determine an estimate for
* not be determined exactly
* (for example: what is the
* memory consumption of an
- * STL @p{map} type with a
+ * STL @p{std::map} type with a
* certain number of
* elements?), this is only
* an estimate. however often
*/
template <int dim, int spacedim>
static void
- write_gmv_reorder_data_vectors (const vector<Patch<dim,spacedim> > &patches,
- vector<vector<double> > &data_vectors);
+ write_gmv_reorder_data_vectors (const
std::vector<Patch<dim,spacedim> > &patches,
+ std::vector<std::vector<double> > &data_vectors);
};
* function and write it to @p{out} in
* UCD format.
*/
- void write_ucd (ostream &out) const;
+ void write_ucd (std::ostream &out) const;
/**
* Obtain data through the @p{get_patches}
* function and write it to @p{out} in
* GNUPLOT format.
*/
- void write_gnuplot (ostream &out) const;
+ void write_gnuplot (std::ostream &out) const;
/**
* Obtain data through the @p{get_patches}
* function and write it to @p{out} in
* POVRAY format.
*/
- void write_povray (ostream &out) const;
+ void write_povray (std::ostream &out) const;
/**
* Obtain data through the @p{get_patches}
* function and write it to @p{out} in
* EPS format.
*/
- void write_eps (ostream &out) const;
+ void write_eps (std::ostream &out) const;
/**
* Obtain data through the @p{get_patches}
* function and write it to @p{out} in
* GMV format.
*/
- void write_gmv (ostream &out) const;
+ void write_gmv (std::ostream &out) const;
/**
* Write data and grid to @p{out} according
* An error occurs if no format is provided and
* the default format is @p{default_format}.
*/
- void write (ostream &out, const OutputFormat output_format = default_format) const;
+ void write (std::ostream &out,
+ const OutputFormat output_format = default_format) const;
/**
* Set the default format. The value set here
* suffix for the
* @p{default_format} is returned.
*/
- string default_suffix (const OutputFormat output_format = default_format) const;
+ std::string default_suffix (const OutputFormat output_format = default_format) const;
/**
* Return the @p{OutputFormat} value
* @p{ParameterHandler} class, use the
* function @p{get_output_format_names ()}.
*/
- static OutputFormat parse_output_format (const string &format_name);
+ static OutputFormat parse_output_format (const std::string &format_name);
/**
* Return a list of implemented output
* as used by the @p{ParameterHandler}
* classes.
*/
- static string get_output_format_names ();
+ static std::string get_output_format_names ();
/**
* Declare parameters for all output
* not be determined exactly
* (for example: what is the
* memory consumption of an
- * STL @p{map} type with a
+ * STL @p{std::map} type with a
* certain number of
* elements?), this is only
* an estimate. however often
* allow the output functions to
* know what they shall print.
*/
- virtual const vector<DataOutBase::Patch<dim,spacedim> > &
+ virtual const std::vector<DataOutBase::Patch<dim,spacedim> > &
get_patches () const = 0;
/**
* obtained by the output functions
* of the base class.
*/
- virtual vector<string> get_dataset_names () const = 0;
+ virtual std::vector<std::string> get_dataset_names () const = 0;
private:
/**
* This declares an exception class named @p{ExcDomain}, which
* has two variables as additional information (named
* @p{arg1} and @p{arg2} by default) and which outputs the
- * given sequence (which is appended to an @p{ostream}
+ * given sequence (which is appended to an @p{std::ostream}
* variable's name, thus the weird syntax). There are
* other @p{DeclExceptionN} macros for exception classes
* with more or no parameters. It is proposed to let start
* In @p{__IssueError} the given data
* is transferred into the @p{exc} object by calling the
* @p{SetFields} function; after that, the general error info
- * is printed onto @p{cerr} using the @p{PrintError} function of
+ * is printed onto @p{std::cerr} using the @p{PrintError} function of
* @p{exc} and finally the exception specific data is printed
* using the user defined function @p{PrintError} (which is
* normally created using the @p{DeclException (...)} macro
* do_something ();
* }
* catch (exception &e) {
- * cerr << "Exception occured:" << endl
+ * std::cerr << "Exception occured:" << std::endl
* << e.what ()
- * << endl;
+ * << std::endl;
* do_something_to_reciver ();
* };
* @end{verbatim}
* public:
* name (const type1 a1, const type2 a2) :
* arg1 (a1), arg2(a2) {};
- * virtual void PrintInfo (ostream &out) const {
- * out outsequence << endl;
+ * virtual void PrintInfo (std::ostream &out) const {
+ * out outsequence << std::endl;
* };
* private:
* type1 arg1;
*
* @author Wolfgang Bangerth, November 1997, extensions 1998
*/
-class ExceptionBase : public exception
+class ExceptionBase : public std::exception
{
public:
/**
* Print out the general part of the error
* information.
*/
- void PrintExcData (ostream &out) const;
+ void PrintExcData (std::ostream &out) const;
/**
* Print more specific information about the
* exception which occured. Overload this
* function in your own exception classes.
*/
- virtual void PrintInfo (ostream &out) const;
+ virtual void PrintInfo (std::ostream &out) const;
/**
{
// Fill the fields of the exception object
e.SetFields (file, line, function, cond, exc_name);
- cerr << "--------------------------------------------------------"
- << endl;
+ std::cerr << "--------------------------------------------------------"
+ << std::endl;
// print out general data
- e.PrintExcData (cerr);
+ e.PrintExcData (std::cerr);
// print out exception specific data
- e.PrintInfo (cerr);
- cerr << "--------------------------------------------------------"
- << endl;
+ e.PrintInfo (std::cerr);
+ std::cerr << "--------------------------------------------------------"
+ << std::endl;
abort ();
};
class Exception1 : public ExceptionBase { \
public: \
Exception1 (const type1 a1) : arg1 (a1) {}; \
- virtual void PrintInfo (ostream &out) const { \
- out outsequence << endl; \
+ virtual void PrintInfo (std::ostream &out) const { \
+ out outsequence << std::endl; \
}; \
private: \
const type1 arg1; \
public: \
Exception2 (const type1 a1, const type2 a2) : \
arg1 (a1), arg2(a2) {}; \
- virtual void PrintInfo (ostream &out) const { \
- out outsequence << endl; \
+ virtual void PrintInfo (std::ostream &out) const { \
+ out outsequence << std::endl; \
}; \
private: \
const type1 arg1; \
public: \
Exception3 (const type1 a1, const type2 a2, const type3 a3) : \
arg1 (a1), arg2(a2), arg3(a3) {}; \
- virtual void PrintInfo (ostream &out) const { \
- out outsequence << endl; \
+ virtual void PrintInfo (std::ostream &out) const { \
+ out outsequence << std::endl; \
}; \
private: \
const type1 arg1; \
Exception4 (const type1 a1, const type2 a2, \
const type3 a3, const type4 a4) : \
arg1 (a1), arg2(a2), arg3(a3), arg4(a4) {}; \
- virtual void PrintInfo (ostream &out) const { \
- out outsequence << endl; \
+ virtual void PrintInfo (std::ostream &out) const { \
+ out outsequence << std::endl; \
}; \
private: \
const type1 arg1; \
Exception5 (const type1 a1, const type2 a2, const type3 a3, \
const type4 a4, const type5 a5) : \
arg1 (a1), arg2(a2), arg3(a3), arg4(a4), arg5(a5) {}; \
- virtual void PrintInfo (ostream &out) const { \
- out outsequence << endl; \
+ virtual void PrintInfo (std::ostream &out) const { \
+ out outsequence << std::endl; \
}; \
private: \
const type1 arg1; \
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* components at a list of points at once:
* @begin{verbatim}
* // access to one component at several points
- * void value_list (const vector<Point<dim> > &point_list,
- * vector<double> &value_list,
+ * void value_list (const
std::vector<Point<dim> > &point_list,
+ * std::vector<double> &value_list,
* const unsigned int component = 0) const;
*
* // return all components at several points
- * void vector_value_list (const vector<Point<dim> > &point_list,
- * vector<Vector<double> > &value_list) const;
+ * void vector_value_list (const
std::vector<Point<dim> > &point_list,
+ * std::vector<Vector<double> > &value_list) const;
* @end{verbatim}
*
* Furthermore, there are functions returning the gradient of the
* right size, i.e. the same
* size as the @p{points} array.
*/
- virtual void value_list (const vector<Point<dim> > &points,
- vector<double> &values,
- const unsigned int component = 0) const;
+ virtual void value_list (const
std::vector<Point<dim> > &points,
+ std::vector<double> &values,
+ const unsigned int component = 0) const;
/**
* Set @p{values} to the point
* the same number of components
* as this function has.
*/
- virtual void vector_value_list (const vector<Point<dim> > &points,
- vector<Vector<double> > &values) const;
+ virtual void vector_value_list (const
std::vector<Point<dim> > &points,
+ std::vector<Vector<double> > &values) const;
/**
* Return the gradient of the
* components of the
* function at the given point.
*/
- virtual void vector_gradient (const Point<dim> &p,
- vector<Tensor<1,dim> > &gradients) const;
+ virtual void vector_gradient (const Point<dim> &p,
+ std::vector<Tensor<1,dim> > &gradients) const;
/**
* Set @p{gradients} to the
* right size, i.e. the same
* size as the @p{points} array.
*/
- virtual void gradient_list (const vector<Point<dim> > &points,
- vector<Tensor<1,dim> > &gradients,
- const unsigned int component = 0) const;
+ virtual void gradient_list (const
std::vector<Point<dim> > &points,
+ std::vector<Tensor<1,dim> > &gradients,
+ const unsigned int component = 0) const;
/**
* Set @p{gradients} to the gradients of
* over the different components
* of the function.
*/
- virtual void vector_gradient_list (const vector<Point<dim> > &points,
- vector<vector<Tensor<1,dim> > > &gradients) const;
+ virtual void vector_gradient_list (const std::vector<Point<dim> > &points,
+ std::vector<std::vector<Tensor<1,dim> > > &gradients) const;
/**
* Compute the Laplacian of a
* store them in @p{values}.
*/
virtual void vector_laplacian (const Point<dim> &p,
- Vector<double> &values) const;
+ Vector<double> &values) const;
/**
* Compute the Laplacian of one
* component at a set of points.
*/
- virtual void laplacian_list (const vector<Point<dim> > &points,
- vector<double> &values,
- const unsigned int component = 0) const;
+ virtual void laplacian_list (const
std::vector<Point<dim> > &points,
+ std::vector<double> &values,
+ const unsigned int component = 0) const;
/**
* Compute the Laplacians of all
* components at a set of points.
*/
- virtual void vector_laplacian_list (const vector<Point<dim> > &points,
- vector<Vector<double> > &values) const;
+ virtual void vector_laplacian_list (const
std::vector<Point<dim> > &points,
+ std::vector<Vector<double> > &values) const;
/**
* Determine an estimate for
* not be determined exactly
* (for example: what is the
* memory consumption of an
- * STL @p{map} type with a
+ * STL @p{std::map} type with a
* certain number of
* elements?), this is only
* an estimate. however often
* the same size as the @p{points}
* array.
*/
- virtual void value_list (const vector<Point<dim> > &points,
- vector<double> &values,
- const unsigned int component = 0) const;
+ virtual void value_list (const
std::vector<Point<dim> > &points,
+ std::vector<double> &values,
+ const unsigned int component = 0) const;
/**
* Set @p{values} to the point values
* the same size as the @p{points}
* array.
*/
- virtual void vector_value_list (const vector<Point<dim> > &points,
- vector<Vector<double> > &values) const;
+ virtual void vector_value_list (const
std::vector<Point<dim> > &points,
+ std::vector<Vector<double> > &values) const;
/**
* Return the gradient of the function
* function at the given point,
* for all components.
*/
- virtual void vector_gradient (const Point<dim> &p,
- vector<Tensor<1,dim> > &gradients) const;
+ virtual void vector_gradient (const Point<dim> &p,
+ std::vector<Tensor<1,dim> > &gradients) const;
/**
* Set @p{gradients} to the gradients of
* already has the right size, i.e.
* the same size as the @p{points} array.
*/
- virtual void gradient_list (const vector<Point<dim> > &points,
- vector<Tensor<1,dim> > &gradients,
- const unsigned int component = 0) const;
+ virtual void gradient_list (const
std::vector<Point<dim> > &points,
+ std::vector<Tensor<1,dim> > &gradients,
+ const unsigned int component = 0) const;
/**
* Set @p{gradients} to the gradients of
* over the different components
* of the function.
*/
- virtual void vector_gradient_list (const vector<Point<dim> > &points,
- vector<vector<Tensor<1,dim> > > &gradients) const;
+ virtual void vector_gradient_list (const std::vector<Point<dim> > &points,
+ std::vector<std::vector<Tensor<1,dim> > > &gradients) const;
};
* the same size as the @p{points}
* array.
*/
- virtual void value_list (const vector<Point<dim> > &points,
- vector<double> &values,
- const unsigned int component = 0) const;
+ virtual void value_list (const
std::vector<Point<dim> > &points,
+ std::vector<double> &values,
+ const unsigned int component = 0) const;
/**
* Set @p{values} to the point values
* the same size as the @p{points}
* array.
*/
- virtual void vector_value_list (const vector<Point<dim> > &points,
- vector<Vector<double> > &values) const;
+ virtual void vector_value_list (const
std::vector<Point<dim> > &points,
+ std::vector<Vector<double> > &values) const;
/**
* Determine an estimate for
* not be determined exactly
* (for example: what is the
* memory consumption of an
- * STL @p{map} type with a
+ * STL @p{std::map} type with a
* certain number of
* elements?), this is only
* an estimate. however often
* the same size as the @p{points}
* array.
*/
- virtual void vector_value_list (const vector<Point<dim> > &points,
- vector<Vector<double> > &values) const;
+ virtual void vector_value_list (const
std::vector<Point<dim> > &points,
+ std::vector<Vector<double> > &values) const;
/**
* Determine an estimate for
* not be determined exactly
* (for example: what is the
* memory consumption of an
- * STL @p{map} type with a
+ * STL @p{std::map} type with a
* certain number of
* elements?), this is only
* an estimate. however often
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
/**
* Function values at multiple points.
*/
- virtual void value_list (const vector<Point<dim> > &points,
- vector<double> &values,
- const unsigned int component = 0) const;
+ virtual void value_list (const
std::vector<Point<dim> > &points,
+ std::vector<double> &values,
+ const unsigned int component = 0) const;
/**
* Determine an estimate for
* not be determined exactly
* (for example: what is the
* memory consumption of an
- * STL @p{map} type with a
+ * STL @p{std::map} type with a
* certain number of
* elements?), this is only
* an estimate. however often
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
/**
* Function values at multiple points.
*/
- virtual void value_list (const vector<Point<dim> > &points,
- vector<double> &values,
- const unsigned int component = 0) const;
+ virtual void value_list (const
std::vector<Point<dim> > &points,
+ std::vector<double> &values,
+ const unsigned int component = 0) const;
/**
* Gradient at one point.
/**
Gradients at multiple points.
- */
- virtual void gradient_list (const vector<Point<dim> > &points,
- vector<Tensor<1,dim> > &gradients,
- const unsigned int component = 0) const;
+ */
+ virtual void gradient_list (const
std::vector<Point<dim> > &points,
+ std::vector<Tensor<1,dim> > &gradients,
+ const unsigned int component = 0) const;
/**
* Laplacian of the function at one point.
/**
* Laplacian of the function at multiple points.
*/
- virtual void laplacian_list (const vector<Point<dim> > &points,
- vector<double> &values,
- const unsigned int component = 0) const;
+ virtual void laplacian_list (const
std::vector<Point<dim> > &points,
+ std::vector<double> &values,
+ const unsigned int component = 0) const;
};
/**
* Function values at multiple points.
*/
- virtual void value_list (const vector<Point<dim> > &points,
- vector<double> &values,
- const unsigned int component = 0) const;
+ virtual void value_list (const
std::vector<Point<dim> > &points,
+ std::vector<double> &values,
+ const unsigned int component = 0) const;
/**
* Gradient at one point.
*/
virtual Tensor<1,dim> gradient (const Point<dim> &p,
- const unsigned int component = 0) const;
+ const unsigned int component = 0) const;
/**
Gradients at multiple points.
- */
- virtual void gradient_list (const vector<Point<dim> > &points,
- vector<Tensor<1,dim> > &gradients,
- const unsigned int component = 0) const;
-
+ */
+ virtual void gradient_list (const
std::vector<Point<dim> > &points,
+ std::vector<Tensor<1,dim> > &gradients,
+ const unsigned int component = 0) const;
+
/**
* Laplacian of the function at one point.
*/
/**
* Laplacian of the function at multiple points.
*/
- virtual void laplacian_list (const vector<Point<dim> > &points,
- vector<double> &values,
- const unsigned int component = 0) const;
+ virtual void laplacian_list (const
std::vector<Point<dim> > &points,
+ std::vector<double> &values,
+ const unsigned int component = 0) const;
};
/**
* Values at multiple points.
*/
- virtual void value_list (const vector<Point<dim> > &points,
- vector<double> &values,
- const unsigned int component = 0) const;
+ virtual void value_list (const
std::vector<Point<dim> > &points,
+ std::vector<double> &values,
+ const unsigned int component = 0) const;
/**
* Gradient at a single point.
/**
* Gradients at multiple points.
*/
- virtual void gradient_list (const vector<Point<dim> > &points,
- vector<Tensor<1,dim> > &gradients,
- const unsigned int component = 0) const;
+ virtual void gradient_list (const
std::vector<Point<dim> > &points,
+ std::vector<Tensor<1,dim> > &gradients,
+ const unsigned int component = 0) const;
/**
* Laplacian at a single point.
/**
* Laplacian at multiple points.
*/
- virtual void laplacian_list (const vector<Point<dim> > &points,
- vector<double> &values,
- const unsigned int component = 0) const;
+ virtual void laplacian_list (const
std::vector<Point<dim> > &points,
+ std::vector<double> &values,
+ const unsigned int component = 0) const;
private:
const double offset;
};
/**
* Values at multiple points.
*/
- virtual void value_list (const vector<Point<dim> > &points,
- vector<double> &values,
- const unsigned int component = 0) const;
+ virtual void value_list (const
std::vector<Point<dim> > &points,
+ std::vector<double> &values,
+ const unsigned int component = 0) const;
/**
* Gradient at a single point.
/**
* Gradients at multiple points.
*/
- virtual void gradient_list (const vector<Point<dim> > &points,
- vector<Tensor<1,dim> > &gradients,
- const unsigned int component = 0) const;
+ virtual void gradient_list (const
std::vector<Point<dim> > &points,
+ std::vector<Tensor<1,dim> > &gradients,
+ const unsigned int component = 0) const;
/**
* Laplacian at a single point.
/**
* Laplacian at multiple points.
*/
- virtual void laplacian_list (const vector<Point<dim> > &points,
- vector<double> &values,
- const unsigned int component = 0) const;
+ virtual void laplacian_list (const
std::vector<Point<dim> > &points,
+ std::vector<double> &values,
+ const unsigned int component = 0) const;
};
/**
* Values at multiple points.
*/
- virtual void value_list (const vector<Point<dim> > &points,
- vector<double> &values,
- const unsigned int component = 0) const;
+ virtual void value_list (const
std::vector<Point<dim> > &points,
+ std::vector<double> &values,
+ const unsigned int component = 0) const;
/**
* Gradient at a single point.
/**
* Gradients at multiple points.
*/
- virtual void gradient_list (const vector<Point<dim> > &points,
- vector<Tensor<1,dim> > &gradients,
- const unsigned int component = 0) const;
+ virtual void gradient_list (const
std::vector<Point<dim> > &points,
+ std::vector<Tensor<1,dim> > &gradients,
+ const unsigned int component = 0) const;
/**
* Laplacian at a single point.
/**
* Laplacian at multiple points.
*/
- virtual void laplacian_list (const vector<Point<dim> > &points,
- vector<double> &values,
- const unsigned int component = 0) const;
+ virtual void laplacian_list (const
std::vector<Point<dim> > &points,
+ std::vector<double> &values,
+ const unsigned int component = 0) const;
};
/**
* Values at multiple points.
*/
- virtual void value_list (const vector<Point<2> > &points,
- vector<double> &values,
- const unsigned int component = 0) const;
+ virtual void value_list (const
std::vector<Point<2> > &points,
+ std::vector<double> &values,
+ const unsigned int component = 0) const;
/**
* Gradient at a single point.
*/
- virtual Tensor<1,2> gradient (const Point<2> &p,
- const unsigned int component = 0) const;
+ virtual Tensor<1,2> gradient (const Point<2> &p,
+ const unsigned int component = 0) const;
/**
* Gradients at multiple points.
*/
- virtual void gradient_list (const vector<Point<2> > &points,
- vector<Tensor<1,2> > &gradients,
- const unsigned int component = 0) const;
+ virtual void gradient_list (const
std::vector<Point<2> > &points,
+ std::vector<Tensor<1,2> > &gradients,
+ const unsigned int component = 0) const;
/**
* Laplacian at a single point.
/**
* Laplacian at multiple points.
*/
- virtual void laplacian_list (const vector<Point<2> > &points,
- vector<double> &values,
- const unsigned int component = 0) const;
+ virtual void laplacian_list (const
std::vector<Point<2> > &points,
+ std::vector<double> &values,
+ const unsigned int component = 0) const;
};
/**
* Values at multiple points.
*/
- virtual void value_list (const vector<Point<2> > &points,
- vector<double> &values,
- const unsigned int component = 0) const;
+ virtual void value_list (const
std::vector<Point<2> > &points,
+ std::vector<double> &values,
+ const unsigned int component = 0) const;
/**
* Gradient at a single point.
*/
virtual Tensor<1,2> gradient (const Point<2> &p,
- const unsigned int component = 0) const;
+ const unsigned int component = 0) const;
/**
* Gradients at multiple points.
*/
- virtual void gradient_list (const vector<Point<2> > &points,
- vector<Tensor<1,2> > &gradients,
- const unsigned int component = 0) const;
+ virtual void gradient_list (const
std::vector<Point<2> > &points,
+ std::vector<Tensor<1,2> > &gradients,
+ const unsigned int component = 0) const;
/**
* Laplacian at a single point.
/**
* Laplacian at multiple points.
*/
- virtual void laplacian_list (const vector<Point<2> > &points,
- vector<double> &values,
- const unsigned int component = 0) const;
+ virtual void laplacian_list (const
std::vector<Point<2> > &points,
+ std::vector<double> &values,
+ const unsigned int component = 0) const;
};
/**
* Function values at multiple points.
*/
- virtual void value_list (const vector<Point<dim> > &points,
- vector<double> &values,
- const unsigned int component = 0) const;
+ virtual void value_list (const
std::vector<Point<dim> > &points,
+ std::vector<double> &values,
+ const unsigned int component = 0) const;
/**
* Gradient at one point.
/**
Gradients at multiple points.
- */
- virtual void gradient_list (const vector<Point<dim> > &points,
- vector<Tensor<1,dim> > &gradients,
- const unsigned int component = 0) const;
+ */
+ virtual void gradient_list (const
std::vector<Point<dim> > &points,
+ std::vector<Tensor<1,dim> > &gradients,
+ const unsigned int component = 0) const;
/**
* Laplacian of the function at one point.
/**
* Laplacian of the function at multiple points.
*/
- virtual void laplacian_list (const vector<Point<dim> > &points,
- vector<double> &values,
- const unsigned int component = 0) const;
+ virtual void laplacian_list (const
std::vector<Point<dim> > &points,
+ std::vector<double> &values,
+ const unsigned int component = 0) const;
/**
* Determine an estimate for
* not be determined exactly
* (for example: what is the
* memory consumption of an
- * STL @p{map} type with a
+ * STL @p{std::map} type with a
* certain number of
* elements?), this is only
* an estimate. however often
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
class JobIdentifier
{
public:
+ /**
+ * Constructor. Set program
+ * identifier to value of
+ * @p{program_id} concatenated
+ * with the present time.
+ */
JobIdentifier();
- ~JobIdentifier();
-
+
+ /**
+ * ???
+ */
static const char* program_id();
- const string operator () ()const;
+
+ /**
+ * Return the value of @p{id}.
+ */
+ const std::string operator () ()const;
+
private:
- string id;
+ /**
+ * String holding the identifier
+ * of the presently running
+ * program.
+ */
+ std::string id;
};
/*------------------------------ Inline functions ------------------------------*/
+
+/**
+ * Global object to identify the presently running program.
+ */
extern JobIdentifier dealjobid;
#endif
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* The usual usage of this class is through the pregenerated object
* @p{deallog}. Typical steps are
* @begin{itemize}
- * @item @p{deallog.attach(ostream)}: write logging information into a file.
+ * @item @p{deallog.attach(std::ostream)}: write logging information into a file.
* @item @p{deallog.depth_console(n)}: restrict output on screen to outer loops.
* @item Before entering a new phase of your program, e.g. a new loop,
* @p{deallog.push("loopname")}.
- * @item @p{deallog << anything << endl;} to write logging information
- * (Usage of @p{endl} is mandatory!).
+ * @item @p{deallog << anything << std::endl;} to write logging information
+ * (Usage of @p{std::endl} is mandatory!).
* @item @p{deallog.pop()} when leaving that stage entered with @p{push}.
* @end{itemize}
*
* allow identification where the
* output was generated.
*/
- stack<string> prefixes;
+ std::stack<std::string> prefixes;
/**
* Default stream, where the output
* is to go to. This stream defaults
- * to @p{cerr}, but can be set to another
+ * to @p{std::cerr}, but can be set to another
* stream through the constructor.
*/
- ostream *std_out;
+ std::ostream *std_out;
/**
* Pointer to a stream, where a copy of
* You can set and reset this stream
* by the @p{attach} function.
*/
- ostream *file;
+ std::ostream *file;
/**
* Flag which stores whether the
* Standard constructor, since we
* intend to provide an object
* @p{deallog} in the library. Set the
- * standard output stream to @p{cerr}.
+ * standard output stream to @p{std::cerr}.
*/
LogStream();
* Enable output to a second
* stream @p{o}.
*/
- void attach(ostream& o);
+ void attach(std::ostream& o);
/**
* Disable output to the second
/**
* Gives the default stream (@p{std_out}).
*/
- ostream& get_console();
+ std::ostream& get_console();
/**
* Gives the file stream.
*/
- ostream& get_file_stream();
+ std::ostream& get_file_stream();
/**
* Push another prefix on the
* colon and there is a double
* colon after the last prefix.
*/
- void push (const string& text);
+ void push (const std::string& text);
/**
* Remove the last prefix.
* function on the present object. It
* works the same way as it is possible
* to output the stream manipulators
- * (like @p{endl}, etc) work on standard
- * streams: @p{stream << endl;}. We need
+ * (like @p{std::endl}, etc) work on standard
+ * streams: @p{stream << std::endl;}. We need
* to overload this function in order
* to know when we have to print the
* prefixes, since a user may use several
* calls to @p{operator <<} before the
* line is complete. The overloaded
- * function @p{void endl(LogStream &)}
+ * function @p{void std::endl(LogStream &)}
* tells the @p{LogStream} that the end of
* the line is reached.
*/
* not be determined exactly
* (for example: what is the
* memory consumption of an
- * STL @p{map} type with a
+ * STL @p{std::map} type with a
* certain number of
* elements?), this is only
* an estimate. however often
LogStream::operator<< (const T& t)
{
// if the previous command was an
- // @p{endl}, print the topmost prefix
+ // @p{std::endl}, print the topmost prefix
// and a colon
if (was_endl)
{
/**
- * Replacement of @p{endl} for @p{LogStream}.
+ * Replacement of @p{std::endl} for @p{LogStream}.
*
- * Overloaded version of the stream manipulator function @p{endl} which
- * results in calling the original version of @p{endl} for each of the
+ * Overloaded version of the stream manipulator function @p{std::endl} which
+ * results in calling the original version of @p{std::endl} for each of the
* two streams, if the present prefix number does not exceed the
* specified maximal number.
*
inline void endl(LogStream& s)
{
if (s.prefixes.size() <= s.std_depth)
- *s.std_out << endl;
+ *s.std_out << std::endl;
if (s.file && (s.prefixes.size() <= s.file_depth))
- *s.file << endl;
+ *s.file << std::endl;
s.was_endl = true;
};
#endif
+
+
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* This namespace provides functions helping to determine the amount
* of memory used by objects. The goal is not necessarily to give the
* amount of memory used up to the last bit (what is the memory used
- * by an STL @p{map<>} object?), but rather to aid in the search for
+ * by an STL @p{std::map<>} object?), but rather to aid in the search for
* memory bottlenecks.
*
* The functions in this namespace work basically by reducing each
* operator to it. If this is not the case, then try to reduce it to
* more basic types.
*
- * For example, if it is a C-style array or a standard C++ @p{vector},
+ * For example, if it is a C-style array or a standard C++ @p{std::vector},
* then sum up the sizes of the array elements by calling
* @p{memory_consumption} on each of them. This way, we can also
- * reduce objects of type @p{vector<vector<double> >} to its atomic
+ * reduce objects of type @p{std::vector<std::vector<double> >} to its atomic
* types, and can thus determine the memory used even if the sizes of
* the elements of the outermost vector differ (e.g. the first
* sub-vector has 3 and the second sub-vector has 10 elements).
*
* There are two exceptions to simply adding up the sizes of the
- * subobjects: for C++ @p{vector} objects, we also have to add the
+ * subobjects: for C++ @p{std::vector} objects, we also have to add the
* size of the vector object, i.e. @p{sizeof(vector<T>)}, to the sizes
* of the elements. Secondly, for the most common used vectors, such
- * as @p{vector<double>} and @p{vector<unsigned int>} we determine the
+ * as @p{std::vector<double>} and @p{std::vector<unsigned int>} we determine the
* size without a loop but rather directly, since we know that the
* sizes of the elements are constant.
*
/**
* Determine an estimate of the
* amount of memory in bytes
- * consumed by a @p{string}
+ * consumed by a @p{std::string}
* variable.
*/
- unsigned int memory_consumption (const string &s);
+ unsigned int memory_consumption (const std::string &s);
/**
* Determine an estimate of the
* amount of memory in bytes
- * consumed by a @p{vector} of
+ * consumed by a @p{std::vector} of
* certain elements. It does so by
* looping over all elements of the
* vector and determining their
* vectors of bools.
*/
template <typename T>
- unsigned int memory_consumption (const vector<T> &v);
+ unsigned int memory_consumption (const std::vector<T> &v);
/**
* Estimate the amount of memory
* store simple data elements
* like @p{double}s in such
* arrays (but rather use STL
- * @p{vector}s or deal.II
+ * @p{std::vector}s or deal.II
* @p{Vector} objects), we do not
* provide specializations like
- * for the @p{vector} arrays, but
+ * for the @p{std::vector} arrays, but
* always use the loop over all
* elements.
*/
* one-by-one, but as a bit
* field.
*/
- unsigned int memory_consumption (const vector<bool> &v);
+ unsigned int memory_consumption (const std::vector<bool> &v);
/**
* Specialization of the
* consumption of a vector, here
* for a vector of @p{int}s.
*/
- unsigned int memory_consumption (const vector<int> &v);
+ unsigned int memory_consumption (const std::vector<int> &v);
/**
* Specialization of the
* consumption of a vector, here
* for a vector of @p{double}s.
*/
- unsigned int memory_consumption (const vector<double> &v);
+ unsigned int memory_consumption (const std::vector<double> &v);
/**
* Specialization of the
* consumption of a vector, here
* for a vector of @p{float}s.
*/
- unsigned int memory_consumption (const vector<float> &v);
+ unsigned int memory_consumption (const std::vector<float> &v);
/**
* Specialization of the
* consumption of a vector, here
* for a vector of @p{char}s.
*/
- unsigned int memory_consumption (const vector<char> &v);
+ unsigned int memory_consumption (const std::vector<char> &v);
/**
* Specialization of the
* consumption of a vector, here
* for a vector of @p{unsigned char}s.
*/
- unsigned int memory_consumption (const vector<unsigned char> &v);
+ unsigned int memory_consumption (const std::vector<unsigned char> &v);
/**
* Specialization of the
* for a vector of pointers.
*/
template <typename T>
- unsigned int memory_consumption (const vector<T *> &v);
+ unsigned int memory_consumption (const std::vector<T *> &v);
/**
* Determine an estimate of the
* consumed by a pair of values.
*/
template <typename A, typename B>
- unsigned int memory_consumption (const pair<A,B> &p);
+ unsigned int memory_consumption (const
std::pair<A,B> &p);
/**
* Return the amount of memory
template <typename T>
- unsigned int memory_consumption (const vector<T> &v)
+ unsigned int memory_consumption (const std::vector<T> &v)
{
- unsigned int mem = sizeof(vector<T>);
+ unsigned int mem = sizeof(std::vector<T>);
const unsigned int n = v.size();
for (unsigned int i=0; i<n; ++i)
mem += memory_consumption(v[i]);
inline
- unsigned int memory_consumption (const vector<bool> &v)
+ unsigned int memory_consumption (const std::vector<bool> &v)
{
return v.capacity() / 8 + sizeof(v);
};
inline
- unsigned int memory_consumption (const vector<int> &v)
+ unsigned int memory_consumption (const std::vector<int> &v)
{
return (v.capacity() * sizeof(int) +
sizeof(v));
inline
- unsigned int memory_consumption (const vector<double> &v)
+ unsigned int memory_consumption (const std::vector<double> &v)
{
return (v.capacity() * sizeof(double) +
sizeof(v));
inline
- unsigned int memory_consumption (const vector<float> &v)
+ unsigned int memory_consumption (const std::vector<float> &v)
{
return (v.capacity() * sizeof(float) +
sizeof(v));
inline
- unsigned int memory_consumption (const vector<char> &v)
+ unsigned int memory_consumption (const std::vector<char> &v)
{
return (v.capacity() * sizeof(char) +
sizeof(v));
inline
- unsigned int memory_consumption (const vector<unsigned char> &v)
+ unsigned int memory_consumption (const std::vector<unsigned char> &v)
{
return (v.capacity() * sizeof(unsigned char) +
sizeof(v));
template <typename T>
inline
- unsigned int memory_consumption (const vector<T *> &v)
+ unsigned int memory_consumption (const std::vector<T *> &v)
{
return (v.capacity() * sizeof(T *) +
sizeof(v));
template <typename A, typename B>
inline
- unsigned int memory_consumption (const pair<A,B> &p)
+ unsigned int memory_consumption (const
std::pair<A,B> &p)
{
return (memory_consumption(p.first) +
memory_consumption(p.second));
// $Id$
// Version: $Name$
//
-// Copyright (C) 2000 by the deal.II authors
+// Copyright (C) 2000, 2001 by the deal authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* not be determined exactly
* (for example: what is the
* memory consumption of an
- * STL @p{map} type with a
+ * STL @p{std::map} type with a
* certain number of
* elements?), this is only
* an estimate. however often
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <string>
#include <base/exceptions.h>
-class istream;
-class ostream;
+// forward declaration
class LogStream;
/**
*/
namespace Patterns
{
- /**
- * Base class to declare common
- * interface.
+ /**
+ * Base class to declare common
+ * interface.
*/
- class PatternBase
- {
- public:
- /**
- * Make destructor of this and all
- * derived classes virtual.
- */
- virtual ~PatternBase ();
+ class PatternBase
+ {
+ public:
+ /**
+ * Make destructor of this and all
+ * derived classes virtual.
+ */
+ virtual ~PatternBase ();
- /**
- * Return true if the given string
- * matches the pattern.
- */
- virtual bool match (const string &test_string) const = 0;
+ /**
+ * Return true if the given string
+ * matches the pattern.
+ */
+ virtual bool match (const std::string &test_string) const = 0;
- /**
- * Return a string describing the
- * pattern.
- */
- virtual string description () const = 0;
+ /**
+ * Return a string describing the
+ * pattern.
+ */
+ virtual std::string description () const = 0;
- /**
- * Return a pointer to an
- * exact copy of the
- * object. This is necessary
- * since we want to store
- * objects of this type in
- * containers, were we need
- * to copy objects without
- * knowledge of their actual
- * data type (we only have
- * pointers to the base
- * class).
- *
- * Ownership of the objects
- * returned by this function
- * is passed to the caller of
- * this function.
- */
- virtual PatternBase * clone () const = 0;
-
- /**
- * Determine an estimate for
- * the memory consumption (in
- * bytes) of this object. To
- * avoid unnecessary
- * overhead, we do not force
- * derivd classes to provide
- * this function as a virtual
- * overloaded one, but rather
- * try to cast the present
- * object to one of the known
- * derived classes and if
- * that fails then take the
- * size of this base class
- * instead and add 32 byte
- * (this value is arbitrary,
- * it should account for
- * virtual function tables,
- * and some possible data
- * elements). Since there are
- * usually not many thousands
- * of objects of this type
- * around, and since the
- * @p{memory_consumption}
- * mechanism is used to find
- * out where memory in the
- * range of many megabytes
- * is, this seems like a
- * reasonable approximation.
- *
- * On the other hand, if you
- * know that your class
- * deviates from this
- * assumption significantly,
- * you can still overload
- * this function.
- */
- virtual unsigned int memory_consumption () const;
- };
+ /**
+ * Return a pointer to an
+ * exact copy of the
+ * object. This is necessary
+ * since we want to store
+ * objects of this type in
+ * containers, were we need
+ * to copy objects without
+ * knowledge of their actual
+ * data type (we only have
+ * pointers to the base
+ * class).
+ *
+ * Ownership of the objects
+ * returned by this function
+ * is passed to the caller of
+ * this function.
+ */
+ virtual PatternBase * clone () const = 0;
+
+ /**
+ * Determine an estimate for
+ * the memory consumption (in
+ * bytes) of this object. To
+ * avoid unnecessary
+ * overhead, we do not force
+ * derivd classes to provide
+ * this function as a virtual
+ * overloaded one, but rather
+ * try to cast the present
+ * object to one of the known
+ * derived classes and if
+ * that fails then take the
+ * size of this base class
+ * instead and add 32 byte
+ * (this value is arbitrary,
+ * it should account for
+ * virtual function tables,
+ * and some possible data
+ * elements). Since there are
+ * usually not many thousands
+ * of objects of this type
+ * around, and since the
+ * @p{memory_consumption}
+ * mechanism is used to find
+ * out where memory in the
+ * range of many megabytes
+ * is, this seems like a
+ * reasonable approximation.
+ *
+ * On the other hand, if you
+ * know that your class
+ * deviates from this
+ * assumption significantly,
+ * you can still overload
+ * this function.
+ */
+ virtual unsigned int memory_consumption () const;
+ };
- /**
+ /**
* Test for the string being an
* integer. If bounds are given
* to the constructor, then the
* performed), or in many other
* cases.
*/
- class Integer : public PatternBase
- {
- public:
- /**
- * Constructor. Bounds can be
- * specified within which a
- * valid parameter has to
- * be. If the upper bound is
- * smaller than the lower
- * bound, then the infinite
- * interval is meant. The
- * default values are chosen
- * such that no bounds are
- * enforced on parameters.
- */
- Integer (const int lower_bound = 1,
- const int upper_bound = 0);
+ class Integer : public PatternBase
+ {
+ public:
+ /**
+ * Constructor. Bounds can be
+ * specified within which a
+ * valid parameter has to
+ * be. If the upper bound is
+ * smaller than the lower
+ * bound, then the infinite
+ * interval is meant. The
+ * default values are chosen
+ * such that no bounds are
+ * enforced on parameters.
+ */
+ Integer (const int lower_bound = 1,
+ const int upper_bound = 0);
- /**
- * Return @p{true} if the
- * string is an integer and
- * its value is within the
- * specified range.
- */
- virtual bool match (const string &test_string) const;
-
- /**
- * Return a description of
- * the pattern that valid
- * string are expected to
- * match. If bounds were
- * specified to the
- * constructor, then include
- * them into this
- * description.
- */
- virtual string description () const;
-
- /**
- * Return a copy of the
- * present object, which is
- * newly allocated on the
- * heap. Ownership of that
- * object is transferred to
- * the caller of this
- * function.
- */
- virtual PatternBase * clone () const;
+ /**
+ * Return @p{true} if the
+ * string is an integer and
+ * its value is within the
+ * specified range.
+ */
+ virtual bool match (const std::string &test_string) const;
+
+ /**
+ * Return a description of
+ * the pattern that valid
+ * string are expected to
+ * match. If bounds were
+ * specified to the
+ * constructor, then include
+ * them into this
+ * description.
+ */
+ virtual std::string description () const;
+
+ /**
+ * Return a copy of the
+ * present object, which is
+ * newly allocated on the
+ * heap. Ownership of that
+ * object is transferred to
+ * the caller of this
+ * function.
+ */
+ virtual PatternBase * clone () const;
- private:
- /**
- * Value of the lower
- * bound. A number that
- * satisfies the @p{match}
- * operation of this class
- * must be equal to this
- * value or larger, if the
- * bounds of the interval for
- * a valid range.
- */
- const int lower_bound;
-
- /**
- * Value of the upper
- * bound. A number that
- * satisfies the @p{match}
- * operation of this class
- * must be equal to this
- * value or less, if the
- * bounds of the interval for
- * a valid range.
- */
- const int upper_bound;
- };
+ private:
+ /**
+ * Value of the lower
+ * bound. A number that
+ * satisfies the @p{match}
+ * operation of this class
+ * must be equal to this
+ * value or larger, if the
+ * bounds of the interval for
+ * a valid range.
+ */
+ const int lower_bound;
+
+ /**
+ * Value of the upper
+ * bound. A number that
+ * satisfies the @p{match}
+ * operation of this class
+ * must be equal to this
+ * value or less, if the
+ * bounds of the interval for
+ * a valid range.
+ */
+ const int upper_bound;
+ };
- /**
+ /**
* Test for the string being a
* @p{double}. If bounds are
* given to the constructor, then
* between zero and one), or in
* many other cases.
*/
- class Double : public PatternBase
- {
- public:
- /**
- * Constructor. Bounds can be
- * specified within which a
- * valid parameter has to
- * be. If the upper bound is
- * smaller than the lower
- * bound, then the infinite
- * interval is meant. The
- * default values are chosen
- * such that no bounds are
- * enforced on parameters.
- */
- Double (const int lower_bound = 1,
- const int upper_bound = 0);
+ class Double : public PatternBase
+ {
+ public:
+ /**
+ * Constructor. Bounds can be
+ * specified within which a
+ * valid parameter has to
+ * be. If the upper bound is
+ * smaller than the lower
+ * bound, then the infinite
+ * interval is meant. The
+ * default values are chosen
+ * such that no bounds are
+ * enforced on parameters.
+ */
+ Double (const int lower_bound = 1,
+ const int upper_bound = 0);
- /**
- * Return @p{true} if the
- * string is a number and its
- * value is within the
- * specified range.
- */
- virtual bool match (const string &test_string) const;
-
- /**
- * Return a description of
- * the pattern that valid
- * string are expected to
- * match. If bounds were
- * specified to the
- * constructor, then include
- * them into this
- * description.
- */
- virtual string description () const;
-
- /**
- * Return a copy of the
- * present object, which is
- * newly allocated on the
- * heap. Ownership of that
- * object is transferred to
- * the caller of this
- * function.
- */
- virtual PatternBase * clone () const;
+ /**
+ * Return @p{true} if the
+ * string is a number and its
+ * value is within the
+ * specified range.
+ */
+ virtual bool match (const std::string &test_string) const;
+
+ /**
+ * Return a description of
+ * the pattern that valid
+ * string are expected to
+ * match. If bounds were
+ * specified to the
+ * constructor, then include
+ * them into this
+ * description.
+ */
+ virtual std::string description () const;
+
+ /**
+ * Return a copy of the
+ * present object, which is
+ * newly allocated on the
+ * heap. Ownership of that
+ * object is transferred to
+ * the caller of this
+ * function.
+ */
+ virtual PatternBase * clone () const;
- private:
- /**
- * Value of the lower
- * bound. A number that
- * satisfies the @p{match}
- * operation of this class
- * must be equal to this
- * value or larger, if the
- * bounds of the interval for
- * a valid range.
- */
- const int lower_bound;
-
- /**
- * Value of the upper
- * bound. A number that
- * satisfies the @p{match}
- * operation of this class
- * must be equal to this
- * value or less, if the
- * bounds of the interval for
- * a valid range.
- */
- const int upper_bound;
- };
+ private:
+ /**
+ * Value of the lower
+ * bound. A number that
+ * satisfies the @p{match}
+ * operation of this class
+ * must be equal to this
+ * value or larger, if the
+ * bounds of the interval for
+ * a valid range.
+ */
+ const int lower_bound;
+
+ /**
+ * Value of the upper
+ * bound. A number that
+ * satisfies the @p{match}
+ * operation of this class
+ * must be equal to this
+ * value or less, if the
+ * bounds of the interval for
+ * a valid range.
+ */
+ const int upper_bound;
+ };
- /**
+ /**
* Test for the string being one
* of a sequence of values given
* like a regular expression. For
* pipe signs do not matter and
* are eliminated.
*/
- class Selection : public PatternBase
- {
- public:
- /**
- * Constructor. Take the
- * given parameter as the
- * specification of valid
- * strings.
- */
- Selection (const string &seq);
-
- /**
- * Return @p{true} if the
- * string is an element of
- * the description list
- * passed to the constructor.
- */
- virtual bool match (const string &test_string) const;
-
- /**
- * Return a description of
- * the pattern that valid
- * string are expected to
- * match. Here, this is the
- * list of valid strings
- * passed to the constructor.
- */
- virtual string description () const;
+ class Selection : public PatternBase
+ {
+ public:
+ /**
+ * Constructor. Take the
+ * given parameter as the
+ * specification of valid
+ * strings.
+ */
+ Selection (const std::string &seq);
+
+ /**
+ * Return @p{true} if the
+ * string is an element of
+ * the description list
+ * passed to the constructor.
+ */
+ virtual bool match (const std::string &test_string) const;
+
+ /**
+ * Return a description of
+ * the pattern that valid
+ * string are expected to
+ * match. Here, this is the
+ * list of valid strings
+ * passed to the constructor.
+ */
+ virtual std::string description () const;
+
+ /**
+ * Return a copy of the
+ * present object, which is
+ * newly allocated on the
+ * heap. Ownership of that
+ * object is transferred to
+ * the caller of this
+ * function.
+ */
+ virtual PatternBase * clone () const;
+
+ /**
+ * Determine an estimate for
+ * the memory consumption (in
+ * bytes) of this object.
+ */
+ unsigned int memory_consumption () const;
+
+ private:
+ /**
+ * List of valid strings as
+ * passed to the
+ * constructor. We don't make
+ * this string constant, as
+ * we process it somewhat in
+ * the constructor.
+ */
+ std::string sequence;
+ };
- /**
- * Return a copy of the
- * present object, which is
- * newly allocated on the
- * heap. Ownership of that
- * object is transferred to
- * the caller of this
- * function.
- */
- virtual PatternBase * clone () const;
-
- /**
- * Determine an estimate for
- * the memory consumption (in
- * bytes) of this object.
- */
- unsigned int memory_consumption () const;
-
- private:
- /**
- * List of valid strings as
- * passed to the
- * constructor. We don't make
- * this string constant, as
- * we process it somewhat in
- * the constructor.
- */
- string sequence;
- };
-
- /**
+ /**
* This class is much like the
* @p{Selection} class, but it
* allows the input to be a
* values given to the
* constructor.
*/
- class MultipleSelection : public PatternBase
- {
- public:
- /**
- * Constructor. Take the
- * given parameter as the
- * specification of valid
- * strings.
- */
- MultipleSelection (const string &seq);
-
- /**
- * Return @p{true} if the
- * string is an element of
- * the description list
- * passed to the constructor.
- */
- virtual bool match (const string &test_string) const;
-
- /**
- * Return a description of
- * the pattern that valid
- * string are expected to
- * match. Here, this is the
- * list of valid strings
- * passed to the constructor.
- */
- virtual string description () const;
-
- /**
- * Return a copy of the
- * present object, which is
- * newly allocated on the
- * heap. Ownership of that
- * object is transferred to
- * the caller of this
- * function.
- */
- virtual PatternBase * clone () const;
-
- /**
- * Determine an estimate for
- * the memory consumption (in
- * bytes) of this object.
- */
- unsigned int memory_consumption () const;
-
- /**
- * Exception.
- */
- DeclException1 (ExcCommasNotAllowed,
- int,
- << "A comma was found at position " << arg1
- << " of your input string, but commas are not allowed here.");
+ class MultipleSelection : public PatternBase
+ {
+ public:
+ /**
+ * Constructor. Take the
+ * given parameter as the
+ * specification of valid
+ * strings.
+ */
+ MultipleSelection (const std::string &seq);
+
+ /**
+ * Return @p{true} if the
+ * string is an element of
+ * the description list
+ * passed to the constructor.
+ */
+ virtual bool match (const std::string &test_string) const;
+
+ /**
+ * Return a description of
+ * the pattern that valid
+ * string are expected to
+ * match. Here, this is the
+ * list of valid strings
+ * passed to the constructor.
+ */
+ virtual std::string description () const;
+
+ /**
+ * Return a copy of the
+ * present object, which is
+ * newly allocated on the
+ * heap. Ownership of that
+ * object is transferred to
+ * the caller of this
+ * function.
+ */
+ virtual PatternBase * clone () const;
+
+ /**
+ * Determine an estimate for
+ * the memory consumption (in
+ * bytes) of this object.
+ */
+ unsigned int memory_consumption () const;
+
+ /**
+ * Exception.
+ */
+ DeclException1 (ExcCommasNotAllowed,
+ int,
+ << "A comma was found at position " << arg1
+ << " of your input string, but commas are not allowed here.");
- private:
- /**
- * List of valid strings as
- * passed to the
- * constructor. We don't make
- * this string constant, as
- * we process it somewhat in
- * the constructor.
- */
- string sequence;
- };
+ private:
+ /**
+ * List of valid strings as
+ * passed to the
+ * constructor. We don't make
+ * this string constant, as
+ * we process it somewhat in
+ * the constructor.
+ */
+ std::string sequence;
+ };
- /**
+ /**
* Test for the string being
* either "true" or "false". This
* is mapped to the @p{Selection}
* class.
*/
- class Bool : public Selection
- {
- public:
- /**
- * Constrcuctor.
- */
- Bool ();
-
- /**
- * Return a copy of the
- * present object, which is
- * newly allocated on the
- * heap. Ownership of that
- * object is transferred to
- * the caller of this
- * function.
- */
- virtual PatternBase * clone () const;
- };
+ class Bool : public Selection
+ {
+ public:
+ /**
+ * Constrcuctor.
+ */
+ Bool ();
+
+ /**
+ * Return a copy of the
+ * present object, which is
+ * newly allocated on the
+ * heap. Ownership of that
+ * object is transferred to
+ * the caller of this
+ * function.
+ */
+ virtual PatternBase * clone () const;
+ };
- /**
+ /**
* Always returns true when testing a
* string.
*/
- class Anything : public PatternBase
- {
- public:
- /**
- * Constructor. (Allow for at
- * least one non-virtual
- * function in this class, as
- * otherwise sometimes no
- * virtual table is emitted.)
- */
- Anything ();
-
- /**
- * Return @p{true} if the
- * string matches its
- * constraints, i.e. always.
- */
- virtual bool match (const string &test_string) const;
-
- /**
- * Return a description of
- * the pattern that valid
- * string are expected to
- * match. Here, this is the
- * string @p{"[Anything]"}.
- */
- virtual string description () const;
-
- /**
- * Return a copy of the
- * present object, which is
- * newly allocated on the
- * heap. Ownership of that
- * object is transferred to
- * the caller of this
- * function.
- */
- virtual PatternBase * clone () const;
- };
+ class Anything : public PatternBase
+ {
+ public:
+ /**
+ * Constructor. (Allow for at
+ * least one non-virtual
+ * function in this class, as
+ * otherwise sometimes no
+ * virtual table is emitted.)
+ */
+ Anything ();
+
+ /**
+ * Return @p{true} if the
+ * string matches its
+ * constraints, i.e. always.
+ */
+ virtual bool match (const std::string &test_string) const;
+
+ /**
+ * Return a description of
+ * the pattern that valid
+ * string are expected to
+ * match. Here, this is the
+ * string @p{"[Anything]"}.
+ */
+ virtual std::string description () const;
+
+ /**
+ * Return a copy of the
+ * present object, which is
+ * newly allocated on the
+ * heap. Ownership of that
+ * object is transferred to
+ * the caller of this
+ * function.
+ */
+ virtual PatternBase * clone () const;
+ };
};
*
* @sect3{Reading data from input sources}
*
- * In order to read input you can use three possibilities: reading from an @p{istream} object,
+ * In order to read input you can use three possibilities: reading from an @p{std::istream} object,
* reading from a file of which the name is given and reading from a string in memory in
* which the lines are separated by @p{\n} characters. These possibilites are used as follows:
* @begin{verbatim}
* yet unknown subsection names after using @p{read_input}. The results in this case are
* unspecified.
*
- * If an error occurs upon reading the input, error messages are written to @p{cerr}.
+ * If an error occurs upon reading the input, error messages are written to @p{std::cerr}.
*
*
* @sect3{Getting entry values out of a @p{ParameterHandler} object}
* @begin{verbatim}
* void NonLinEq::get_parameters (ParameterHandler &prm) {
* prm.enter_subsection ("Nonlinear solver");
- * string method = prm.get ("Nonlinear method");
+ * std::string method = prm.get ("Nonlinear method");
* eq.get_parameters (prm);
* prm.leave_subsection ();
* };
* static void declare_parameters (ParameterHandler &prm);
* void get_parameters (ParameterHandler &prm);
* private:
- * string Method;
+ * std::string Method;
* int MaxIterations;
* };
*
* class Problem {
* private:
* LinEq eq1, eq2;
- * string Matrix1, Matrix2;
- * string outfile;
+ * std::string Matrix1, Matrix2;
+ * std::string outfile;
* public:
* static void declare_parameters (ParameterHandler &prm);
* void get_parameters (ParameterHandler &prm);
* Method = prm.get ("Solver");
* MaxIterations = prm.get_integer ("Maximum number of iterations");
* prm.leave_subsection ();
- * cout << " LinEq: Method=" << Method << ", MaxIterations=" << MaxIterations << endl;
+ * std::cout << " LinEq: Method=" << Method << ", MaxIterations=" << MaxIterations << std::endl;
* };
*
*
* // entries of the problem class
* outfile = prm.get ("Output file");
*
- * string equation1 = prm.get ("Equation 1"),
+ * std::string equation1 = prm.get ("Equation 1"),
* equation2 = prm.get ("Equation 2");
*
* // get parameters for the
* eq2.get_parameters (prm); // for eq2
* prm.leave_subsection ();
*
- * cout << " Problem: outfile=" << outfile << endl
- * << " eq1=" << equation1 << ", eq2=" << equation2 << endl
- * << " Matrix1=" << Matrix1 << ", Matrix2=" << Matrix2 << endl;
+ * std::cout << " Problem: outfile=" << outfile << std::endl
+ * << " eq1=" << equation1 << ", eq2=" << equation2 << std::endl
+ * << " Matrix1=" << Matrix1 << ", Matrix2=" << Matrix2 << std::endl;
* };
*
*
* // argv[1] would also be a good idea
* prm.read_input ("prmtest.prm");
*
- * // print parameters to cout as ASCII text
- * cout << endl << endl;
- * prm.print_parameters (cout, Text);
+ * // print parameters to std::cout as ASCII text
+ * std::cout << std::endl << std::endl;
+ * prm.print_parameters (std::cout, Text);
*
* // get parameters into the program
- * cout << endl << endl
- * << "Getting parameters:" << endl;
+ * std::cout << std::endl << std::endl
+ * << "Getting parameters:" << std::endl;
* p.get_parameters (prm);
* };
* @end{verbatim}
*
* Return whether the read was successful.
*/
- virtual bool read_input (istream &input);
+ virtual bool read_input (std::istream &input);
/**
* Read input from a file the name of which
* the requested file with default values if
* the file did not exist.
*/
- virtual bool read_input (const string &filename);
+ virtual bool read_input (const std::string &filename);
/**
* Read input from a string in memory. The
* the regular expression;
* @p{true} otherwise.
*/
- bool declare_entry (const string &entry,
- const string &default_value,
- const Patterns::PatternBase &pattern
- = Patterns::Anything());
+ bool declare_entry (const std::string &entry,
+ const std::string &default_value,
+ const Patterns::PatternBase &pattern = Patterns::Anything());
/**
* Enter a subsection; if not yet
* existent, declare it.
*/
- void enter_subsection (const string &subsection);
+ void enter_subsection (const std::string &subsection);
/**
* Leave present subsection.
* was declared (therefore an exception may be
* thrown).
*/
- const string & get (const string &entry_string) const;
+ const std::string & get (const std::string &entry_string) const;
/**
* Return value of entry @p{entry_string} as
* @p{long int}.
*/
- long int get_integer (const string &entry_string) const;
+ long int get_integer (const std::string &entry_string) const;
/**
* Return value of entry @p{entry_string} as
* @p{double}.
*/
- double get_double (const string &entry_string) const;
+ double get_double (const std::string &entry_string) const;
/**
* Return value of entry @p{entry_string} as
* @p{bool}.
*/
- bool get_bool (const string &entry_string) const;
+ bool get_bool (const std::string &entry_string) const;
/**
* Print all parameters with the given style
* by simply copying the output to your
* input file.
*/
- ostream & print_parameters (ostream &out, const OutputStyle style);
+ std::ostream & print_parameters (std::ostream &out,
+ const OutputStyle style);
/**
* Print out the parameters of the subsection
* given by the @p{subsection_path} member
* variable.
*/
- void print_parameters_section (ostream &out,
- const OutputStyle Style,
- const unsigned int indent_level);
+ void print_parameters_section (std::ostream &out,
+ const OutputStyle style,
+ const unsigned int indent_level);
- /**
- * Print parameters to a logstream.
- * This function allows to print
- * all parameters into a log-file.
- * Sections will be indented in the
- * usual log-file style.
- */
+ /**
+ * Print parameters to a logstream.
+ * This function allows to print
+ * all parameters into a log-file.
+ * Sections will be indented in the
+ * usual log-file style.
+ */
void log_parameters (LogStream& out);
/**
* Exception
*/
DeclException1 (ExcEntryAlreadyExists,
- string,
+ std::string,
<< "The following entry already exists: " << arg1);
/**
* Exception
*/
DeclException2 (ExcDefaultDoesNotMatchPattern,
- string, string,
+ std::string, std::string,
<< "The default string <" << arg1
<< "> does not match the given pattern <" << arg2 << ">");
/**
* Exception
*/
DeclException1 (ExcEntryUndeclared,
- string,
+ std::string,
<< "You cant ask for entry <" << arg1 << "> you have not yet declared");
/**
* Exception
*/
DeclException1 (ExcConversionError,
- string,
+ std::string,
<< "Error when trying to convert the following string: " << arg1);
private:
{
~Section ();
- typedef map<string, pair<string,Patterns::PatternBase*> > EntryType;
+ typedef std::map<std::string, std::pair<std::string,Patterns::PatternBase*> > EntryType;
- EntryType entries;
- map<string, Section*> subsections;
+ EntryType entries;
+ std::map<std::string, Section*> subsections;
/**
* Determine an estimate for
* not be determined exactly
* (for example: what is the
* memory consumption of an
- * STL @p{map} type with a
+ * STL @p{std::map} type with a
* certain number of
* elements?), this is only
* an estimate. however often
* subsections; empty list means
* top level
*/
- vector<string> subsection_path;
+ std::vector<std::string> subsection_path;
/**
* List of default values
* non-declared entry was given
* or teh entry value did not
* match the regular
- * expression. @p{true} otherwise
+ * expression. @p{true} otherwise.
+ *
+ * The function modifies its
+ * argument, but also takes it by
+ * value, so the caller's
+ * variable is not changed.
*/
- bool scan_line (string line, const unsigned int lineno);
+ bool scan_line (std::string line,
+ const unsigned int lineno);
/**
* Get a pointer to the
* Read input from a stream until stream
* returns @p{eof} condition or error.
*/
- virtual bool read_input (istream &Input);
+ virtual bool read_input (std::istream &Input);
/**
* Read input from a file the name of which
* is given.
*/
- virtual bool read_input (const string &FileName);
+ virtual bool read_input (const std::string &FileName);
/**
* Read input from a string in memory. The
* into the different variants is done
* later by @p{split_different_values}.
*/
- Entry (const vector<string> &Path, const string &Name, const string &Value);
+ Entry (const std::vector<std::string> &Path,
+ const std::string &Name,
+ const std::string &Value);
/**
* Split the entry value into the different
/**
* Path to variant entry.
*/
- vector<string> subsection_path;
+ std::vector<std::string> subsection_path;
/**
* Name of entry.
*/
- string entry_name;
+ std::string entry_name;
/**
* Original variant value.
*/
- string entry_value;
+ std::string entry_value;
/**
* List of entry values constructed out of
* what was given in the input file (that
* is stored in @p{EntryValue}.
*/
- vector<string> different_values;
+ std::vector<std::string> different_values;
/**
* Store whether this entry is a variant
/**
* List of variant entry values.
*/
- vector<Entry> multiple_choices;
+ std::vector<Entry> multiple_choices;
/**
- * Number of branches constructed from the
- * different combinations of the variants.
- * This obviously equals the number of runs
- * to be performed.
+ * Number of branches constructed
+ * from the different
+ * combinations of the variants.
+ * This obviously equals the
+ * number of runs to be
+ * performed.
*/
- int n_branches;
+ unsigned int n_branches;
/**
- * Initialize the different branches, i.e.
- * construct the combinations.
+ * Initialize the different
+ * branches, i.e. construct the
+ * combinations.
*/
void init_branches ();
/**
- * Initialize the branches in the given
- * section.
+ * Initialize the branches in the
+ * given section.
*/
void init_branches_section (const ParameterHandler::Section &sec);
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
*/
Point<dim> operator - (const Point<dim> &) const;
- /**
- * The opposite vector.
- */
+ /**
+ * The opposite vector.
+ */
Point<dim> operator - () const;
/**
template <int dim>
inline
double Point<dim>::operator () (const unsigned int index) const
- {
+{
Assert (index<dim, ExcIndexRange (index, 0, dim));
return values[index];
};
{
Point<dim> result;
for (unsigned int i=0; i<dim; ++i)
- result.values[i] = -values[i];
+ result.values[i] = -values[i];
return result;
};
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
/**
* Constructor from given vectors.
*/
- Quadrature (const vector<Point<dim> > & points,
- const vector<double> & weights);
+ Quadrature (const std::vector<Point<dim> > &points,
+ const std::vector<double> &weights);
/**
* Virtual destructor.
* Return a reference to the whole array of
* quadrature points.
*/
- const vector<Point<dim> > & get_points () const;
+ const
std::vector<Point<dim> > & get_points () const;
/**
* Return the weight of the @p{i}th
* Return a reference to the whole array
* of weights.
*/
- const vector<double> & get_weights () const;
+ const std::vector<double> & get_weights () const;
/**
* Determine an estimate for
* List of quadrature points. To be filled
* by the constructors of derived classes.
*/
- vector<Point<dim> > quadrature_points;
+
std::vector<Point<dim> > quadrature_points;
/**
* List of weights of the quadrature points.
* To be filled by the constructors of
* derived classes.
*/
- vector<double> weights;
+ std::vector<double> weights;
};
* details, see the general doc for
* this class.
*/
- static void project_to_face (const Quadrature<dim-1> &quadrature,
- const unsigned int face_no,
- vector<Point<dim> > &q_points);
+ static void project_to_face (const Quadrature<dim-1> &quadrature,
+ const unsigned int face_no,
+ std::vector<Point<dim> > &q_points);
/**
* Projection to all faces.
* Generate a formula that integrates
* over all faces at the same time.
*/
- static void project_to_faces (const Quadrature<dim-1> &quadrature,
- vector<Point<dim> > &q_points);
+ static void project_to_faces (const Quadrature<dim-1> &quadrature,
+ std::vector<Point<dim> > &q_points);
/**
* Compute the quadrature points on the
* details, see the general doc for
* this class.
*/
- static void project_to_subface (const Quadrature<dim-1> &quadrature,
- const unsigned int face_no,
- const unsigned int subface_no,
- vector<Point<dim> > &q_points);
+ static void project_to_subface (const Quadrature<dim-1> &quadrature,
+ const unsigned int face_no,
+ const unsigned int subface_no,
+ std::vector<Point<dim> > &q_points);
/**
* Projection to all child faces.
* ordering is first by face,
* then by subface
*/
- static void project_to_subfaces (const Quadrature<dim-1> &quadrature,
- vector<Point<dim> > &q_points);
+ static void project_to_subfaces (const Quadrature<dim-1> &quadrature,
+ std::vector<Point<dim> > &q_points);
};
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* have deliberately chosen a
* short name.
*/
- T * t;
+ T * t;
};
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* constructor, we obtain it in
* between and store it here.
*/
- mutable const type_info * object_info;
+ mutable const std::type_info * object_info;
};
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
/**
* Write the table entry as text.
*/
- virtual void write_text (ostream &) const =0;
+ virtual void write_text (std::ostream &) const =0;
/**
* Write the table entry in tex format.
*/
- virtual void write_tex (ostream &) const =0;
+ virtual void write_tex (std::ostream &) const =0;
};
/**
* Write the table entry as text.
*/
- virtual void write_text (ostream &out) const;
+ virtual void write_text (std::ostream &out) const;
/**
* Write the table entry in tex format.
*/
- virtual void write_tex (ostream &out) const;
+ virtual void write_tex (std::ostream &out) const;
private:
/**
* @sect3{Usage}
*
* The most important function is the templatized function
- * @p{add_value(const string &key, const value_type value)}, that adds a column
+ * @p{add_value(const std::string &key, const value_type value)}, that adds a column
* with the name @p{key} to the table if this column does not yet exist and adds the
- * value of @p{value_type} (e.g. @p{unsigned int}, @p{double}, @p{string}, ...) to this column.
+ * value of @p{value_type} (e.g. @p{unsigned int}, @p{double}, @p{std::string}, ...) to this column.
* After the table is complete there are different possibilities of output, e.g.
- * into a tex file with @p{write_tex(ofstream &file)} or as text with
- * @p{write_text (ostream &out)}.
+ * into a tex file with @p{write_tex(std::ofstream &file)} or as text with
+ * @p{write_text (std::ostream &out)}.
*
* Two (or more) columns may be merged into a "supercolumn" by twice
* (or multiple) calling @p{add_column_to_supercolumn(...)}, see
* table.set_precision("square roots", 6);
*
* // output
- * ofstream out_file("number_table.tex");
+ * std::ofstream out_file("number_table.tex");
* table.write_tex(out_file);
* out_file.close();
* @end{verbatim}
* to the column.
*/
template <typename value_type>
- void add_value (const string &key,
- const value_type value);
+ void add_value (const std::string &key,
+ const value_type value);
/**
* Creates a sypercolumn (if not yet
* the order of output follows the order
* the columns are added to the supercolumn.
*/
- void add_column_to_supercolumn (const string &key,
- const string &superkey);
+ void add_column_to_supercolumn (const std::string &key,
+ const std::string &superkey);
/**
* Change the order of columns and
* next e.g. five columns and again @p{write_*},
* and so on.
*/
- void set_column_order (const vector<string> &new_order);
+ void set_column_order (const std::vector<std::string> &new_order);
/**
* Sets the @p{precision} e.g. double or float
* the same as in calling
* @p{out << setprecision(precision)}.
*/
- void set_precision (const string &key,
+ void set_precision (const std::string &key,
const unsigned int precision);
/**
* scientific, false means fixed point
* notation.
*/
- void set_scientific (const string &key,
- bool scientific);
+ void set_scientific (const std::string &key,
+ const bool scientific);
/**
* Sets the caption of the column @p{key}
* this different from @p{key}, if it
* contains formulas or similar constructs.
*/
- void set_tex_caption (const string &key,
- const string &tex_caption);
+ void set_tex_caption (const std::string &key,
+ const std::string &tex_caption);
/**
* Sets the caption the the supercolumn
* if it contains formulas or similar
* constructs.
*/
- void set_tex_supercaption (const string &superkey,
- const string &tex_supercaption);
+ void set_tex_supercaption (const std::string &superkey,
+ const std::string &tex_supercaption);
/**
* Sets the tex output format of a column.
* is not called for a column, the default
* is preset to be @p{c}.
*/
- void set_tex_format (const string &key,
- const string &format="c");
+ void set_tex_format (const std::string &key,
+ const std::string &format="c");
/**
* Write table as formatted text, e.g.
* to the standard output.
*/
- void write_text (ostream &out) const;
+ void write_text (std::ostream &out) const;
/**
* Write table as a tex file.
*/
- void write_tex (ofstream &file) const;
+ void write_tex (std::ofstream &file) const;
/**
* Exception
*/
DeclException1 (ExcColumnNotExistent,
- string,
+ std::string,
<< "Column <" << arg1 << "> does not exist.");
/**
* Exception
*/
DeclException1 (ExcSuperColumnNotExistent,
- string,
+ std::string,
<< "Supercolumn <" << arg1 << "> does not exist.");
/**
* Exception
*/
DeclException1 (ExcColumnOrSuperColumnNotExistent,
- string,
+ std::string,
<< "Column or supercolumn <" << arg1 << "> does not exist.");
/**
* Exception
*/
DeclException4 (ExcWrongNumberOfDataEntries,
- string, int, string, int,
+ std::string, int, std::string, int,
<< "Column <" << arg1 << "> has got " << arg2
<< " rows, but Column <" << arg3 << "> has got " << arg4 << ".");
* Exception
*/
DeclException1 (ExcUndefinedTexFormat,
- string,
+ std::string,
<< "<" << arg1 << "> is not a tex column format. Use l,c,r.");
protected:
/**
* Constructor.
*/
- Column(const string &tex_caption);
+ Column(const std::string &tex_caption);
/**
* Destructor.
* a wrapper for @p{T}, but is derived
* from @p{TableEntryBase}.
*/
- vector<TableEntryBase *> entries;
+
std::vector<TableEntryBase *> entries;
/**
* The caption of the column in tex output.
* be changed by calling
* @p{TableHandler::set_tex_caption(...)}.
*/
- string tex_caption;
+ std::string tex_caption;
/**
* The column format in tex output.
* right or left.
*/
- string tex_format;
+ std::string tex_format;
/**
* Double or float entries are written with
* consistency of the data. The result is
* returned in @p{sel_columns}.
*/
- void get_selected_columns (vector<string> &sel_columns) const;
+ void get_selected_columns (std::vector<std::string> &sel_columns) const;
/**
* Builtin function, that gives the
* adding the columns. This order may be
* changed by @p{set_column_order(...)}.
*/
- vector<string> column_order;
+ std::vector<std::string> column_order;
/**
* Maps the column keys to the columns
* (not supercolumns).
*/
- map<string,Column> columns;
+ std::map<std::string,Column> columns;
/**
* Maps each supercolumn key to the
* keys for each supercolumn key is
* relevant.
*/
- map<string, vector<string> > supercolumns;
+ std::map<std::string, std::vector<std::string> > supercolumns;
/**
* Maps the supercolumn keys to the
* supercolumn keys but they may be changed
* by @p{set_tex_supercaptions(...)}.
*/
- map<string, string> tex_supercaptions;
+ std::map<std::string, std::string> tex_supercaptions;
};
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
*/
Tensor<rank_,dim> operator - (const Tensor<rank_,dim> &) const;
- /**
- * Invert all entries of a tensor.
- */
+ /**
+ * Invert all entries of a tensor.
+ */
Tensor<rank_,dim> operator - () const;
/**
for (unsigned int i=0; i<dim; ++i)
for (unsigned int j=0; j<dim; ++j)
for (unsigned int k=0; k<dim; ++k)
- dst[i][j][k] = src1[i] * src2[j][k];
+ dst[i][j][k] = src1[i] * src2[j][k];
};
for (unsigned int i=0; i<dim; ++i)
for (unsigned int j=0; j<dim; ++j)
for (unsigned int k=0; k<dim; ++k)
- dst[i][j][k] = src1[i][j] * src2[k];
+ dst[i][j][k] = src1[i][j] * src2[k];
};
default:
AssertThrow (false, ExcNotImplemented());
- };
+ };
return return_tensor;
};
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
template <int dim>
class Tensor<1,dim>
{
- public:
+ public:
/**
* Provide a way to get the
* dimension of an object without
*/
Tensor<1,dim> operator - (const Tensor<1,dim> &) const;
- /**
- * Tensor with inverted entries.
- */
+ /**
+ * Tensor with inverted entries.
+ */
Tensor<1,dim> operator - () const;
/**
*/
double values[(dim!=0) ? (dim) : 1];
- /**
- * Point is allowed access to
- * the coordinates. This is
- * supposed to improve speed.
- */
+ /**
+ * Point is allowed access to
+ * the coordinates. This is
+ * supposed to improve speed.
+ */
friend class Point<dim>;
};
* form @p{x1 x2 x3 etc}.
*/
template <int dim>
-ostream & operator << (ostream &out, const Tensor<1,dim> &p);
+std::ostream & operator << (std::ostream &out, const Tensor<1,dim> &p);
/*------------------------------- Inline functions: Tensor ---------------------------*/
+template <>
+inline
+Tensor<1,0>::Tensor (const Tensor<1,0> &)
+{
+ // at some places in the library,
+ // we have Point<0> for formal
+ // reasons (e.g., we sometimes have
+ // Quadrature<dim-1> for faces, so
+ // we have Quadrature<0> for dim=1,
+ // and then we have Point<0>). To
+ // avoid warnings in the above
+ // function that the loop end check
+ // always fails, we implement this
+ // function here
+};
+
+
+
template <int dim>
inline
double Tensor<1,dim>::operator [] (const unsigned int index) const
+template <>
+inline
+Tensor<1,0> & Tensor<1,0>::operator = (const Tensor<1,0> &)
+{
+ // at some places in the library,
+ // we have Point<0> for formal
+ // reasons (e.g., we sometimes have
+ // Quadrature<dim-1> for faces, so
+ // we have Quadrature<0> for dim=1,
+ // and then we have Point<0>). To
+ // avoid warnings in the above
+ // function that the loop end check
+ // always fails, we implement this
+ // function here
+ return *this;
+};
+
+
+
template <int dim>
inline
bool Tensor<1,dim>::operator == (const Tensor<1,dim> &p) const
{
Tensor<1,dim> result;
for (unsigned int i=0; i<dim; ++i)
- result.values[i] = -values[i];
+ result.values[i] = -values[i];
return result;
};
*/
template <int dim>
inline
-ostream & operator << (ostream &out, const Tensor<1,dim> &p)
+std::ostream & operator << (std::ostream &out, const Tensor<1,dim> &p)
{
for (unsigned int i=0; i<dim-1; ++i)
out << p[i] << ' ';
* a compiler warning that the loop is empty.
*/
inline
-ostream & operator << (ostream &out, const Tensor<1,1> &p)
+std::ostream & operator << (std::ostream &out, const Tensor<1,1> &p)
{
out << p[0];
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* the right size, i.e. the same
* size as the @p{points} array.
*/
- virtual void value_list (const vector<Point<dim> > &points,
- vector<Tensor<rank,dim> > &values) const;
+ virtual void value_list (const
std::vector<Point<dim> > &points,
+ std::vector<Tensor<rank,dim> > &values) const;
/**
* Return the gradient of the
* the right size, i.e. the same
* size as the @p{points} array.
*/
- virtual void gradient_list (const vector<Point<dim> > &points,
- vector<Tensor<rank+1,dim> > &gradients) const;
+ virtual void gradient_list (const std::vector<Point<dim> > &points,
+ std::vector<Tensor<rank+1,dim> > &gradients) const;
/**
* Exception
friend
typename FunData7<Arg1_,Arg2_,Arg3_,Arg4_,Arg5_,Arg6_,Arg7_,void>::ArgCollector
encapsulate (void (*fun_ptr)(Arg1_, Arg2_, Arg3_,
- Arg4_, Arg5_, Arg6_, Arg7_));
+ Arg4_, Arg5_, Arg6_, Arg7_));
};
friend
typename FunData8<Arg1_,Arg2_,Arg3_,Arg4_,Arg5_,Arg6_,Arg7_,Arg8_,void>::ArgCollector
encapsulate (void (*fun_ptr)(Arg1_, Arg2_, Arg3_,
- Arg4_, Arg5_, Arg6_,
- Arg7_, Arg8_));
+ Arg4_, Arg5_, Arg6_,
+ Arg7_, Arg8_));
};
*/
template <class Class_, typename Arg1_>
friend
- typename MemFunData1<Class,Arg1_,void>::ArgCollector
+ typename MemFunData1<Class_,Arg1_,void>::ArgCollector
encapsulate (void (Class_::*fun_ptr)(Arg1_));
};
*/
template <class Class_, typename Arg1_, typename Arg2_>
friend
- typename MemFunData2<Class,Arg1_,Arg2_,void>::ArgCollector
+ typename MemFunData2<Class_,Arg1_,Arg2_,void>::ArgCollector
encapsulate (void (Class_::*fun_ptr)(Arg1_, Arg2_));
};
*/
template <class Class_, typename Arg1_, typename Arg2_, typename Arg3_>
friend
- typename MemFunData3<Class,Arg1_,Arg2_,Arg3_,void>::ArgCollector
+ typename MemFunData3<Class_,Arg1_,Arg2_,Arg3_,void>::ArgCollector
encapsulate (void (Class_::*fun_ptr)(Arg1_,Arg2_,Arg3_));
};
*/
template <class Class_, typename Arg1_, typename Arg2_, typename Arg3_, typename Arg4_>
friend
- typename MemFunData4<Class,Arg1_,Arg2_,Arg3_,Arg4_,void>::ArgCollector
+ typename MemFunData4<Class_,Arg1_,Arg2_,Arg3_,Arg4_,void>::ArgCollector
encapsulate (void (Class_::*fun_ptr)(Arg1_, Arg2_, Arg3_, Arg4_));
};
*/
template <class Class_, typename Arg1_, typename Arg2_, typename Arg3_, typename Arg4_, typename Arg5_>
friend
- typename MemFunData5<Class,Arg1_,Arg2_,Arg3_,Arg4_,Arg5_,void>::ArgCollector
+ typename MemFunData5<Class_,Arg1_,Arg2_,Arg3_,Arg4_,Arg5_,void>::ArgCollector
encapsulate (void (Class_::*fun_ptr)(Arg1_, Arg2_, Arg3_,
Arg4_, Arg5_));
};
*/
template <class Class_, typename Arg1_, typename Arg2_, typename Arg3_, typename Arg4_, typename Arg5_, typename Arg6_>
friend
- typename MemFunData6<Class,Arg1_,Arg2_,Arg3_,Arg4_,Arg5_,Arg6_,void>::ArgCollector
+ typename MemFunData6<Class_,Arg1_,Arg2_,Arg3_,Arg4_,Arg5_,Arg6_,void>::ArgCollector
encapsulate (void (Class_::*fun_ptr)(Arg1_, Arg2_, Arg3_,
Arg4_, Arg5_, Arg6_));
};
* @p{[begin[i],end[i])}.
*/
template <typename ForwardIterator>
- vector<pair<ForwardIterator,ForwardIterator> >
+ std::vector<std::pair<ForwardIterator,ForwardIterator> >
split_range (const ForwardIterator &begin,
const ForwardIterator &end,
const unsigned int n_intervals);
* iterators, now values are taken
* that define the whole interval.
*/
- vector<pair<unsigned int,unsigned int> >
+ std::vector<std::pair<unsigned int,unsigned int> >
split_interval (const unsigned int begin,
const unsigned int end,
const unsigned int n_intervals);
const ThisClass *fun_data
= dynamic_cast<const ThisClass*> (fun_encapsulation->fun_data_base);
- // copy the parameters
+ // copy the parameters
ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
- // copying of parameters is done,
- // now we can release the lock on
- // @p{fun_data}
+ // copying of parameters is done,
+ // now we can release the lock on
+ // @p{fun_data}
fun_data->lock.release ();
// call the function
const ThisClass *fun_data
= dynamic_cast<const ThisClass*> (fun_encapsulation->fun_data_base);
- // copy the parameters
+ // copy the parameters
ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
Arg1 arg1 = fun_data->arg1;
- // copying of parameters is done,
- // now we can release the lock on
- // @p{fun_data}
+ // copying of parameters is done,
+ // now we can release the lock on
+ // @p{fun_data}
fun_data->lock.release ();
// call the function
const ThisClass *fun_data
= dynamic_cast<const ThisClass*> (fun_encapsulation->fun_data_base);
- // copy the parameters
+ // copy the parameters
ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
Arg1 arg1 = fun_data->arg1;
Arg2 arg2 = fun_data->arg2;
- // copying of parameters is done,
- // now we can release the lock on
- // @p{fun_data}
+ // copying of parameters is done,
+ // now we can release the lock on
+ // @p{fun_data}
fun_data->lock.release ();
// call the function
const ThisClass *fun_data
= dynamic_cast<const ThisClass*> (fun_encapsulation->fun_data_base);
- // copy the parameters
+ // copy the parameters
ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
Arg1 arg1 = fun_data->arg1;
Arg2 arg2 = fun_data->arg2;
Arg3 arg3 = fun_data->arg3;
- // copying of parameters is done,
- // now we can release the lock on
- // @p{fun_data}
+ // copying of parameters is done,
+ // now we can release the lock on
+ // @p{fun_data}
fun_data->lock.release ();
// call the function
const ThisClass *fun_data
= dynamic_cast<const ThisClass*> (fun_encapsulation->fun_data_base);
- // copy the parameters
+ // copy the parameters
ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
Arg1 arg1 = fun_data->arg1;
Arg2 arg2 = fun_data->arg2;
Arg4 arg4 = fun_data->arg4;
- // copying of parameters is done,
- // now we can release the lock on
- // @p{fun_data}
+ // copying of parameters is done,
+ // now we can release the lock on
+ // @p{fun_data}
fun_data->lock.release ();
// call the function
const ThisClass *fun_data
= dynamic_cast<const ThisClass*> (fun_encapsulation->fun_data_base);
- // copy the parameters
+ // copy the parameters
ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
Arg1 arg1 = fun_data->arg1;
Arg2 arg2 = fun_data->arg2;
Arg5 arg5 = fun_data->arg5;
- // copying of parameters is done,
- // now we can release the lock on
- // @p{fun_data}
+ // copying of parameters is done,
+ // now we can release the lock on
+ // @p{fun_data}
fun_data->lock.release ();
// call the function
template <typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename RetType>
-
FunData6<Arg1,Arg2,Arg3,Arg4,Arg5,Arg6,RetType>::FunData6 (const FunData6 &fun_data) :
- FunDataBase (fun_data),
- fun_ptr (fun_data.fun_ptr),
- arg1 (fun_data.arg1),
- arg2 (fun_data.arg2),
- arg3 (fun_data.arg3),
- arg4 (fun_data.arg4),
- arg5 (fun_data.arg5),
- arg6 (fun_data.arg6)
+ FunData6<Arg1,Arg2,Arg3,Arg4,Arg5,Arg6,RetType>::FunData6 (const FunData6 &fun_data) :
+ FunDataBase (fun_data),
+ fun_ptr (fun_data.fun_ptr),
+ arg1 (fun_data.arg1),
+ arg2 (fun_data.arg2),
+ arg3 (fun_data.arg3),
+ arg4 (fun_data.arg4),
+ arg5 (fun_data.arg5),
+ arg6 (fun_data.arg6)
{};
const ThisClass *fun_data
= dynamic_cast<const ThisClass*> (fun_encapsulation->fun_data_base);
- // copy the parameters
+ // copy the parameters
ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
Arg1 arg1 = fun_data->arg1;
Arg2 arg2 = fun_data->arg2;
Arg6 arg6 = fun_data->arg6;
- // copying of parameters is done,
- // now we can release the lock on
- // @p{fun_data}
+ // copying of parameters is done,
+ // now we can release the lock on
+ // @p{fun_data}
fun_data->lock.release ();
// call the function
template <typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7, typename RetType>
-
FunData7<Arg1,Arg2,Arg3,Arg4,Arg5,Arg6,Arg7,RetType>::FunData7 (const FunData7 &fun_data) :
- FunDataBase (fun_data),
- fun_ptr (fun_data.fun_ptr),
- arg1 (fun_data.arg1),
- arg2 (fun_data.arg2),
- arg3 (fun_data.arg3),
- arg4 (fun_data.arg4),
- arg5 (fun_data.arg5),
- arg6 (fun_data.arg6),
- arg7 (fun_data.arg7)
+ FunData7<Arg1,Arg2,Arg3,Arg4,Arg5,Arg6,Arg7,RetType>::FunData7 (const FunData7 &fun_data) :
+ FunDataBase (fun_data),
+ fun_ptr (fun_data.fun_ptr),
+ arg1 (fun_data.arg1),
+ arg2 (fun_data.arg2),
+ arg3 (fun_data.arg3),
+ arg4 (fun_data.arg4),
+ arg5 (fun_data.arg5),
+ arg6 (fun_data.arg6),
+ arg7 (fun_data.arg7)
{};
const ThisClass *fun_data
= dynamic_cast<const ThisClass*> (fun_encapsulation->fun_data_base);
- // copy the parameters
+ // copy the parameters
ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
Arg1 arg1 = fun_data->arg1;
Arg2 arg2 = fun_data->arg2;
Arg7 arg7 = fun_data->arg7;
- // copying of parameters is done,
- // now we can release the lock on
- // @p{fun_data}
+ // copying of parameters is done,
+ // now we can release the lock on
+ // @p{fun_data}
fun_data->lock.release ();
// call the function
template <typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7, typename Arg8, typename RetType>
FunData8<Arg1,Arg2,Arg3,Arg4,Arg5,Arg6,Arg7,Arg8,RetType>::FunData8 (FunPtr fun_ptr,
- Arg1 arg1,
- Arg2 arg2,
- Arg3 arg3,
- Arg4 arg4,
- Arg5 arg5,
- Arg6 arg6,
- Arg7 arg7,
- Arg8 arg8) :
+ Arg1 arg1,
+ Arg2 arg2,
+ Arg3 arg3,
+ Arg4 arg4,
+ Arg5 arg5,
+ Arg6 arg6,
+ Arg7 arg7,
+ Arg8 arg8) :
FunDataBase (&FunData8<Arg1,Arg2,Arg3,Arg4,Arg5,Arg6,Arg7,Arg8,RetType>::thread_entry_point),
fun_ptr (fun_ptr),
arg1 (arg1),
template <typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7, typename Arg8, typename RetType>
-
FunData8<Arg1,Arg2,Arg3,Arg4,Arg5,Arg6,Arg7,Arg8,RetType>::FunData8 (const FunData8 &fun_data) :
- FunDataBase (fun_data),
- fun_ptr (fun_data.fun_ptr),
- arg1 (fun_data.arg1),
- arg2 (fun_data.arg2),
- arg3 (fun_data.arg3),
- arg4 (fun_data.arg4),
- arg5 (fun_data.arg5),
- arg6 (fun_data.arg6),
- arg7 (fun_data.arg7),
- arg8 (fun_data.arg8)
+ FunData8<Arg1,Arg2,Arg3,Arg4,Arg5,Arg6,Arg7,Arg8,RetType>::FunData8 (const FunData8 &fun_data) :
+ FunDataBase (fun_data),
+ fun_ptr (fun_data.fun_ptr),
+ arg1 (fun_data.arg1),
+ arg2 (fun_data.arg2),
+ arg3 (fun_data.arg3),
+ arg4 (fun_data.arg4),
+ arg5 (fun_data.arg5),
+ arg6 (fun_data.arg6),
+ arg7 (fun_data.arg7),
+ arg8 (fun_data.arg8)
{};
const ThisClass *fun_data
= dynamic_cast<const ThisClass*> (fun_encapsulation->fun_data_base);
- // copy the parameters
+ // copy the parameters
ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
Arg1 arg1 = fun_data->arg1;
Arg2 arg2 = fun_data->arg2;
Arg8 arg8 = fun_data->arg8;
- // copying of parameters is done,
- // now we can release the lock on
- // @p{fun_data}
+ // copying of parameters is done,
+ // now we can release the lock on
+ // @p{fun_data}
fun_data->lock.release ();
// call the function
const ThisClass *fun_data
= dynamic_cast<const ThisClass*> (fun_encapsulation->fun_data_base);
- // copy the parameters
+ // copy the parameters
ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
Class *object = fun_data->object;
- // copying of parameters is done,
- // now we can release the lock on
- // @p{fun_data}
+ // copying of parameters is done,
+ // now we can release the lock on
+ // @p{fun_data}
fun_data->lock.release ();
// call the function
const ThisClass *fun_data
= dynamic_cast<const ThisClass*> (fun_encapsulation->fun_data_base);
- // copy the parameters
+ // copy the parameters
ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
Class *object = fun_data->object;
Arg1 arg1 = fun_data->arg1;
- // copying of parameters is done,
- // now we can release the lock on
- // @p{fun_data}
+ // copying of parameters is done,
+ // now we can release the lock on
+ // @p{fun_data}
fun_data->lock.release ();
// call the function
const ThisClass *fun_data
= dynamic_cast<const ThisClass*> (fun_encapsulation->fun_data_base);
- // copy the parameters
+ // copy the parameters
ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
Class *object = fun_data->object;
Arg1 arg1 = fun_data->arg1;
Arg2 arg2 = fun_data->arg2;
- // copying of parameters is done,
- // now we can release the lock on
- // @p{fun_data}
+ // copying of parameters is done,
+ // now we can release the lock on
+ // @p{fun_data}
fun_data->lock.release ();
// call the function
const ThisClass *fun_data
= dynamic_cast<const ThisClass*> (fun_encapsulation->fun_data_base);
- // copy the parameters
+ // copy the parameters
ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
Class *object = fun_data->object;
Arg1 arg1 = fun_data->arg1;
Arg3 arg3 = fun_data->arg3;
- // copying of parameters is done,
- // now we can release the lock on
- // @p{fun_data}
+ // copying of parameters is done,
+ // now we can release the lock on
+ // @p{fun_data}
fun_data->lock.release ();
// call the function
const ThisClass *fun_data
= dynamic_cast<const ThisClass*> (fun_encapsulation->fun_data_base);
- // copy the parameters
+ // copy the parameters
ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
Class *object = fun_data->object;
Arg1 arg1 = fun_data->arg1;
Arg4 arg4 = fun_data->arg4;
- // copying of parameters is done,
- // now we can release the lock on
- // @p{fun_data}
+ // copying of parameters is done,
+ // now we can release the lock on
+ // @p{fun_data}
fun_data->lock.release ();
// call the function
const ThisClass *fun_data
= dynamic_cast<const ThisClass*> (fun_encapsulation->fun_data_base);
- // copy the parameters
+ // copy the parameters
ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
Class *object = fun_data->object;
Arg1 arg1 = fun_data->arg1;
Arg5 arg5 = fun_data->arg5;
- // copying of parameters is done,
- // now we can release the lock on
- // @p{fun_data}
+ // copying of parameters is done,
+ // now we can release the lock on
+ // @p{fun_data}
fun_data->lock.release ();
// call the function
Arg4 arg4,
Arg5 arg5,
Arg6 arg6) :
- FunDataBase (&MemFunData6<Class,Arg1,Arg2,Arg3,Arg4,Arg5,Arg6,RetType>::thread_entry_point),
- fun_ptr (fun_ptr),
- object (object),
- arg1 (arg1),
- arg2 (arg2),
- arg3 (arg3),
- arg4 (arg4),
- arg5 (arg5),
- arg6 (arg6)
+ FunDataBase (&MemFunData6<Class,Arg1,Arg2,Arg3,Arg4,Arg5,Arg6,RetType>::thread_entry_point),
+ fun_ptr (fun_ptr),
+ object (object),
+ arg1 (arg1),
+ arg2 (arg2),
+ arg3 (arg3),
+ arg4 (arg4),
+ arg5 (arg5),
+ arg6 (arg6)
{};
const ThisClass *fun_data
= dynamic_cast<const ThisClass*> (fun_encapsulation->fun_data_base);
- // copy the parameters
+ // copy the parameters
ThisClass::FunPtr fun_ptr = fun_data->fun_ptr;
Class *object = fun_data->object;
Arg1 arg1 = fun_data->arg1;
Arg6 arg6 = fun_data->arg6;
- // copying of parameters is done,
- // now we can release the lock on
- // @p{fun_data}
+ // copying of parameters is done,
+ // now we can release the lock on
+ // @p{fun_data}
fun_data->lock.release ();
// call the function
Arg4 arg4,
Arg5 arg5,
Arg6 arg6)
- {
- return collect_args (&object, arg1, arg2, arg3, arg4, arg5, arg6);
- };
+ {
+ return collect_args (&object, arg1, arg2, arg3, arg4, arg5, arg6);
+ };
/* ---------------------------------------------------------------- */
template <typename ForwardIterator>
- vector<pair<ForwardIterator,ForwardIterator> >
+ std::vector<std::pair<ForwardIterator,ForwardIterator> >
split_range (const ForwardIterator &begin, const ForwardIterator &end,
const unsigned int n_intervals)
{
const unsigned int n_elements_per_interval = n_elements / n_intervals;
const unsigned int residual = n_elements % n_intervals;
- vector<pair<ForwardIterator,ForwardIterator> >
+ std::vector<std::pair<ForwardIterator,ForwardIterator> >
return_values (n_intervals);
return_values[0].first = begin;
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
*
* timer.stop ();
*
- * cout << "Elapsed time: " << timer() << " seconds.";
+ * std::cout << "Elapsed time: " << timer() << " seconds.";
*
* // reset timer for the next thing it shall do
* timer.reset();
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
{}
-void ConvergenceTable::evaluate_convergence_rates(const string &data_column_key,
- const string &reference_column_key,
- const RateMode rate_mode)
+void ConvergenceTable::evaluate_convergence_rates(const std::string &data_column_key,
+ const std::string &reference_column_key,
+ const RateMode rate_mode)
{
Assert(columns.count(data_column_key),
ExcColumnNotExistent(data_column_key));
if (rate_mode==none)
return;
- vector<TableEntryBase *> &entries=columns[data_column_key].entries;
- string rate_key=data_column_key;
+
std::vector<TableEntryBase *> &entries=columns[data_column_key].entries;
+ std::string rate_key=data_column_key;
const unsigned int n=entries.size();
- vector<double> values(n);
+ std::vector<double> values(n);
for (unsigned int i=0; i<n; ++i)
{
if (dynamic_cast<TableEntry<double>*>(entries[i]) != 0)
columns[rate_key].flag=1;
set_precision(rate_key, 2);
- string superkey=data_column_key;
+ std::string superkey=data_column_key;
if (!supercolumns.count(superkey))
{
add_column_to_supercolumn(data_column_key, superkey);
}
-void ConvergenceTable::evaluate_convergence_rates(const string &data_column_key,
- const RateMode rate_mode)
+void ConvergenceTable::evaluate_convergence_rates(const std::string &data_column_key,
+ const RateMode rate_mode)
{
Assert(columns.count(data_column_key), ExcColumnNotExistent(data_column_key));
- vector<TableEntryBase *> &entries=columns[data_column_key].entries;
- string rate_key=data_column_key+"...";
+
std::vector<TableEntryBase *> &entries=columns[data_column_key].entries;
+ std::string rate_key=data_column_key+"...";
const unsigned int n=entries.size();
- vector<double> values(n);
+ std::vector<double> values(n);
for (unsigned int i=0; i<n; ++i)
{
if (dynamic_cast<TableEntry<double>*>(entries[i]) != 0)
Assert(columns.count(rate_key)==0, ExcRateColumnAlreadyExists(rate_key));
// no value available for the
// first row
- add_value(rate_key, string("-"));
+ add_value(rate_key, std::string("-"));
for (unsigned int i=1; i<n; ++i)
add_value(rate_key, values[i-1]/values[i]);
break;
Assert(columns.count(rate_key)==0, ExcRateColumnAlreadyExists(rate_key));
// no value availble for the
// first row
- add_value(rate_key, string("-"));
+ add_value(rate_key, std::string("-"));
for (unsigned int i=1; i<n; ++i)
add_value(rate_key, log(values[i-1]/values[i])/log(2));
break;
set_precision(rate_key, 2);
// set the superkey equal to the key
- string superkey=data_column_key;
+ std::string superkey=data_column_key;
// and set the tex caption of the supercolumn
// to the tex caption of the data_column.
if (!supercolumns.count(superkey))
add_column_to_supercolumn(rate_key, superkey);
}
-void ConvergenceTable::omit_column_from_convergence_rate_evaluation(const string &key)
+void ConvergenceTable::omit_column_from_convergence_rate_evaluation(const std::string &key)
{
Assert(columns.count(key), ExcColumnNotExistent(key));
- const map<string, Column>::iterator col_iter=columns.find(key);
+ const std::map<std::string, Column>::iterator col_iter=columns.find(key);
col_iter->second.flag=1;
}
-void ConvergenceTable::evaluate_all_convergence_rates(const string &reference_column_key,
+void ConvergenceTable::evaluate_all_convergence_rates(const std::string &reference_column_key,
const RateMode rate_mode)
{
- for (map<string, Column>::const_iterator col_iter=columns.begin();
+ for (std::map<std::string, Column>::const_iterator col_iter=columns.begin();
col_iter!=columns.end(); ++col_iter)
if (!col_iter->second.flag)
evaluate_convergence_rates(col_iter->first, reference_column_key, rate_mode);
void ConvergenceTable::evaluate_all_convergence_rates(const RateMode rate_mode)
{
- for (map<string, Column>::const_iterator col_iter=columns.begin();
+ for (std::map<std::string, Column>::const_iterator col_iter=columns.begin();
col_iter!=columns.end(); ++col_iter)
if (!col_iter->second.flag)
evaluate_convergence_rates(col_iter->first, rate_mode);
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
template <int dim, int spacedim>
DataOutBase::Patch<dim,spacedim>::Patch () :
n_subdivisions (1)
- // all the other data has a
- // constructor of its own
+ // all the other data has a
+ // constructor of its own
{
Assert (dim<=spacedim, ExcInvalidCombinationOfDimensions(dim,spacedim));
Assert (spacedim<=3, ExcNotImplemented());
template <int dim, int spacedim>
-void DataOutBase::write_ucd (const vector<Patch<dim,spacedim> > &patches,
- const vector<string> &data_names,
- const UcdFlags &flags,
- ostream &out)
+void DataOutBase::write_ucd (const
std::vector<Patch<dim,spacedim> > &patches,
+ const std::vector<std::string> &data_names,
+ const UcdFlags &flags,
+ std::ostream &out)
{
AssertThrow (out, ExcIO());
// and cells for later use
unsigned int n_cells = 0,
n_nodes = 0;
- for (typename vector<Patch<dim,spacedim> >::const_iterator patch=patches.begin();
+ for (typename
std::vector<Patch<dim,spacedim> >::const_iterator patch=patches.begin();
patch!=patches.end(); ++patch)
switch (dim)
{
{
time_t time1= time (0);
tm *time = localtime(&time1);
- out << "# This file was generated by the deal.II library." << endl
+ out << "# This file was generated by the deal.II library." << std::endl
<< "# Date = "
<< time->tm_year+1900 << "/"
<< time->tm_mon+1 << "/"
- << time->tm_mday << endl
+ << time->tm_mday << std::endl
<< "# Time = "
<< time->tm_hour << ":"
- << setw(2) << time->tm_min << ":"
- << setw(2) << time->tm_sec << endl
- << "#" << endl
+ << std::setw(2) << time->tm_min << ":"
+ << std::setw(2) << time->tm_sec << std::endl
+ << "#" << std::endl
<< "# For a description of the UCD format see the AVS Developer's guide."
- << endl
- << "#" << endl;
+ << std::endl
+ << "#" << std::endl;
};
// start with ucd data
<< n_data_sets << ' '
<< 0 << ' ' // no cell data at present
<< 0 // no model data
- << endl;
+ << std::endl;
///////////////////////////////
// first make up the list of used
{
unsigned int present_node = 1;
- for (typename vector<Patch<dim,spacedim> >::const_iterator patch=patches.begin();
+ for (typename
std::vector<Patch<dim,spacedim> >::const_iterator patch=patches.begin();
patch!=patches.end(); ++patch)
{
const unsigned int n_subdivisions = patch->n_subdivisions;
// fill with zeroes
for (unsigned int i=spacedim; i<3; ++i)
out << "0 ";
- out << endl;
+ out << std::endl;
};
break;
// fill with zeroes
for (unsigned int i=spacedim; i<3; ++i)
out << "0 ";
- out << endl;
+ out << std::endl;
++present_node;
};
// fill with zeroes unnecessary here
for (unsigned int i=spacedim; i<3; ++i)
out << "0 ";
- out << endl;
+ out << std::endl;
++present_node;
};
unsigned int present_cell = 1;
unsigned int first_vertex_of_patch = 0;
- for (typename vector<Patch<dim,spacedim> >::const_iterator patch=patches.begin();
+ for (typename
std::vector<Patch<dim,spacedim> >::const_iterator patch=patches.begin();
patch!=patches.end(); ++patch)
{
const unsigned int n_subdivisions = patch->n_subdivisions;
out << present_cell
<< " 0 line " // set material id to 0
<< first_vertex_of_patch+i+1 << ' '
- << first_vertex_of_patch+i+1+1 << endl;
+ << first_vertex_of_patch+i+1+1 << std::endl;
break;
};
<< first_vertex_of_patch+(i+1)*(n_subdivisions+1)+j+1 << ' '
<< first_vertex_of_patch+(i+1)*(n_subdivisions+1)+j+1+1 << ' '
<< first_vertex_of_patch+i*(n_subdivisions+1)+j+1+1
- << endl;
+ << std::endl;
++present_cell;
};
break;
<< first_vertex_of_patch+((i+1)*(n_subdivisions+1)+j )*(n_subdivisions+1)+k+1+1 << ' '
<< first_vertex_of_patch+((i+1)*(n_subdivisions+1)+j+1)*(n_subdivisions+1)+k+1+1 << ' '
<< first_vertex_of_patch+(i*(n_subdivisions+1)+j+1 )*(n_subdivisions+1)+k+1+1 << ' '
- << endl;
+ << std::endl;
++present_cell;
};
break;
Assert (false, ExcNotImplemented());
};
};
- out << endl;
+ out << std::endl;
// note that we number starting with 1!
Assert (present_cell == n_cells+1,
for (unsigned int i=0; i<n_data_sets; ++i)
out << 1 << ' '; // number of components;
// only 1 supported presently
- out << endl;
+ out << std::endl;
for (unsigned int data_set=0; data_set<n_data_sets; ++data_set)
out << data_names[data_set]
<< ",dimensionless" // no units supported at present
- << endl;
+ << std::endl;
// loop over all patches
unsigned int present_node = 1;
- for (typename vector<Patch<dim,spacedim> >::const_iterator patch=patches.begin();
+ for (typename
std::vector<Patch<dim,spacedim> >::const_iterator patch=patches.begin();
patch != patches.end(); ++patch)
{
const unsigned int n_subdivisions = patch->n_subdivisions;
for (unsigned int data_set=0; data_set<n_data_sets; ++data_set)
out << patch->data(data_set,i) << ' ';
- out << endl;
+ out << std::endl;
};
break;
for (unsigned int data_set=0; data_set<n_data_sets; ++data_set)
out << patch->data(data_set,i*(n_subdivisions+1) + j) << ' ';
- out << endl;
+ out << std::endl;
++present_node;
};
(i*(n_subdivisions+1)+j)*(n_subdivisions+1)+k)
<< ' ';
- out << endl;
+ out << std::endl;
++present_node;
};
template <int dim, int spacedim>
-void DataOutBase::write_gnuplot (const vector<Patch<dim,spacedim> > &patches,
- const vector<string> &data_names,
- const GnuplotFlags &/*flags*/,
- ostream &out)
+void DataOutBase::write_gnuplot (const
std::vector<Patch<dim,spacedim> > &patches,
+ const std::vector<std::string> &data_names,
+ const GnuplotFlags &/*flags*/,
+ std::ostream &out)
{
AssertThrow (out, ExcIO());
// use
const time_t time1= time (0);
const tm *time = localtime(&time1);
- out << "# This file was generated by the deal.II library." << endl
+ out << "# This file was generated by the deal.II library." << std::endl
<< "# Date = "
<< time->tm_year+1900 << "/"
<< time->tm_mon+1 << "/"
- << time->tm_mday << endl
+ << time->tm_mday << std::endl
<< "# Time = "
<< time->tm_hour << ":"
- << setw(2) << time->tm_min << ":"
- << setw(2) << time->tm_sec << endl
- << "#" << endl
+ << std::setw(2) << time->tm_min << ":"
+ << std::setw(2) << time->tm_sec << std::endl
+ << "#" << std::endl
<< "# For a description of the GNUPLOT format see the GNUPLOT manual."
- << endl
- << "#" << endl
+ << std::endl
+ << "#" << std::endl
<< "# ";
switch (spacedim)
out << '<'
<< data_names[i]
<< "> ";
- out << endl;
+ out << std::endl;
};
// loop over all patches
- for (typename vector<Patch<dim,spacedim> >::const_iterator patch=patches.begin();
+ for (typename
std::vector<Patch<dim,spacedim> >::const_iterator patch=patches.begin();
patch != patches.end(); ++patch)
{
const unsigned int n_subdivisions = patch->n_subdivisions;
for (unsigned int data_set=0; data_set<n_data_sets; ++data_set)
out << patch->data(data_set,i) << ' ';
- out << endl;
+ out << std::endl;
};
// end of patch
- out << endl
- << endl;
+ out << std::endl
+ << std::endl;
break;
};
for (unsigned int data_set=0; data_set<n_data_sets; ++data_set)
out << patch->data(data_set,i*(n_subdivisions+1) + j) << ' ';
- out << endl;
+ out << std::endl;
};
// end of row in patch
- out << endl;
+ out << std::endl;
};
// end of patch
- out << endl;
+ out << std::endl;
break;
};
out << ' '
<< patch->data(data_set,
(i*(n_subdivisions+1) + j)*(n_subdivisions+1)+k);
- out << endl;
+ out << std::endl;
// write point there
// and its data
out << ' '
<< patch->data(data_set,
((i+1)*(n_subdivisions+1) + j)*(n_subdivisions+1)+k);
- out << endl;
+ out << std::endl;
// end of line
- out << endl
- << endl;
+ out << std::endl
+ << std::endl;
};
// line into positive y-direction
out << ' '
<< patch->data(data_set,
(i*(n_subdivisions+1) + j)*(n_subdivisions+1)+k);
- out << endl;
+ out << std::endl;
// write point there
// and its data
out << ' '
<< patch->data(data_set,
(i*(n_subdivisions+1) + (j+1))*(n_subdivisions+1)+k);
- out << endl;
+ out << std::endl;
// end of line
- out << endl
- << endl;
+ out << std::endl
+ << std::endl;
};
// line into positive z-direction
out << ' '
<< patch->data(data_set,
(i*(n_subdivisions+1) + j)*(n_subdivisions+1)+k);
- out << endl;
+ out << std::endl;
// write point there
// and its data
out << ' '
<< patch->data(data_set,
(i*(n_subdivisions+1) + j)*(n_subdivisions+1)+k+1);
- out << endl;
+ out << std::endl;
// end of line
- out << endl
- << endl;
+ out << std::endl
+ << std::endl;
};
};
template <int dim, int spacedim>
-void DataOutBase::write_povray (const vector<Patch<dim,spacedim> > &patches,
- const vector<string> &data_names,
- const PovrayFlags &flags,
- ostream &out)
+void DataOutBase::write_povray (const
std::vector<Patch<dim,spacedim> > &patches,
+ const std::vector<std::string> &data_names,
+ const PovrayFlags &flags,
+ std::ostream &out)
{
AssertThrow (out, ExcIO());
const unsigned int n_data_sets = data_names.size();
- // write preamble
+ // write preamble
if (true)
{
- // block this to have local
- // variables destroyed after use
+ // block this to have local
+ // variables destroyed after use
const time_t time1= time (0);
const tm *time = localtime(&time1);
- out << "/* This file was generated by the deal.II library." << endl
+ out << "/* This file was generated by the deal.II library." << std::endl
<< " Date = "
<< time->tm_year+1900 << "/"
<< time->tm_mon+1 << "/"
- << time->tm_mday << endl
+ << time->tm_mday << std::endl
<< " Time = "
<< time->tm_hour << ":"
- << setw(2) << time->tm_min << ":"
- << setw(2) << time->tm_sec << endl
- << endl
+ << std::setw(2) << time->tm_min << ":"
+ << std::setw(2) << time->tm_sec << std::endl
+ << std::endl
<< " For a description of the POVRAY format see the POVRAY manual."
- << endl
- << "*/ " << endl;
+ << std::endl
+ << "*/ " << std::endl;
// include files
- out << "#include \"colors.inc\" " << endl
- << "#include \"textures.inc\" " << endl;
+ out << "#include \"colors.inc\" " << std::endl
+ << "#include \"textures.inc\" " << std::endl;
// use external include file for textures,
// camera and light
if (flags.external_data)
- out << "#include \"data.inc\" " << endl;
+ out << "#include \"data.inc\" " << std::endl;
else // all definitions in data file
{
// camera
- out << endl << endl
- << "camera {" << endl
- << " location <1,4,-7>" << endl
- << " look_at <0,0,0>" << endl
- << " angle 30" << endl
- << "}" << endl;
+ out << std::endl << std::endl
+ << "camera {" << std::endl
+ << " location <1,4,-7>" << std::endl
+ << " look_at <0,0,0>" << std::endl
+ << " angle 30" << std::endl
+ << "}" << std::endl;
// light
- out << endl
- << "light_source {" << endl
- << " <1,4,-7>" << endl
- << " color Grey" << endl
- << "}" << endl;
- out << endl
- << "light_source {" << endl
- << " <0,20,0>" << endl
- << " color White" << endl
- << "}" << endl;
+ out << std::endl
+ << "light_source {" << std::endl
+ << " <1,4,-7>" << std::endl
+ << " color Grey" << std::endl
+ << "}" << std::endl;
+ out << std::endl
+ << "light_source {" << std::endl
+ << " <0,20,0>" << std::endl
+ << " color White" << std::endl
+ << "}" << std::endl;
}
};
// max. and min. heigth of solution
double hmin=0, hmax=0;
- for (typename vector<Patch<dim,spacedim> >::const_iterator patch=patches.begin();
+ for (typename
std::vector<Patch<dim,spacedim> >::const_iterator patch=patches.begin();
patch != patches.end(); ++patch)
{
const unsigned int n_subdivisions = patch->n_subdivisions;
}
}
- out << "#declare HMIN=" << hmin << ";" << endl
- << "#declare HMAX=" << hmax << ";" << endl << endl;
+ out << "#declare HMIN=" << hmin << ";" << std::endl
+ << "#declare HMAX=" << hmax << ";" << std::endl << std::endl;
if (!flags.external_data)
{
- // texture with scaled niveau lines
- // 10 lines in the surface
- out << "#declare Tex=texture{" << endl
- << " pigment {" << endl
- << " gradient y" << endl
- << " scale y*(HMAX-HMIN)*" << 0.1 << endl
- << " color_map {" << endl
- << " [0.00 color Light_Purple] " << endl
- << " [0.95 color Light_Purple] " << endl
- << " [1.00 color White] " << endl
- << "} } }" << endl << endl;
+ // texture with scaled niveau lines
+ // 10 lines in the surface
+ out << "#declare Tex=texture{" << std::endl
+ << " pigment {" << std::endl
+ << " gradient y" << std::endl
+ << " scale y*(HMAX-HMIN)*" << 0.1 << std::endl
+ << " color_map {" << std::endl
+ << " [0.00 color Light_Purple] " << std::endl
+ << " [0.95 color Light_Purple] " << std::endl
+ << " [1.00 color White] " << std::endl
+ << "} } }" << std::endl << std::endl;
}
if (!flags.bicubic_patch)
{ // start of mesh header
- out << endl
- << "mesh {" << endl;
+ out << std::endl
+ << "mesh {" << std::endl;
}
- // loop over all patches
- for (typename vector<Patch<dim,spacedim> >::const_iterator patch=patches.begin();
+ // loop over all patches
+ for (typename
std::vector<Patch<dim,spacedim> >::const_iterator patch=patches.begin();
patch != patches.end(); ++patch)
{
const unsigned int n_subdivisions = patch->n_subdivisions;
for (unsigned int j=0; j<n_subdivisions+1; ++j)
{
const double x_frac = i * 1./n_subdivisions,
- y_frac = j * 1./n_subdivisions;
- // compute coordinates for
- // this patch point, storing in ver
+ y_frac = j * 1./n_subdivisions;
+ // compute coordinates for
+ // this patch point, storing in ver
ver[i*(n_subdivisions+1)+j]= (((patch->vertices[1] * x_frac) +
(patch->vertices[0] * (1-x_frac))) * (1-y_frac) +
((patch->vertices[2] * x_frac) +
{
for (unsigned int j=0; j<n_subdivisions; ++j)
{
- // down/left vertex of triangle
+ // down/left vertex of triangle
const int dl = i*(n_subdivisions+1)+j;
if (flags.smooth) // only if smooth triangles are used
{
if (j!=n_subdivisions&&j!=0) nrml[i*(n_subdivisions+1)+j](2)/=2;
nrml[i*(n_subdivisions+1)+j](1)=1.;
- // normalize Vektor
+ // normalize Vektor
double norm=sqrt(
- pow(nrml[i*(n_subdivisions+1)+j](0),2.)+
- pow(nrml[i*(n_subdivisions+1)+j](1),2.)+1.);
+ pow(nrml[i*(n_subdivisions+1)+j](0),2.)+
+ pow(nrml[i*(n_subdivisions+1)+j](1),2.)+1.);
for (unsigned int k=0;k<3;++k) nrml[i*(n_subdivisions+1)+j](k)/=norm;
}
}
- // writing smooth_triangles
+ // writing smooth_triangles
- // down/right triangle
- out << "smooth_triangle {" << endl << "\t<"
+ // down/right triangle
+ out << "smooth_triangle {" << std::endl << "\t<"
<< ver[dl](0) << ","
<< patch->data(0,dl) << ","
<< ver[dl](1) << ">, <"
- << nrml[dl] << ">," << endl
+ << nrml[dl] << ">," << std::endl
<< " \t<"
<< ver[dl+n_subdivisions+1](0) << ","
<< patch->data(0,dl+n_subdivisions+1) << ","
<< ver[dl+n_subdivisions+1](1) << ">, <"
- << nrml[dl+n_subdivisions+1] << ">," << endl
+ << nrml[dl+n_subdivisions+1] << ">," << std::endl
<< "\t<"
<< ver[dl+n_subdivisions+2](0) << ","
<< patch->data(0,dl+n_subdivisions+2) << ","
<< ver[dl+n_subdivisions+2](1) << ">, <"
- << nrml[dl+n_subdivisions+2] << ">}" << endl;
+ << nrml[dl+n_subdivisions+2] << ">}" << std::endl;
- // upper/left triangle
- out << "smooth_triangle {" << endl << "\t<"
+ // upper/left triangle
+ out << "smooth_triangle {" << std::endl << "\t<"
<< ver[dl](0) << ","
<< patch->data(0,dl) << ","
<< ver[dl](1) << ">, <"
- << nrml[dl] << ">," << endl
+ << nrml[dl] << ">," << std::endl
<< "\t<"
<< ver[dl+n_subdivisions+2](0) << ","
<< patch->data(0,dl+n_subdivisions+2) << ","
<< ver[dl+n_subdivisions+2](1) << ">, <"
- << nrml[dl+n_subdivisions+2] << ">," << endl
+ << nrml[dl+n_subdivisions+2] << ">," << std::endl
<< "\t<"
<< ver[dl+1](0) << ","
<< patch->data(0,dl+1) << ","
<< ver[dl+1](1) << ">, <"
- << nrml[dl+1] << ">}" << endl;
+ << nrml[dl+1] << ">}" << std::endl;
}
else
{
- // writing standard triangles
- // down/right triangle
- out << "triangle {" << endl << "\t<"
+ // writing standard triangles
+ // down/right triangle
+ out << "triangle {" << std::endl << "\t<"
<< ver[dl](0) << ","
<< patch->data(0,dl) << ","
- << ver[dl](1) << ">," << endl
+ << ver[dl](1) << ">," << std::endl
<< "\t<"
<< ver[dl+n_subdivisions+1](0) << ","
<< patch->data(0,dl+n_subdivisions+1) << ","
- << ver[dl+n_subdivisions+1](1) << ">," << endl
+ << ver[dl+n_subdivisions+1](1) << ">," << std::endl
<< "\t<"
<< ver[dl+n_subdivisions+2](0) << ","
<< patch->data(0,dl+n_subdivisions+2) << ","
- << ver[dl+n_subdivisions+2](1) << ">}" << endl;
+ << ver[dl+n_subdivisions+2](1) << ">}" << std::endl;
- // upper/left triangle
- out << "triangle {" << endl << "\t<"
+ // upper/left triangle
+ out << "triangle {" << std::endl << "\t<"
<< ver[dl](0) << ","
<< patch->data(0,dl) << ","
- << ver[dl](1) << ">," << endl
+ << ver[dl](1) << ">," << std::endl
<< "\t<"
<< ver[dl+n_subdivisions+2](0) << ","
<< patch->data(0,dl+n_subdivisions+2) << ","
- << ver[dl+n_subdivisions+2](1) << ">," << endl
+ << ver[dl+n_subdivisions+2](1) << ">," << std::endl
<< "\t<"
<< ver[dl+1](0) << ","
<< patch->data(0,dl+1) << ","
- << ver[dl+1](1) << ">}" << endl;
+ << ver[dl+1](1) << ">}" << std::endl;
};
};
};
else
{ // writing bicubic_patch
Assert (n_subdivisions==3, ExcUnexpectedNumberOfSubdivisions(n_subdivisions,3));
- out << endl
- << "bicubic_patch {" << endl
- << " type 0" << endl
- << " flatness 0" << endl
- << " u_steps 0" << endl
- << " v_steps 0" << endl;
+ out << std::endl
+ << "bicubic_patch {" << std::endl
+ << " type 0" << std::endl
+ << " flatness 0" << std::endl
+ << " u_steps 0" << std::endl
+ << " v_steps 0" << std::endl;
for (int i=0;i<16;++i)
{
out << "\t<" << ver[i](0) << "," << patch->data(0,i) << "," << ver[i](1) << ">";
if (i!=15) out << ",";
- out << endl;
+ out << std::endl;
};
- out << " texture {Tex}" << endl
- << "}" << endl;
+ out << " texture {Tex}" << std::endl
+ << "}" << std::endl;
};
};
if (!flags.bicubic_patch)
{ // the end of the mesh
- out << " texture {Tex}" << endl
- << "}" << endl
- << endl;
+ out << " texture {Tex}" << std::endl
+ << "}" << std::endl
+ << std::endl;
}
AssertThrow (out, ExcIO());
template <int dim, int spacedim>
-void DataOutBase::write_eps (const vector<Patch<dim,spacedim> > &patches,
- const vector<string> &/*data_names*/,
- const EpsFlags &flags,
- ostream &out)
+void DataOutBase::write_eps (const
std::vector<Patch<dim,spacedim> > &patches,
+ const std::vector<std::string> &/*data_names*/,
+ const EpsFlags &flags,
+ std::ostream &out)
{
Assert (out, ExcIO());
// of the center point of the cell
// along the line of sight as value
// for sorting
- multiset<EpsCell2d> cells;
+ std::multiset<EpsCell2d> cells;
// two variables in which we
// will store the minimum and
// note that since dim==2, we
// have exactly four vertices per
// patch and per cell
- for (typename vector<Patch<dim,spacedim> >::const_iterator patch=patches.begin();
+ for (typename
std::vector<Patch<dim,spacedim> >::const_iterator patch=patches.begin();
patch!=patches.end(); ++patch)
{
const unsigned int n_subdivisions = patch->n_subdivisions;
((patch->vertices[2] * x_frac) +
(patch->vertices[3] * (1-x_frac))) * y_frac),
- (((patch->vertices[1] * x_frac1) +
- (patch->vertices[0] * (1-x_frac1))) * (1-y_frac) +
- ((patch->vertices[2] * x_frac1) +
- (patch->vertices[3] * (1-x_frac1))) * y_frac),
+ (((patch->vertices[1] * x_frac1) +
+ (patch->vertices[0] * (1-x_frac1))) * (1-y_frac) +
+ ((patch->vertices[2] * x_frac1) +
+ (patch->vertices[3] * (1-x_frac1))) * y_frac),
- (((patch->vertices[1] * x_frac1) +
- (patch->vertices[0] * (1-x_frac1))) * (1-y_frac1) +
- ((patch->vertices[2] * x_frac1) +
- (patch->vertices[3] * (1-x_frac1))) * y_frac1),
+ (((patch->vertices[1] * x_frac1) +
+ (patch->vertices[0] * (1-x_frac1))) * (1-y_frac1) +
+ ((patch->vertices[2] * x_frac1) +
+ (patch->vertices[3] * (1-x_frac1))) * y_frac1),
- (((patch->vertices[1] * x_frac) +
- (patch->vertices[0] * (1-x_frac))) * (1-y_frac1) +
- ((patch->vertices[2] * x_frac) +
- (patch->vertices[3] * (1-x_frac))) * y_frac1)
- };
+ (((patch->vertices[1] * x_frac) +
+ (patch->vertices[0] * (1-x_frac))) * (1-y_frac1) +
+ ((patch->vertices[2] * x_frac) +
+ (patch->vertices[3] * (1-x_frac))) * y_frac1)
+ };
Assert ((flags.height_vector < patch->data.m()) ||
patch->data.m() == 0,
double y_min = cells.begin()->vertices[0](1);
double y_max = y_min;
- for (multiset<EpsCell2d>::const_iterator cell=cells.begin();
+ for (std::multiset<EpsCell2d>::const_iterator cell=cells.begin();
cell!=cells.end(); ++cell)
for (unsigned int vertex=0; vertex<4; ++vertex)
{
- x_min = min (x_min, cell->vertices[vertex](0));
- x_max = max (x_max, cell->vertices[vertex](0));
- y_min = min (y_min, cell->vertices[vertex](1));
- y_max = max (y_max, cell->vertices[vertex](1));
+ x_min = std::min (x_min, cell->vertices[vertex](0));
+ x_max = std::max (x_max, cell->vertices[vertex](0));
+ y_min = std::min (y_min, cell->vertices[vertex](1));
+ y_max = std::max (y_max, cell->vertices[vertex](1));
};
// scale in x-direction such that
// use
time_t time1= time (0);
tm *time = localtime(&time1);
- out << "%!PS-Adobe-2.0 EPSF-1.2" << endl
- << "%%Title: deal.II Output" << endl
- << "%%Creator: the deal.II library" << endl
+ out << "%!PS-Adobe-2.0 EPSF-1.2" << std::endl
+ << "%%Title: deal.II Output" << std::endl
+ << "%%Creator: the deal.II library" << std::endl
<< "%%Creation Date: "
<< time->tm_year+1900 << "/"
<< time->tm_mon+1 << "/"
<< time->tm_mday << " - "
<< time->tm_hour << ":"
- << setw(2) << time->tm_min << ":"
- << setw(2) << time->tm_sec << endl
+ << std::setw(2) << time->tm_min << ":"
+ << std::setw(2) << time->tm_sec << std::endl
<< "%%BoundingBox: "
// lower left corner
<< "0 0 "
<< static_cast<unsigned int>( (x_max-x_min) * scale )
<< ' '
<< static_cast<unsigned int>( (y_max-y_min) * scale )
- << endl;
+ << std::endl;
// define some abbreviations to keep
// the output small:
// sg=set gray value
// lx=close the line and plot the line
// lf=close the line and fill the interior
- out << "/m {moveto} bind def" << endl
- << "/l {lineto} bind def" << endl
- << "/s {setrgbcolor} bind def" << endl
- << "/sg {setgray} bind def" << endl
- << "/lx {lineto closepath stroke} bind def" << endl
- << "/lf {lineto closepath fill} bind def" << endl;
+ out << "/m {moveto} bind def" << std::endl
+ << "/l {lineto} bind def" << std::endl
+ << "/s {setrgbcolor} bind def" << std::endl
+ << "/sg {setgray} bind def" << std::endl
+ << "/lx {lineto closepath stroke} bind def" << std::endl
+ << "/lf {lineto closepath fill} bind def" << std::endl;
- out << "%%EndProlog" << endl
- << endl;
+ out << "%%EndProlog" << std::endl
+ << std::endl;
// set fine lines
- out << flags.line_width << " setlinewidth" << endl;
+ out << flags.line_width << " setlinewidth" << std::endl;
// allow only five digits
// for output (instead of the
// default six); this should suffice
// even for fine grids, but reduces
// the file size significantly
- out << setprecision (5);
+ out << std::setprecision (5);
};
// now we've got all the information
// note: due to the ordering, we
// traverse the list of cells
// back-to-front
- for (multiset<EpsCell2d>::const_iterator cell=cells.begin();
+ for (std::multiset<EpsCell2d>::const_iterator cell=cells.begin();
cell!=cells.end(); ++cell)
{
if (flags.draw_cells)
<< (cell->vertices[1]-offset) * scale << " l "
<< (cell->vertices[2]-offset) * scale << " l "
<< (cell->vertices[3]-offset) * scale << " lf"
- << endl;
+ << std::endl;
};
if (flags.draw_mesh)
<< (cell->vertices[1]-offset) * scale << " l "
<< (cell->vertices[2]-offset) * scale << " l "
<< (cell->vertices[3]-offset) * scale << " lx"
- << endl;
+ << std::endl;
};
- out << "showpage" << endl;
+ out << "showpage" << std::endl;
break;
};
template <int dim, int spacedim>
-void DataOutBase::write_gmv (const vector<Patch<dim,spacedim> > &patches,
- const vector<string> &data_names,
- const GmvFlags &/*flags*/,
- ostream &out)
+void DataOutBase::write_gmv (const
std::vector<Patch<dim,spacedim> > &patches,
+ const std::vector<std::string> &data_names,
+ const GmvFlags &/*flags*/,
+ std::ostream &out)
{
AssertThrow (out, ExcIO());
///////////////////////
// preamble
out << "gmvinput ascii"
- << endl
- << endl;
+ << std::endl
+ << std::endl;
// first count the number of cells
// and cells for later use
unsigned int n_cells = 0,
n_nodes = 0;
- for (typename vector<Patch<dim,spacedim> >::const_iterator patch=patches.begin();
+ for (typename
std::vector<Patch<dim,spacedim> >::const_iterator patch=patches.begin();
patch!=patches.end(); ++patch)
switch (dim)
{
// separate thread and when wanting
// to write out the data, we wait
// for that thread to finish
- vector<vector<double> > data_vectors (n_data_sets,
- vector<double> (n_nodes));
+ std::vector<std::vector<double> > data_vectors (n_data_sets,
+ std::vector<double> (n_nodes));
Threads::ThreadManager thread_manager;
Threads::spawn (thread_manager,
Threads::encapsulate (&DataOutBase::template
//
// note that we have to print
// d=1..3 dimensions
- out << "nodes " << n_nodes << endl;
+ out << "nodes " << n_nodes << std::endl;
for (unsigned int d=1; d<=3; ++d)
{
- for (typename vector<Patch<dim,spacedim> >::const_iterator patch=patches.begin();
+ for (typename
std::vector<Patch<dim,spacedim> >::const_iterator patch=patches.begin();
patch!=patches.end(); ++patch)
{
const unsigned int n_subdivisions = patch->n_subdivisions;
out << "0 ";
};
};
- out << endl;
+ out << std::endl;
};
- out << endl;
+ out << std::endl;
/////////////////////////////////
// now for the cells. note that
// vertices are counted from 1 onwards
if (true)
{
- out << "cells " << n_cells << endl;
+ out << "cells " << n_cells << std::endl;
unsigned int first_vertex_of_patch = 0;
- for (typename vector<Patch<dim,spacedim> >::const_iterator patch=patches.begin();
+ for (typename
std::vector<Patch<dim,spacedim> >::const_iterator patch=patches.begin();
patch!=patches.end(); ++patch)
{
const unsigned int n_subdivisions = patch->n_subdivisions;
for (unsigned int i=0; i<n_subdivisions; ++i)
out << "line 2\n "
<< first_vertex_of_patch+i+1 << ' '
- << first_vertex_of_patch+i+1+1 << endl;
+ << first_vertex_of_patch+i+1+1 << std::endl;
break;
};
<< first_vertex_of_patch+(i+1)*(n_subdivisions+1)+j+1 << ' '
<< first_vertex_of_patch+(i+1)*(n_subdivisions+1)+j+1+1 << ' '
<< first_vertex_of_patch+i*(n_subdivisions+1)+j+1+1
- << endl;
+ << std::endl;
break;
};
<< first_vertex_of_patch+((i+1)*(n_subdivisions+1)+j )*(n_subdivisions+1)+k+1+1 << ' '
<< first_vertex_of_patch+((i+1)*(n_subdivisions+1)+j+1)*(n_subdivisions+1)+k+1+1 << ' '
<< first_vertex_of_patch+(i*(n_subdivisions+1)+j+1 )*(n_subdivisions+1)+k+1+1 << ' '
- << endl;
+ << std::endl;
};
break;
};
Assert (false, ExcNotImplemented());
};
};
- out << endl;
+ out << std::endl;
};
///////////////////////////////////////
// data output.
- out << "variable" << endl;
+ out << "variable" << std::endl;
// now write the data vectors to
// @p{out} first make sure that all
// support explicitely here)
for (unsigned int data_set=0; data_set<n_data_sets; ++data_set)
{
- out << data_names[data_set] << " 1" << endl;
+ out << data_names[data_set] << " 1" << std::endl;
copy(data_vectors[data_set].begin(),
data_vectors[data_set].end(),
- ostream_iterator<double>(out, " "));
- out << endl
- << endl;
+ std::ostream_iterator<double>(out, " "));
+ out << std::endl
+ << std::endl;
};
// end of variable section
- out << "endvars" << endl;
+ out << "endvars" << std::endl;
// end of output
out << "endgmv"
- << endl;
+ << std::endl;
// assert the stream is still ok
AssertThrow (out, ExcIO());
template <int dim, int spacedim>
void
-DataOutBase::write_gmv_reorder_data_vectors (const vector<Patch<dim,spacedim> > &patches,
- vector<vector<double> > &data_vectors)
+DataOutBase::write_gmv_reorder_data_vectors (const
std::vector<Patch<dim,spacedim> > &patches,
+ std::vector<std::vector<double> > &data_vectors)
{
// unlike in the main function, we
// don't have here the data_names
// loop over all patches
unsigned int next_value = 0;
- for (typename vector<Patch<dim,spacedim> >::const_iterator patch=patches.begin();
+ for (typename
std::vector<Patch<dim,spacedim> >::const_iterator patch=patches.begin();
patch != patches.end(); ++patch)
{
const unsigned int n_subdivisions = patch->n_subdivisions;
template <int dim, int spacedim>
-void DataOutInterface<dim,spacedim>::write_ucd (ostream &out) const
+void DataOutInterface<dim,spacedim>::write_ucd (std::ostream &out) const
{
DataOutBase::write_ucd (get_patches(), get_dataset_names(),
- ucd_flags, out);
+ ucd_flags, out);
};
template <int dim, int spacedim>
-void DataOutInterface<dim,spacedim>::write_gnuplot (ostream &out) const
+void DataOutInterface<dim,spacedim>::write_gnuplot (std::ostream &out) const
{
DataOutBase::write_gnuplot (get_patches(), get_dataset_names(),
gnuplot_flags, out);
template <int dim, int spacedim>
-void DataOutInterface<dim,spacedim>::write_povray (ostream &out) const
+void DataOutInterface<dim,spacedim>::write_povray (std::ostream &out) const
{
DataOutBase::write_povray (get_patches(), get_dataset_names(),
povray_flags, out);
template <int dim, int spacedim>
-void DataOutInterface<dim,spacedim>::write_eps (ostream &out) const
+void DataOutInterface<dim,spacedim>::write_eps (std::ostream &out) const
{
DataOutBase::write_eps (get_patches(), get_dataset_names(),
eps_flags, out);
template <int dim, int spacedim>
-void DataOutInterface<dim,spacedim>::write_gmv (ostream &out) const
+void DataOutInterface<dim,spacedim>::write_gmv (std::ostream &out) const
{
DataOutBase::write_gmv (get_patches(), get_dataset_names(),
gmv_flags, out);
template <int dim, int spacedim>
-void DataOutInterface<dim,spacedim>::write (ostream &out,
- OutputFormat output_format) const
+void DataOutInterface<dim,spacedim>::write (std::ostream &out,
+ OutputFormat output_format) const
{
if (output_format == default_format)
output_format = default_fmt;
template <int dim, int spacedim>
-string DataOutInterface<dim,spacedim>::default_suffix (OutputFormat output_format) const
+std::string DataOutInterface<dim,spacedim>::default_suffix (OutputFormat output_format) const
{
if (output_format == default_format)
output_format = default_fmt;
template <int dim, int spacedim>
DataOutInterface<dim,spacedim>::OutputFormat
-DataOutInterface<dim,spacedim>::parse_output_format (const string &format_name)
+DataOutInterface<dim,spacedim>::parse_output_format (const std::string &format_name)
{
if (format_name == "ucd")
return ucd;
template <int dim, int spacedim>
-string DataOutInterface<dim,spacedim>::get_output_format_names ()
+std::string DataOutInterface<dim,spacedim>::get_output_format_names ()
{
return "ucd|gnuplot|povray|eps|gmv";
}
template <int dim, int spacedim>
void DataOutInterface<dim,spacedim>::parse_parameters (ParameterHandler &prm)
{
- const string& output_name = prm.get ("Output format");
+ const std::string& output_name = prm.get ("Output format");
default_fmt = parse_output_format (output_name);
prm.enter_subsection ("UCD output parameters");
-void ExceptionBase::PrintExcData (ostream &out) const
+void ExceptionBase::PrintExcData (std::ostream &out) const
{
out << "An error occurred in line <" << line
<< "> of file <" << file
- << "> in function" << endl
- << " " << function << endl
- << "The violated condition was: "<< endl
- << " " << cond << endl
- << "The name and call sequence of the exception was:" << endl
- << " " << exc << endl
- << "Additional Information: " << endl;
+ << "> in function" << std::endl
+ << " " << function << std::endl
+ << "The violated condition was: "<< std::endl
+ << " " << cond << std::endl
+ << "The name and call sequence of the exception was:" << std::endl
+ << " " << exc << std::endl
+ << "Additional Information: " << std::endl;
};
-void ExceptionBase::PrintInfo (ostream &out) const
+void ExceptionBase::PrintInfo (std::ostream &out) const
{
- out << "(none)" << endl;
+ out << "(none)" << std::endl;
};
// and therefore need a liftime which is
// longer than the execution time of this
// function
- static string description;
+ static std::string description;
// convert the messages printed by the
- // exceptions into a string
- ostrstream converter;
+ // exceptions into a std::string
+ std::ostrstream converter;
converter << "--------------------------------------------------------"
- << endl;
- // put general info into the string
+ << std::endl;
+ // put general info into the std::string
PrintExcData (converter);
// put in exception specific data
PrintInfo (converter);
converter << "--------------------------------------------------------"
- << endl
- << ends;
+ << std::endl
+ << std::ends;
description = converter.str();
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
template <int dim>
-void Function<dim>::value_list (const vector<Point<dim> > &points,
- vector<double> &values,
- const unsigned int component) const
+void Function<dim>::value_list (const
std::vector<Point<dim> > &points,
+ std::vector<double> &values,
+ const unsigned int component) const
{
// check whether component is in
// the valid range is up to the
template <int dim>
-void Function<dim>::vector_value_list (const vector<Point<dim> > &points,
- vector<Vector<double> > &values) const
+void Function<dim>::vector_value_list (const
std::vector<Point<dim> > &points,
+ std::vector<Vector<double> > &values) const
{
// check whether component is in
// the valid range is up to the
template <int dim>
void Function<dim>::vector_gradient (const Point<dim> &,
- vector<Tensor<1,dim> > &) const
+ std::vector<Tensor<1,dim> > &) const
{
Assert (false, ExcPureFunctionCalled());
};
template <int dim>
-void Function<dim>::gradient_list (const vector<Point<dim> > &points,
- vector<Tensor<1,dim> > &gradients,
- const unsigned int component) const
+void Function<dim>::gradient_list (const
std::vector<Point<dim> > &points,
+ std::vector<Tensor<1,dim> > &gradients,
+ const unsigned int component) const
{
Assert (gradients.size() == points.size(),
ExcDimensionMismatch(gradients.size(), points.size()));
template <int dim>
-void Function<dim>::vector_gradient_list (const vector<Point<dim> > &points,
- vector<vector<Tensor<1,dim> > > &gradients) const
+void Function<dim>::vector_gradient_list (const std::vector<Point<dim> > &points,
+ std::vector<std::vector<Tensor<1,dim> > > &gradients) const
{
Assert (gradients.size() == points.size(),
ExcDimensionMismatch(gradients.size(), points.size()));
template <int dim>
double Function<dim>::laplacian (const Point<dim> &,
- const unsigned int) const
+ const unsigned int) const
{
Assert (false, ExcPureFunctionCalled());
return 0;
template <int dim>
void Function<dim>::vector_laplacian (const Point<dim> &,
- Vector<double> &) const
+ Vector<double> &) const
{
Assert (false, ExcPureFunctionCalled());
}
template <int dim>
-void Function<dim>::laplacian_list (const vector<Point<dim> > &points,
- vector<double> &laplacians,
- const unsigned int component) const
+void Function<dim>::laplacian_list (const
std::vector<Point<dim> > &points,
+ std::vector<double> &laplacians,
+ const unsigned int component) const
{
// check whether component is in
// the valid range is up to the
template <int dim>
-void Function<dim>::vector_laplacian_list (const vector<Point<dim> > &points,
- vector<Vector<double> > &laplacians) const
+void Function<dim>::vector_laplacian_list (const
std::vector<Point<dim> > &points,
+ std::vector<Vector<double> > &laplacians) const
{
// check whether component is in
// the valid range is up to the
template <int dim>
double ZeroFunction<dim>::value (const Point<dim> &,
- const unsigned int) const
+ const unsigned int) const
{
return 0.;
};
Assert (return_value.size() == n_components,
ExcDimensionMismatch (return_value.size(), n_components));
- fill_n (return_value.begin(), n_components, 0.0);
+ std::fill_n (return_value.begin(), n_components, 0.0);
};
template <int dim>
-void ZeroFunction<dim>::value_list (const vector<Point<dim> > &points,
- vector<double> &values,
+void ZeroFunction<dim>::value_list (const
std::vector<Point<dim> > &points,
+ std::vector<double> &values,
const unsigned int /*component*/) const {
Assert (values.size() == points.size(),
ExcDimensionMismatch(values.size(), points.size()));
template <int dim>
-void ZeroFunction<dim>::vector_value_list (const vector<Point<dim> > &points,
- vector<Vector<double> > &values) const
+void ZeroFunction<dim>::vector_value_list (const
std::vector<Point<dim> > &points,
+ std::vector<Vector<double> > &values) const
{
Assert (values.size() == points.size(),
ExcDimensionMismatch(values.size(), points.size()));
{
Assert (values[i].size() == n_components,
ExcDimensionMismatch(values[i].size(), n_components));
- fill_n (values[i].begin(), n_components, 0.);
+ std::fill_n (values[i].begin(), n_components, 0.);
};
};
template <int dim>
void ZeroFunction<dim>::vector_gradient (const Point<dim> &,
- vector<Tensor<1,dim> > &gradients) const
+ std::vector<Tensor<1,dim> > &gradients) const
{
Assert (gradients.size() == n_components,
ExcDimensionMismatch(gradients.size(), n_components));
template <int dim>
-void ZeroFunction<dim>::gradient_list (const vector<Point<dim> > &points,
- vector<Tensor<1,dim> > &gradients,
- const unsigned int /*component*/) const
+void ZeroFunction<dim>::gradient_list (const
std::vector<Point<dim> > &points,
+ std::vector<Tensor<1,dim> > &gradients,
+ const unsigned int /*component*/) const
{
Assert (gradients.size() == points.size(),
ExcDimensionMismatch(gradients.size(), points.size()));
template <int dim>
-void ZeroFunction<dim>::vector_gradient_list (const vector<Point<dim> > &points,
- vector<vector<Tensor<1,dim> > > &gradients) const
+void ZeroFunction<dim>::vector_gradient_list (const std::vector<Point<dim> > &points,
+ std::vector<std::vector<Tensor<1,dim> > > &gradients) const
{
Assert (gradients.size() == points.size(),
ExcDimensionMismatch(gradients.size(), points.size()));
ConstantFunction<dim>::ConstantFunction (const double value,
const unsigned int n_components) :
ZeroFunction<dim> (n_components),
- function_value (value) {};
+ function_value (value) {};
template <int dim>
template <int dim>
double ConstantFunction<dim>::value (const Point<dim> &,
- const unsigned int) const
+ const unsigned int) const
{
return function_value;
};
Assert (return_value.size() == n_components,
ExcDimensionMismatch (return_value.size(), n_components));
- fill_n (return_value.begin(), n_components, function_value);
+ std::fill_n (return_value.begin(), n_components, function_value);
};
template <int dim>
-void ConstantFunction<dim>::value_list (const vector<Point<dim> > &points,
- vector<double> &values,
- const unsigned int /*component*/) const {
+void ConstantFunction<dim>::value_list (const std::vector<Point<dim> > &points,
+ std::vector<double> &values,
+ const unsigned int /*component*/) const
+{
Assert (values.size() == points.size(),
ExcDimensionMismatch(values.size(), points.size()));
template <int dim>
-void ConstantFunction<dim>::vector_value_list (const vector<Point<dim> > &points,
- vector<Vector<double> > &values) const
+void ConstantFunction<dim>::vector_value_list (const
std::vector<Point<dim> > &points,
+ std::vector<Vector<double> > &values) const
{
Assert (values.size() == points.size(),
ExcDimensionMismatch(values.size(), points.size()));
{
Assert (values[i].size() == n_components,
ExcDimensionMismatch(values[i].size(), n_components));
- fill_n (values[i].begin(), n_components, function_value);
+ std::fill_n (values[i].begin(), n_components, function_value);
};
};
const unsigned int n_components)
:
ConstantFunction<dim> (value, n_components),
- selected(selected)
+ selected(selected)
{}
Assert (return_value.size() == n_components,
ExcDimensionMismatch (return_value.size(), n_components));
- fill_n (return_value.begin(), n_components, 0.);
+ std::fill_n (return_value.begin(), n_components, 0.);
return_value(selected) = function_value;
}
template <int dim>
-void ComponentSelectFunction<dim>::vector_value_list (const vector<Point<dim> > &points,
- vector<Vector<double> > &values) const
+void ComponentSelectFunction<dim>::vector_value_list (const
std::vector<Point<dim> > &points,
+ std::vector<Vector<double> > &values) const
{
Assert (values.size() == points.size(),
ExcDimensionMismatch(values.size(), points.size()));
{
Assert (values[i].size() == n_components,
ExcDimensionMismatch(values[i].size(), n_components));
- fill_n (values[i].begin(), n_components, 0.);
+ std::fill_n (values[i].begin(), n_components, 0.);
values[i](selected) = function_value;
}
}
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
const Point<dim>& dir)
:
Function<dim> (f.n_components, f.get_time()),
- f(f),
- direction(dir)
+ f(f),
+ direction(dir)
{
set_h();
set_formula();
template <int dim>
void
-FunctionDerivative<dim>::value_list (const vector<Point<dim> > &points,
- vector<double> &values,
- const unsigned int component) const
+FunctionDerivative<dim>::value_list (const
std::vector<Point<dim> > &points,
+ std::vector<double> &values,
+ const unsigned int component) const
{
const unsigned int n = points.size();
switch (formula)
{
- case Euler:
- {
- vector<Point<dim> > p1(n);
- vector<Point<dim> > p2(n);
- vector<double> e2(n);
- for (unsigned int i=0;i<n;++i)
- {
- p1[i] = points[i]+incr;
- p2[i] = points[i]-incr;
- }
- f.value_list(p1, values, component);
- f.value_list(p2, e2, component);
+ case Euler:
+ {
+
std::vector<Point<dim> > p1(n);
+
std::vector<Point<dim> > p2(n);
+ std::vector<double> e2(n);
+ for (unsigned int i=0;i<n;++i)
+ {
+ p1[i] = points[i]+incr;
+ p2[i] = points[i]-incr;
+ }
+ f.value_list(p1, values, component);
+ f.value_list(p2, e2, component);
- for (unsigned int i=0;i<n;++i)
- {
- values[i] = (values[i]-e2[i])/(2*h);
- }
- break;
- }
- case UpwindEuler:
- {
- vector<Point<dim> > p2(n);
- vector<double> e2(n);
- for (unsigned int i=0;i<n;++i)
- p2[i] = points[i]-incr;
- f.value_list(points, values, component);
- f.value_list(p2, e2, component);
- for (unsigned int i=0;i<n;++i)
- values[i] = (values[i]-e2[i])/h;
- break;
- }
- case FourthOrder:
- {
- vector<Point<dim> > p_p(n);
- vector<Point<dim> > p_pp(n);
- vector<Point<dim> > p_m(n);
- vector<Point<dim> > p_mm(n);
- vector<double> e_p(n);
- vector<double> e_pp(n);
- vector<double> e_m(n);
- for (unsigned int i=0;i<n;++i)
- {
- p_p[i] = points[i]+incr;
- p_pp[i] = p_p[i]+incr;
- p_m[i] = points[i]-incr;
- p_mm[i] = p_m[i]-incr;
- }
- f.value_list(p_mm, values, component);
- f.value_list(p_pp, e_pp, component);
- f.value_list(p_p, e_p, component);
- f.value_list(p_m, e_m, component);
+ for (unsigned int i=0;i<n;++i)
+ {
+ values[i] = (values[i]-e2[i])/(2*h);
+ }
+ break;
+ }
+ case UpwindEuler:
+ {
+
std::vector<Point<dim> > p2(n);
+ std::vector<double> e2(n);
+ for (unsigned int i=0;i<n;++i)
+ p2[i] = points[i]-incr;
+ f.value_list(points, values, component);
+ f.value_list(p2, e2, component);
+ for (unsigned int i=0;i<n;++i)
+ values[i] = (values[i]-e2[i])/h;
+ break;
+ }
+ case FourthOrder:
+ {
+
std::vector<Point<dim> > p_p(n);
+
std::vector<Point<dim> > p_pp(n);
+
std::vector<Point<dim> > p_m(n);
+
std::vector<Point<dim> > p_mm(n);
+ std::vector<double> e_p(n);
+ std::vector<double> e_pp(n);
+ std::vector<double> e_m(n);
+ for (unsigned int i=0;i<n;++i)
+ {
+ p_p[i] = points[i]+incr;
+ p_pp[i] = p_p[i]+incr;
+ p_m[i] = points[i]-incr;
+ p_mm[i] = p_m[i]-incr;
+ }
+ f.value_list(p_mm, values, component);
+ f.value_list(p_pp, e_pp, component);
+ f.value_list(p_p, e_p, component);
+ f.value_list(p_m, e_m, component);
- for (unsigned int i=0;i<n;++i)
- {
- values[i] = (values[i]-e_pp[i]+8*(e_p[i]-e_m[i]))/(12*h);
- }
- break;
- }
-
- default:
- Assert(false, ExcInvalidFormula());
+ for (unsigned int i=0;i<n;++i)
+ {
+ values[i] = (values[i]-e_pp[i]+8*(e_p[i]-e_m[i]))/(12*h);
+ }
+ break;
+ }
+
+ default:
+ Assert(false, ExcInvalidFormula());
}
}
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
template<int dim>
void
-SquareFunction<dim>::value_list (const vector<Point<dim> > &points,
- vector<double> &values,
+SquareFunction<dim>::value_list (const
std::vector<Point<dim> > &points,
+ std::vector<double> &values,
const unsigned int) const
{
Assert (values.size() == points.size(),
template<int dim>
void
-SquareFunction<dim>::laplacian_list (const vector<Point<dim> > &points,
- vector<double> &values,
+SquareFunction<dim>::laplacian_list (const
std::vector<Point<dim> > &points,
+ std::vector<double> &values,
const unsigned int) const
{
Assert (values.size() == points.size(),
template<int dim>
void
-SquareFunction<dim>::gradient_list (const vector<Point<dim> > &points,
- vector<Tensor<1,dim> > &gradients,
+SquareFunction<dim>::gradient_list (const
std::vector<Point<dim> > &points,
+ std::vector<Tensor<1,dim> > &gradients,
const unsigned int) const
{
Assert (gradients.size() == points.size(),
template<int dim>
double
Q1WedgeFunction<dim>::value (const Point<dim> &p,
- const unsigned int) const
+ const unsigned int) const
{
return p(0)*p(1);
}
template<int dim>
void
-Q1WedgeFunction<dim>::value_list (const vector<Point<dim> > &points,
- vector<double> &values,
- const unsigned int) const
+Q1WedgeFunction<dim>::value_list (const
std::vector<Point<dim> > &points,
+ std::vector<double> &values,
+ const unsigned int) const
{
Assert (values.size() == points.size(),
ExcDimensionMismatch(values.size(), points.size()));
template<int dim>
double
Q1WedgeFunction<dim>::laplacian (const Point<dim> &,
- const unsigned int) const
+ const unsigned int) const
{
return 0.;
}
template<int dim>
void
-Q1WedgeFunction<dim>::laplacian_list (const vector<Point<dim> > &points,
- vector<double> &values,
- const unsigned int) const
+Q1WedgeFunction<dim>::laplacian_list (const
std::vector<Point<dim> > &points,
+ std::vector<double> &values,
+ const unsigned int) const
{
Assert (values.size() == points.size(),
ExcDimensionMismatch(values.size(), points.size()));
template<int dim>
Tensor<1,dim>
Q1WedgeFunction<dim>::gradient (const Point<dim> &p,
- const unsigned int) const
+ const unsigned int) const
{
Tensor<1,dim> erg;
erg[0] = p(1);
template<int dim>
void
-Q1WedgeFunction<dim>::gradient_list (const vector<Point<dim> > &points,
- vector<Tensor<1,dim> > &gradients,
- const unsigned int) const
+Q1WedgeFunction<dim>::gradient_list (const
std::vector<Point<dim> > &points,
+ std::vector<Tensor<1,dim> > &gradients,
+ const unsigned int) const
{
Assert (gradients.size() == points.size(),
ExcDimensionMismatch(gradients.size(), points.size()));
template<int dim>
void
-PillowFunction<dim>::value_list (const vector<Point<dim> > &points,
- vector<double> &values,
+PillowFunction<dim>::value_list (const
std::vector<Point<dim> > &points,
+ std::vector<double> &values,
const unsigned int) const
{
Assert (values.size() == points.size(),
template<int dim>
void
-PillowFunction<dim>::laplacian_list (const vector<Point<dim> > &points,
- vector<double> &values,
+PillowFunction<dim>::laplacian_list (const
std::vector<Point<dim> > &points,
+ std::vector<double> &values,
const unsigned int) const
{
Assert (values.size() == points.size(),
template<int dim>
void
-PillowFunction<dim>::gradient_list (const vector<Point<dim> > &points,
- vector<Tensor<1,dim> > &gradients,
+PillowFunction<dim>::gradient_list (const
std::vector<Point<dim> > &points,
+ std::vector<Tensor<1,dim> > &gradients,
const unsigned int) const
{
Assert (gradients.size() == points.size(),
template<int dim>
void
-CosineFunction<dim>::value_list (const vector<Point<dim> > &points,
- vector<double> &values,
+CosineFunction<dim>::value_list (const
std::vector<Point<dim> > &points,
+ std::vector<double> &values,
const unsigned int) const
{
Assert (values.size() == points.size(),
template<int dim>
void
-CosineFunction<dim>::laplacian_list (const vector<Point<dim> > &points,
- vector<double> &values,
+CosineFunction<dim>::laplacian_list (const
std::vector<Point<dim> > &points,
+ std::vector<double> &values,
const unsigned int) const
{
Assert (values.size() == points.size(),
template<int dim>
void
-CosineFunction<dim>::gradient_list (const vector<Point<dim> > &points,
- vector<Tensor<1,dim> > &gradients,
+CosineFunction<dim>::gradient_list (const
std::vector<Point<dim> > &points,
+ std::vector<Tensor<1,dim> > &gradients,
const unsigned int) const
{
Assert (gradients.size() == points.size(),
template<int dim>
void
-ExpFunction<dim>::value_list (const vector<Point<dim> > &points,
- vector<double> &values,
+ExpFunction<dim>::value_list (const
std::vector<Point<dim> > &points,
+ std::vector<double> &values,
const unsigned int) const
{
Assert (values.size() == points.size(),
template<int dim>
void
-ExpFunction<dim>::laplacian_list (const vector<Point<dim> > &points,
- vector<double> &values,
+ExpFunction<dim>::laplacian_list (const
std::vector<Point<dim> > &points,
+ std::vector<double> &values,
const unsigned int) const
{
Assert (values.size() == points.size(),
template<int dim>
void
-ExpFunction<dim>::gradient_list (const vector<Point<dim> > &points,
- vector<Tensor<1,dim> > &gradients,
+ExpFunction<dim>::gradient_list (const
std::vector<Point<dim> > &points,
+ std::vector<Tensor<1,dim> > &gradients,
const unsigned int) const
{
Assert (gradients.size() == points.size(),
void
-LSingularityFunction::value_list (const vector<Point<2> > &points,
- vector<double> &values,
+LSingularityFunction::value_list (const
std::vector<Point<2> > &points,
+ std::vector<double> &values,
const unsigned int) const
{
Assert (values.size() == points.size(),
void
-LSingularityFunction::laplacian_list (const vector<Point<2> > &points,
- vector<double> &values,
+LSingularityFunction::laplacian_list (const
std::vector<Point<2> > &points,
+ std::vector<double> &values,
const unsigned int) const
{
Assert (values.size() == points.size(),
void
-LSingularityFunction::gradient_list (const vector<Point<2> > &points,
- vector<Tensor<1,2> > &gradients,
+LSingularityFunction::gradient_list (const
std::vector<Point<2> > &points,
+ std::vector<Tensor<1,2> > &gradients,
const unsigned int) const
{
Assert (gradients.size() == points.size(),
void
-SlitSingularityFunction::value_list (const vector<Point<2> > &points,
- vector<double> &values,
+SlitSingularityFunction::value_list (const
std::vector<Point<2> > &points,
+ std::vector<double> &values,
const unsigned int) const
{
Assert (values.size() == points.size(),
void
-SlitSingularityFunction::laplacian_list (const vector<Point<2> > &points,
- vector<double> &values,
+SlitSingularityFunction::laplacian_list (const
std::vector<Point<2> > &points,
+ std::vector<double> &values,
const unsigned int) const
{
Assert (values.size() == points.size(),
void
-SlitSingularityFunction::gradient_list (const vector<Point<2> > &points,
- vector<Tensor<1,2> > &gradients,
+SlitSingularityFunction::gradient_list (const
std::vector<Point<2> > &points,
+ std::vector<Tensor<1,2> > &gradients,
const unsigned int) const
{
Assert (gradients.size() == points.size(),
template<int dim>
void
-JumpFunction<dim>::value_list (const vector<Point<dim> > &p,
- vector<double> &values,
+JumpFunction<dim>::value_list (const
std::vector<Point<dim> > &p,
+ std::vector<double> &values,
const unsigned int) const
{
Assert (values.size() == p.size(),
template<int dim>
void
-JumpFunction<dim>::laplacian_list (const vector<Point<dim> > &p,
- vector<double> &values,
+JumpFunction<dim>::laplacian_list (const
std::vector<Point<dim> > &p,
+ std::vector<double> &values,
const unsigned int) const
{
Assert (values.size() == p.size(),
template<int dim>
void
-JumpFunction<dim>::gradient_list (const vector<Point<dim> > &p,
- vector<Tensor<1,dim> > &gradients,
+JumpFunction<dim>::gradient_list (const
std::vector<Point<dim> > &p,
+ std::vector<Tensor<1,dim> > &gradients,
const unsigned int) const
{
Assert (gradients.size() == p.size(),
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
JobIdentifier dealjobid;
+
JobIdentifier::JobIdentifier()
{
time_t t = time(0);
- id = string(program_id()) + string(ctime(&t));
+ id = std::string(program_id()) + std::string(ctime(&t));
}
-JobIdentifier::~JobIdentifier()
-{}
-const string
+const std::string
JobIdentifier::operator ()() const
{
return id;
}
+
+
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
LogStream::LogStream()
- : std_out(&cerr), file(0), was_endl(true),
+ : std_out(&std::cerr), file(0), was_endl(true),
std_depth(10000), file_depth(10000),
print_utime(false)
{
prefixes.push("DEAL:");
- std_out->setf(ios::showpoint | ios::left);
+ std_out->setf(std::ios::showpoint | std::ios::left);
}
void
-LogStream::attach(ostream& o)
+LogStream::attach(std::ostream& o)
{
file = &o;
- o.setf(ios::showpoint | ios::left);
+ o.setf(std::ios::showpoint | std::ios::left);
o << dealjobid();
}
};
-ostream&
+std::ostream&
LogStream::get_console()
{
return *std_out;
}
-ostream&
+std::ostream&
LogStream::get_file_stream()
{
Assert(file, ExcNoFileStreamGiven());
void
-LogStream::push (const string& text)
+LogStream::push (const std::string& text)
{
- string pre=prefixes.top();
+ std::string pre=prefixes.top();
pre += text;
- pre += string(":");
+ pre += std::string(":");
prefixes.push(pre);
};
*std_out << utime << ':';
std_out->width(p);
}
- *std_out << prefixes.top() << ':';
+ *std_out << prefixes.top() << ':';
}
if (file && (prefixes.size() <= file_depth))
*file << utime << ':';
file->width(p);
}
- *file << prefixes.top() << ':';
+ *file << prefixes.top() << ':';
}
}
// elements, we have to copy the
// stack since we can't access
// elements from further below
- stack<string> tmp;
+ std::stack<std::string> tmp;
while (tmp.size() > 0)
{
mem += MemoryConsumption::memory_consumption (tmp.top());
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
namespace MemoryConsumption
{
- unsigned int memory_consumption (const string &s)
+ unsigned int memory_consumption (const std::string &s)
{
return sizeof(s) + s.length();
};
- unsigned int memory_consumption (const vector<string> &v)
- {
- unsigned int mem = sizeof(v);
- for (unsigned int i=0; i<v.size(); ++i)
- mem += memory_consumption(v[i]);
- return mem;
- };
+ unsigned int memory_consumption (const std::vector<std::string> &v)
+ {
+ unsigned int mem = sizeof(v);
+ for (unsigned int i=0; i<v.size(); ++i)
+ mem += memory_consumption(v[i]);
+ return mem;
+ };
};
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
unsigned int MultithreadInfo::get_n_cpus()
{
- ifstream cpuinfo;
- string search;
+ std::ifstream cpuinfo;
+ std::string search;
unsigned int nCPU = 0;
cpuinfo.open("/proc/cpuinfo");
while(cpuinfo)
{
cpuinfo >> search;
- if (search.find("processor")!=string::npos)
+ if (search.find("processor")!=std::string::npos)
nCPU++;
}
cpuinfo.close();
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
unsigned int
- PatternBase::memory_consumption () const
- {
- if (dynamic_cast<const Integer*>(this) != 0)
- return sizeof(Integer);
- else if (dynamic_cast<const Double*>(this) != 0)
- return sizeof(Double);
- else if (dynamic_cast<const Bool*>(this) != 0)
- return sizeof(Bool);
- else if (dynamic_cast<const Anything*>(this) != 0)
- return sizeof(Anything);
- else
- return sizeof(*this) + 32;
- };
+ PatternBase::memory_consumption () const
+ {
+ if (dynamic_cast<const Integer*>(this) != 0)
+ return sizeof(Integer);
+ else if (dynamic_cast<const Double*>(this) != 0)
+ return sizeof(Double);
+ else if (dynamic_cast<const Bool*>(this) != 0)
+ return sizeof(Bool);
+ else if (dynamic_cast<const Anything*>(this) != 0)
+ return sizeof(Anything);
+ else
+ return sizeof(*this) + 32;
+ };
- bool Integer::match (const string &test_string) const
+ bool Integer::match (const std::string &test_string) const
{
- istrstream str(test_string.c_str());
+ std::istrstream str(test_string.c_str());
int i;
if (str >> i)
{
- string Integer::description () const
+ std::string Integer::description () const
{
// check whether valid bounds
// were specified, and if so
// output their values
if (lower_bound <= upper_bound)
{
- ostrstream description;
+ std::ostrstream description;
description << "[Integer range "
<< lower_bound << "..." << upper_bound
<< " (inclusive)]"
- << ends;
+ << std::ends;
return description.str();
}
else
- bool Double::match (const string &test_string) const
+ bool Double::match (const std::string &test_string) const
{
- istrstream str(test_string.c_str());
+ std::istrstream str(test_string.c_str());
double d;
if (str >> d)
{
- string Double::description () const
+ std::string Double::description () const
{
// check whether valid bounds
// were specified, and if so
// output their values
if (lower_bound <= upper_bound)
{
- ostrstream description;
+ std::ostrstream description;
description << "[Floating point range "
<< lower_bound << "..." << upper_bound
<< " (inclusive)]"
- << ends;
+ << std::ends;
return description.str();
}
else
- Selection::Selection (const string &seq)
+ Selection::Selection (const std::string &seq)
{
sequence = seq;
- while (sequence.find(" |") != string::npos)
+ while (sequence.find(" |") != std::string::npos)
sequence.replace (sequence.find(" |"), 2, "|");
- while (sequence.find("| ") != string::npos)
+ while (sequence.find("| ") != std::string::npos)
sequence.replace (sequence.find("| "), 2, "|");
};
- bool Selection::match (const string &test_string) const
+ bool Selection::match (const std::string &test_string) const
{
- vector<string> choices;
- string tmp(sequence);
+ std::vector<std::string> choices;
+ std::string tmp(sequence);
// check the different possibilities
- while (tmp.find('|') != string::npos)
+ while (tmp.find('|') != std::string::npos)
{
- if (test_string == string(tmp, 0, tmp.find('|')))
+ if (test_string == std::string(tmp, 0, tmp.find('|')))
return true;
tmp.erase (0, tmp.find('|')+1);
- string Selection::description () const
+ std::string Selection::description () const
{
return sequence;
};
unsigned int
- Selection::memory_consumption () const
- {
- return (sizeof(PatternBase) +
- MemoryConsumption::memory_consumption(sequence));
- };
+ Selection::memory_consumption () const
+ {
+ return (sizeof(PatternBase) +
+ MemoryConsumption::memory_consumption(sequence));
+ };
- MultipleSelection::MultipleSelection (const string &seq)
+ MultipleSelection::MultipleSelection (const std::string &seq)
{
- Assert (seq.find (",") == string::npos, ExcCommasNotAllowed(seq.find(",")));
+ Assert (seq.find (",") == std::string::npos, ExcCommasNotAllowed(seq.find(",")));
sequence = seq;
- while (sequence.find(" |") != string::npos)
+ while (sequence.find(" |") != std::string::npos)
sequence.replace (sequence.find(" |"), 2, "|");
- while (sequence.find("| ") != string::npos)
+ while (sequence.find("| ") != std::string::npos)
sequence.replace (sequence.find("| "), 2, "|");
};
- bool MultipleSelection::match (const string &test_string_list) const
+ bool MultipleSelection::match (const std::string &test_string_list) const
{
- string tmp = test_string_list;
- list<string> split_list;
+ std::string tmp = test_string_list;
+ std::list<std::string> split_list;
// first split the input list
while (tmp.length() != 0)
{
- string name;
+ std::string name;
name = tmp;
- if (name.find(",") != string::npos)
+ if (name.find(",") != std::string::npos)
{
- name.erase (name.find(","), string::npos);
+ name.erase (name.find(","), std::string::npos);
tmp.erase (0, test_string_list.find(",")+1);
}
else
// check the different possibilities
- for (list<string>::const_iterator test_string = split_list.begin();
+ for (std::list<std::string>::const_iterator test_string = split_list.begin();
test_string != split_list.end(); ++test_string)
{
bool string_found = false;
tmp = sequence;
- while (tmp.find('|') != string::npos)
+ while (tmp.find('|') != std::string::npos)
{
- if (*test_string == string(tmp, 0, tmp.find('|')))
+ if (*test_string == std::string(tmp, 0, tmp.find('|')))
{
// string found, quit
// loop. don't change
- string MultipleSelection::description () const
+ std::string MultipleSelection::description () const
{
return sequence;
};
unsigned int
- MultipleSelection::memory_consumption () const
- {
- return (sizeof(PatternBase) +
- MemoryConsumption::memory_consumption(sequence));
- };
+ MultipleSelection::memory_consumption () const
+ {
+ return (sizeof(PatternBase) +
+ MemoryConsumption::memory_consumption(sequence));
+ };
- bool Anything::match (const string &) const
+ bool Anything::match (const std::string &) const
{
return true;
};
- string Anything::description () const
+ std::string Anything::description () const
{
return "[Anything]";
};
-bool ParameterHandler::read_input (istream &input)
+bool ParameterHandler::read_input (std::istream &input)
{
AssertThrow (input, ExcIO());
- string line;
+ std::string line;
int lineno=0;
while (input)
{
-bool ParameterHandler::read_input (const string &filename)
+bool ParameterHandler::read_input (const std::string &filename)
{
- ifstream input (filename.c_str());
+ std::ifstream input (filename.c_str());
if (!input)
{
- cerr << "ParameterHandler::read_input: could not open file <"
- << filename << "> for reading." << endl
- << "Trying to make file <"
- << filename << "> with default values for you." << endl;
+ std::cerr << "ParameterHandler::read_input: could not open file <"
+ << filename << "> for reading." << std::endl
+ << "Trying to make file <"
+ << filename << "> with default values for you." << std::endl;
- ofstream output (filename.c_str());
+ std::ofstream output (filename.c_str());
if (output)
{
print_parameters (output, Text);
bool ParameterHandler::read_input_from_string (const char *s)
{
- // if empty string then exit
+ // if empty std::string then exit
// with success
if ((s == 0) || ((*s) == 0)) return true;
- string line;
- string input (s);
+ std::string line;
+ std::string input (s);
int lineno=0;
// if necessary append a newline char
defaults.entries.clear ();
changed_entries.entries.clear ();
- map<string, Section*>::iterator p;
+ std::map<std::string, Section*>::iterator p;
for (p=defaults.subsections.begin(); p!=defaults.subsections.end(); ++p)
delete p->second;
-bool ParameterHandler::declare_entry (const string &entry,
- const string &default_value,
+bool ParameterHandler::declare_entry (const std::string &entry,
+ const std::string &default_value,
const Patterns::PatternBase &pattern)
{
Section* p = get_present_defaults_subsection ();
-void ParameterHandler::enter_subsection (const string &subsection)
+void ParameterHandler::enter_subsection (const std::string &subsection)
{
Section* pd = get_present_defaults_subsection ();
// does subsection already exist?
if (pd->subsections.find (subsection) == pd->subsections.end())
{
- // subsection does not yet exist:
- // create entry in Defaults and
- // changed_entries trees
+ // subsection does not yet exist:
+ // create entry in Defaults and
+ // changed_entries trees
pd->subsections[subsection] = new Section();
Section* pc = get_present_changed_subsection ();
-const string & ParameterHandler::get (const string &entry_string) const
+const std::string & ParameterHandler::get (const std::string &entry_string) const
{
const Section* pd = get_present_defaults_subsection ();
const Section* pc = get_present_changed_subsection ();
if (pd->entries.find (entry_string) == pd->entries.end())
{
- static const string empty_string;
+ static const std::string empty_string;
return empty_string;
};
-long int ParameterHandler::get_integer (const string &entry_string) const
+long int ParameterHandler::get_integer (const std::string &entry_string) const
{
- string s = get (entry_string);
+ std::string s = get (entry_string);
char *endptr;
long int i = strtol (s.c_str(), &endptr, 10);
// assert there was no error
-double ParameterHandler::get_double (const string &entry_string) const
+double ParameterHandler::get_double (const std::string &entry_string) const
{
- string s = get (entry_string);
+ std::string s = get (entry_string);
char *endptr;
double d = strtod (s.c_str(), &endptr);
// assert there was no error
-bool ParameterHandler::get_bool (const string &entry_string) const
+bool ParameterHandler::get_bool (const std::string &entry_string) const
{
- string s = get(entry_string);
+ std::string s = get(entry_string);
AssertThrow ((s=="true") || (s=="false"), ExcConversionError(s));
if (s=="true")
-ostream & ParameterHandler::print_parameters (ostream &out, OutputStyle style)
+std::ostream & ParameterHandler::print_parameters (std::ostream &out, OutputStyle style)
{
// assert that only known formats are
// given as "style"
switch (style)
{
case Text:
- out << "#Listing of Parameters" << endl
- << "#---------------------" << endl;
+ out << "#Listing of Parameters" << std::endl
+ << "#---------------------" << std::endl;
break;
case LaTeX:
out << "\\subsubsection*{Listing of parameters}";
- out << endl << endl;
+ out << std::endl << std::endl;
out << "\\begin{itemize}"
- << endl;
+ << std::endl;
break;
default:
Assert (false, ExcNotImplemented());
case Text:
break;
case LaTeX:
- out << "\\end{itemize}" << endl;
+ out << "\\end{itemize}" << std::endl;
break;
default:
Assert (false, ExcNotImplemented());
-void ParameterHandler::print_parameters_section (ostream &out,
+void ParameterHandler::print_parameters_section (std::ostream &out,
const OutputStyle style,
const unsigned int indent_level)
{
switch (style)
{
case Text:
- out << setw(indent_level*2) << ""
+ out << std::setw(indent_level*2) << ""
<< "set "
<< ptr->first
- << setw(longest_entry-ptr->first.length()+3) << " = "
+ << std::setw(longest_entry-ptr->first.length()+3) << " = "
<< pc->entries[ptr->first].first
<< " #"
<< pd->entries[ptr->first].first
- << endl;
+ << std::endl;
break;
case LaTeX:
out << "\\item {\\bf " << ptr->first << ":} "
<< " ({\\it default:} "
<< pd->entries[ptr->first].first
<< ")"
- << endl;
+ << std::endl;
break;
default:
Assert (false, ExcNotImplemented());
switch (style)
{
case Text:
- out << setw(indent_level*2) << ""
+ out << std::setw(indent_level*2) << ""
<< "set "
<< ptr->first
- << setw(longest_entry-ptr->first.length()+3) << "= "
- << ptr->second.first << endl;
+ << std::setw(longest_entry-ptr->first.length()+3) << "= "
+ << ptr->second.first << std::endl;
break;
case LaTeX:
out << "\\item {\\bf " << ptr->first << ":} "
<< ptr->second.first
- << endl;
+ << std::endl;
break;
default:
Assert (false, ExcNotImplemented());
// now transverse subsections tree
- map<string, Section*>::const_iterator ptrss;
+ std::map<std::string, Section*>::const_iterator ptrss;
for (ptrss = pd->subsections.begin(); ptrss != pd->subsections.end(); ++ptrss)
{
switch (style)
{
case Text:
- out << setw(indent_level*2) << ""
- << "subsection " << ptrss->first << endl;
+ out << std::setw(indent_level*2) << ""
+ << "subsection " << ptrss->first << std::endl;
break;
case LaTeX:
- out << endl
+ out << std::endl
<< "\\item {\\bf "
<< "Subsection " << ptrss->first
- << "}" << endl
+ << "}" << std::endl
<< "\\begin{itemize}"
- << endl;
+ << std::endl;
break;
default:
Assert (false, ExcNotImplemented());
case Text:
// write end of subsection. one
// blank line after each subsection
- out << setw(indent_level*2) << ""
- << "end" << endl
- << endl;
+ out << std::setw(indent_level*2) << ""
+ << "end" << std::endl
+ << std::endl;
// if this is a toplevel
// subsection, then have two
// newlines
if (indent_level == 0)
- out << endl;
+ out << std::endl;
break;
case LaTeX:
out << "\\end{itemize}"
- << endl;
+ << std::endl;
break;
default:
Assert (false, ExcNotImplemented());
{
if ((pc->entries.find(ptr->first) != pc->entries.end()) &&
(pc->entries[ptr->first].first != pd->entries[ptr->first].first))
- // check whether this entry is listed
- // in the Changed tree and actually
- // differs from the default value
- out << ptr->first << ": "
- << pc->entries[ptr->first].first << endl;
+ // check whether this entry is listed
+ // in the Changed tree and actually
+ // differs from the default value
+ out << ptr->first << ": "
+ << pc->entries[ptr->first].first << endl;
else
- out << ptr->first << ": "
- << ptr->second.first << endl;
+ out << ptr->first << ": "
+ << ptr->second.first << endl;
};
// now transverse subsections tree
- map<string, Section*>::const_iterator ptrss;
+ std::map<std::string, Section*>::const_iterator ptrss;
for (ptrss = pd->subsections.begin(); ptrss != pd->subsections.end(); ++ptrss)
{
out.push(ptrss->first);
-bool ParameterHandler::scan_line (string line,
+bool ParameterHandler::scan_line (std::string line,
const unsigned int lineno)
{
// if there is a comment, delete it
- if (line.find('#') != string::npos)
- line.erase (line.find("#"), string::npos);
+ if (line.find('#') != std::string::npos)
+ line.erase (line.find("#"), std::string::npos);
// replace every whitespace sequence
// by " "
- while (line.find('\t') != string::npos)
+ while (line.find('\t') != std::string::npos)
line.replace (line.find('\t'), 1, " ");
- while (line.find(" ") != string::npos)
+ while (line.find(" ") != std::string::npos)
line.erase (line.find(" "), 1);
// now every existing whitespace
// should be exactly one ' ';
(line.find ("subsection ") == 0))
{
// delete this prefix
- line.erase (0, string("subsection").length()+1);
+ line.erase (0, std::string("subsection").length()+1);
- string SecName = line;
+ std::string SecName = line;
Section* pc = get_present_changed_subsection ();
// check whether subsection exists
if (pc->subsections.find(SecName) == pc->subsections.end())
{
- cerr << "Line " << lineno << ": There is no such subsection to be entered:" << endl;
+ std::cerr << "Line " << lineno << ": There is no such subsection to be entered:" << std::endl;
for (unsigned int i=0; i<subsection_path.size(); ++i)
- cerr << setw(i*2+4) << " "
- << "subsection " << subsection_path[i] << endl;
- cerr << setw(subsection_path.size()*2+4) << " "
- << "subsection " << SecName << endl;
+ std::cerr << std::setw(i*2+4) << " "
+ << "subsection " << subsection_path[i] << std::endl;
+ std::cerr << std::setw(subsection_path.size()*2+4) << " "
+ << "subsection " << SecName << std::endl;
return false;
};
(line.find ("end") == 0))
if (subsection_path.size() == 0)
{
- cerr << "Line " << lineno
- << ": There is no subsection to leave here!" << endl;
+ std::cerr << "Line " << lineno
+ << ": There is no subsection to leave here!" << std::endl;
return false;
}
else
// erase "set" statement and eliminate
// spaces around the '='
line.erase (0, 4);
- if (line.find(" =") != string::npos)
+ if (line.find(" =") != std::string::npos)
line.replace (line.find(" ="), 2, "=");
- if (line.find("= ") != string::npos)
+ if (line.find("= ") != std::string::npos)
line.replace (line.find("= "), 2, "=");
// extract entry name and value
- string entry_name (line, 0, line.find('='));
- string entry_value (line, line.find('=')+1, string::npos);
+ std::string entry_name (line, 0, line.find('='));
+ std::string entry_value (line, line.find('=')+1, std::string::npos);
Section* pd = get_present_defaults_subsection ();
// check whether entry was declared
if (pd->entries.find(entry_name) == pd->entries.end())
{
- cerr << "Line " << lineno
- << ": No such entry was declared:" << endl
- << " " << entry_name << endl
- << " <Present subsection:" << endl;
+ std::cerr << "Line " << lineno
+ << ": No such entry was declared:" << std::endl
+ << " " << entry_name << std::endl
+ << " <Present subsection:" << std::endl;
for (unsigned int i=0; i<subsection_path.size(); ++i)
- cerr << setw(i*2+8) << " "
- << "subsection " << subsection_path[i] << endl;
- cerr << " >" << endl;
+ std::cerr << std::setw(i*2+8) << " "
+ << "subsection " << subsection_path[i] << std::endl;
+ std::cerr << " >" << std::endl;
return false;
};
// exception: if it contains characters
// which specify it as a multiple loop
// entry, then ignore content
- if (entry_value.find ('{') == string::npos)
+ if (entry_value.find ('{') == std::string::npos)
if (!pd->entries[entry_name].second->match(entry_value))
{
- cerr << "Line " << lineno << ":" << endl
- << " The entry value" << endl
- << " " << entry_value << endl
- << " for the entry named" << endl
- << " " << entry_name << endl
- << " does not match the given pattern" << endl
- << " " << pd->entries[entry_name].second->description() << endl;
+ std::cerr << "Line " << lineno << ":" << std::endl
+ << " The entry value" << std::endl
+ << " " << entry_value << std::endl
+ << " for the entry named" << std::endl
+ << " " << entry_name << std::endl
+ << " does not match the given pattern" << std::endl
+ << " " << pd->entries[entry_name].second->description() << std::endl;
return false;
};
};
// this line matched nothing known
- cerr << "Line " << lineno << ": This line matched nothing known:" << endl
- << " " << line << endl;
+ std::cerr << "Line " << lineno << ": This line matched nothing known:" << std::endl
+ << " " << line << std::endl;
return false;
};
ParameterHandler::Section* ParameterHandler::get_present_defaults_subsection ()
{
Section* sec = &defaults;
- vector<string>::const_iterator SecName = subsection_path.begin();
+ std::vector<std::string>::const_iterator SecName = subsection_path.begin();
while (SecName != subsection_path.end())
{
{
Section* sec = const_cast<Section*>(&defaults); // not nice, but needs to be and
// after all: we do not change @p{sec}
- vector<string>::const_iterator SecName = subsection_path.begin();
+ std::vector<std::string>::const_iterator SecName = subsection_path.begin();
while (SecName != subsection_path.end())
{
ParameterHandler::Section* ParameterHandler::get_present_changed_subsection ()
{
Section* sec = &changed_entries;
- vector<string>::iterator SecName = subsection_path.begin();
+ std::vector<std::string>::iterator SecName = subsection_path.begin();
while (SecName != subsection_path.end())
{
const ParameterHandler::Section* ParameterHandler::get_present_changed_subsection () const
{
Section* sec = const_cast<Section*>(&changed_entries); // same as in get_present_default_s...
- vector<string>::const_iterator SecName = subsection_path.begin();
+ std::vector<std::string>::const_iterator SecName = subsection_path.begin();
while (SecName != subsection_path.end())
{
{
entries.clear ();
- map<string, Section*>::iterator p;
+ std::map<std::string, Section*>::iterator p;
for (p=subsections.begin(); p!=subsections.end(); ++p)
delete p->second;
mem += (MemoryConsumption::memory_consumption (i->first) +
MemoryConsumption::memory_consumption (i->second.first) +
MemoryConsumption::memory_consumption (*i->second.second));
- for (map<string, Section*>::const_iterator i=subsections.begin(); i!=subsections.end(); ++i)
+ for (std::map<std::string, Section*>::const_iterator i=subsections.begin(); i!=subsections.end(); ++i)
mem += (MemoryConsumption::memory_consumption (i->first) +
MemoryConsumption::memory_consumption (*(i->second)));
return mem;
-bool MultipleParameterLoop::read_input (istream &input)
+bool MultipleParameterLoop::read_input (std::istream &input)
{
AssertThrow (input, ExcIO());
-bool MultipleParameterLoop::read_input (const string &filename)
+bool MultipleParameterLoop::read_input (const std::string &filename)
{
return ParameterHandler::read_input (filename);
// don't call init_branches, since this read_input
// function calls
- // MultipleParameterLoop::Readinput(istream &, ostream &)
+ // MultipleParameterLoop::Readinput(std::istream &, std::ostream &)
// which itself calls init_branches.
};
void MultipleParameterLoop::loop (MultipleParameterLoop::UserClass &uc)
{
- for (int run_no=0; run_no<n_branches; ++run_no)
+ for (unsigned int run_no=0; run_no<n_branches; ++run_no)
{
// give create_new one-based numbers
uc.create_new (run_no+1);
// has only one single value after reading the
// input
if (multiple_choices.size() > 0)
- for (vector<Entry>::iterator i=multiple_choices.end()-1;
+ for (std::vector<Entry>::iterator i=multiple_choices.end()-1;
i >= multiple_choices.begin(); --i)
if (i->different_values.size() == 1)
multiple_choices.erase (i);
// number of entries
for (unsigned int i=0; i<multiple_choices.size(); ++i)
if (multiple_choices[i].type == array)
- if (multiple_choices[i].different_values.size() != (unsigned int)n_branches)
- cerr << " The entry value" << endl
- << " " << multiple_choices[i].entry_value << endl
- << " for the entry named" << endl
- << " " << multiple_choices[i].entry_name << endl
- << " does not have the right number of entries for the " << endl
- << " " << n_branches << " variant runs that will be performed." << endl;
+ if (multiple_choices[i].different_values.size() != n_branches)
+ std::cerr << " The entry value" << std::endl
+ << " " << multiple_choices[i].entry_value << std::endl
+ << " for the entry named" << std::endl
+ << " " << multiple_choices[i].entry_name << std::endl
+ << " does not have the right number of entries for the " << std::endl
+ << " " << n_branches << " variant runs that will be performed." << std::endl;
// do a first run on filling the values to
// check for the conformance with the regexp
// (afterwards, this will be lost in the whole
// other output)
- for (int i=0; i<n_branches; ++i)
+ for (unsigned int i=0; i<n_branches; ++i)
fill_entry_values (i);
};
// whether it is a multiple entry
Section::EntryType::const_iterator e;
for (e = sec.entries.begin(); e != sec.entries.end(); ++e)
- if (e->second.first.find('{') != string::npos)
+ if (e->second.first.find('{') != std::string::npos)
multiple_choices.push_back (Entry(subsection_path,
e->first,
e->second.first));
// transverse subsections
- map<string, Section*>::const_iterator s;
+ std::map<std::string, Section*>::const_iterator s;
for (s = sec.subsections.begin(); s != sec.subsections.end(); ++s)
{
enter_subsection (s->first);
{
int possibilities = 1;
- vector<Entry>::iterator choice;
+ std::vector<Entry>::iterator choice;
for (choice = multiple_choices.begin();
choice != multiple_choices.end();
++choice)
// set entry
Section* pd = get_present_defaults_subsection ();
int selection = (run_no/possibilities) % choice->different_values.size();
- string entry_value;
+ std::string entry_value;
if (choice->type == variant)
entry_value = choice->different_values[selection];
else
{
if (run_no>=choice->different_values.size())
{
- cerr << "The given array for entry "
- << pd->entries[choice->entry_name].first
- << " does not conatin enough elements! Taking empty string instead." << endl;
+ std::cerr << "The given array for entry "
+ << pd->entries[choice->entry_name].first
+ << " does not conatin enough elements! Taking empty string instead." << std::endl;
entry_value = "";
}
else
// check conformance with regex
if (!pd->entries[choice->entry_name].second->match(entry_value))
{
- cerr << "In run no. " << run_no+1 << ":" << endl
- << " The entry value" << endl
- << " " << entry_value << endl
- << " for the entry named" << endl
- << " " << choice->entry_name << endl
- << " does not match the given pattern" << endl
- << " " << pd->entries[choice->entry_name].second->description() << endl
- << " Taking default value" << endl
- << " " << pd->entries[choice->entry_name].first << endl;
+ std::cerr << "In run no. " << run_no+1 << ":" << std::endl
+ << " The entry value" << std::endl
+ << " " << entry_value << std::endl
+ << " for the entry named" << std::endl
+ << " " << choice->entry_name << std::endl
+ << " does not match the given pattern" << std::endl
+ << " " << pd->entries[choice->entry_name].second->description() << std::endl
+ << " Taking default value" << std::endl
+ << " " << pd->entries[choice->entry_name].first << std::endl;
// select default instead
entry_value = pd->entries[choice->entry_name].first;
-MultipleParameterLoop::Entry::Entry (const vector<string> &ssp,
- const string& Name,
- const string& Value) :
- subsection_path (ssp), entry_name(Name), entry_value(Value)
+MultipleParameterLoop::Entry::Entry (const std::vector<std::string> &ssp,
+ const std::string &Name,
+ const std::string &Value) :
+ subsection_path (ssp), entry_name(Name), entry_value(Value)
{};
// part before the opening "{",
// the selection itself, final
// part after "}"
- string prefix (entry_value, 0, entry_value.find('{'));
- string multiple(entry_value, entry_value.find('{')+1,
- entry_value.rfind('}')-entry_value.find('{')-1);
- string postfix (entry_value, entry_value.rfind('}')+1, string::npos);
+ std::string prefix (entry_value, 0, entry_value.find('{'));
+ std::string multiple(entry_value, entry_value.find('{')+1,
+ entry_value.rfind('}')-entry_value.find('{')-1);
+ std::string postfix (entry_value, entry_value.rfind('}')+1, std::string::npos);
// if array entry {{..}}: delete inner
// pair of braces
if (multiple[0]=='{')
while (multiple[multiple.size()-1] == ' ') multiple.erase (multiple.size()-1,1);
// delete spaces around '|'
- while (multiple.find(" |") != string::npos)
+ while (multiple.find(" |") != std::string::npos)
multiple.replace (multiple.find(" |"), 2, "|");
- while (multiple.find("| ") != string::npos)
+ while (multiple.find("| ") != std::string::npos)
multiple.replace (multiple.find("| "), 2, "|");
- while (multiple.find('|') != string::npos)
+ while (multiple.find('|') != std::string::npos)
{
different_values.push_back (prefix +
- string(multiple, 0, multiple.find('|'))+
+ std::string(multiple, 0, multiple.find('|'))+
postfix);
multiple.erase (0, multiple.find('|')+1);
};
// make up the last selection ("while" broke
// because there was no '|' any more
different_values.push_back (prefix+multiple+postfix);
- // finally check whether this was a variant
- // entry ({...}) or an array ({{...}})
- if ((entry_value.find("{{") != string::npos) &&
- (entry_value.find("}}") != string::npos))
+ // finally check whether this was a variant
+ // entry ({...}) or an array ({{...}})
+ if ((entry_value.find("{{") != std::string::npos) &&
+ (entry_value.find("}}") != std::string::npos))
type = array;
else
type = variant;
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
template <int dim>
-Quadrature<dim>::Quadrature (const vector<Point<dim> > & points,
- const vector<double> & weights)
+Quadrature<dim>::Quadrature (const std::vector<Point<dim> > &points,
+ const std::vector<double> &weights)
: n_quadrature_points(points.size()),
quadrature_points(points),
weights(weights)
template <>
-const vector<Point<0> > & Quadrature<0>::get_points () const
+const
std::vector<Point<0> > & Quadrature<0>::get_points () const
{
Assert (false, ExcInternalError());
return quadrature_points;
template <int dim>
-const vector<Point<dim> > & Quadrature<dim>::get_points () const
+const
std::vector<Point<dim> > & Quadrature<dim>::get_points () const
{
return quadrature_points;
};
template <int dim>
-const vector<double> & Quadrature<dim>::get_weights () const
+const std::vector<double> & Quadrature<dim>::get_weights () const
{
return weights;
};
template <>
-const vector<double> & Quadrature<0>::get_weights () const
+const std::vector<double> & Quadrature<0>::get_weights () const
{
Assert (false, ExcInternalError());
return weights;
template <>
-void QProjector<2>::project_to_face (const Quadrature<1> &quadrature,
- const unsigned int face_no,
- vector<Point<2> > &q_points)
+void QProjector<2>::project_to_face (const Quadrature<1> &quadrature,
+ const unsigned int face_no,
+ std::vector<Point<2> > &q_points)
{
const unsigned int dim=2;
Assert (face_no<2*dim, ExcIndexRange (face_no, 0, 2*dim));
template <>
-void QProjector<3>::project_to_face (const Quadrature<2> &quadrature,
- const unsigned int face_no,
- vector<Point<3> > &q_points)
+void QProjector<3>::project_to_face (const Quadrature<2> &quadrature,
+ const unsigned int face_no,
+ std::vector<Point<3> > &q_points)
{
const unsigned int dim=3;
Assert (face_no<2*dim, ExcIndexRange (face_no, 0, 2*dim));
template <>
-void QProjector<2>::project_to_subface (const Quadrature<1> &quadrature,
- const unsigned int face_no,
- const unsigned int subface_no,
- vector<Point<2> > &q_points)
+void QProjector<2>::project_to_subface (const Quadrature<1> &quadrature,
+ const unsigned int face_no,
+ const unsigned int subface_no,
+ std::vector<Point<2> > &q_points)
{
const unsigned int dim=2;
Assert (face_no<2*dim, ExcIndexRange (face_no, 0, 2*dim));
template <>
-void QProjector<3>::project_to_subface (const Quadrature<2> &quadrature,
- const unsigned int face_no,
- const unsigned int subface_no,
- vector<Point<3> > &q_points)
+void QProjector<3>::project_to_subface (const Quadrature<2> &quadrature,
+ const unsigned int face_no,
+ const unsigned int subface_no,
+ std::vector<Point<3> > &q_points)
{
const unsigned int dim=3;
Assert (face_no<2*dim, ExcIndexRange (face_no, 0, 2*dim));
template <int dim>
void
-QProjector<dim>::project_to_faces (const Quadrature<dim-1> &quadrature,
- vector<Point<dim> > &q_points)
+QProjector<dim>::project_to_faces (const Quadrature<dim-1> &quadrature,
+ std::vector<Point<dim> > &q_points)
{
unsigned int npt = quadrature.n_quadrature_points;
unsigned int nf = GeometryInfo<dim>::faces_per_cell;
q_points.resize (npt*nf);
- vector <Point<dim> > help(npt);
+
std::vector <Point<dim> > help(npt);
unsigned k=0;
for (unsigned int i=0;i<nf;++i)
template <int dim>
void
-QProjector<dim>::project_to_subfaces (const Quadrature<dim-1> &quadrature,
- vector<Point<dim> > &q_points)
+QProjector<dim>::project_to_subfaces (const Quadrature<dim-1> &quadrature,
+ std::vector<Point<dim> > &q_points)
{
unsigned int npt = quadrature.n_quadrature_points;
unsigned int nf = GeometryInfo<dim>::faces_per_cell;
unsigned int nc = GeometryInfo<dim>::subfaces_per_face;
q_points.resize (npt*nf*nc);
- vector <Point<dim> > help(npt);
+
std::vector <Point<dim> > help(npt);
unsigned k=0;
for (unsigned int i=0;i<nf;++i)
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
template <typename number>
-void TableEntry<number>::write_tex (ostream &out) const
+void TableEntry<number>::write_tex (std::ostream &out) const
{
out << val;
}
template <typename number>
-void TableEntry<number>::write_text (ostream &out) const
+void TableEntry<number>::write_text (std::ostream &out) const
{
out << val;
}
/*---------------------------------------------------------------------*/
-TableHandler::Column::Column(const string &tex_caption):
+TableHandler::Column::Column(const std::string &tex_caption):
tex_caption(tex_caption),
tex_format("c"),
precision(4),
template <typename number>
-void TableHandler::add_value (const string &key,
+void TableHandler::add_value (const std::string &key,
const number value)
{
if (!columns.count(key))
{
- pair<string, Column> new_column(key, Column(key));
+ std::pair<std::string, Column> new_column(key, Column(key));
columns.insert(new_column);
column_order.push_back(key);
}
TableEntry<number> *entry_ptr=new TableEntry<number>(value);
- const map<string, Column>::iterator col_iter=columns.find(key);
+ const std::map<std::string, Column>::iterator col_iter=columns.find(key);
Assert(col_iter!=columns.end(), ExcInternalError());
col_iter->second.entries.push_back(entry_ptr);
}
-void TableHandler::add_column_to_supercolumn (const string &key,
- const string &superkey)
+void TableHandler::add_column_to_supercolumn (const std::string &key,
+ const std::string &superkey)
{
Assert(columns.count(key), ExcColumnNotExistent(key));
if (!supercolumns.count(superkey))
{
- pair<string, vector<string> > new_column(superkey, vector<string>());
+ std::pair<std::string, std::vector<std::string> > new_column(superkey,
+ std::vector<std::string>());
supercolumns.insert(new_column);
// replace key in column_order
// by superkey
{
// remove key from column_order
// for erase we need an iterator
- for (vector<string>::iterator order_iter=column_order.begin();
+ for (std::vector<std::string>::iterator order_iter=column_order.begin();
order_iter!=column_order.end(); ++order_iter)
if (*order_iter==key)
{
supercolumns[superkey].push_back(key);
// By default set the
// tex_supercaption to superkey
- pair<string, string> new_tex_supercaption(superkey, superkey);
+ std::pair<std::string, std::string> new_tex_supercaption(superkey, superkey);
tex_supercaptions.insert(new_tex_supercaption);
}
else
}
-void TableHandler::set_column_order (const vector<string> &new_order)
+void TableHandler::set_column_order (const std::vector<std::string> &new_order)
{
for (unsigned int j=0; j<new_order.size(); ++j)
Assert(supercolumns.count(new_order[j]) || columns.count(new_order[j]),
}
-void TableHandler::set_tex_caption (const string &key,
- const string &tex_caption)
+void TableHandler::set_tex_caption (const std::string &key,
+ const std::string &tex_caption)
{
Assert(columns.count(key), ExcColumnNotExistent(key));
columns[key].tex_caption=tex_caption;
}
-void TableHandler::set_tex_supercaption (const string &superkey,
- const string &tex_supercaption)
+void TableHandler::set_tex_supercaption (const std::string &superkey,
+ const std::string &tex_supercaption)
{
Assert(supercolumns.count(superkey), ExcSuperColumnNotExistent(superkey));
Assert(tex_supercaptions.count(superkey), ExcInternalError());
}
-void TableHandler::set_tex_format (const string &key,
- const string &tex_format)
+void TableHandler::set_tex_format (const std::string &key,
+ const std::string &tex_format)
{
Assert(columns.count(key), ExcColumnNotExistent(key));
Assert(tex_format=="l" || tex_format=="c" || tex_format=="r",
}
-void TableHandler::set_precision (const string &key,
+void TableHandler::set_precision (const std::string &key,
unsigned int precision)
{
Assert(columns.count(key), ExcColumnNotExistent(key));
}
-void TableHandler::set_scientific (const string &key,
+void TableHandler::set_scientific (const std::string &key,
bool scientific)
{
Assert(columns.count(key), ExcColumnNotExistent(key));
}
-void TableHandler::write_text(ostream &out) const
+void TableHandler::write_text(std::ostream &out) const
{
- vector<string> sel_columns;
+ std::vector<std::string> sel_columns;
get_selected_columns(sel_columns);
// write the caption line
for (unsigned int j=0; j<column_order.size(); ++j)
{
- string key=column_order[j];
+ std::string key=column_order[j];
unsigned int column_string_size=0;
- const map<string, vector<string> >::const_iterator
+ const std::map<std::string, std::vector<std::string> >::const_iterator
super_iter=supercolumns.find(key);
if (super_iter!=supercolumns.end()) // if supercolumn
{
- vector<string>::const_iterator col_key=super_iter->second.begin();
+ std::vector<std::string>::const_iterator col_key=super_iter->second.begin();
for (;col_key!=super_iter->second.end(); ++col_key)
{
- const map<string, Column>::const_iterator
+ const std::map<std::string, Column>::const_iterator
col_iter=columns.find(*col_key);
if (col_iter->second.scientific &&
col_iter->second.precision>1)
}
else
{
- const map<string, Column>::const_iterator
+ const std::map<std::string, Column>::const_iterator
col_iter=columns.find(key);
if (col_iter->second.scientific &&
col_iter->second.precision>1)
if (key.size()>column_string_size)
key.erase(column_string_size);
- out.setf(ios::left);
- out << setw(column_string_size)
+ out.setf(std::ios::left);
+ out << std::setw(column_string_size)
// << setfill('*')
<< key.c_str() << "\t";
}
- out << endl;
+ out << std::endl;
const unsigned int nrows=n_rows();
for (unsigned int i=0; i<nrows; ++i)
for (unsigned int j=0; j<n_cols; ++j)
{
- string key=sel_columns[j];
+ std::string key=sel_columns[j];
// avoid `column[key]'
- const map<string, Column>::const_iterator
+ const std::map<std::string, Column>::const_iterator
col_iter=columns.find(key);
Assert(col_iter!=columns.end(), ExcInternalError());
const Column &column=col_iter->second;
- out << setprecision(column.precision);
+ out << std::setprecision(column.precision);
if (col_iter->second.scientific)
- out.setf(ios::scientific, ios::floatfield);
+ out.setf(std::ios::scientific, std::ios::floatfield);
else
- out.setf(ios::fixed, ios::floatfield);
+ out.setf(std::ios::fixed, std::ios::floatfield);
column.entries[i]->write_tex(out);
if (j<n_cols-1)
out << "\t";
}
- out << endl;
+ out << std::endl;
}
}
-void TableHandler::write_tex(ofstream &out) const
+void TableHandler::write_tex(std::ofstream &out) const
{
- out << "\\documentclass[10pt]{report}" << endl
- << "\\usepackage{float}" << endl << endl << endl
- << "\\begin{document}" << endl
- << "\\begin{table}[H]" << endl
- << "\\begin{center}" << endl
+ out << "\\documentclass[10pt]{report}" << std::endl
+ << "\\usepackage{float}" << std::endl << std::endl << std::endl
+ << "\\begin{document}" << std::endl
+ << "\\begin{table}[H]" << std::endl
+ << "\\begin{center}" << std::endl
<< "\\begin{tabular}{|";
- vector<string> sel_columns;
+ std::vector<std::string> sel_columns;
get_selected_columns(sel_columns);
// write the column formats
for (unsigned int j=0; j<column_order.size(); ++j)
{
- string key=column_order[j];
+ std::string key=column_order[j];
// avoid `supercolumns[key]'
- const map<string, vector<string> >::const_iterator
+ const std::map<std::string, std::vector<std::string> >::const_iterator
super_iter=supercolumns.find(key);
if (super_iter!=supercolumns.end())
for (unsigned int k=0; k<n_subcolumns; ++k)
{
// avoid `columns[supercolumns[key]]'
- const map<string, Column>::const_iterator
+ const std::map<std::string, Column>::const_iterator
col_iter=columns.find(super_iter->second[k]);
Assert(col_iter!=columns.end(), ExcInternalError());
else
{
// avoid `columns[key]';
- const map<string, Column>::const_iterator
+ const std::map<std::string, Column>::const_iterator
col_iter=columns.find(key);
Assert(col_iter!=columns.end(), ExcInternalError());
out << col_iter->second.tex_format << "|";
}
}
- out << "} \\hline" << endl;
+ out << "} \\hline" << std::endl;
// write the caption line of the table
for (unsigned int j=0; j<column_order.size(); ++j)
{
- string key=column_order[j];
- const map<string, vector<string> >::const_iterator
+ std::string key=column_order[j];
+ const std::map<std::string, std::vector<std::string> >::const_iterator
super_iter=supercolumns.find(key);
if (super_iter!=supercolumns.end())
{
const unsigned int n_subcolumns=super_iter->second.size();
// avoid use of `tex_supercaptions[key]'
- map<string,string>::const_iterator
+ std::map<std::string,std::string>::const_iterator
tex_super_cap_iter=tex_supercaptions.find(key);
- out << endl << "\\multicolumn{" << n_subcolumns << "}{|c|}{"
+ out << std::endl << "\\multicolumn{" << n_subcolumns << "}{|c|}{"
<< tex_super_cap_iter->second << "}";
}
else
{
// col_iter->second=columns[col];
- const map<string, Column>::const_iterator
+ const std::map<std::string, Column>::const_iterator
col_iter=columns.find(key);
Assert(col_iter!=columns.end(), ExcInternalError());
out << col_iter->second.tex_caption;
if (j<column_order.size()-1)
out << " & ";
}
- out << "\\\\ \\hline" << endl;
+ out << "\\\\ \\hline" << std::endl;
// write the n rows
const unsigned int nrows=n_rows();
for (unsigned int j=0; j<n_cols; ++j)
{
- string key=sel_columns[j];
+ std::string key=sel_columns[j];
// avoid `column[key]'
- const map<string, Column>::const_iterator
+ const std::map<std::string, Column>::const_iterator
col_iter=columns.find(key);
Assert(col_iter!=columns.end(), ExcInternalError());
const Column &column=col_iter->second;
- out << setprecision(column.precision);
+ out << std::setprecision(column.precision);
if (col_iter->second.scientific)
- out.setf(ios::scientific, ios::floatfield);
+ out.setf(std::ios::scientific, std::ios::floatfield);
else
- out.setf(ios::fixed, ios::floatfield);
+ out.setf(std::ios::fixed, std::ios::floatfield);
column.entries[i]->write_tex(out);
if (j<n_cols-1)
out << " & ";
}
- out << "\\\\ \\hline" << endl;
+ out << "\\\\ \\hline" << std::endl;
}
- string caption="table";
+ std::string caption="table";
- out << "\\end{tabular}" << endl
- << "\\end{center}" << endl
-// << "\\caption{" << caption << "}" << endl
- << "\\end{table}" << endl
- << "\\end{document}" << endl;
+ out << "\\end{tabular}" << std::endl
+ << "\\end{center}" << std::endl
+// << "\\caption{" << caption << "}" << std::endl
+ << "\\end{table}" << std::endl
+ << "\\end{document}" << std::endl;
}
unsigned int TableHandler::n_rows() const
{
- map<string, Column>::const_iterator col_iter=columns.begin();
+ std::map<std::string, Column>::const_iterator col_iter=columns.begin();
unsigned int n=col_iter->second.entries.size();
- string first_name=col_iter->first;
+ std::string first_name=col_iter->first;
for (++col_iter; col_iter!=columns.end(); ++col_iter)
Assert(col_iter->second.entries.size()==n,
}
-void TableHandler::get_selected_columns(vector<string> &sel_columns) const
+void TableHandler::get_selected_columns(std::vector<std::string> &sel_columns) const
{
sel_columns.clear();
for (unsigned int j=0; j<column_order.size(); ++j)
{
- string key=column_order[j];
- const map<string, vector<string> >::const_iterator
+ std::string key=column_order[j];
+ const std::map<std::string, std::vector<std::string> >::const_iterator
super_iter=supercolumns.find(key);
if (super_iter!=supercolumns.end())
const unsigned int n_subcolumns=super_iter->second.size();
for (unsigned int j=0; j<n_subcolumns; ++j)
{
- const string subkey=super_iter->second[j];
+ const std::string subkey=super_iter->second[j];
Assert(columns.count(subkey), ExcInternalError());
sel_columns.push_back(subkey);
}
sel_columns.push_back(key);
}
}
- cout << endl;
+ std::cout << std::endl;
}
template class TableEntry<float>;
template class TableEntry<int>;
template class TableEntry<unsigned int>;
-template class TableEntry<string>;
+template class TableEntry<std::string>;
template
-void TableHandler::add_value(const string &, double);
+void TableHandler::add_value(const std::string &, double);
template
-void TableHandler::add_value(const string &, int);
+void TableHandler::add_value(const std::string &, int);
template
-void TableHandler::add_value(const string &, unsigned int);
+void TableHandler::add_value(const std::string &, unsigned int);
template
-void TableHandler::add_value(const string &, string);
+void TableHandler::add_value(const std::string &, std::string);
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
template <int rank, int dim>
void
-TensorFunction<rank, dim>::value_list (const vector<Point<dim> > &points,
- vector<Tensor<rank,dim> > &values) const
+TensorFunction<rank, dim>::value_list (const
std::vector<Point<dim> > &points,
+ std::vector<Tensor<rank,dim> > &values) const
{
Assert (values.size() == points.size(),
ExcDimensionMismatch(values.size(), points.size()));
template <int rank, int dim>
void
-TensorFunction<rank, dim>::gradient_list (const vector<Point<dim> > &points,
- vector<Tensor<rank+1,dim> > &gradients) const
+TensorFunction<rank, dim>::gradient_list (const
std::vector<Point<dim> > &points,
+ std::vector<Tensor<rank+1,dim> > &gradients) const
{
Assert (gradients.size() == points.size(),
ExcDimensionMismatch(gradients.size(), points.size()));
- vector<pair<unsigned int,unsigned int> >
+ std::vector<std::pair<unsigned int,unsigned int> >
split_interval (const unsigned int begin,
const unsigned int end,
const unsigned int n_intervals)
const unsigned int n_elements_per_interval = n_elements / n_intervals;
const unsigned int residual = n_elements % n_intervals;
- vector<pair<unsigned int,unsigned int> > return_values (n_intervals);
+ std::vector<std::pair<unsigned int,unsigned int> > return_values (n_intervals);
return_values[0].first = begin;
for (unsigned int i=0; i<n_intervals; ++i)
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* to a @ref{DoFHandler} object.
*/
DoFObjectAccessor (Triangulation<dim> *tria,
- const int level,
- const int index,
- const AccessorData *local_data) :
+ const int level,
+ const int index,
+ const AccessorData *local_data) :
DoFAccessor<dim> (local_data),
- DoFObjectAccessor_Inheritance<celldim,dim>::BaseClass (tria,level,index) {};
+ DoFObjectAccessor_Inheritance<celldim,dim>::BaseClass (tria,level,index) {};
/**
* Index of the @p{i}th degree
* right size before being passed
* to this function.
*/
- void get_dof_indices (vector<unsigned int> &dof_indices) const;
+ void get_dof_indices (std::vector<unsigned int> &dof_indices) const;
/**
* Return the values of the given vector
const int index,
const AccessorData *local_data) :
DoFAccessor<dim> (local_data),
- DoFObjectAccessor_Inheritance<1,dim>::BaseClass (tria,level,index) {};
+ DoFObjectAccessor_Inheritance<1,dim>::BaseClass (tria,level,index) {};
/**
* Return the index of the @p{i}th degree
* It is assumed that the vector already
* has the right size beforehand.
*/
- void get_dof_indices (vector<unsigned int> &dof_indices) const;
+ void get_dof_indices (std::vector<unsigned int> &dof_indices) const;
/**
* Return the values of the given vector
* to a @ref{DoFHandler} object.
*/
DoFObjectAccessor (Triangulation<dim> *tria,
- const int level,
- const int index,
- const AccessorData *local_data) :
+ const int level,
+ const int index,
+ const AccessorData *local_data) :
DoFAccessor<dim> (local_data),
- DoFObjectAccessor_Inheritance<2,dim>::BaseClass (tria,level,index) {};
+ DoFObjectAccessor_Inheritance<2,dim>::BaseClass (tria,level,index) {};
/**
* Return the index of the @p{i}th degree
* It is assumed that the vector already
* has the right size beforehand.
*/
- void get_dof_indices (vector<unsigned int> &dof_indices) const;
+ void get_dof_indices (std::vector<unsigned int> &dof_indices) const;
/**
* Return the values of the given vector
* to a @ref{DoFHandler} object.
*/
DoFObjectAccessor (Triangulation<dim> *tria,
- const int level,
- const int index,
- const AccessorData *local_data) :
+ const int level,
+ const int index,
+ const AccessorData *local_data) :
DoFAccessor<dim> (local_data),
- DoFObjectAccessor_Inheritance<3,dim>::BaseClass (tria,level,index) {};
+ DoFObjectAccessor_Inheritance<3,dim>::BaseClass (tria,level,index) {};
/**
* Return the index of the @p{i}th degree
* It is assumed that the vector already
* has the right size beforehand.
*/
- void get_dof_indices (vector<unsigned int> &dof_indices) const;
+ void get_dof_indices (std::vector<unsigned int> &dof_indices) const;
/**
* Return the values of the given vector
const int level,
const int index,
const AccessorData *local_data) :
- DoFObjectAccessor<dim, dim> (tria,level,index,local_data) {};
+ DoFObjectAccessor<dim, dim> (tria,level,index,local_data) {};
/**
* Return the @p{i}th neighbor as a DoF cell
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
template <int dim>
inline
void
-DoFObjectAccessor<1,dim>::get_dof_indices (vector<unsigned int> &dof_indices) const
+DoFObjectAccessor<1,dim>::get_dof_indices (std::vector<unsigned int> &dof_indices) const
{
// since the exception classes are
// from a template dependent base
const unsigned int dofs_per_vertex = dof_handler->get_fe().dofs_per_vertex,
dofs_per_line = dof_handler->get_fe().dofs_per_line;
- vector<unsigned int>::iterator next = dof_indices.begin();
+ std::vector<unsigned int>::iterator next = dof_indices.begin();
for (unsigned int vertex=0; vertex<2; ++vertex)
for (unsigned int d=0; d<dofs_per_vertex; ++d)
*next++ = vertex_dof_index(vertex,d);
DoFObjectAccessor<1,dim>::child (const unsigned int i) const
{
TriaIterator<dim,DoFObjectAccessor<1,dim> > q (tria,
- present_level+1,
- child_index (i),
- dof_handler);
+ present_level+1,
+ child_index (i),
+ dof_handler);
#ifdef DEBUG
if (q.state() != past_the_end)
template <int dim>
inline
void
-DoFObjectAccessor<2,dim>::get_dof_indices (vector<unsigned int> &dof_indices) const
+DoFObjectAccessor<2,dim>::get_dof_indices (std::vector<unsigned int> &dof_indices) const
{
Assert (dof_handler != 0,
typename DoFAccessor<dim>::ExcInvalidObject());
const unsigned int dofs_per_vertex = dof_handler->get_fe().dofs_per_vertex,
dofs_per_line = dof_handler->get_fe().dofs_per_line,
dofs_per_quad = dof_handler->get_fe().dofs_per_quad;
- vector<unsigned int>::iterator next = dof_indices.begin();
+ std::vector<unsigned int>::iterator next = dof_indices.begin();
for (unsigned int vertex=0; vertex<4; ++vertex)
for (unsigned int d=0; d<dofs_per_vertex; ++d)
*next++ = vertex_dof_index(vertex,d);
DoFObjectAccessor<2,dim>::child (const unsigned int i) const
{
TriaIterator<dim,DoFObjectAccessor<2,dim> > q (tria,
- present_level+1,
- child_index (i),
- dof_handler);
+ present_level+1,
+ child_index (i),
+ dof_handler);
#ifdef DEBUG
if (q.state() != past_the_end)
template <int dim>
inline
void
-DoFObjectAccessor<3,dim>::get_dof_indices (vector<unsigned int> &dof_indices) const
+DoFObjectAccessor<3,dim>::get_dof_indices (std::vector<unsigned int> &dof_indices) const
{
Assert (dof_handler != 0,
typename DoFAccessor<dim>::ExcInvalidObject());
dofs_per_line = dof_handler->get_fe().dofs_per_line,
dofs_per_quad = dof_handler->get_fe().dofs_per_quad,
dofs_per_hex = dof_handler->get_fe().dofs_per_hex;
- vector<unsigned int>::iterator next = dof_indices.begin();
+ std::vector<unsigned int>::iterator next = dof_indices.begin();
for (unsigned int vertex=0; vertex<8; ++vertex)
for (unsigned int d=0; d<dofs_per_vertex; ++d)
*next++ = vertex_dof_index(vertex,d);
DoFObjectAccessor<3,dim>::child (const unsigned int i) const
{
TriaIterator<dim,DoFObjectAccessor<3,dim> > q (tria,
- present_level+1,
- child_index (i),
- dof_handler);
+ present_level+1,
+ child_index (i),
+ dof_handler);
#ifdef DEBUG
if (q.state() != past_the_end)
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* preceeding function more
* several times, but is faster.
*/
- void add_entries (const unsigned int line,
- const vector<pair<unsigned int,double> > &col_val_pairs);
+ void add_entries (const unsigned int line,
+ const std::vector<std::pair<unsigned int,double> > &col_val_pairs);
/**
* Close the filling of entries. Since the
* not stored in this object and are not
* printed.
*/
- void print (ostream &) const;
+ void print (std::ostream &) const;
/**
* Determine an estimate for the
* thereof, the same applies as what is
* said for @ref{ConstraintMatrix}@p{::lines}.
*/
- vector<pair<unsigned int,double> > entries;
+ std::vector<std::pair<unsigned int,double> > entries;
/**
* This operator is a bit
* additionally make usage of this matrix
* much slower.
*/
- vector<ConstraintLine> lines;
+ std::vector<ConstraintLine> lines;
/**
* Store whether the arrays are sorted.
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// its new line number
// after compression. If the shift is
// -1, this line will be condensed away
- vector<int> new_line;
+ std::vector<int> new_line;
new_line.reserve (uncondensed_struct.n_rows());
- vector<ConstraintLine>::const_iterator next_constraint = lines.begin();
- unsigned int shift = 0;
+ std::vector<ConstraintLine>::const_iterator next_constraint = lines.begin();
+ unsigned int shift = 0;
const unsigned int n_rows = uncondensed_struct.n_rows();
if (next_constraint == lines.end())
{
// let c point to the constraint
// of this column
- vector<ConstraintLine>::const_iterator c = lines.begin();
+ std::vector<ConstraintLine>::const_iterator c = lines.begin();
while (c->line != uncondensed_struct.get_column_numbers()[j])
++c;
if (new_line[uncondensed_struct.get_column_numbers()[j]] != -1)
// column is not constrained
for (unsigned int q=0; q!=next_constraint->entries.size(); ++q)
- condensed.add (new_line[next_constraint->entries[q].first],
- new_line[uncondensed_struct.get_column_numbers()[j]],
- uncondensed.global_entry(j) *
- next_constraint->entries[q].second);
+ condensed.add (new_line[next_constraint->entries[q].first],
+ new_line[uncondensed_struct.get_column_numbers()[j]],
+ uncondensed.global_entry(j) *
+ next_constraint->entries[q].second);
else
// not only this line but
{
// let c point to the constraint
// of this column
- vector<ConstraintLine>::const_iterator c = lines.begin();
+ std::vector<ConstraintLine>::const_iterator c = lines.begin();
while (c->line != uncondensed_struct.get_column_numbers()[j])
++c;
for (unsigned int p=0; p!=c->entries.size(); ++p)
for (unsigned int q=0; q!=next_constraint->entries.size(); ++q)
- condensed.add (new_line[next_constraint->entries[q].first],
- new_line[c->entries[p].first],
- uncondensed.global_entry(j) *
- next_constraint->entries[q].second *
- c->entries[p].second);
+ condensed.add (new_line[next_constraint->entries[q].first],
+ new_line[c->entries[p].first],
+ uncondensed.global_entry(j) *
+ next_constraint->entries[q].second *
+ c->entries[p].second);
};
++next_constraint;
// otherwise, the number states which
// line in the constraint matrix handles
// this index
- vector<int> distribute (sparsity.n_rows(), -1);
+ std::vector<int> distribute (sparsity.n_rows(), -1);
for (unsigned int c=0; c<lines.size(); ++c)
distribute[lines[c].line] = static_cast<signed int>(c);
// otherwise, the number states which
// line in the constraint matrix handles
// this index
- vector<int> distribute (sparsity.n_rows(), -1);
+ std::vector<int> distribute (sparsity.n_rows(), -1);
for (unsigned int c=0; c<lines.size(); ++c)
distribute[lines[c].line] = static_cast<signed int>(c);
{
// get index of this row
// within the blocks
- const pair<unsigned int,unsigned int>
+ const std::pair<unsigned int,unsigned int>
block_index = index_mapping.global_to_local(row);
const unsigned int block_row = block_index.first;
// its new line number
// after compression. If the shift is
// -1, this line will be condensed away
- vector<int> new_line;
+ std::vector<int> new_line;
new_line.reserve (uncondensed.size());
- vector<ConstraintLine>::const_iterator next_constraint = lines.begin();
- unsigned int shift = 0;
+ std::vector<ConstraintLine>::const_iterator next_constraint = lines.begin();
+ unsigned int shift = 0;
unsigned int n_rows = uncondensed.size();
if (next_constraint == lines.end())
// nothing to do
return;
- vector<ConstraintLine>::const_iterator next_constraint = lines.begin();
+ std::vector<ConstraintLine>::const_iterator next_constraint = lines.begin();
for (unsigned int row=0; row<vec.size(); ++row)
if (row == next_constraint->line)
// line must be distributed
// nothing to do
return;
- vector<ConstraintLine>::const_iterator next_constraint = lines.begin();
+ std::vector<ConstraintLine>::const_iterator next_constraint = lines.begin();
for (unsigned int row=0; row<vec.size(); ++row)
if (row == next_constraint->line)
{
// its old line number before
// distribution. If the shift is
// -1, this line was condensed away
- vector<int> old_line;
+ std::vector<int> old_line;
old_line.reserve (uncondensed.size());
- vector<ConstraintLine>::const_iterator next_constraint = lines.begin();
- unsigned int shift = 0;
+ std::vector<ConstraintLine>::const_iterator next_constraint = lines.begin();
+ unsigned int shift = 0;
unsigned int n_rows = uncondensed.size();
if (next_constraint == lines.end())
{
Assert (sorted == true, ExcMatrixNotClosed());
- vector<ConstraintLine>::const_iterator next_constraint = lines.begin();
+ std::vector<ConstraintLine>::const_iterator next_constraint = lines.begin();
for (; next_constraint != lines.end(); ++next_constraint)
{
// make entry in line next_constraint.line
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* for each boundary indicator, which is
* guaranteed by the @p{map} data type.
*/
- typedef map<unsigned char,const Function<dim>*> FunctionMap;
+ typedef std::map<unsigned char,const Function<dim>*> FunctionMap;
/**
* When the arrays holding the
* wants to implement an ordering scheme
* herself, for example downwind numbering.
*/
- void renumber_dofs (const vector<unsigned int> &new_numbers);
+ void renumber_dofs (const std::vector<unsigned int> &new_numbers);
/**
* Return the maximum number of
* consideration.
*/
unsigned int
- n_boundary_dofs (const set<unsigned char> &boundary_indicators) const;
+ n_boundary_dofs (const std::set<unsigned char> &boundary_indicators) const;
/**
* Return a constant reference to the
* @p{levels[]} tree of the @ref{Triangulation}
* objects.
*/
- vector<DoFLevel<dim>*> levels;
+ std::vector<DoFLevel<dim>*> levels;
/**
* Store the number of dofs created last
* Array to store the indices for degrees
* of freedom located at vertices.
*/
- vector<unsigned int> vertex_dofs;
+ std::vector<unsigned int> vertex_dofs;
#if (__GNUC__==2) && (__GNUC_MINOR__ < 95)
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* of freedom. See @ref{DoFLevel} for
* detailed information.
*/
- vector<unsigned int> line_dofs;
+ std::vector<unsigned int> line_dofs;
/**
* Determine an estimate for the
* of freedom. See @ref{DoFLevel} for
* detailed information.
*/
- vector<unsigned int> quad_dofs;
+ std::vector<unsigned int> quad_dofs;
/**
* Determine an estimate for the
* of freedom. See @ref{DoFLevel} for
* detailed information.
*/
- vector<unsigned int> hex_dofs;
+ std::vector<unsigned int> hex_dofs;
/**
* Determine an estimate for the
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
*/
template<int dim, class SparsityPattern>
static void make_sparsity_pattern (const DoFHandler<dim> &dof,
- const vector<vector<bool> > &mask,
+ const std::vector<std::vector<bool> > &mask,
SparsityPattern &sparsity_pattern);
/**
*/
template<int dim>
static void
- make_boundary_sparsity_pattern (const DoFHandler<dim> &dof,
- const vector<unsigned int> &dof_to_boundary_mapping,
- SparsityPattern &sparsity_pattern);
+ make_boundary_sparsity_pattern (const DoFHandler<dim> &dof,
+ const std::vector<unsigned int> &dof_to_boundary_mapping,
+ SparsityPattern &sparsity_pattern);
/**
* Write the sparsity structure of the
*/
template<int dim>
static void
- make_boundary_sparsity_pattern (const DoFHandler<dim>& dof,
+ make_boundary_sparsity_pattern (const DoFHandler<dim> &dof,
const typename DoFHandler<dim>::FunctionMap &boundary_indicators,
- const vector<unsigned int> &dof_to_boundary_mapping,
+ const std::vector<unsigned int> &dof_to_boundary_mapping,
SparsityPattern &sparsity);
/**
*/
template <int dim>
static void
- extract_dofs (const DoFHandler<dim> &dof_handler,
- const vector<bool> &component_select,
- vector<bool> &selected_dofs);
+ extract_dofs (const DoFHandler<dim> &dof_handler,
+ const std::vector<bool> &component_select,
+ std::vector<bool> &selected_dofs);
/**
* Do the same thing as
static void
extract_level_dofs (const unsigned int level,
const MGDoFHandler<dim> &dof,
- const vector<bool> &select,
- vector<bool> &selected_dofs);
+ const std::vector<bool> &select,
+ std::vector<bool> &selected_dofs);
/**
* Extract all degrees of freedom
*/
template <int dim>
static void
- extract_boundary_dofs (const DoFHandler<dim> &dof_handler,
- const vector<bool> &component_select,
- vector<bool> &selected_dofs,
- const set<unsigned char> &boundary_indicators = set<unsigned char>());
+ extract_boundary_dofs (const DoFHandler<dim> &dof_handler,
+ const std::vector<bool> &component_select,
+ std::vector<bool> &selected_dofs,
+ const std::set<unsigned char> &boundary_indicators = std::set<unsigned char>());
/**
* Select all dofs that will be
template <int dim>
static void
extract_hanging_node_dofs (const DoFHandler<dim> &dof_handler,
- vector<bool> &selected_dofs);
+ std::vector<bool> &selected_dofs);
/**
* This function can be used when
*/
template <int dim>
static void
- map_dof_to_boundary_indices (const DoFHandler<dim> &dof_handler,
- vector<unsigned int> &mapping);
+ map_dof_to_boundary_indices (const DoFHandler<dim> &dof_handler,
+ std::vector<unsigned int> &mapping);
/**
* Same as the previous function,
*/
template <int dim>
static void
- map_dof_to_boundary_indices (const DoFHandler<dim> &dof_handler,
- const set<unsigned char> &boundary_indicators,
- vector<unsigned int> &mapping);
+ map_dof_to_boundary_indices (const DoFHandler<dim> &dof_handler,
+ const std::set<unsigned char> &boundary_indicators,
+ std::vector<unsigned int> &mapping);
/**
compute_intergrid_weights (const DoFHandler<dim> &coarse_grid,
const unsigned int coarse_component,
const InterGridMap<DoFHandler,dim> &coarse_to_fine_grid_map,
- const vector<Vector<double> > ¶meter_dofs,
- const vector<int> &weight_mapping,
+ const std::vector<Vector<double> > ¶meter_dofs,
+ const std::vector<int> &weight_mapping,
FullMatrix<float> &weights);
/**
compute_intergrid_weights_1 (const DoFHandler<dim> &coarse_grid,
const unsigned int coarse_component,
const InterGridMap<DoFHandler,dim> &coarse_to_fine_grid_map,
- const vector<Vector<double> > ¶meter_dofs,
- const vector<int> &weight_mapping,
+ const std::vector<Vector<double> > ¶meter_dofs,
+ const std::vector<int> &weight_mapping,
FullMatrix<float> &weights,
const typename DoFHandler<dim>::active_cell_iterator &begin,
const typename DoFHandler<dim>::active_cell_iterator &end);
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* this base class' constructor.
*/
FiniteElementBase (const FiniteElementData<dim> &fe_data,
- const vector<bool> &restriction_is_additive_flags);
+ const std::vector<bool> &restriction_is_additive_flags);
/**
* Return a readonly reference to the
* component and second index in
* component.
*/
- pair<unsigned int,unsigned int> system_to_component_index (unsigned int index) const;
+ std::pair<unsigned int,unsigned int>
+ system_to_component_index (unsigned int index) const;
/**
* Compute system index from components on a face.
* component and second index in
* component.
*/
- pair<unsigned int,unsigned int> face_system_to_component_index (unsigned int index) const;
+ std::pair<unsigned int,unsigned int>
+ face_system_to_component_index (unsigned int index) const;
/**
* The base element establishing a
* Map between linear dofs and
* component dofs.
*/
- vector< pair<unsigned int, unsigned int> > system_to_component_table;
+ std::vector< std::pair<unsigned int, unsigned int> > system_to_component_table;
/**
* Map between linear dofs and
* component dofs on face.
*/
- vector< pair<unsigned int, unsigned int> > face_system_to_component_table;
+ std::vector< std::pair<unsigned int, unsigned int> > face_system_to_component_table;
/**
* Map between component and
* linear dofs.
*/
- vector< vector<unsigned int> > component_to_system_table;
+ std::vector< std::vector<unsigned int> > component_to_system_table;
/**
* Map between component and
* linear dofs on a face.
*/
- vector< vector<unsigned int> > face_component_to_system_table;
+ std::vector< std::vector<unsigned int> > face_component_to_system_table;
/**
* The base element establishing
* shape functions of the base
* element.
*/
- vector<unsigned int> component_to_base_table;
+ std::vector<unsigned int> component_to_base_table;
/**
* This flag determines how the
* There is one flag per
* component.
*/
- const vector<bool> restriction_is_additive_flags;
+ const std::vector<bool> restriction_is_additive_flags;
};
* Constructor
*/
FiniteElement (const FiniteElementData<dim> &fe_data,
- const vector<bool> &restriction_is_additive_flags);
+ const std::vector<bool> &restriction_is_additive_flags);
/**
* Destructor. Only declared to
* absolutely needed.
*/
virtual void fill_fe_values (const DoFHandler<dim>::cell_iterator &cell,
- const vector<Point<dim> > &unit_points,
- vector<Tensor<2,dim> > &jacobians,
- const bool compute_jacobians,
- vector<Tensor<3,dim> > &jacobians_grad,
- const bool compute_jacobians_grad,
- vector<Point<dim> > &support_points,
- const bool compute_support_points,
- vector<Point<dim> > &q_points,
- const bool compute_q_points,
- const FullMatrix<double> &shape_values_transform,
- const vector<vector<Tensor<1,dim> > > &shape_grads_transform) const;
+ const
std::vector<Point<dim> > &unit_points,
+ std::vector<Tensor<2,dim> > &jacobians,
+ const bool compute_jacobians,
+ std::vector<Tensor<3,dim> > &jacobians_grad,
+ const bool compute_jacobians_grad,
+
std::vector<Point<dim> > &support_points,
+ const bool compute_support_points,
+
std::vector<Point<dim> > &q_points,
+ const bool compute_q_points,
+ const FullMatrix<double> &shape_values_transform,
+ const std::vector<std::vector<Tensor<1,dim> > > &shape_grads_transform) const;
/**
* Do the same thing that the
*/
virtual void fill_fe_face_values (const DoFHandler<dim>::cell_iterator &cell,
const unsigned int face_no,
- const vector<Point<dim-1> > &unit_points,
- const vector<Point<dim> > &global_unit_points,
- vector<Tensor<2,dim> > &jacobians,
- const bool compute_jacobians,
- vector<Tensor<3,dim> > &jacobians_grad,
- const bool compute_jacobians_grad,
- vector<Point<dim> > &support_points,
- const bool compute_support_points,
- vector<Point<dim> > &q_points,
- const bool compute_q_points,
- vector<double> &face_jacobi_determinants,
- const bool compute_face_jacobians,
- vector<Point<dim> > &normal_vectors,
- const bool compute_normal_vectors,
- const FullMatrix<double> &shape_values_transform,
- const vector<vector<Tensor<1,dim> > > &shape_grads_transform) const;
+ const
std::vector<Point<dim-1> > &unit_points,
+ const
std::vector<Point<dim> > &global_unit_points,
+ std::vector<Tensor<2,dim> > &jacobians,
+ const bool compute_jacobians,
+ std::vector<Tensor<3,dim> > &jacobians_grad,
+ const bool compute_jacobians_grad,
+
std::vector<Point<dim> > &support_points,
+ const bool compute_support_points,
+
std::vector<Point<dim> > &q_points,
+ const bool compute_q_points,
+ std::vector<double> &face_jacobi_determinants,
+ const bool compute_face_jacobians,
+
std::vector<Point<dim> > &normal_vectors,
+ const bool compute_normal_vectors,
+ const FullMatrix<double> &shape_values_transform,
+ const std::vector<std::vector<Tensor<1,dim> > > &shape_grads_transform) const;
/**
* This function does almost the
virtual void fill_fe_subface_values (const DoFHandler<dim>::cell_iterator &cell,
const unsigned int face_no,
const unsigned int subface_no,
- const vector<Point<dim-1> > &unit_points,
- const vector<Point<dim> > &global_unit_points,
- vector<Tensor<2,dim> > &jacobians,
- const bool compute_jacobians,
- vector<Tensor<3,dim> > &jacobians_grad,
- const bool compute_jacobians_grad,
- vector<Point<dim> > &q_points,
- const bool compute_q_points,
- vector<double> &face_jacobi_determinants,
- const bool compute_face_jacobians,
- vector<Point<dim> > &normal_vectors,
- const bool compute_normal_vectors,
- const FullMatrix<double> &shape_values_transform,
- const vector<vector<Tensor<1,dim> > > &shape_grads_transform) const;
+ const
std::vector<Point<dim-1> > &unit_points,
+ const
std::vector<Point<dim> > &global_unit_points,
+ std::vector<Tensor<2,dim> > &jacobians,
+ const bool compute_jacobians,
+ std::vector<Tensor<3,dim> > &jacobians_grad,
+ const bool compute_jacobians_grad,
+
std::vector<Point<dim> > &q_points,
+ const bool compute_q_points,
+ std::vector<double> &face_jacobi_determinants,
+ const bool compute_face_jacobians,
+
std::vector<Point<dim> > &normal_vectors,
+ const bool compute_normal_vectors,
+ const FullMatrix<double> &shape_values_transform,
+ const std::vector<std::vector<Tensor<1,dim> > > &shape_grads_transform) const;
/**
* Return the support points of
* dimensions, an overwritten
* function has to be provided.
*/
- virtual void get_unit_support_points (vector<Point<dim> > &unit_points) const;
+ virtual void get_unit_support_points (
std::vector<Point<dim> > &unit_points) const;
/**
* Compute the off-points of the
* stored by the triangulation.
*/
virtual void get_support_points (const DoFHandler<dim>::cell_iterator &cell,
- vector<Point<dim> > &support_points) const;
+
std::vector<Point<dim> > &support_points) const;
/**
* Compute the off-points of the
* function.
*/
virtual void get_face_support_points (const DoFHandler<dim>::face_iterator &face,
- vector<Point<dim> > &support_points) const =0;
+
std::vector<Point<dim> > &support_points) const =0;
/**
* This is the second separated function
* function.
*/
virtual void get_face_jacobians (const DoFHandler<dim>::face_iterator &face,
- const vector<Point<dim-1> > &unit_points,
- vector<double> &face_jacobi_determinants) const =0;
+ const
std::vector<Point<dim-1> > &unit_points,
+ std::vector<double> &face_jacobi_determinants) const =0;
/**
* Does the same as the above
*/
virtual void get_subface_jacobians (const DoFHandler<dim>::face_iterator &face,
const unsigned int subface_no,
- const vector<Point<dim-1> > &unit_points,
- vector<double> &face_jacobi_determinants) const =0;
+ const
std::vector<Point<dim-1> > &unit_points,
+ std::vector<double> &face_jacobi_determinants) const =0;
/**
* Compute the normal vectors to
* function.
*/
virtual void get_normal_vectors (const DoFHandler<dim>::cell_iterator &cell,
- const unsigned int face_no,
- const vector<Point<dim-1> > &unit_points,
- vector<Point<dim> > &normal_vectors) const =0;
+ const unsigned int face_no,
+ const
std::vector<Point<dim-1> > &unit_points,
+
std::vector<Point<dim> > &normal_vectors) const =0;
/**
* Does the same as the above function,
virtual void get_normal_vectors (const DoFHandler<dim>::cell_iterator &cell,
const unsigned int face_no,
const unsigned int subface_no,
- const vector<Point<dim-1> > &unit_points,
- vector<Point<dim> > &normal_vectors) const =0;
+ const
std::vector<Point<dim-1> > &unit_points,
+
std::vector<Point<dim> > &normal_vectors) const =0;
/**
* Fill in the given matrix with
template <int dim>
inline
-pair<unsigned int,unsigned int>
+std::pair<unsigned int,unsigned int>
FiniteElementBase<dim>::system_to_component_index (unsigned int index) const
{
Assert(index < system_to_component_table.size(),
template <int dim>
inline
-pair<unsigned int,unsigned int>
+std::pair<unsigned int,unsigned int>
FiniteElementBase<dim>::face_system_to_component_index (unsigned int index) const
{
Assert(index < face_system_to_component_table.size(),
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* Refer to the base class for detailed
* information on this function.
*/
- virtual void get_unit_support_points (vector<Point<dim> > &support_points) const;
+ virtual void get_unit_support_points (
std::vector<Point<dim> > &support_points) const;
/**
* Refer to the base class for detailed
* information on this function.
*/
virtual void get_support_points (const DoFHandler<dim>::cell_iterator &cell,
- vector<Point<dim> > &support_points) const;
+
std::vector<Point<dim> > &support_points) const;
/**
* Refer to the base class for detailed
* information on this function.
*/
virtual void get_face_support_points (const DoFHandler<dim>::face_iterator &face,
- vector<Point<dim> > &support_points) const;
+
std::vector<Point<dim> > &support_points) const;
/**
* Refer to the base class for detailed
* simply returns the length of the face.
*/
virtual void get_face_jacobians (const DoFHandler<dim>::face_iterator &face,
- const vector<Point<dim-1> > &unit_points,
- vector<double> &face_jacobi_determinants) const;
+ const
std::vector<Point<dim-1> > &unit_points,
+ std::vector<double> &face_jacobi_determinants) const;
/**
* Refer to the base class for detailed
*/
virtual void get_subface_jacobians (const DoFHandler<dim>::face_iterator &face,
const unsigned int subface_no,
- const vector<Point<dim-1> > &unit_points,
- vector<double> &face_jacobi_determinants) const;
+ const
std::vector<Point<dim-1> > &unit_points,
+ std::vector<double> &face_jacobi_determinants) const;
/**
* Return the normal vectors to the
*/
virtual void get_normal_vectors (const DoFHandler<dim>::cell_iterator &cell,
const unsigned int face_no,
- const vector<Point<dim-1> > &unit_points,
- vector<Point<dim> > &normal_vectors) const;
+ const
std::vector<Point<dim-1> > &unit_points,
+
std::vector<Point<dim> > &normal_vectors) const;
/**
* Return the normal vectors to the
virtual void get_normal_vectors (const DoFHandler<dim>::cell_iterator &cell,
const unsigned int face_no,
const unsigned int subface_no,
- const vector<Point<dim-1> > &unit_points,
- vector<Point<dim> > &normal_vectors) const;
+ const
std::vector<Point<dim-1> > &unit_points,
+
std::vector<Point<dim> > &normal_vectors) const;
/**
* Refer to the base class for detailed
* we use multilinear mappings.
*/
virtual void fill_fe_values (const DoFHandler<dim>::cell_iterator &cell,
- const vector<Point<dim> > &unit_points,
- vector<Tensor<2,dim> > &jacobians,
+ const
std::vector<Point<dim> > &unit_points,
+ std::vector<Tensor<2,dim> > &jacobians,
const bool compute_jacobians,
- vector<Tensor<3,dim> > &jacobians_grad,
+ std::vector<Tensor<3,dim> > &jacobians_grad,
const bool compute_jacobians_grad,
- vector<Point<dim> > &support_points,
+
std::vector<Point<dim> > &support_points,
const bool compute_support_points,
- vector<Point<dim> > &q_points,
+
std::vector<Point<dim> > &q_points,
const bool compute_q_points,
const FullMatrix<double> &shape_values_transform,
- const vector<vector<Tensor<1,dim> > > &shape_grad_transform) const;
+ const std::vector<std::vector<Tensor<1,dim> > > &shape_grad_transform) const;
DeclException0 (ExcNotUseful);
};
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* Refer to the base class for detailed
* information on this function.
*/
- virtual void get_unit_support_points (vector<Point<dim> > &support_points) const;
+ virtual void get_unit_support_points (
std::vector<Point<dim> > &support_points) const;
/**
* Refer to the base class for detailed
* information on this function.
*/
virtual void get_support_points (const DoFHandler<dim>::cell_iterator &cell,
- vector<Point<dim> > &support_points) const;
+
std::vector<Point<dim> > &support_points) const;
/**
* Refer to the base class for detailed
* information on this function.
*/
virtual void get_face_support_points (const DoFHandler<dim>::face_iterator &face,
- vector<Point<dim> > &support_points) const;
+
std::vector<Point<dim> > &support_points) const;
/**
* Refer to the base class for detailed
* information on this function.
*/
virtual void get_face_support_points (const DoFHandler<dim>::face_iterator &face,
- vector<Point<dim> > &support_points) const;
+
std::vector<Point<dim> > &support_points) const;
};
* information on this function.
*/
virtual void get_face_support_points (const DoFHandler<dim>::face_iterator &face,
- vector<Point<dim> > &support_points) const;
+
std::vector<Point<dim> > &support_points) const;
};
* information on this function.
*/
virtual void get_face_support_points (const DoFHandler<dim>::face_iterator &face,
- vector<Point<dim> > &support_points) const;
+
std::vector<Point<dim> > &support_points) const;
};
* information on this function.
*/
virtual void get_face_support_points (const DoFHandler<dim>::face_iterator &face,
- vector<Point<dim> > &support_points) const;
+
std::vector<Point<dim> > &support_points) const;
};
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* Refer to the base class for detailed
* information on this function.
*/
- virtual void get_unit_support_points (vector<Point<dim> > &support_points) const;
+ virtual void get_unit_support_points (
std::vector<Point<dim> > &support_points) const;
/**
* Refer to the base class for detailed
* information on this function.
*/
virtual void get_support_points (const DoFHandler<dim>::cell_iterator &cell,
- vector<Point<dim> > &support_points) const;
+
std::vector<Point<dim> > &support_points) const;
/**
* Refer to the base class for detailed
* information on this function.
*/
virtual void get_face_support_points (const DoFHandler<dim>::face_iterator &face,
- vector<Point<dim> > &support_points) const;
+
std::vector<Point<dim> > &support_points) const;
/**
* Refer to the base class for detailed
* Refer to the base class for detailed
* information on this function.
*/
- virtual void get_unit_support_points (vector<Point<dim> > &support_points) const;
+ virtual void get_unit_support_points (
std::vector<Point<dim> > &support_points) const;
/**
* Refer to the base class for detailed
* information on this function.
*/
virtual void get_support_points (const DoFHandler<dim>::cell_iterator &cell,
- vector<Point<dim> > &support_points) const;
+
std::vector<Point<dim> > &support_points) const;
/**
* Refer to the base class for detailed
* information on this function.
*/
virtual void get_face_support_points (const DoFHandler<dim>::face_iterator &face,
- vector<Point<dim> > &support_points) const;
+
std::vector<Point<dim> > &support_points) const;
/**
* Refer to the base class for detailed
* Refer to the base class for detailed
* information on this function.
*/
- virtual void get_unit_support_points (vector<Point<dim> > &support_points) const;
+ virtual void get_unit_support_points (
std::vector<Point<dim> > &support_points) const;
/**
* Refer to the base class for detailed
* information on this function.
*/
virtual void get_support_points (const DoFHandler<dim>::cell_iterator &cell,
- vector<Point<dim> > &support_points) const;
+
std::vector<Point<dim> > &support_points) const;
/**
* Refer to the base class for detailed
* information on this function.
*/
virtual void get_face_support_points (const DoFHandler<dim>::face_iterator &face,
- vector<Point<dim> > &support_points) const;
+
std::vector<Point<dim> > &support_points) const;
/**
* Refer to the base class for detailed
* Refer to the base class for detailed
* information on this function.
*/
- virtual void get_unit_support_points (vector<Point<dim> > &support_points) const;
+ virtual void get_unit_support_points (
std::vector<Point<dim> > &support_points) const;
/**
* Refer to the base class for detailed
* information on this function.
*/
virtual void get_support_points (const DoFHandler<dim>::cell_iterator &cell,
- vector<Point<dim> > &support_points) const;
+
std::vector<Point<dim> > &support_points) const;
/**
* Refer to the base class for detailed
* information on this function.
*/
virtual void get_face_support_points (const DoFHandler<dim>::face_iterator &face,
- vector<Point<dim> > &support_points) const;
+
std::vector<Point<dim> > &support_points) const;
/**
* Refer to the base class for detailed
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* Refer to the base class for detailed
* information on this function.
*/
- virtual void get_unit_support_points (vector<Point<dim> > &support_points) const;
+ virtual void get_unit_support_points (
std::vector<Point<dim> > &support_points) const;
/**
* Refer to the base class for detailed
* information on this function.
*/
virtual void get_support_points (const DoFHandler<dim>::cell_iterator &cell,
- vector<Point<dim> > &support_points) const;
+
std::vector<Point<dim> > &support_points) const;
/**
* Refer to the base class for detailed
* information on this function.
*/
virtual void get_face_support_points (const DoFHandler<dim>::face_iterator &face,
- vector<Point<dim> > &support_points) const;
+
std::vector<Point<dim> > &support_points) const;
/**
* Refer to the base class for detailed
* Refer to the base class for detailed
* information on this function.
*/
- virtual void get_unit_support_points (vector<Point<dim> > &support_points) const;
+ virtual void get_unit_support_points (
std::vector<Point<dim> > &support_points) const;
/**
* Refer to the base class for detailed
* information on this function.
*/
virtual void get_support_points (const DoFHandler<dim>::cell_iterator &cell,
- vector<Point<dim> > &support_points) const;
+
std::vector<Point<dim> > &support_points) const;
/**
* Refer to the base class for detailed
* information on this function.
*/
virtual void get_face_support_points (const DoFHandler<dim>::face_iterator &face,
- vector<Point<dim> > &support_points) const;
+
std::vector<Point<dim> > &support_points) const;
/**
* Refer to the base class for detailed
* Refer to the base class for detailed
* information on this function.
*/
- virtual void get_unit_support_points (vector<Point<dim> > &support_points) const;
+ virtual void get_unit_support_points (
std::vector<Point<dim> > &support_points) const;
/**
* Refer to the base class for detailed
* information on this function.
*/
virtual void get_support_points (const DoFHandler<dim>::cell_iterator &cell,
- vector<Point<dim> > &support_points) const;
+
std::vector<Point<dim> > &support_points) const;
/**
* Refer to the base class for detailed
* information on this function.
*/
virtual void get_face_support_points (const DoFHandler<dim>::face_iterator &face,
- vector<Point<dim> > &support_points) const;
+
std::vector<Point<dim> > &support_points) const;
/**
* Refer to the base class for detailed
* Refer to the base class for detailed
* information on this function.
*/
- virtual void get_unit_support_points (vector<Point<dim> > &support_points) const;
+ virtual void get_unit_support_points (
std::vector<Point<dim> > &support_points) const;
/**
* Refer to the base class for detailed
* information on this function.
*/
virtual void get_support_points (const DoFHandler<dim>::cell_iterator &cell,
- vector<Point<dim> > &support_points) const;
+
std::vector<Point<dim> > &support_points) const;
/**
* Refer to the base class for detailed
* information on this function.
*/
virtual void get_face_support_points (const DoFHandler<dim>::face_iterator &face,
- vector<Point<dim> > &support_points) const;
+
std::vector<Point<dim> > &support_points) const;
/**
* Refer to the base class for detailed
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* For the ordering of shape functions
* refer to the @p{shape_value} function.
*/
- virtual void get_unit_support_points (vector<Point<dim> > &support_points) const;
+ virtual void get_unit_support_points (
std::vector<Point<dim> > &support_points) const;
/**
* Refer to the base class for detailed
* refer to the @p{shape_value} function.
*/
virtual void get_support_points (const DoFHandler<dim>::cell_iterator &cell,
- vector<Point<dim> > &support_points) const;
+
std::vector<Point<dim> > &support_points) const;
/**
* Refer to the base class for detailed
* information on this function.
*/
virtual void get_face_support_points (const DoFHandler<dim>::face_iterator &face,
- vector<Point<dim> > &support_points) const;
+
std::vector<Point<dim> > &support_points) const;
/**
* Fill the local mass matrix. The elements
* underlying object.
*/
virtual void get_face_jacobians (const DoFHandler<dim>::face_iterator &face,
- const vector<Point<dim-1> > &unit_points,
- vector<double> &face_jacobi_determinants) const;
+ const
std::vector<Point<dim-1> > &unit_points,
+ std::vector<double> &face_jacobi_determinants) const;
/**
* Refer to the base class for detailed
*/
virtual void get_subface_jacobians (const DoFHandler<dim>::face_iterator &face,
const unsigned int subface_no,
- const vector<Point<dim-1> > &unit_points,
- vector<double> &face_jacobi_determinants) const;
+ const
std::vector<Point<dim-1> > &unit_points,
+ std::vector<double> &face_jacobi_determinants) const;
/**
* Return the normal vectors to the
*/
virtual void get_normal_vectors (const DoFHandler<dim>::cell_iterator &cell,
const unsigned int face_no,
- const vector<Point<dim-1> > &unit_points,
- vector<Point<dim> > &normal_vectors) const;
+ const
std::vector<Point<dim-1> > &unit_points,
+
std::vector<Point<dim> > &normal_vectors) const;
/**
* Return the normal vectors to the
virtual void get_normal_vectors (const DoFHandler<dim>::cell_iterator &cell,
const unsigned int face_no,
const unsigned int subface_no,
- const vector<Point<dim-1> > &unit_points,
- vector<Point<dim> > &normal_vectors) const;
+ const
std::vector<Point<dim-1> > &unit_points,
+
std::vector<Point<dim> > &normal_vectors) const;
/**
* Implementation of the
* @p{FiniteElement}.
*/
virtual void fill_fe_values (const DoFHandler<dim>::cell_iterator &cell,
- const vector<Point<dim> > &unit_points,
- vector<Tensor<2,dim> > &jacobians,
+ const
std::vector<Point<dim> > &unit_points,
+ std::vector<Tensor<2,dim> > &jacobians,
const bool compute_jacobians,
- vector<Tensor<3,dim> > &jacobians_grad,
+ std::vector<Tensor<3,dim> > &jacobians_grad,
const bool compute_jacobians_grad,
- vector<Point<dim> > &support_points,
+
std::vector<Point<dim> > &support_points,
const bool compute_support_points,
- vector<Point<dim> > &q_points,
+
std::vector<Point<dim> > &q_points,
const bool compute_q_points,
const FullMatrix<double> &shape_values_transform,
- const vector<vector<Tensor<1,dim> > > &shape_grad_transform) const;
+ const std::vector<std::vector<Tensor<1,dim> > > &shape_grad_transform) const;
/**
* Number of different base
* Pairs of multiplicity and
* element type.
*/
- typedef pair<const FiniteElement<dim> *, unsigned int> ElementPair;
+ typedef std::pair<const FiniteElement<dim> *, unsigned int> ElementPair;
/**
* Pointer to underlying finite
* created by the constructor and
* constant afterwards.
*/
- vector<ElementPair> base_elements;
+ std::vector<ElementPair> base_elements;
/**
* the mixed element consisting of @p{N}
* elements of the sub-element @p{fe}.
*/
- static vector<bool>
+ static std::vector<bool>
compute_restriction_is_additive_flags (const FiniteElement<dim> &fe,
const unsigned int N);
* Same as above for mixed elements
* with two different sub-elements.
*/
- static vector<bool>
+ static std::vector<bool>
compute_restriction_is_additive_flags (const FiniteElement<dim> &fe1,
const unsigned int N1,
const FiniteElement<dim> &fe2,
* Same as above for mixed elements
* with three different sub-elements.
*/
- static vector<bool>
+ static std::vector<bool>
compute_restriction_is_additive_flags (const FiniteElement<dim> &fe1,
const unsigned int N1,
const FiniteElement<dim> &fe2,
FESystem<dim>::FESystem (const FE &fe, const unsigned int n_elements) :
FiniteElement<dim> (multiply_dof_numbers(fe, n_elements),
compute_restriction_is_additive_flags (fe, n_elements)),
- base_elements(1)
+ base_elements(1)
{
base_elements[0] = ElementPair(new FE, n_elements);
base_elements[0].first -> subscribe ();
FiniteElement<dim> (multiply_dof_numbers(fe1, n1, fe2, n2),
compute_restriction_is_additive_flags (fe1, n1,
fe2, n2)),
- base_elements(2)
+ base_elements(2)
{
Assert(fe1.n_transform_functions() == fe2.n_transform_functions(),
ExcElementTransformNotEqual());
compute_restriction_is_additive_flags (fe1, n1,
fe2, n2,
fe3, n3)),
- base_elements(3)
+ base_elements(3)
{
Assert(fe1.n_transform_functions() == fe2.n_transform_functions(),
ExcElementTransformNotEqual());
// $Id$
// Version: $Name$
//
-// Copyright (C) 2000 by the deal.II authors
+// Copyright (C) 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
class FETools
{
public:
- /**
- * Gives the interpolation matrix
- * that interpolates a @p{fe1}-
- * function to a @p{fe2}-function on
- * each cell. The interpolation_matrix
- * needs to be of size
- * @p{(fe2.dofs_per_cell, fe1.dofs_per_cell)}.
- *
- * Note, that if the finite element
- * space @p{fe1} is a subset of
- * the finite element space
- * @p{fe2} than the @p{interpolation_matrix}
- * is an embedding matrix.
- */
- template <int dim, typename number>
+ /**
+ * Gives the interpolation matrix
+ * that interpolates a @p{fe1}-
+ * function to a @p{fe2}-function on
+ * each cell. The interpolation_matrix
+ * needs to be of size
+ * @p{(fe2.dofs_per_cell, fe1.dofs_per_cell)}.
+ *
+ * Note, that if the finite element
+ * space @p{fe1} is a subset of
+ * the finite element space
+ * @p{fe2} than the @p{interpolation_matrix}
+ * is an embedding matrix.
+ */
+ template <int dim, typename number>
static void get_interpolation_matrix(const FiniteElement<dim> &fe1,
const FiniteElement<dim> &fe2,
FullMatrix<number> &interpolation_matrix);
- /**
- * Gives the interpolation matrix
- * that interpolates a @p{fe1}-
- * function to a @p{fe2}-function, and
- * interpolates this to a second
- * @p{fe1}-function on
- * each cell. The interpolation_matrix
- * needs to be of size
- * @p{(fe1.dofs_per_cell, fe1.dofs_per_cell)}.
- *
- * Note, that this function only
- * makes sense if the finite element
- * space due to @p{fe1} is not a subset of
- * the finite element space due to
- * @p{fe2}, as if it were a subset then
- * the @p{interpolation_matrix} would be
- * only the unit matrix.
- */
- template <int dim, typename number>
+ /**
+ * Gives the interpolation matrix
+ * that interpolates a @p{fe1}-
+ * function to a @p{fe2}-function, and
+ * interpolates this to a second
+ * @p{fe1}-function on
+ * each cell. The interpolation_matrix
+ * needs to be of size
+ * @p{(fe1.dofs_per_cell, fe1.dofs_per_cell)}.
+ *
+ * Note, that this function only
+ * makes sense if the finite element
+ * space due to @p{fe1} is not a subset of
+ * the finite element space due to
+ * @p{fe2}, as if it were a subset then
+ * the @p{interpolation_matrix} would be
+ * only the unit matrix.
+ */
+ template <int dim, typename number>
static void get_back_interpolation_matrix(const FiniteElement<dim> &fe1,
const FiniteElement<dim> &fe2,
FullMatrix<number> &interpolation_matrix);
- /**
- * Gives the unit matrix minus the
- * back interpolation matrix.
- * The @p{difference_matrix}
- * needs to be of size
- * @p{(fe1.dofs_per_cell, fe1.dofs_per_cell)}.
- *
- * This function gives
- * the matrix that transforms a
- * @p{fe1} function $z$ to $z-I_hz$
- * where $I_h$ denotes the interpolation
- * operator from the @p{fe1} space to
- * the @p{fe2} space. This matrix hence
- * is useful to evaluate
- * error-representations where $z$
- * denotes the dual solution.
- */
- template <int dim, typename number>
+ /**
+ * Gives the unit matrix minus the
+ * back interpolation matrix.
+ * The @p{difference_matrix}
+ * needs to be of size
+ * @p{(fe1.dofs_per_cell, fe1.dofs_per_cell)}.
+ *
+ * This function gives
+ * the matrix that transforms a
+ * @p{fe1} function $z$ to $z-I_hz$
+ * where $I_h$ denotes the interpolation
+ * operator from the @p{fe1} space to
+ * the @p{fe2} space. This matrix hence
+ * is useful to evaluate
+ * error-representations where $z$
+ * denotes the dual solution.
+ */
+ template <int dim, typename number>
static void get_interpolation_difference_matrix(
const FiniteElement<dim> &fe1,
const FiniteElement<dim> &fe2,
FullMatrix<number> &difference_matrix);
- /**
- * Gives the interpolation of a the
- * @p{dof1}-function @p{u1} to a
- * @p{dof2}-function @p{u2}. @p{dof1} and
- * @p{dof2} need to be @ref{DoFHandler}s
- * based on the same triangulation.
- *
- * If the elements @p{fe1} and @p{fe2}
- * are either both continuous or
- * both discontinuous then this
- * interpolation is the usual point
- * interpolation. The same is true
- * if @p{fe1} is a continuous and
- * @p{fe2} is a discontinuous finite
- * element. For the case that @p{fe1}
- * is a discontinuous and @p{fe2} is
- * a continuous finite element
- * there is no point interpolation
- * defined at the discontinuities.
- * Therefore the meanvalue is taken
- * at the DoF values on the
- * discontinuities.
- */
- template <int dim, typename number>
+ /**
+ * Gives the interpolation of a the
+ * @p{dof1}-function @p{u1} to a
+ * @p{dof2}-function @p{u2}. @p{dof1} and
+ * @p{dof2} need to be @ref{DoFHandler}s
+ * based on the same triangulation.
+ *
+ * If the elements @p{fe1} and @p{fe2}
+ * are either both continuous or
+ * both discontinuous then this
+ * interpolation is the usual point
+ * interpolation. The same is true
+ * if @p{fe1} is a continuous and
+ * @p{fe2} is a discontinuous finite
+ * element. For the case that @p{fe1}
+ * is a discontinuous and @p{fe2} is
+ * a continuous finite element
+ * there is no point interpolation
+ * defined at the discontinuities.
+ * Therefore the meanvalue is taken
+ * at the DoF values on the
+ * discontinuities.
+ */
+ template <int dim, typename number>
static void interpolate(const DoFHandler<dim> &dof1,
const Vector<number> &u1,
const DoFHandler<dim> &dof2,
Vector<number> &u2);
- /**
- * Gives the interpolation of the @p{fe1}-
- * function @p{u1} to a @p{fe2}-function, and
- * interpolates this to a second
- * @p{fe1}-function named @p{u1_interpolated}.
- *
- * Note, that this function only
- * makes sense if the finite element
- * space due to @p{fe1} is not a subset of
- * the finite element space due to
- * @p{fe2}, as if it were a subset then
- * @p{u1_interpolated} would be equal to @p{u1}.
- */
- template <int dim, typename number>
+ /**
+ * Gives the interpolation of the @p{fe1}-
+ * function @p{u1} to a @p{fe2}-function, and
+ * interpolates this to a second
+ * @p{fe1}-function named @p{u1_interpolated}.
+ *
+ * Note, that this function only
+ * makes sense if the finite element
+ * space due to @p{fe1} is not a subset of
+ * the finite element space due to
+ * @p{fe2}, as if it were a subset then
+ * @p{u1_interpolated} would be equal to @p{u1}.
+ */
+ template <int dim, typename number>
static void back_interpolate(const DoFHandler<dim> &dof1,
const Vector<number> &u1,
const FiniteElement<dim> &fe2,
Vector<number> &u1_interpolated);
- /**
- * Gives $(Id-I_h)z2$ for a given
- * @p{fe2}-function @p{z2}, where $I_h$
- * is the interpolation from @p{fe2}
- * to @p{fe1}. $(Id-I_h)z2$ is
- * denoted by @p{z2_difference}.
- */
- template <int dim, typename number>
+ /**
+ * Gives $(Id-I_h)z2$ for a given
+ * @p{fe2}-function @p{z2}, where $I_h$
+ * is the interpolation from @p{fe2}
+ * to @p{fe1}. $(Id-I_h)z2$ is
+ * denoted by @p{z2_difference}.
+ */
+ template <int dim, typename number>
static void interpolation_difference(const DoFHandler<dim> &dof1,
const Vector<number> &z1,
const FiniteElement<dim> &fe2,
Vector<number> &z1_difference);
- /**
- * Gives the patchwise
- * extrapolation of a @p{dof1}
- * function @p{z1} to a @p{dof2}
- * function @p{z2}. @p{dof1} and
- * @p{dof2} need to be @ref{DoFHandler}
- * based on the same triangulation.
- *
- * This function is interesting for
- * e.g. extrapolating patchwise a
- * piecewise linear dual solution
- * to a piecewise quadratic dual
- * solution.
- */
- template <int dim, typename number>
+ /**
+ * Gives the patchwise
+ * extrapolation of a @p{dof1}
+ * function @p{z1} to a @p{dof2}
+ * function @p{z2}. @p{dof1} and
+ * @p{dof2} need to be @ref{DoFHandler}
+ * based on the same triangulation.
+ *
+ * This function is interesting for
+ * e.g. extrapolating patchwise a
+ * piecewise linear dual solution
+ * to a piecewise quadratic dual
+ * solution.
+ */
+ template <int dim, typename number>
static void extrapolate(const DoFHandler<dim> &dof1,
const Vector<number> &z1,
const DoFHandler<dim> &dof2,
Vector<number> &z2);
- /**
- * Exception
- */
- DeclException0 (ExcTriangulationMismatch);
+ /**
+ * Exception
+ */
+ DeclException0 (ExcTriangulationMismatch);
- /**
- * Exception
- */
- DeclException4 (ExcMatrixDimensionMismatch,
- int, int, int, int,
- << "This is a " << arg1 << "x" << arg2 << " matrix, "
- << "but should be a " << arg1 << "x" << arg2 << " matrix.");
+ /**
+ * Exception
+ */
+ DeclException4 (ExcMatrixDimensionMismatch,
+ int, int, int, int,
+ << "This is a " << arg1 << "x" << arg2 << " matrix, "
+ << "but should be a " << arg1 << "x" << arg2 << " matrix.");
};
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
*/
template <class InputVector, typename number>
void get_function_values (const InputVector &fe_function,
- vector<number> &values) const;
+ std::vector<number> &values) const;
/**
* Access to vector valued finite
*/
template <class InputVector, typename number>
void get_function_values (const InputVector &fe_function,
- vector<Vector<number> > &values) const;
+ std::vector<Vector<number> > &values) const;
/**
* Return the gradient of the @p{i}th shape
* For the format of this matrix, see the
* documentation for the matrix itself.
*/
- const vector<vector<Tensor<1,dim> > > & get_shape_grads () const;
+ const std::vector<std::vector<Tensor<1,dim> > > & get_shape_grads () const;
/**
* Return the gradients of the finite
*/
template <class InputVector>
void get_function_grads (const InputVector &fe_function,
- vector<Tensor<1,dim> > &gradients) const;
+ std::vector<Tensor<1,dim> > &gradients) const;
/**
* Return the gradients of the finite
*/
template <class InputVector>
void get_function_grads (const InputVector &fe_function,
- vector<vector<Tensor<1,dim> > > &gradients) const;
+ std::vector<std::vector<Tensor<1,dim> > > &gradients) const;
/**
* Return the 2nd derivatives of
* documentation for the matrix
* itself.
*/
- const vector<vector<Tensor<2,dim> > > & get_shape_2nd_derivatives () const;
+ const std::vector<std::vector<Tensor<2,dim> > > & get_shape_2nd_derivatives () const;
/**
* Return the tensor of second
*/
template <class InputVector>
void get_function_2nd_derivatives (const InputVector &fe_function,
- vector<Tensor<2,dim> > &second_derivatives) const;
+ std::vector<Tensor<2,dim> > &second_derivatives) const;
/**
*/
template <class InputVector>
void get_function_2nd_derivatives (const InputVector &fe_function,
- vector<vector<Tensor<2,dim> > > &second_derivatives) const;
+ std::vector<std::vector<Tensor<2,dim> > > &second_derivatives) const;
/**
* Return the position of the @p{i}th
* Return a pointer to the vector of
* quadrature points.
*/
- const vector<Point<dim> > & get_quadrature_points () const;
+ const
std::vector<Point<dim> > & get_quadrature_points () const;
/**
* Return the point in real space where
* denoting the location of the trial
* functions.
*/
- const vector<Point<dim> > & get_support_points () const;
+ const
std::vector<Point<dim> > & get_support_points () const;
/**
* Return the Jacobi determinant times
* quadrature weight at the different
* quadrature points.
*/
- const vector<double> & get_JxW_values () const;
+ const std::vector<double> & get_JxW_values () const;
/**
* Return a constant reference to the
* is determined by the @p{selected_dataset}
* variable.
*/
- vector<FullMatrix<double> > shape_values;
+ std::vector<FullMatrix<double> > shape_values;
/**
* Store the gradients of the shape
* gradients on the real element, rather
* than on the reference element.
*/
- vector<vector<Tensor<1,dim> > > shape_gradients;
+ std::vector<std::vector<Tensor<1,dim> > > shape_gradients;
/**
* Store the 2nd derivatives of the shape
* gradients on the real element, rather
* than on the reference element.
*/
- vector<vector<Tensor<2,dim> > > shape_2nd_derivatives;
+ std::vector<std::vector<Tensor<2,dim> > > shape_2nd_derivatives;
/**
* Store an array of the weights of the
* not transformed and are thus the same
* for all faces.
*/
- vector<double> weights;
+ std::vector<double> weights;
/**
* Store an array of weights times the
* see the general documentation of this
* class for more information.
*/
- vector<double> JxW_values;
+ std::vector<double> JxW_values;
/**
* Array of quadrature points. This array
* real element, rather than on the
* reference element.
*/
- vector<Point<dim> > quadrature_points;
+
std::vector<Point<dim> > quadrature_points;
/**
* Array of points denoting the off-point
* on the unit cell, so no function is
* provided for this).
*/
- vector<Point<dim> > support_points;
+
std::vector<Point<dim> > support_points;
/**
* Store the jacobi matrices at the
* transformation of the gradients to the
* real cell.
*/
- vector<Tensor<2,dim> > jacobi_matrices;
+ std::vector<Tensor<2,dim> > jacobi_matrices;
/**
* Store the derivatives of the jacobi
* The same general remarks apply as for
* @p{jacobi_matrices}.
*/
- vector<Tensor<3,dim> > jacobi_matrices_grad;
+ std::vector<Tensor<3,dim> > jacobi_matrices_grad;
/**
* Store the values of the basis functions
* of the @p{i}th transfer basis function
* at the @p{j}th quadrature point.
*/
- vector<FullMatrix<double> > shape_values_transform;
+ std::vector<FullMatrix<double> > shape_values_transform;
/**
* Store which of the data sets in the
* of the object and contains the gradients
* on the reference element.
*/
- vector<vector<Tensor<1,dim> > > unit_shape_gradients;
+ std::vector<std::vector<Tensor<1,dim> > > unit_shape_gradients;
/**
* Store the 2nd derivatives of the shape
* of the object and contains the
* derivatives on the reference element.
*/
- vector<vector<Tensor<2,dim> > > unit_shape_2nd_derivatives;
+ std::vector<std::vector<Tensor<2,dim> > > unit_shape_2nd_derivatives;
/**
* Gradients of the basis
* Analogous to the @p{shape_values_transform}
* array of the base class.
*/
- vector<vector<Tensor<1,dim> > > unit_shape_gradients_transform;
+ std::vector<std::vector<Tensor<1,dim> > > unit_shape_gradients_transform;
/**
* Array of quadrature points in the unit
* construction and contains the quadrature
* points on the reference element.
*/
- vector<Point<dim> > unit_quadrature_points;
+
std::vector<Point<dim> > unit_quadrature_points;
};
* vectors to the cell at the
* quadrature points.
*/
- const vector<Point<dim> > & get_normal_vectors () const;
+ const
std::vector<Point<dim> > & get_normal_vectors () const;
/**
* Return the present
* subface, with indices like that:
* @p{unit_shape_gradients[face][dof][q_point]}
*/
- vector<vector<vector<Tensor<1,dim> > > > unit_shape_gradients;
+ std::vector<std::vector<std::vector<Tensor<1,dim> > > > unit_shape_gradients;
/**
* Store the 2nd derivatives of the shape
* of the object and contains the
* derivatives on the reference element.
*/
- vector<vector<vector<Tensor<2,dim> > > > unit_shape_2nd_derivatives;
+ std::vector<std::vector<std::vector<Tensor<2,dim> > > > unit_shape_2nd_derivatives;
/**
* Gradients of the basis
* Analogous to the @p{shape_values_transform}
* array of the base class.
*/
- vector<vector<vector<Tensor<1,dim> > > > unit_shape_gradients_transform;
+ std::vector<std::vector<std::vector<Tensor<1,dim> > > > unit_shape_gradients_transform;
/**
* Array of quadrature points on the
* alike field of the quadrature formula
* passed upon construction.
*/
- vector<Point<dim-1> > unit_face_quadrature_points;
+
std::vector<Point<dim-1> > unit_face_quadrature_points;
/**
* Array of quadrature points in the unit
* those on the unit face, but are stored
* as coordinates on the unit cell.
*/
-
vector<vector<Point<dim> > > unit_quadrature_points;
+
std::vector<std::vector<Point<dim> > > unit_quadrature_points;
/**
* List of values denoting the determinant
* to the real face or subface. Needed to
* actually compute the JxW values.
*/
- vector<double> face_jacobi_determinants;
+ std::vector<double> face_jacobi_determinants;
/**
* List of outward normal vectors at the
* quadrature points. This field is filled
* in by the finite element class.
*/
- vector<Point<dim> > normal_vectors;
+
std::vector<Point<dim> > normal_vectors;
/**
* Stores the face or subface,
template <int dim>
inline
-const vector<vector<Tensor<1,dim> > > &
+const std::vector<std::vector<Tensor<1,dim> > > &
FEValuesBase<dim>::get_shape_grads () const
{
Assert (update_flags & update_gradients, ExcAccessToUninitializedField());
template <int dim>
inline
-const vector<vector<Tensor<2,dim> > > &
+const std::vector<std::vector<Tensor<2,dim> > > &
FEValuesBase<dim>::get_shape_2nd_derivatives () const
{
Assert (update_flags & update_second_derivatives, ExcAccessToUninitializedField());
template <int dim>
inline
-const vector<Point<dim> > &
+const
std::vector<Point<dim> > &
FEValuesBase<dim>::get_quadrature_points () const
{
Assert (update_flags & update_q_points, ExcAccessToUninitializedField());
template <int dim>
inline
-const vector<Point<dim> > &
+const
std::vector<Point<dim> > &
FEValuesBase<dim>::get_support_points () const
{
Assert (update_flags & update_support_points, ExcAccessToUninitializedField());
template <int dim>
inline
-const vector<double> &
+const std::vector<double> &
FEValuesBase<dim>::get_JxW_values () const
{
Assert (update_flags & update_JxW_values, ExcAccessToUninitializedField());
template <int dim>
inline
-const vector<Point<dim> > &
+const
std::vector<Point<dim> > &
FEFaceValuesBase<dim>::get_normal_vectors () const
{
Assert (update_flags & update_normal_vectors,
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
const unsigned int dofs_per_quad,
const unsigned int dofs_per_hex,
const unsigned int n_components,
- const vector<bool> &restriction_is_additive_flags);
+ const std::vector<bool> &restriction_is_additive_flags);
/**
* Transforms the point @p{p} on
* simply returns the length of the face.
*/
virtual void get_face_jacobians (const DoFHandler<dim>::face_iterator &face,
- const vector<Point<dim-1> > &unit_points,
- vector<double> &face_jacobi_determinants) const;
+ const
std::vector<Point<dim-1> > &unit_points,
+ std::vector<double> &face_jacobi_determinants) const;
/**
* Refer to the base class for detailed
*/
virtual void get_subface_jacobians (const DoFHandler<dim>::face_iterator &face,
const unsigned int subface_no,
- const vector<Point<dim-1> > &unit_points,
- vector<double> &face_jacobi_determinants) const;
+ const
std::vector<Point<dim-1> > &unit_points,
+ std::vector<double> &face_jacobi_determinants) const;
/**
* Return the normal vectors to the
*/
virtual void get_normal_vectors (const DoFHandler<dim>::cell_iterator &cell,
const unsigned int face_no,
- const vector<Point<dim-1> > &unit_points,
- vector<Point<dim> > &normal_vectors) const;
+ const
std::vector<Point<dim-1> > &unit_points,
+
std::vector<Point<dim> > &normal_vectors) const;
/**
* Return the normal vectors to the
virtual void get_normal_vectors (const DoFHandler<dim>::cell_iterator &cell,
const unsigned int face_no,
const unsigned int subface_no,
- const vector<Point<dim-1> > &unit_points,
- vector<Point<dim> > &normal_vectors) const;
+ const
std::vector<Point<dim-1> > &unit_points,
+
std::vector<Point<dim> > &normal_vectors) const;
/**
* Refer to the base class for detailed
* we use multilinear mappings.
*/
virtual void fill_fe_values (const DoFHandler<dim>::cell_iterator &cell,
- const vector<Point<dim> > &unit_points,
- vector<Tensor<2,dim> > &jacobians,
+ const
std::vector<Point<dim> > &unit_points,
+ std::vector<Tensor<2,dim> > &jacobians,
const bool compute_jacobians,
- vector<Tensor<3,dim> > &jacobians_grad,
+ std::vector<Tensor<3,dim> > &jacobians_grad,
const bool compute_jacobians_grad,
- vector<Point<dim> > &support_points,
+
std::vector<Point<dim> > &support_points,
const bool compute_support_points,
- vector<Point<dim> > &q_points,
+
std::vector<Point<dim> > &q_points,
const bool compute_q_points,
const FullMatrix<double> &shape_values_transform,
- const vector<vector<Tensor<1,dim> > > &shape_grad_transform) const;
+ const std::vector<std::vector<Tensor<1,dim> > > &shape_grad_transform) const;
/**
* Compute the gradients of the jacobian
* points on the unit cell.
*/
static void compute_jacobian_gradients (const DoFHandler<dim>::cell_iterator &cell,
- const vector<Point<dim> > &unit_points,
- vector<Tensor<3,dim> > &jacobians);
+ const
std::vector<Point<dim> > &unit_points,
+ std::vector<Tensor<3,dim> > &jacobians);
/**
-forward_declarations.h
+ forward_declarations.h
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
struct GeometryInfo
{
/**
- * Present dimension. Does not look useful, but might be.
+ * Present dimension. Does not
+ * look useful, but might be.
*/
static const unsigned int dim = _dim;
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* Read grid data from an ucd file.
* Numerical data is ignored.
*/
- void read_ucd (istream &);
+ void read_ucd (std::istream &);
/**
* Read grid data from a file
* containing data in the DB mesh
* format.
*/
- void read_dbmesh (istream &);
+ void read_dbmesh (std::istream &);
/**
* Exception
*/
DeclException1 (ExcUnknownIdentifier,
- string,
+ std::string,
<< "The identifier <" << arg1 << "> as name of a "
<< "part in an UCD input file is unknown or the "
<< "respective input routine is not implemented.");
* Exception
*/
DeclException1 (ExcInvalidDBMESHInput,
- string,
+ std::string,
<< "The string <" << arg1 << "> is not recognized at the present"
<< " position of a DB Mesh file.");
* contain either nothing or only
* whitespace.
*/
- static void skip_empty_lines (istream &in);
+ static void skip_empty_lines (std::istream &in);
/**
* Skip lines of comment that
* there were no lines of
* comments.
*/
- static void skip_comment_lines (istream &in,
+ static void skip_comment_lines (std::istream &in,
const char comment_start);
/**
* have to eliminate unused
* vertices beforehand.
*/
- static void delete_unused_vertices (vector<Point<dim> > &vertices,
- vector<CellData<dim> > &cells,
- SubCellData &subcelldata);
+ static void delete_unused_vertices (
std::vector<Point<dim> > &vertices,
+ std::vector<CellData<dim> > &cells,
+ SubCellData &subcelldata);
/**
* This function can write the
* without further ado by the
* user.
*/
- static void debug_output_grid (const vector<CellData<dim> > &cells,
- const vector<Point<dim> > &vertices,
- ostream &out);
+ static void debug_output_grid (const std::vector<CellData<dim> > &cells,
+ const
std::vector<Point<dim> > &vertices,
+ std::ostream &out);
};
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
*/
template <int dim>
void write_gnuplot (const Triangulation<dim> &tria,
- ostream &out);
+ std::ostream &out);
/**
* Write the triangulation in the
*/
template <int dim>
void write_ucd (const Triangulation<dim> &tria,
- ostream &out);
+ std::ostream &out);
/**
* Write the triangulation in the
*/
template <int dim>
void write_eps (const Triangulation<dim> &tria,
- ostream &out);
+ std::ostream &out);
/**
* Write data and grid to @p{out} according
*/
template <int dim>
void write (const Triangulation<dim> &tria,
- ostream &out,
+ std::ostream &out,
const OutputFormat output_format);
/**
* thus be called without creating an
* object of this class.
*/
- static string default_suffix (const OutputFormat output_format);
+ static std::string default_suffix (const OutputFormat output_format);
/**
* Return the @p{OutputFormat} value
* @ref{ParameterHandler} class, use the
* function @p{get_output_format_names ()}.
*/
- static OutputFormat parse_output_format (const string &format_name);
+ static OutputFormat parse_output_format (const std::string &format_name);
/**
* Return a list of implemented output
* as used by the @ref{ParameterHandler}
* classes.
*/
- static string get_output_format_names ();
+ static std::string get_output_format_names ();
/**
* Determine an estimate for the
template <int dim>
void write_ucd_faces (const Triangulation<dim> &tria,
const unsigned int starting_index,
- ostream &out) const;
+ std::ostream &out) const;
/**
* Return the number of faces in the
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#define __deal2__grid_refinement_h
-#include<lac/vector.h>
-#include<vector>
+#include <lac/vector.h>
+#include <vector>
// forward declarations
template <int dim> class Triangulation;
* @p{refine_and_coarsen_optimize}
*/
template<typename number>
- static void qsort_index(const Vector<number> &a,
- vector<unsigned int> &ind,
- int l,
- int r);
+ static void qsort_index(const Vector<number> &a,
+ std::vector<unsigned int> &ind,
+ int l,
+ int r);
};
// $Id$
// Version: $Name$
//
-// Copyright (C) 2000 by the deal.II authors
+// Copyright (C) 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* general documentation of this
* class.
*/
- static void reorder_cells (vector<CellData<dim> > &original_cells);
+ static void reorder_cells (std::vector<CellData<dim> > &original_cells);
private:
* the @p{stack} adaptor from
* STL.
*/
- typedef vector<unsigned int> RotationStack;
+ typedef std::vector<unsigned int> RotationStack;
/**
* Class that describes the
* each orientation of the
* cell.
*/
- typename map<Face,FaceData>::iterator
+ typename std::map<Face,FaceData>::iterator
faces[GridReorderingInfo<dim>::rotational_states_of_cells][GeometryInfo<dim>::faces_per_cell];
/**
* @p{adjacent_cells} field
* of the inserted faces.
*/
- void insert_faces (map<Face,FaceData > &global_faces);
+ void insert_faces (std::map<Face,FaceData > &global_faces);
/**
* Find out the neighbors of the
* important for the
* algorithm.
*/
- typename map<Face,FaceData >::const_iterator
+ typename std::map<Face,FaceData >::const_iterator
reverse_faces[GridReorderingInfo<dim>::rotational_states_of_faces-1];
/**
* as recursive calls but rather
* as eliminated tail-recursion.
*/
- static void track_back (vector<Cell> &cells,
- RotationStack &rotation_states,
- unsigned int track_back_to_cell);
+ static void track_back (std::vector<Cell> &cells,
+ RotationStack &rotation_states,
+ const unsigned int track_back_to_cell);
- static bool try_rotate_single_neighbors (vector<Cell> &cells,
- RotationStack &rotation_states);
+ static bool try_rotate_single_neighbors (std::vector<Cell> &cells,
+ RotationStack &rotation_states);
/**
* This is the main function that
* between original cells and
* presorted cells.
*/
- static void find_reordering (vector<Cell> &cells,
- vector<CellData<dim> > &original_cells,
- const vector<unsigned int> &new_cell_numbers);
+ static void find_reordering (std::vector<Cell> &cells,
+ std::vector<CellData<dim> > &original_cells,
+ const std::vector<unsigned int> &new_cell_numbers);
/**
* Preorder the incoming cells by
* stored.
*/
static
- vector<unsigned int>
- presort_cells (vector<Cell> &cells,
- map<Face,FaceData> &faces);
+ std::vector<unsigned int>
+ presort_cells (std::vector<Cell> &cells,
+ std::map<Face,FaceData> &faces);
};
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* The actual data. Hold one iterator
* for each cell on each level.
*/
- vector<vector<cell_iterator> > mapping;
+ std::vector<std::vector<cell_iterator> > mapping;
/**
* Store a pointer to the source grid.
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* is not useful in the context of this
* class.
*/
- virtual void create_triangulation (const vector<Point<dim> > &vertices,
- const vector<CellData<dim> > &cells,
- const SubCellData &subcelldata);
+ virtual void create_triangulation (const
std::vector<Point<dim> > &vertices,
+ const std::vector<CellData<dim> > &cells,
+ const SubCellData &subcelldata);
/**
* Writes all refine and coarsen
* flags to the ostream @p{out}.
*/
- virtual void write_flags(ostream &out) const;
+ virtual void write_flags(std::ostream &out) const;
/**
* Reads all refine and coarsen flags
* after the end or breakdown of a program
* and its restart.
*/
- virtual void read_flags(istream &in);
+ virtual void read_flags(std::istream &in);
/**
* Determine an estimate for the
* vectors therefore hold the history
* of the grid.
*/
- vector<vector<bool> > refine_flags;
+ std::vector<std::vector<bool> > refine_flags;
/**
* @see refine_flags
*/
- vector<vector<bool> > coarsen_flags;
+ std::vector<std::vector<bool> > coarsen_flags;
};
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* a line on the boundary and its boundary
* indicator.
*/
- vector<CellData<1> > boundary_lines;
+ std::vector<CellData<1> > boundary_lines;
/**
* Each record of this vector describes
* a quad on the boundary and its boundary
* indicator.
*/
- vector<CellData<2> > boundary_quads;
+ std::vector<CellData<2> > boundary_quads;
/**
* This function checks whether the vectors
* Array holding the number of used
* lines on each level.
*/
- vector<unsigned int> n_lines_level;
+ std::vector<unsigned int> n_lines_level;
/**
* Number of active lines in the
* Array holding the number of active
* lines on each level.
*/
- vector<unsigned int> n_active_lines_level;
+ std::vector<unsigned int> n_active_lines_level;
/**
* Constructor. Set values to zero
* Array holding the number of used
* quads on each level.
*/
- vector<unsigned int> n_quads_level;
+ std::vector<unsigned int> n_quads_level;
/**
* Number of active quads in the
* Array holding the number of active
* quads on each level.
*/
- vector<unsigned int> n_active_quads_level;
+ std::vector<unsigned int> n_active_quads_level;
/**
* Constructor. Set values to zero
* Array holding the number of used
* hexes on each level.
*/
- vector<unsigned int> n_hexes_level;
+ std::vector<unsigned int> n_hexes_level;
/**
* Number of active hexes in the
* Array holding the number of active
* hexes on each level.
*/
- vector<unsigned int> n_active_hexes_level;
+ std::vector<unsigned int> n_active_hexes_level;
/**
* Constructor. Set values to zero
* and the @ref{GridIn} and
* @ref{GridReordering} class.
*/
- virtual void create_triangulation (const vector<Point<dim> > &vertices,
- const vector<CellData<dim> > &cells,
- const SubCellData &subcelldata);
+ virtual void create_triangulation (const
std::vector<Point<dim> > &vertices,
+ const std::vector<CellData<dim> > &cells,
+ const SubCellData &subcelldata);
/**
* Distort the grid by randomly
* usage, read the general
* documentation for this class.
*/
- void save_refine_flags (ostream &out) const;
+ void save_refine_flags (std::ostream &out) const;
/**
* Same as above, but store the flags to
* a bitvector rather than to a file.
*/
- void save_refine_flags (vector<bool> &v) const;
+ void save_refine_flags (std::vector<bool> &v) const;
/**
* Read the information stored by
* @p{save_refine_flags}.
*/
- void load_refine_flags (istream &in);
+ void load_refine_flags (std::istream &in);
/**
* Read the information stored by
* @p{save_refine_flags}.
*/
- void load_refine_flags (const vector<bool> &v);
+ void load_refine_flags (const std::vector<bool> &v);
/**
* Analogue to @p{save_refine_flags}.
*/
- void save_coarsen_flags (ostream &out) const;
+ void save_coarsen_flags (std::ostream &out) const;
/**
* Same as above, but store the flags to
* a bitvector rather than to a file.
*/
- void save_coarsen_flags (vector<bool> &v) const;
+ void save_coarsen_flags (std::vector<bool> &v) const;
/**
* Analogue to @p{load_refine_flags}.
*/
- void load_coarsen_flags (istream &out);
+ void load_coarsen_flags (std::istream &out);
/**
* Analogue to @p{load_refine_flags}.
*/
- void load_coarsen_flags (const vector<bool> &v);
+ void load_coarsen_flags (const std::vector<bool> &v);
/*@}*/
* @p{save_refine_flags} for more
* details.
*/
- void save_user_flags (ostream &out) const;
+ void save_user_flags (std::ostream &out) const;
/**
* Same as above, but store the flags to
* The output vector is resized if
* necessary.
*/
- void save_user_flags (vector<bool> &v) const;
+ void save_user_flags (std::vector<bool> &v) const;
/**
* Read the information stored by
* @p{save_user_flags}.
*/
- void load_user_flags (istream &in);
+ void load_user_flags (std::istream &in);
/**
* Read the information stored by
* @p{save_user_flags}.
*/
- void load_user_flags (const vector<bool> &v);
+ void load_user_flags (const std::vector<bool> &v);
/**
* Save the user flags on lines.
*/
- void save_user_flags_line (ostream &out) const;
+ void save_user_flags_line (std::ostream &out) const;
/**
* Same as above, but store the flags to
* The output vector is resized if
* necessary.
*/
- void save_user_flags_line (vector<bool> &v) const;
+ void save_user_flags_line (std::vector<bool> &v) const;
/**
* Load the user flags located on lines.
*/
- void load_user_flags_line (istream &in);
+ void load_user_flags_line (std::istream &in);
/**
* Load the user flags located on lines.
*/
- void load_user_flags_line (const vector<bool> &v);
+ void load_user_flags_line (const std::vector<bool> &v);
/**
* Save the user flags on quads.
*/
- void save_user_flags_quad (ostream &out) const;
+ void save_user_flags_quad (std::ostream &out) const;
/**
* Same as above, but store the flags to
* The output vector is resized if
* necessary.
*/
- void save_user_flags_quad (vector<bool> &v) const;
+ void save_user_flags_quad (std::vector<bool> &v) const;
/**
* Load the user flags located on quads.
*/
- void load_user_flags_quad (istream &in);
+ void load_user_flags_quad (std::istream &in);
/**
* Load the user flags located on quads.
*/
- void load_user_flags_quad (const vector<bool> &v);
+ void load_user_flags_quad (const std::vector<bool> &v);
/**
* Save the user flags on hexs.
*/
- void save_user_flags_hex (ostream &out) const;
+ void save_user_flags_hex (std::ostream &out) const;
/**
* Same as above, but store the flags to
* The output vector is resized if
* necessary.
*/
- void save_user_flags_hex (vector<bool> &v) const;
+ void save_user_flags_hex (std::vector<bool> &v) const;
/**
* Load the user flags located on hexs.
*/
- void load_user_flags_hex (istream &in);
+ void load_user_flags_hex (std::istream &in);
/**
* Load the user flags located on hexs.
*/
- void load_user_flags_hex (const vector<bool> &v);
+ void load_user_flags_hex (const std::vector<bool> &v);
/*@}*/
/* ------------------------------------ */
* as well. The format should therefore be
* interplatform compatible.
*/
- static void write_bool_vector (const unsigned int magic_number1,
- const vector<bool> &v,
- const unsigned int magic_number2,
- ostream &out);
+ static void write_bool_vector (const unsigned int magic_number1,
+ const std::vector<bool> &v,
+ const unsigned int magic_number2,
+ std::ostream &out);
/**
* Re-read a vector of bools previously
* written by @p{write_bool_vector} and
* compare with the magic numbers.
*/
- static void read_bool_vector (const unsigned int magic_number1,
- vector<bool> &v,
- const unsigned int magic_number2,
- istream &in);
+ static void read_bool_vector (const unsigned int magic_number1,
+ std::vector<bool> &v,
+ const unsigned int magic_number2,
+ std::istream &in);
private:
/**
*
* Usage is like @p{levels[3]->quads}.
*/
- vector<TriangulationLevel<dim>*> levels;
+ std::vector<TriangulationLevel<dim>*> levels;
/**
* Array of the vertices of this
* triangulation.
*/
- vector<Point<dim> > vertices;
+
std::vector<Point<dim> > vertices;
/**
* Array storing a bit-pattern which
* vertices are used.
*/
- vector<bool> vertices_used;
+ std::vector<bool> vertices_used;
/**
* Collection of boundary
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* accessor is constructed.
*/
TriaObjectAccessor (Triangulation<dim> *parent = 0,
- const int level = -1,
- const int index = -1,
- const AccessorData *local_data = 0) :
+ const int level = -1,
+ const int index = -1,
+ const AccessorData *local_data = 0) :
TriaAccessor<dim> (parent, level, index, local_data) {};
/**
* Constructor.
*/
TriaObjectAccessor (Triangulation<dim> *parent = 0,
- const int level = -1,
- const int index = -1,
- const AccessorData *local_data = 0) :
+ const int level = -1,
+ const int index = -1,
+ const AccessorData *local_data = 0) :
TriaAccessor<dim> (parent, level, index, local_data) {};
/**
* Constructor.
*/
TriaObjectAccessor (Triangulation<dim> *parent = 0,
- const int level = -1,
- const int index = -1,
- const AccessorData *local_data = 0) :
+ const int level = -1,
+ const int index = -1,
+ const AccessorData *local_data = 0) :
TriaAccessor<dim> (parent, level, index, local_data) {};
/**
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
const unsigned int depths[2] = { child(0)->max_refinement_depth() + 1,
child(1)->max_refinement_depth() + 1 };
- return max (depths[0], depths[1]);
+ return std::max (depths[0], depths[1]);
};
child(1)->max_refinement_depth() + 1,
child(2)->max_refinement_depth() + 1,
child(3)->max_refinement_depth() + 1 };
- return max (max (depths[0], depths[1]),
- max (depths[2], depths[3]));
+ return std::max (std::max (depths[0], depths[1]),
+ std::max (depths[2], depths[3]));
};
child(5)->max_refinement_depth() + 1,
child(6)->max_refinement_depth() + 1,
child(7)->max_refinement_depth() + 1 };
- return max (max (max (depths[0], depths[1]),
- max (depths[2], depths[3])),
- max (max (depths[4], depths[5]),
- max (depths[6], depths[7])));
+ return std::max (std::max (std::max (depths[0], depths[1]),
+ std::max (depths[2], depths[3])),
+ std::max (std::max (depths[4], depths[5]),
+ std::max (depths[6], depths[7])));
};
return quad(0)->line(i);
else
if (i<8)
- return quad(1)->line(i-4);
+ return quad(1)->line(i-4);
else
switch (i)
{
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* @author Wolfgang Bangerth, 1998
*/
template <int dim, typename Accessor>
-class TriaRawIterator : public bidirectional_iterator<Accessor,int>
+class TriaRawIterator : public
std::bidirectional_iterator<Accessor,int>
{
public:
/**
* Print the iterator to @p{out}. The
* format is like @p{level.index}.
*/
- void print (ostream &out) const;
+ void print (std::ostream &out) const;
/**
template <int dim, typename Accessor>
inline
void
-TriaRawIterator<dim,Accessor>::print (ostream &out) const
+TriaRawIterator<dim,Accessor>::print (std::ostream &out) const
{
out << accessor.level() << "." << accessor.index();
};
*/
template <int dim, typename Accessor>
inline
-ostream & operator << (ostream &out, const TriaRawIterator<dim,Accessor> &i)
+std::ostream & operator << (std::ostream &out,
+ const TriaRawIterator<dim,Accessor> &i)
{
i.print(out);
return out;
*/
template <int dim, typename Accessor>
inline
-ostream & operator << (ostream &out, const TriaIterator<dim,Accessor> &i)
+std::ostream & operator << (std::ostream &out,
+ const TriaIterator<dim,Accessor> &i)
{
i.print(out);
return out;
*/
template <int dim, typename Accessor>
inline
-ostream & operator << (ostream &out, const TriaActiveIterator<dim,Accessor> &i)
+std::ostream & operator << (std::ostream &out,
+ const TriaActiveIterator<dim,Accessor> &i)
{
i.print(out);
return out;
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* @p{lines} vector, in two dimensions
* that of the @p{quads} vector, etc.
*/
- vector<bool> refine_flags;
+ std::vector<bool> refine_flags;
/**
* Same meaning as the one above, but
* specifies whether a cell must be
* coarsened.
*/
- vector<bool> coarsen_flags;
+ std::vector<bool> coarsen_flags;
/**
* Levels and indices of the neighbors
* which case its neighbor pointer points
* to the mother cell of this cell).
*/
- vector<pair<int,int> > neighbors;
+ std::vector<std::pair<int,int> > neighbors;
/**
* Reserve enough space to accomodate
* index of a line is stored in the
* line itself.
*/
- vector<Line> lines;
+ std::vector<Line> lines;
/**
* Index of the first child of a line
* in the list on the next level.
* @ref{TriaIterator}@p{::active()}
* tests for this.
*/
- vector<int> children;
+ std::vector<int> children;
/**
* Vector storing whether a line is
* rather the according @p{used} flag
* is set to @p{false}.
*/
- vector<bool> used;
+ std::vector<bool> used;
/**
* Make available a field for user data,
* You can clear all used flags using
* @ref{Triangulation}@p{::clear_user_flags()}.
*/
- vector<bool> user_flags;
+ std::vector<bool> user_flags;
/**
* Store boundary and material data. In
* is not possible if you don't know
* which cell it belongs to.
*/
- vector<unsigned char> material_id;
+ std::vector<unsigned char> material_id;
/**
* Pointer which is not used by the
* by the user to handle data local to
* a line/quad/etc.
*/
- vector<void*> user_pointers;
+ std::vector<void*> user_pointers;
};
public:
/**
* Same as for the @p{lines} array.
*/
- vector<Quad> quads;
+ std::vector<Quad> quads;
/**
* Same as for the
* @ref{TriangulationLevel<1>::LinesData}@p{::chilren}
* following immediately
* afterwards.
*/
- vector<int> children;
+ std::vector<int> children;
/**
* Same as for
* @ref{TriangulationLevel<1>::LinesData}@p{::used}.
*/
- vector<bool> used;
+ std::vector<bool> used;
/**
* Same as for
* @ref{TriangulationLevel<1>::LinesData}@p{::used}.
*/
- vector<bool> user_flags;
+ std::vector<bool> user_flags;
/**
* Store boundary and material data. In
* is not possible if you don't know
* which cell it belongs to.
*/
- vector<unsigned char> material_id;
+ std::vector<unsigned char> material_id;
/**
* by the user to handle data local to
* a line/quad/etc.
*/
- vector<void*> user_pointers;
+ std::vector<void*> user_pointers;
};
public:
/**
* Same as for the @p{lines} array.
*/
- vector<Hexahedron> hexes;
+ std::vector<Hexahedron> hexes;
/**
* Same as for the
* @ref{TriangulationLevel<1>::LinesData}@p{::chilren}
* following immediately
* afterwards.
*/
- vector<int> children;
+ std::vector<int> children;
/**
* Same as for
* @ref{TriangulationLevel<1>::LinesData}@p{::used}.
*/
- vector<bool> used;
+ std::vector<bool> used;
/**
* Same as for
* @ref{TriangulationLevel<1>::LinesData}@p{::used}.
*/
- vector<bool> user_flags;
+ std::vector<bool> user_flags;
/**
* Store boundary and material data. In
* is not possible if you don't know
* which cell it belongs to.
*/
- vector<unsigned char> material_id;
+ std::vector<unsigned char> material_id;
/**
* by the user to handle data local to
* a line/quad/etc.
*/
- vector<void*> user_pointers;
+ std::vector<void*> user_pointers;
};
public:
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
/**
* Global indices of the two end points.
*/
- int end_points[2];
+ int end_points[2];
};
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
<< "Indices for the line number must be 0, 1, 2 or 3, "
<< "but you gave " << arg1);
protected:
- int lines[4];
+ int lines[4];
};
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* is created empty.
*/
MGLevelObject (const unsigned int minlevel = 0,
- const unsigned int maxlevel = 0);
+ const unsigned int maxlevel = 0);
/**
* Access object on level @p{level}.
* @p{Object==Vector<T>}, @p{clear}
* will set all entries to zero,
* while if
- * @p{Object==std::vector<T>},
+ * @p{Object==vector<T>},
* @p{clear} deletes the elements
* of the vectors. This class
* might therefore not be useful
/**
* Array of the objects to be held.
*/
- vector<Object> objects;
+ std::vector<Object> objects;
};
void
MGLevelObject<Object>::clear ()
{
- typename vector<Object>::iterator v;
+ typename std::vector<Object>::iterator v;
for (v = objects.begin(); v != objects.end(); ++v)
v->clear();
};
template<class SOLVER, class MATRIX, class PRECOND>
MGCoarseGridLACIteration<SOLVER,MATRIX,PRECOND>::MGCoarseGridLACIteration(SOLVER &s,
- const MATRIX &m,
- const PRECOND &p)
+ const MATRIX &m,
+ const PRECOND &p)
:
solver(s),
matrix(&m),
template<class SOLVER, class MATRIX, class PRECOND>
void
MGCoarseGridLACIteration<SOLVER,MATRIX,PRECOND>::operator() (const unsigned int /* level */,
- Vector<double> &dst,
- const Vector<double> &src) const
+ Vector<double> &dst,
+ const Vector<double> &src) const
{
solver.solve(*matrix, dst, src, precondition);
}
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* indices refer to the local numbering
* for the level this line lives on.
*/
- void get_mg_dof_indices (vector<unsigned int> &dof_indices) const;
+ void get_mg_dof_indices (std::vector<unsigned int> &dof_indices) const;
/**
* Return the value of the given vector
* to a @ref{DoFHandler} object.
*/
MGDoFObjectAccessor (Triangulation<dim> *tria,
- const int level,
- const int index,
- const AccessorData *local_data);
+ const int level,
+ const int index,
+ const AccessorData *local_data);
/**
* Return the index of the @p{i}th degree
* indices refer to the local numbering
* for the level this quad lives on.
*/
- void get_mg_dof_indices (vector<unsigned int> &dof_indices) const;
+ void get_mg_dof_indices (std::vector<unsigned int> &dof_indices) const;
/**
* Return the value of the given vector
* to a @ref{DoFHandler} object.
*/
MGDoFObjectAccessor (Triangulation<dim> *tria,
- const int level,
- const int index,
- const AccessorData *local_data);
+ const int level,
+ const int index,
+ const AccessorData *local_data);
/**
* Return the index of the @p{i}th degree
* indices refer to the local numbering
* for the level this hex lives on.
*/
- void get_mg_dof_indices (vector<unsigned int> &dof_indices) const;
+ void get_mg_dof_indices (std::vector<unsigned int> &dof_indices) const;
/**
* Return the value of the given vector
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* indices after renumbering in the
* order of the old indices.
*/
- void renumber_dofs (const unsigned int level,
- const vector<unsigned int> &new_numbers);
+ void renumber_dofs (const unsigned int level,
+ const std::vector<unsigned int> &new_numbers);
/*--------------------------------------*/
/**
- * Return an iterator pointing to the
- * last line, used or not.
- */
+ * Return an iterator pointing to the
+ * last line, used or not.
+ */
raw_line_iterator last_raw_line () const;
/**
/**
- * Return an iterator pointing to the
- * last quad, used or not.
- */
+ * Return an iterator pointing to the
+ * last quad, used or not.
+ */
raw_quad_iterator last_raw_quad () const;
/**
/**
- * Return an iterator pointing to the
- * last hex, used or not.
- */
+ * Return an iterator pointing to the
+ * last hex, used or not.
+ */
raw_hex_iterator last_raw_hex () const;
/**
/**
- * Distribute dofs on the given cell,
- * with new dofs starting with index
- * @p{next_free_dof}. Return the next
- * unused index number. The finite
- * element used is the one given to
- * @p{distribute_dofs}, which is copied
- * to @p{selected_fe}.
- *
- * This function is excluded from the
- * @p{distribute_dofs} function since
- * it can not be implemented dimension
- * independent.
- *
- * Note that unlike for the usual dofs,
- * here all cells and not only active
- * ones are allowed.
- */
+ * Distribute dofs on the given cell,
+ * with new dofs starting with index
+ * @p{next_free_dof}. Return the next
+ * unused index number. The finite
+ * element used is the one given to
+ * @p{distribute_dofs}, which is copied
+ * to @p{selected_fe}.
+ *
+ * This function is excluded from the
+ * @p{distribute_dofs} function since
+ * it can not be implemented dimension
+ * independent.
+ *
+ * Note that unlike for the usual dofs,
+ * here all cells and not only active
+ * ones are allowed.
+ */
unsigned int distribute_dofs_on_cell (cell_iterator &cell,
unsigned int next_free_dof);
* numbers which start from zero on each
* level.
*/
- vector<DoFLevel<dim>*> mg_levels;
+ std::vector<DoFLevel<dim>*> mg_levels;
/**
* For each vertex there is a list of
* on the different levels it lives on and
* which are these levels.
*/
- vector<MGVertexDoFs> mg_vertex_dofs;
+ std::vector<MGVertexDoFs> mg_vertex_dofs;
/**
* Vectors storing the number of degrees of
* freedom on each level.
*/
- vector<unsigned int> mg_used_dofs;
+ std::vector<unsigned int> mg_used_dofs;
#if (__GNUC__==2) && (__GNUC_MINOR__ < 95)
// this seems to be disallowed
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* These arrays are set by the constructor.
* The entries for each level are sorted ascendingly.
*/
- vector<vector<unsigned int> > interior_boundary_dofs;
+ std::vector<std::vector<unsigned int> > interior_boundary_dofs;
};
template<typename number>
template<int dim>
MGSmootherRelaxation<number>::MGSmootherRelaxation (const MGDoFHandler<dim> &mg_dof,
- const MGLevelObject<SparseMatrix<number> > &matrix,
- const function_ptr relaxation,
- const unsigned int steps,
- const double omega)
+ const MGLevelObject<SparseMatrix<number> > &matrix,
+ const function_ptr relaxation,
+ const unsigned int steps,
+ const double omega)
:
MGSmoother(mg_dof, steps),
matrix(&matrix),
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
/**
* Negative @p{vmult} on a level.
//TODO: what does this function do?
- * @see MGBase.
- */
+* @see MGBase.
+*/
virtual void level_vmult (const unsigned int level,
Vector<double> &dest,
const Vector<double> &src,
/**
- * Sparsity patterns for each level.
- */
+ * Sparsity patterns for each level.
+ */
SmartPointer<const MGLevelObject<SparsityPattern> > level_sparsities;
/**
private:
- vector<SparsityPattern> prolongation_sparsities;
-
- /**
- * The actual prolongation matrix.
- * column indices belong to the
- * dof indices of the mother cell,
- * i.e. the coarse level.
- * while row indices belong to the
- * child cell, i.e. the fine level.
- */
- vector<SparseMatrix<double> > prolongation_matrices;
+ std::vector<SparsityPattern> prolongation_sparsities;
+
+ /**
+ * The actual prolongation matrix.
+ * column indices belong to the
+ * dof indices of the mother cell,
+ * i.e. the coarse level.
+ * while row indices belong to the
+ * child cell, i.e. the fine level.
+ */
+ std::vector<SparseMatrix<double> > prolongation_matrices;
};
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// on all levels to zero
defect.clear();
- vector<unsigned int> global_dof_indices (dofs_per_cell);
- vector<unsigned int> level_dof_indices (dofs_per_cell);
- vector<unsigned int> level_face_indices (dofs_per_face);
+ std::vector<unsigned int> global_dof_indices (dofs_per_cell);
+ std::vector<unsigned int> level_dof_indices (dofs_per_cell);
+ std::vector<unsigned int> level_face_indices (dofs_per_face);
// initialize the objects with
// their correct size
{
const unsigned int dofs_per_cell = mg_dof_handler->get_fe().dofs_per_cell;
- vector<unsigned int> global_dof_indices (dofs_per_cell);
- vector<unsigned int> level_dof_indices (dofs_per_cell);
+ std::vector<unsigned int> global_dof_indices (dofs_per_cell);
+ std::vector<unsigned int> level_dof_indices (dofs_per_cell);
MGDoFHandler<dim>::active_cell_iterator
level_cell = mg_dof_handler->begin_active();
const unsigned int dofs_per_cell = mg_dof_handler->get_fe().dofs_per_cell;
- vector<unsigned int> global_dof_indices (dofs_per_cell);
- vector<unsigned int> level_dof_indices (dofs_per_cell);
+ std::vector<unsigned int> global_dof_indices (dofs_per_cell);
+ std::vector<unsigned int> level_dof_indices (dofs_per_cell);
DoFHandler<dim>::active_cell_iterator
global_cell = dof->begin_active(level);
= v(level_dof_indices[i]);
}
- ofstream out_file(name);
+ std::ofstream out_file(name);
DataOut<dim> out;
out.attach_dof_handler(*dof);
out.add_data_vector(out_vector, "v");
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* See the general documentation of this
* class for more detail.
*/
- typedef map<unsigned char,const Function<dim>*> FunctionMap;
+ typedef std::map<unsigned char,const Function<dim>*> FunctionMap;
/**
* Typdedef an iterator which assembles
* matrices and vectors.
* Overload this function, if you
* want anything else.
*/
- virtual string get_solution_name () const;
+ virtual std::string get_solution_name () const;
/**
* Exception
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* class to see which characters
* are valid and which are not.
*/
- void add_data_vector (const Vector<double> &data,
- const vector<string> &names);
+ void add_data_vector (const Vector<double> &data,
+ const std::vector<std::string> &names);
/**
* This function is an
* each component to @p{name}
*/
void add_data_vector (const Vector<double> &data,
- const string &name);
+ const std::string &name);
/**
* Release the pointers to the
* Exception
*/
DeclException1 (ExcInvalidCharacter,
- string,
- << "Please use only the characters [a-zA-Z0-9_<>()] for" << endl
- << "description strings since AVS will only accept these." << endl
+ std::string,
+ << "Please use only the characters [a-zA-Z0-9_<>()] for" << std::endl
+ << "description strings since AVS will only accept these." << std::endl
<< "The string you gave was <" << arg1 << ">.");
/**
* Exception
* with no explicit arguments for
* STL classes).
*/
- DataEntry (const Vector<double> *data = 0,
- const vector<string> &names = vector<string>());
+ DataEntry (const Vector<double> *data = 0,
+ const std::vector<std::string> &names = std::vector<std::string>());
/**
* Determine an estimate for the
* Names of the components of this
* data vector.
*/
- vector<string> names;
+ std::vector<std::string> names;
/**
* Physical unit name of this
* component.
*/
- string units;
+ std::string units;
};
/**
* List of data elements with vectors of
* values for each degree of freedom.
*/
- vector<DataEntry> dof_data;
+ std::vector<DataEntry> dof_data;
/**
* List of data elements with vectors of
* values for each cell.
*/
- vector<DataEntry> cell_data;
+ std::vector<DataEntry> cell_data;
/**
* This is a list of patches that is
* in the output routines of the base
* classes.
*/
- vector<DataOutBase::Patch<patch_dim,patch_space_dim> > patches;
+
std::vector<DataOutBase::Patch<patch_dim,patch_space_dim> > patches;
/**
* Function by which the base
* what patches they shall write
* to a file.
*/
- virtual const vector<DataOutBase::Patch<patch_dim,patch_space_dim> > &
+ virtual const
std::vector<DataOutBase::Patch<patch_dim,patch_space_dim> > &
get_patches () const;
/**
* obtained by the output functions
* of the base class.
*/
- virtual vector<string> get_dataset_names () const;
+ virtual std::vector<std::string> get_dataset_names () const;
};
unsigned int n_components;
unsigned int n_datasets;
unsigned int n_subdivisions;
- vector<double> patch_values;
- vector<Vector<double> > patch_values_system;
+ std::vector<double> patch_values;
+ std::vector<Vector<double> > patch_values_system;
Data ()
{}
};
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* aliased to a name that is
* better to type.
*/
- typedef pair<typename DoFHandler<dim>::cell_iterator,unsigned int> FaceDescriptor;
+ typedef std::pair<typename DoFHandler<dim>::cell_iterator,unsigned int> FaceDescriptor;
/**
unsigned int n_components;
unsigned int n_datasets;
unsigned int n_subdivisions;
- vector<double> patch_values;
- vector<Vector<double> > patch_values_system;
+ std::vector<double> patch_values;
+ std::vector<Vector<double> > patch_values_system;
Data ()
{}
};
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
unsigned int n_datasets;
unsigned int n_patches_per_circle;
unsigned int n_subdivisions;
- vector<double> patch_values;
- vector<Vector<double> > patch_values_system;
+ std::vector<double> patch_values;
+ std::vector<Vector<double> > patch_values_system;
Data ()
{}
};
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* and therefore only one name needs to
* be given.
*/
- void declare_data_vector (const string &name,
- const VectorType vector_type);
+ void declare_data_vector (const std::string &name,
+ const VectorType vector_type);
/**
* Declare a data vector. The @p{vector_type}
* element if the finite element has
* only one component.
*/
- void declare_data_vector (const vector<string> &name,
- const VectorType vector_type);
+ void declare_data_vector (const std::vector<std::string> &name,
+ const VectorType vector_type);
/**
*/
template <typename number>
void add_data_vector (const Vector<number> &vec,
- const string &name);
+ const std::string &name);
/**
* Add a data vector for the presently
* are already done.
*/
template <typename number>
- void add_data_vector (const Vector<number> &vec,
- const vector<string> &names);
+ void add_data_vector (const Vector<number> &vec,
+ const std::vector<std::string> &names);
/**
* Actually build the patches for output
* Exception
*/
DeclException1 (ExcInvalidCharacter,
- string,
- << "Please use only the characters [a-zA-Z0-9_<>()] for" << endl
- << "description strings since AVS will only accept these." << endl
+ std::string,
+ << "Please use only the characters [a-zA-Z0-9_<>()] for" << std::endl
+ << "description strings since AVS will only accept these." << std::endl
<< "The string you gave was <" << arg1 << ">.");
/**
* Exception
* Exception
*/
DeclException1 (ExcVectorNotDeclared,
- string,
+ std::string,
<< "The data vector for which the first component has the name "
<< arg1 << " has not been declared before.");
/**
* Exception
*/
DeclException1 (ExcNameAlreadyUsed,
- string,
+ std::string,
<< "You tried to declare a component of a data vector with "
<< "the name <" << arg1 << ">, but that name is already used.");
/**
* List of patches of all past and
* present parameter value data sets.
*/
- vector<DataOutBase::Patch<dim+1> > patches;
+ std::vector<DataOutBase::Patch<dim+1> > patches;
/**
* Structure holding data vectors
* Names of the different components
* within each such data set.
*/
- vector<string> names;
+ std::vector<std::string> names;
/**
* Determine an estimate for
/**
* List of DoF data vectors.
*/
- vector<DataVector> dof_data;
+ std::vector<DataVector> dof_data;
/**
* List of cell data vectors.
*/
- vector<DataVector> cell_data;
+ std::vector<DataVector> cell_data;
/**
* This is the function through
* the base class @ref{DataOutBase}) to
* the actual output function.
*/
- virtual const vector<DataOutBase::Patch<dim+1> > & get_patches () const;
+ virtual const std::vector<DataOutBase::Patch<dim+1> > & get_patches () const;
/**
* obtained by the output functions
* of the base class.
*/
- virtual vector<string> get_dataset_names () const;
+ virtual std::vector<std::string> get_dataset_names () const;
};
// $Id$
// Version: $Name$
//
-// Copyright (C) 2000 by the deal.II authors
+// Copyright (C) 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* a certain thread shall
* operate.
*/
- typedef pair<unsigned int,unsigned int> IndexInterval;
+ typedef std::pair<unsigned int,unsigned int> IndexInterval;
/**
* Kind of the main function of
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
DoFPrintSolverStep (SolverControl& control,
VectorMemory<VECTOR>& mem,
DataOut<dim>& data_out,
- const string& basename);
+ const std::string& basename);
/**
* Call-back function for the
/**
* Base of filenames.
*/
- const string basename;
+ const std::string basename;
};
DoFPrintSolverStep<dim, SOLVER, VECTOR>::DoFPrintSolverStep (SolverControl& control,
VectorMemory<VECTOR>& mem,
DataOut<dim>& data_out,
- const string& basename)
+ const std::string& basename)
: SOLVER (control, mem),
out (data_out),
basename (basename)
<< setw(3) << setfill('0') << step
<< out.default_suffix() << ends;
- const string fname = filename.str();
+ const std::string fname = filename.str();
- deallog << "Writing file:" << fname << endl;
+ deallog << "Writing file:" << fname << std::endl;
out.build_patches();
- ofstream of (fname.c_str());
+ std::ofstream of (fname.c_str());
out.write (of);
}
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
Cuthill_McKee (DoFHandler<dim> &dof_handler,
const bool reversed_numbering = false,
const bool use_constraints = false,
- const vector<unsigned int> &starting_indices = vector<unsigned int>());
+ const std::vector<unsigned int> &starting_indices = std::vector<unsigned int>());
/**
* Renumber the degrees of freedom
Cuthill_McKee (MGDoFHandler<dim> &dof_handler,
const unsigned int level,
const bool reversed_numbering = false,
- const vector<unsigned int> &starting_indices = vector<unsigned int> ());
+ const std::vector<unsigned int> &starting_indices = std::vector<unsigned int> ());
/**
* Sort the degrees of freedom by
template <int dim>
static void
component_wise (DoFHandler<dim> &dof_handler,
- const vector<unsigned int> &component_order = vector<unsigned int>());
+ const std::vector<unsigned int> &component_order = std::vector<unsigned int>());
/**
* Cell-wise renumbering for DG
template <int dim>
static void
cell_wise_dg (DoFHandler<dim> &dof_handler,
- const vector<typename DoFHandler<dim>::cell_iterator> &cell_order);
+ const std::vector<typename DoFHandler<dim>::cell_iterator> &cell_order);
/**
static void
cell_wise_dg (MGDoFHandler<dim> &dof_handler,
const unsigned int level,
- const vector<typename MGDoFHandler<dim>::cell_iterator> &cell_order);
+ const std::vector<typename MGDoFHandler<dim>::cell_iterator> &cell_order);
/**
*/
template <int dim>
static void
- sort_selected_dofs_back (DoFHandler<dim> &dof_handler,
- const vector<bool> &selected_dofs);
+ sort_selected_dofs_back (DoFHandler<dim> &dof_handler,
+ const std::vector<bool> &selected_dofs);
/**
* Renumber the degrees of
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* for each boundary indicator, which is
* guaranteed by the @p{map} data type.
*/
- typedef map<unsigned char,const Function<dim>*> FunctionMap;
+ typedef std::map<unsigned char,const Function<dim>*> FunctionMap;
/**
const FunctionMap &neumann_bc,
const Vector<double> &solution,
Vector<float> &error,
- const vector<bool> &component_mask = vector<bool>(),
+ const std::vector<bool> &component_mask = std::vector<bool>(),
const Function<dim> *coefficients = 0,
unsigned int n_threads = multithread_info.n_default_threads);
static void estimate (const DoFHandler<dim> &dof,
const Quadrature<dim-1> &quadrature,
const FunctionMap &neumann_bc,
- const vector<const Vector<double>*> &solutions,
- vector<Vector<float>*> &errors,
- const vector<bool> &component_mask = vector<bool>(),
+ const std::vector<const Vector<double>*> &solutions,
+ std::vector<Vector<float>*> &errors,
+ const std::vector<bool> &component_mask = std::vector<bool>(),
const Function<dim> *coefficients = 0,
unsigned int n_threads = multithread_info.n_default_threads);
* general documentation of this
* class for more information.
*/
- typedef map<typename DoFHandler<dim>::face_iterator,vector<double> > FaceIntegrals;
+ typedef std::map<typename DoFHandler<dim>::face_iterator,std::vector<double> > FaceIntegrals;
/**
const DoFHandler<dim> &dof_handler;
const Quadrature<dim-1> &quadrature;
const FunctionMap &neumann_bc;
- const vector<const Vector<double>*> &solutions;
- const vector<bool> component_mask;
+ const std::vector<const Vector<double>*> &solutions;
+ const std::vector<bool> component_mask;
const Function<dim> *coefficients;
const unsigned int n_threads;
const unsigned int n_solution_vectors;
* synchronisation makes
* things even slower.
*/
- vector<vector<vector<double> > > phi;
+ std::vector<std::vector<std::vector<double> > > phi;
/**
* A vector for the gradients of
* index of the solution
* vector.
*/
- vector<vector<vector<Tensor<1,dim> > > > psi;
+ std::vector<std::vector<std::vector<Tensor<1,dim> > > > psi;
/**
* The same vector for a neighbor cell
*/
- vector<vector<vector<Tensor<1,dim> > > > neighbor_psi;
+ std::vector<std::vector<std::vector<Tensor<1,dim> > > > neighbor_psi;
/**
* The normal vectors of the finite
* element function on one face
*/
- vector<Point<dim> > normal_vectors;
+
std::vector<Point<dim> > normal_vectors;
/**
* Two arrays needed for the
* the jumps, if they are
* given.
*/
- vector<double> coefficient_values1;
- vector<Vector<double> > coefficient_values;
+ std::vector<double> coefficient_values1;
+ std::vector<Vector<double> > coefficient_values;
/**
* Array for the products of
* weights of quadraturs
* points.
*/
- vector<double> JxW_values;
+ std::vector<double> JxW_values;
/**
* A constructor of the
Data(const DoFHandler<dim> &dof,
const Quadrature<dim-1> &quadrature,
const FunctionMap &neumann_bc,
- const vector<const Vector<double>*> &solutions,
- const vector<bool> &component_mask,
+ const std::vector<const Vector<double>*> &solutions,
+ const std::vector<bool> &component_mask,
const Function<dim> *coefficients,
const unsigned int n_threads,
FaceIntegrals &face_integrals);
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* on this.
*/
template <typename number>
- void evaluate (const vector<Vector<number> > &values,
- const vector<double> &y_values,
- const unsigned int n_intervals,
- const IntervalSpacing interval_spacing = linear);
+ void evaluate (const std::vector<Vector<number> > &values,
+ const std::vector<double> &y_values,
+ const unsigned int n_intervals,
+ const IntervalSpacing interval_spacing = linear);
/**
* This function is only a wrapper
* the GNUPLOT program. The function
* generates 2d or 3d histograms.
*/
- void write_gnuplot (ostream &out) const;
+ void write_gnuplot (std::ostream &out) const;
/**
* Return allowed names for the interval
* spacing as string. At present this
* is "linear|logarithmic".
*/
- static string get_interval_spacing_names ();
+ static std::string get_interval_spacing_names ();
/**
* Get a string containing one of the
* @p{IntervalSpacing}. Throw an error
* if the string is no valid one.
*/
- static IntervalSpacing parse_interval_spacing (const string &name);
+ static IntervalSpacing parse_interval_spacing (const std::string &name);
/**
* Determine an estimate for the
* Exception.
*/
DeclException1 (ExcInvalidName,
- string,
+ std::string,
<< "The given name <" << arg1
<< "> does not match any of the known formats.");
* for each data set given to the
* @p{evaluate} function.
*/
- vector<vector<Interval> > intervals;
+ std::vector<std::vector<Interval> > intervals;
/**
* Values for the depth axis of 3d
* histograms. Stored in the @p{evaluate}
* function.
*/
- vector<double> y_values;
+ std::vector<double> y_values;
};
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* See the general documentation of this
* class for more detail.
*/
- typedef map<unsigned char,const Function<dim>*> FunctionMap;
+ typedef std::map<unsigned char,const Function<dim>*> FunctionMap;
/**
* Assemble the mass matrix. If no
SparseMatrix<double> &matrix,
const FunctionMap &rhs,
Vector<double> &rhs_vector,
- vector<unsigned int> &vec_to_dof_mapping,
+ std::vector<unsigned int>&vec_to_dof_mapping,
const Function<dim> *a = 0);
/**
*/
template <typename number>
static void
- apply_boundary_values (const map<unsigned int,double> &boundary_values,
+ apply_boundary_values (const std::map<unsigned int,double> &boundary_values,
SparseMatrix<number> &matrix,
Vector<number> &solution,
Vector<number> &right_hand_side,
* matrices and block vectors
*/
static void
- apply_boundary_values (const map<unsigned int,double> &boundary_values,
+ apply_boundary_values (const std::map<unsigned int,double> &boundary_values,
BlockSparseMatrix<double> &matrix,
BlockVector<double> &solution,
BlockVector<double> &right_hand_side,
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* onto the new (refined and/or
* coarsenend) grid.
*/
- void prepare_for_coarsening_and_refinement (const vector<Vector<number> > &all_in);
+ void prepare_for_coarsening_and_refinement (const std::vector<Vector<number> > &all_in);
/**
* Same as previous function
* several functions can be
* performed in one step.
*/
- void interpolate (const vector<Vector<number> >&all_in,
- vector<Vector<number> > &all_out) const;
+ void interpolate (const std::vector<Vector<number> >&all_in,
+ std::vector<Vector<number> > &all_out) const;
/**
* Same as the previous function.
* and stores all dof indices
* of the cells that'll be refined
*/
- vector<vector<unsigned int> > indices_on_cell;
+ std::vector<std::vector<unsigned int> > indices_on_cell;
/**
* All cell data (the dof indices and
struct Pointerstruct {
unsigned int memory_consumption () const;
- vector<unsigned int> *indices_ptr;
- vector<Vector<number> > *dof_values_ptr;
+ std::vector<unsigned int> *indices_ptr;
+ std::vector<Vector<number> > *dof_values_ptr;
};
/**
* collecting all these structures in a vector
* helps avoiding fraqmentation of the memory.
*/
- vector<Pointerstruct> all_pointerstructs;
+
std::vector<Pointerstruct> all_pointerstructs;
/**
* Is used for
* of all cells that'll be coarsened
* will be stored in this vector.
*/
- vector<vector<Vector<number> > > dof_values_on_cell;
+ std::vector<std::vector<Vector<number> > > dof_values_on_cell;
};
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* objects pointed to by the pointers
* in this collection.
*/
- vector<TimeStepBase*> timesteps;
+ std::vector<TimeStepBase*> timesteps;
/**
* Number of the present sweep. This is
* vectors therefore hold the history
* of the grid.
*/
- vector<vector<bool> > refine_flags;
+ std::vector<std::vector<bool> > refine_flags;
/**
* @see refine_flags
*/
- vector<vector<bool> > coarsen_flags;
+ std::vector<std::vector<bool> > coarsen_flags;
/**
* Restore the grid according to the saved
* See the general description of this
* class for more information.
*/
- typedef vector<vector<pair<unsigned int, double> > > CorrectionRelaxations;
+ typedef std::vector<std::vector<std::pair<unsigned int, double> > > CorrectionRelaxations;
/**
* Default values for the relaxations:
* List of relaxations to the correction
* step.
*/
- const vector<vector<pair<unsigned int,double> > > correction_relaxations;
+ const std::vector<std::vector<std::pair<unsigned int,double> > > correction_relaxations;
/**
* Number of iterations to be performed
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
static void interpolate_boundary_values (const DoFHandler<dim> &dof,
const unsigned char boundary_component,
const Function<dim> &boundary_function,
- map<unsigned int,double> &boundary_values,
- const vector<bool> &component_mask = vector<bool>());
+ std::map<unsigned int,double> &boundary_values,
+ const std::vector<bool> &component_mask = std::vector<bool>());
//TODO: Update project_boundary_values for more components
//TODO: Replace FunctionMap
*/
template <int dim>
static void project_boundary_values (const DoFHandler<dim> &dof,
- const map<unsigned char,const Function<dim>*> &boundary_function,
+ const std::map<unsigned char,const Function<dim>*> &boundary_function,
const Quadrature<dim-1> &q,
- map<unsigned int,double> &boundary_values);
+ std::map<unsigned int,double> &boundary_values);
/**
* Compute the error of the finite element solution.
* be computed and later
* subtracted.
*/
- static void subtract_mean_value(Vector<double> &v,
- const vector<bool> &p_select);
+ static void subtract_mean_value(Vector<double> &v,
+ const std::vector<bool> &p_select);
/**
* Compute the mean value of one
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
const unsigned int n_dofs = local_source.size();
// get indices of dofs
- vector<unsigned int> dofs (n_dofs);
+ std::vector<unsigned int> dofs (n_dofs);
get_dof_indices (dofs);
// distribute cell vector
const unsigned int n_dofs = local_source.m();
// get indices of dofs
- vector<unsigned int> dofs (n_dofs);
+ std::vector<unsigned int> dofs (n_dofs);
get_dof_indices (dofs);
// distribute cell matrix
const unsigned int dofs_per_vertex = dof_handler->get_fe().dofs_per_vertex,
dofs_per_line = dof_handler->get_fe().dofs_per_line;
- typename vector<number>::iterator next_local_value=local_values.begin();
+ typename Vector<number>::iterator next_local_value=local_values.begin();
for (unsigned int vertex=0; vertex<2; ++vertex)
for (unsigned int d=0; d<dofs_per_vertex; ++d)
*next_local_value++ = values(vertex_dof_index(vertex,d));
const unsigned int dofs_per_vertex = dof_handler->get_fe().dofs_per_vertex,
dofs_per_line = dof_handler->get_fe().dofs_per_line;
- typename vector<number>::const_iterator next_local_value=local_values.begin();
+ typename Vector<number>::const_iterator next_local_value=local_values.begin();
for (unsigned int vertex=0; vertex<2; ++vertex)
for (unsigned int d=0; d<dofs_per_vertex; ++d)
- values(vertex_dof_index(vertex,d)) = *next_local_value++;
+ values(vertex_dof_index(vertex,d)) = *next_local_value++;
for (unsigned int d=0; d<dofs_per_line; ++d)
values(dof_index(d)) = *next_local_value++;
const unsigned int n_dofs = local_source.size();
// get indices of dofs
- vector<unsigned int> dofs (n_dofs);
+ std::vector<unsigned int> dofs (n_dofs);
get_dof_indices (dofs);
// distribute cell vector
const unsigned int n_dofs = local_source.m();
// get indices of dofs
- vector<unsigned int> dofs (n_dofs);
+ std::vector<unsigned int> dofs (n_dofs);
get_dof_indices (dofs);
// distribute cell matrix
const unsigned int dofs_per_vertex = dof_handler->get_fe().dofs_per_vertex,
dofs_per_line = dof_handler->get_fe().dofs_per_line,
dofs_per_quad = dof_handler->get_fe().dofs_per_quad;
- typename vector<number>::iterator next_local_value=local_values.begin();
+ typename Vector<number>::iterator next_local_value=local_values.begin();
for (unsigned int vertex=0; vertex<4; ++vertex)
for (unsigned int d=0; d<dofs_per_vertex; ++d)
*next_local_value++ = values(vertex_dof_index(vertex,d));
const unsigned int dofs_per_vertex = dof_handler->get_fe().dofs_per_vertex,
dofs_per_line = dof_handler->get_fe().dofs_per_line,
dofs_per_quad = dof_handler->get_fe().dofs_per_quad;
- typename vector<number>::const_iterator next_local_value=local_values.begin();
+ typename Vector<number>::const_iterator next_local_value=local_values.begin();
for (unsigned int vertex=0; vertex<4; ++vertex)
for (unsigned int d=0; d<dofs_per_vertex; ++d)
values(vertex_dof_index(vertex,d)) = *next_local_value++;
template <int dim>
void DoFObjectAccessor<3, dim>::
distribute_local_to_global (const Vector<double> &local_source,
- Vector<double> &global_destination) const {
+ Vector<double> &global_destination) const
+{
Assert (dof_handler != 0,
typename DoFAccessor<dim>::ExcInvalidObject());
Assert (dof_handler->selected_fe != 0,
const unsigned int n_dofs = local_source.size();
// get indices of dofs
- vector<unsigned int> dofs (n_dofs);
+ std::vector<unsigned int> dofs (n_dofs);
get_dof_indices (dofs);
// distribute cell vector
const unsigned int n_dofs = local_source.m();
// get indices of dofs
- vector<unsigned int> dofs (n_dofs);
+ std::vector<unsigned int> dofs (n_dofs);
get_dof_indices (dofs);
// distribute cell matrix
dofs_per_line = dof_handler->get_fe().dofs_per_line,
dofs_per_quad = dof_handler->get_fe().dofs_per_quad,
dofs_per_hex = dof_handler->get_fe().dofs_per_hex;
- typename vector<number>::iterator next_local_value = local_values.begin();
+ typename Vector<number>::iterator next_local_value = local_values.begin();
for (unsigned int vertex=0; vertex<GeometryInfo<3>::vertices_per_cell; ++vertex)
for (unsigned int d=0; d<dofs_per_vertex; ++d)
*next_local_value++ = values(vertex_dof_index(vertex,d));
dofs_per_line = dof_handler->get_fe().dofs_per_line,
dofs_per_quad = dof_handler->get_fe().dofs_per_quad,
dofs_per_hex = dof_handler->get_fe().dofs_per_hex;
- typename vector<number>::const_iterator next_local_value=local_values.begin();
+ typename Vector<number>::const_iterator next_local_value=local_values.begin();
for (unsigned int vertex=0; vertex<GeometryInfo<dim>::vertices_per_cell; ++vertex)
for (unsigned int d=0; d<dofs_per_vertex; ++d)
values(vertex_dof_index(vertex,d)) = *next_local_value++;
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
{
Assert (sorted==false, ExcMatrixIsClosed());
- vector<ConstraintLine>::iterator line_ptr;
- const vector<ConstraintLine>::const_iterator start=lines.begin();
+ std::vector<ConstraintLine>::iterator line_ptr;
+ const std::vector<ConstraintLine>::const_iterator start=lines.begin();
// the usual case is that the line where
// a value is entered is the one we
// added last, so we search backward
- for (line_ptr=&lines.back(); line_ptr!=start; --line_ptr)
+ for (line_ptr=(lines.end()-1); line_ptr!=start; --line_ptr)
if (line_ptr->line == line)
break;
// in any case: exit the function if an
// entry for this column already exists,
// since we don't want to enter it twice
- for (vector<pair<unsigned int,double> >::const_iterator p=line_ptr->entries.begin();
+ for (std::vector<std::pair<unsigned int,double> >::const_iterator p=line_ptr->entries.begin();
p != line_ptr->entries.end(); ++p)
if (p->first == column)
{
return;
};
- line_ptr->entries.push_back (make_pair(column,value));
+ line_ptr->entries.push_back (std::make_pair(column,value));
};
void ConstraintMatrix::add_entries (const unsigned int line,
- const vector<pair<unsigned int,double> > &col_val_pairs)
+ const std::vector<std::pair<unsigned int,double> > &col_val_pairs)
{
Assert (sorted==false, ExcMatrixIsClosed());
- vector<ConstraintLine>::iterator line_ptr;
- const vector<ConstraintLine>::const_iterator start=lines.begin();
+ std::vector<ConstraintLine>::iterator line_ptr;
+ const std::vector<ConstraintLine>::const_iterator start=lines.begin();
// the usual case is that the line where
// a value is entered is the one we
// added last, so we search backward
- for (line_ptr=&lines.back(); line_ptr!=start; --line_ptr)
+ for (line_ptr=(lines.end()-1); line_ptr!=start; --line_ptr)
if (line_ptr->line == line)
break;
// an entry for this column already
// exists, since we don't want to
// enter it twice
- for (vector<pair<unsigned int,double> >::const_iterator col_val_pair = col_val_pairs.begin();
+ for (std::vector<std::pair<unsigned int,double> >::const_iterator col_val_pair = col_val_pairs.begin();
col_val_pair!=col_val_pairs.end(); ++col_val_pair)
{
- for (vector<pair<unsigned int,double> >::const_iterator p=line_ptr->entries.begin();
+ for (std::vector<std::pair<unsigned int,double> >::const_iterator p=line_ptr->entries.begin();
p != line_ptr->entries.end(); ++p)
if (p->first == col_val_pair->first)
{
// sort the entries in the different lines
// and strip zero entries
- vector<ConstraintLine>::iterator line = lines.begin(),
- endl = lines.end();
+ std::vector<ConstraintLine>::iterator line = lines.begin(),
+ endl = lines.end();
for (; line!=endl; ++line)
{
// first remove zero
// 0*something can be omitted
line->entries.erase (remove_if (line->entries.begin(),
line->entries.end(),
- compose1 (bind2nd (equal_to<double>(), 0),
- select2nd<pair<unsigned int,double> >())),
+ std::compose1 (std::bind2nd (std::equal_to<double>(), 0),
+ std::select2nd<std::pair<unsigned int,double> >())),
line->entries.end());
// now sort the remainder
// if in debug mode: check that no
// dof is constraint to another dof
// that is also constrained
- for (vector<ConstraintLine>::const_iterator line=lines.begin();
+ for (std::vector<ConstraintLine>::const_iterator line=lines.begin();
line!=lines.end(); ++line)
- for (vector<pair<unsigned int,double> >::const_iterator entry=line->entries.begin();
+ for (std::vector<std::pair<unsigned int,double> >::const_iterator entry=line->entries.begin();
entry!=line->entries.end(); ++entry)
{
// make sure that
// index of a line itself
ConstraintLine test_line;
test_line.line = entry->first;
- const vector<ConstraintLine>::const_iterator
+ const std::vector<ConstraintLine>::const_iterator
test_line_position = lower_bound (lines.begin(),
lines.end(),
test_line);
void ConstraintMatrix::clear ()
{
- lines = vector<ConstraintLine>();
+ lines = std::vector<ConstraintLine>();
sorted = false;
};
// its new line number
// after compression. If the shift is
// -1, this line will be condensed away
- vector<int> new_line;
+ std::vector<int> new_line;
new_line.reserve (uncondensed.n_rows());
- vector<ConstraintLine>::const_iterator next_constraint = lines.begin();
- unsigned int shift = 0;
+ std::vector<ConstraintLine>::const_iterator next_constraint = lines.begin();
+ unsigned int shift = 0;
unsigned int n_rows = uncondensed.n_rows();
if (next_constraint == lines.end())
{
// let c point to the constraint
// of this column
- vector<ConstraintLine>::const_iterator c = lines.begin();
+ std::vector<ConstraintLine>::const_iterator c = lines.begin();
while (c->line != uncondensed.get_column_numbers()[j])
++c;
if (new_line[uncondensed.get_column_numbers()[j]] != -1)
// column is not constrained
for (unsigned int q=0; q!=next_constraint->entries.size(); ++q)
- condensed.add (new_line[next_constraint->entries[q].first],
- new_line[uncondensed.get_column_numbers()[j]]);
+ condensed.add (new_line[next_constraint->entries[q].first],
+ new_line[uncondensed.get_column_numbers()[j]]);
else
// not only this line but
{
// let c point to the constraint
// of this column
- vector<ConstraintLine>::const_iterator c = lines.begin();
+ std::vector<ConstraintLine>::const_iterator c = lines.begin();
while (c->line != uncondensed.get_column_numbers()[j]) ++c;
for (unsigned int p=0; p!=c->entries.size(); ++p)
for (unsigned int q=0; q!=next_constraint->entries.size(); ++q)
- condensed.add (new_line[next_constraint->entries[q].first],
- new_line[c->entries[p].first]);
+ condensed.add (new_line[next_constraint->entries[q].first],
+ new_line[c->entries[p].first]);
};
++next_constraint;
// otherwise, the number states which
// line in the constraint matrix handles
// this index
- vector<int> distribute(sparsity.n_rows(), -1);
+ std::vector<int> distribute(sparsity.n_rows(), -1);
for (unsigned int c=0; c<lines.size(); ++c)
distribute[lines[c].line] = static_cast<signed int>(c);
// otherwise, the number states which
// line in the constraint matrix handles
// this index
- vector<int> distribute (sparsity.n_rows(), -1);
+ std::vector<int> distribute (sparsity.n_rows(), -1);
for (unsigned int c=0; c<lines.size(); ++c)
distribute[lines[c].line] = static_cast<signed int>(c);
{
// get index of this row
// within the blocks
- const pair<unsigned int,unsigned int>
+ const std::pair<unsigned int,unsigned int>
block_index = index_mapping.global_to_local(row);
const unsigned int block_row = block_index.first;
}
else
{
- for (vector<ConstraintLine>::const_iterator i=lines.begin();
+ for (std::vector<ConstraintLine>::const_iterator i=lines.begin();
i!=lines.end(); ++i)
if (i->line == index)
return true;
unsigned int ConstraintMatrix::max_constraint_indirections () const
{
unsigned int return_value = 0;
- for (vector<ConstraintLine>::const_iterator i=lines.begin();
+ for (std::vector<ConstraintLine>::const_iterator i=lines.begin();
i!=lines.end(); ++i)
// use static cast, since
// typeof(size)==size_t, which is
// != unsigned int on AIX
- return_value = max(return_value,
- static_cast<unsigned int>(i->entries.size()));
+ return_value = std::max(return_value,
+ static_cast<unsigned int>(i->entries.size()));
return return_value;
};
-void ConstraintMatrix::print (ostream &out) const
+void ConstraintMatrix::print (std::ostream &out) const
{
for (unsigned int i=0; i!=lines.size(); ++i)
for (unsigned int j=0; j!=lines[i].entries.size(); ++j)
out << " " << lines[i].line
<< " " << lines[i].entries[j].first
- << ": " << lines[i].entries[j].second << endl;
+ << ": " << lines[i].entries[j].second << std::endl;
AssertThrow (out, ExcIO());
};
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
{
Assert (selected_fe != 0, ExcNoFESelected());
- set<int> boundary_dofs;
+ std::set<int> boundary_dofs;
const unsigned int dofs_per_face = selected_fe->dofs_per_face;
- vector<unsigned int> dofs_on_face(dofs_per_face);
+ std::vector<unsigned int> dofs_on_face(dofs_per_face);
active_face_iterator face = begin_active_face (),
endf = end_face();
for (; face!=endf; ++face)
Assert (boundary_indicators.find(255) == boundary_indicators.end(),
ExcInvalidBoundaryIndicator());
- set<int> boundary_dofs;
+ std::set<int> boundary_dofs;
const unsigned int dofs_per_face = selected_fe->dofs_per_face;
- vector<unsigned int> dofs_on_face(dofs_per_face);
+ std::vector<unsigned int> dofs_on_face(dofs_per_face);
active_face_iterator face = begin_active_face (),
endf = end_face();
for (; face!=endf; ++face)
template <int dim>
unsigned int
-DoFHandler<dim>::n_boundary_dofs (const set<unsigned char> &boundary_indicators) const
+DoFHandler<dim>::n_boundary_dofs (const std::set<unsigned char> &boundary_indicators) const
{
Assert (selected_fe != 0, ExcNoFESelected());
Assert (boundary_indicators.find (255) == boundary_indicators.end(),
ExcInvalidBoundaryIndicator());
- set<int> boundary_dofs;
+ std::set<int> boundary_dofs;
const unsigned int dofs_per_face = selected_fe->dofs_per_face;
- vector<unsigned int> dofs_on_face(dofs_per_face);
+ std::vector<unsigned int> dofs_on_face(dofs_per_face);
active_face_iterator face = begin_active_face (),
endf = end_face();
for (; face!=endf; ++face)
if (neighbor.state() == valid)
{
- // find true neighbor; may be its
- // a child of @p{neighbor}
+ // find true neighbor; may be its
+ // a child of @p{neighbor}
while (neighbor->has_children())
neighbor = neighbor->child(v==0 ? 1 : 0);
// has neighbor already been processed?
if (neighbor->user_flag_set())
- // copy dofs
+ // copy dofs
{
if (v==0)
for (unsigned int d=0; d<selected_fe->dofs_per_vertex; ++d)
#if deal_II_dimension == 1
template <>
-void DoFHandler<1>::renumber_dofs (const vector<unsigned int> &new_numbers) {
+void DoFHandler<1>::renumber_dofs (const std::vector<unsigned int> &new_numbers)
+{
Assert (new_numbers.size() == n_dofs(), ExcRenumberingIncomplete());
#ifdef DEBUG
// assert that the new indices are
// consecutively numbered
if (true)
{
- vector<unsigned int> tmp(new_numbers);
+ std::vector<unsigned int> tmp(new_numbers);
sort (tmp.begin(), tmp.end());
- vector<unsigned int>::const_iterator p = tmp.begin();
+ std::vector<unsigned int>::const_iterator p = tmp.begin();
unsigned int i = 0;
for (; p!=tmp.end(); ++p, ++i)
Assert (*p == i, ExcNewNumbersNotConsecutive(i));
// faster; note, however, that dof numbers
// may be invalid_dof_index, namely when the appropriate
// vertex/line/etc is unused
- for (vector<unsigned int>::iterator i=vertex_dofs.begin(); i!=vertex_dofs.end(); ++i)
+ for (std::vector<unsigned int>::iterator i=vertex_dofs.begin(); i!=vertex_dofs.end(); ++i)
if (*i != invalid_dof_index)
*i = new_numbers[*i];
else
ExcInternalError ());
for (unsigned int level=0; level<levels.size(); ++level)
- for (vector<unsigned int>::iterator i=levels[level]->line_dofs.begin();
+ for (std::vector<unsigned int>::iterator i=levels[level]->line_dofs.begin();
i!=levels[level]->line_dofs.end(); ++i)
if (*i != invalid_dof_index)
*i = new_numbers[*i];
#if deal_II_dimension == 2
template <>
-void DoFHandler<2>::renumber_dofs (const vector<unsigned int> &new_numbers) {
+void DoFHandler<2>::renumber_dofs (const std::vector<unsigned int> &new_numbers)
+{
Assert (new_numbers.size() == n_dofs(), ExcRenumberingIncomplete());
#ifdef DEBUG
// assert that the new indices are
// consecutively numbered
if (true)
{
- vector<unsigned int> tmp(new_numbers);
+ std::vector<unsigned int> tmp(new_numbers);
sort (tmp.begin(), tmp.end());
- vector<unsigned int>::const_iterator p = tmp.begin();
+ std::vector<unsigned int>::const_iterator p = tmp.begin();
unsigned int i = 0;
for (; p!=tmp.end(); ++p, ++i)
Assert (*p == i, ExcNewNumbersNotConsecutive(i));
// faster; note, however, that dof numbers
// may be invalid_dof_index, namely when the appropriate
// vertex/line/etc is unused
- for (vector<unsigned int>::iterator i=vertex_dofs.begin(); i!=vertex_dofs.end(); ++i)
+ for (std::vector<unsigned int>::iterator i=vertex_dofs.begin(); i!=vertex_dofs.end(); ++i)
if (*i != invalid_dof_index)
*i = new_numbers[*i];
else
for (unsigned int level=0; level<levels.size(); ++level)
{
- for (vector<unsigned int>::iterator i=levels[level]->line_dofs.begin();
+ for (std::vector<unsigned int>::iterator i=levels[level]->line_dofs.begin();
i!=levels[level]->line_dofs.end(); ++i)
if (*i != invalid_dof_index)
*i = new_numbers[*i];
- for (vector<unsigned int>::iterator i=levels[level]->quad_dofs.begin();
+ for (std::vector<unsigned int>::iterator i=levels[level]->quad_dofs.begin();
i!=levels[level]->quad_dofs.end(); ++i)
if (*i != invalid_dof_index)
*i = new_numbers[*i];
#if deal_II_dimension == 3
template <>
-void DoFHandler<3>::renumber_dofs (const vector<unsigned int> &new_numbers) {
+void DoFHandler<3>::renumber_dofs (const std::vector<unsigned int> &new_numbers)
+{
Assert (new_numbers.size() == n_dofs(), ExcRenumberingIncomplete());
#ifdef DEBUG
// assert that the new indices are
// consecutively numbered
if (true)
{
- vector<unsigned int> tmp(new_numbers);
+ std::vector<unsigned int> tmp(new_numbers);
sort (tmp.begin(), tmp.end());
- vector<unsigned int>::const_iterator p = tmp.begin();
- unsigned int i = 0;
+ std::vector<unsigned int>::const_iterator p = tmp.begin();
+ unsigned int i = 0;
for (; p!=tmp.end(); ++p, ++i)
Assert (*p == i, ExcNewNumbersNotConsecutive(i));
};
// faster; note, however, that dof numbers
// may be invalid_dof_index, namely when the appropriate
// vertex/line/etc is unused
- for (vector<unsigned int>::iterator i=vertex_dofs.begin(); i!=vertex_dofs.end(); ++i)
+ for (std::vector<unsigned int>::iterator i=vertex_dofs.begin(); i!=vertex_dofs.end(); ++i)
if (*i != invalid_dof_index)
*i = new_numbers[*i];
else
for (unsigned int level=0; level<levels.size(); ++level)
{
- for (vector<unsigned int>::iterator i=levels[level]->line_dofs.begin();
+ for (std::vector<unsigned int>::iterator i=levels[level]->line_dofs.begin();
i!=levels[level]->line_dofs.end(); ++i)
if (*i != invalid_dof_index)
*i = new_numbers[*i];
- for (vector<unsigned int>::iterator i=levels[level]->quad_dofs.begin();
+ for (std::vector<unsigned int>::iterator i=levels[level]->quad_dofs.begin();
i!=levels[level]->quad_dofs.end(); ++i)
if (*i != invalid_dof_index)
*i = new_numbers[*i];
- for (vector<unsigned int>::iterator i=levels[level]->hex_dofs.begin();
+ for (std::vector<unsigned int>::iterator i=levels[level]->hex_dofs.begin();
i!=levels[level]->hex_dofs.end(); ++i)
if (*i != invalid_dof_index)
*i = new_numbers[*i];
template <>
unsigned int DoFHandler<1>::max_couplings_between_dofs () const {
Assert (selected_fe != 0, ExcNoFESelected());
- return min(3*selected_fe->dofs_per_vertex + 2*selected_fe->dofs_per_line, n_dofs());
+ return std::min(3*selected_fe->dofs_per_vertex +
+ 2*selected_fe->dofs_per_line, n_dofs());
};
Assert (false, ExcNotImplemented());
max_couplings=0;
};
- return(min(max_couplings,n_dofs()));
+ return std::min(max_couplings,n_dofs());
};
max_couplings=0;
}
- return min(max_couplings,n_dofs());
+ return std::min(max_couplings,n_dofs());
};
// their size
clear_space ();
- vertex_dofs = vector<unsigned int>(tria->vertices.size()*
- selected_fe->dofs_per_vertex,
- invalid_dof_index);
+ vertex_dofs = std::vector<unsigned int>(tria->vertices.size()*
+ selected_fe->dofs_per_vertex,
+ invalid_dof_index);
for (unsigned int i=0; i<tria->n_levels(); ++i)
{
levels.push_back (new DoFLevel<1>);
- levels.back()->line_dofs = vector<unsigned int>(tria->levels[i]->lines.lines.size() *
- selected_fe->dofs_per_line,
- invalid_dof_index);
+ levels.back()->line_dofs = std::vector<unsigned int>(tria->levels[i]->lines.lines.size() *
+ selected_fe->dofs_per_line,
+ invalid_dof_index);
};
};
// their size
clear_space ();
- vertex_dofs = vector<unsigned int>(tria->vertices.size()*
- selected_fe->dofs_per_vertex,
- invalid_dof_index);
+ vertex_dofs = std::vector<unsigned int>(tria->vertices.size()*
+ selected_fe->dofs_per_vertex,
+ invalid_dof_index);
for (unsigned int i=0; i<tria->n_levels(); ++i)
{
levels.push_back (new DoFLevel<2>);
- levels.back()->line_dofs = vector<unsigned int> (tria->levels[i]->lines.lines.size() *
- selected_fe->dofs_per_line,
- invalid_dof_index);
- levels.back()->quad_dofs = vector<unsigned int> (tria->levels[i]->quads.quads.size() *
- selected_fe->dofs_per_quad,
- invalid_dof_index);
+ levels.back()->line_dofs = std::vector<unsigned int> (tria->levels[i]->lines.lines.size() *
+ selected_fe->dofs_per_line,
+ invalid_dof_index);
+ levels.back()->quad_dofs = std::vector<unsigned int> (tria->levels[i]->quads.quads.size() *
+ selected_fe->dofs_per_quad,
+ invalid_dof_index);
};
};
// their size
clear_space ();
- vertex_dofs = vector<unsigned int>(tria->vertices.size()*
- selected_fe->dofs_per_vertex,
- invalid_dof_index);
+ vertex_dofs = std::vector<unsigned int>(tria->vertices.size()*
+ selected_fe->dofs_per_vertex,
+ invalid_dof_index);
for (unsigned int i=0; i<tria->n_levels(); ++i)
{
levels.push_back (new DoFLevel<3>);
- levels.back()->line_dofs = vector<unsigned int> (tria->levels[i]->lines.lines.size() *
- selected_fe->dofs_per_line,
- invalid_dof_index);
- levels.back()->quad_dofs = vector<unsigned int> (tria->levels[i]->quads.quads.size() *
- selected_fe->dofs_per_quad,
- invalid_dof_index);
- levels.back()->hex_dofs = vector<unsigned int> (tria->levels[i]->hexes.hexes.size() *
- selected_fe->dofs_per_hex,
- invalid_dof_index);
+ levels.back()->line_dofs = std::vector<unsigned int> (tria->levels[i]->lines.lines.size() *
+ selected_fe->dofs_per_line,
+ invalid_dof_index);
+ levels.back()->quad_dofs = std::vector<unsigned int> (tria->levels[i]->quads.quads.size() *
+ selected_fe->dofs_per_quad,
+ invalid_dof_index);
+ levels.back()->hex_dofs = std::vector<unsigned int> (tria->levels[i]->hexes.hexes.size() *
+ selected_fe->dofs_per_hex,
+ invalid_dof_index);
};
};
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
template <int dim>
-void DoFRenumbering::Cuthill_McKee (DoFHandler<dim> &dof_handler,
- const bool reversed_numbering,
- const bool use_constraints,
- const vector<unsigned int> &starting_indices)
+void DoFRenumbering::Cuthill_McKee (DoFHandler<dim> &dof_handler,
+ const bool reversed_numbering,
+ const bool use_constraints,
+ const std::vector<unsigned int> &starting_indices)
{
// make the connection graph
SparsityPattern sparsity (dof_handler.n_dofs(),
const unsigned int n_dofs = sparsity.n_rows();
// store the new dof numbers; invalid_dof_index means
// that no new number was chosen yet
- vector<unsigned int> new_number(sparsity.n_rows(), DoFHandler<dim>::invalid_dof_index);
+ std::vector<unsigned int> new_number(sparsity.n_rows(),
+ DoFHandler<dim>::invalid_dof_index);
// store the indices of the dofs renumbered
// in the last round. Default to starting
// points
- vector<unsigned int> last_round_dofs (starting_indices);
+ std::vector<unsigned int> last_round_dofs (starting_indices);
// delete disallowed elements
for (unsigned int i=0; i<last_round_dofs.size(); ++i)
(last_round_dofs[i]>=n_dofs))
last_round_dofs[i] = DoFHandler<dim>::invalid_dof_index;
- remove_if (last_round_dofs.begin(), last_round_dofs.end(),
- bind2nd(equal_to<unsigned int>(), DoFHandler<dim>::invalid_dof_index));
+ std::remove_if (last_round_dofs.begin(), last_round_dofs.end(),
+ std::bind2nd(std::equal_to<unsigned int>(),
+ DoFHandler<dim>::invalid_dof_index));
// now if no valid points remain:
// find dof with lowest coordination
{
// store the indices of the dofs to be
// renumbered in the next round
- vector<unsigned int> next_round_dofs;
+ std::vector<unsigned int> next_round_dofs;
// find all neighbors of the
// dofs numbered in the last
sort (next_round_dofs.begin(), next_round_dofs.end());
// delete multiple entries
- vector<unsigned int>::iterator end_sorted;
+ std::vector<unsigned int>::iterator end_sorted;
end_sorted = unique (next_round_dofs.begin(), next_round_dofs.end());
next_round_dofs.erase (end_sorted, next_round_dofs.end());
// already numbered
for (int s=next_round_dofs.size()-1; s>=0; --s)
if (new_number[next_round_dofs[s]] != DoFHandler<dim>::invalid_dof_index)
- next_round_dofs.erase (&next_round_dofs[s]);
+ next_round_dofs.erase (next_round_dofs.begin() + s);
// check whether there are any new
// dofs
// store for each coordination
// number the dofs with these
// coordination number
- multimap<unsigned int, int> dofs_by_coordination;
+ std::multimap<unsigned int, int> dofs_by_coordination;
// find coordination number for
// each of these dofs
- for (vector<unsigned int>::iterator s=next_round_dofs.begin();
+ for (std::vector<unsigned int>::iterator s=next_round_dofs.begin();
s!=next_round_dofs.end(); ++s)
{
unsigned int coordination = 0;
// insert this dof at its
// coordination number
- const pair<const unsigned int, int> new_entry (coordination, *s);
+ const std::pair<const unsigned int, int> new_entry (coordination, *s);
dofs_by_coordination.insert (new_entry);
};
// assign new DoF numbers to
// the elements of the present
// front:
- multimap<unsigned int, int>::iterator i;
+ std::multimap<unsigned int, int>::iterator i;
for (i = dofs_by_coordination.begin(); i!=dofs_by_coordination.end(); ++i)
new_number[i->second] = next_free_number++;
#endif
if (reversed_numbering)
- for (vector<unsigned int>::iterator i=new_number.begin(); i!=new_number.end(); ++i)
+ for (std::vector<unsigned int>::iterator i=new_number.begin(); i!=new_number.end(); ++i)
*i = n_dofs-*i;
// actually perform renumbering;
template <int dim>
-void DoFRenumbering::Cuthill_McKee (MGDoFHandler<dim> &dof_handler,
- const unsigned int level,
- const bool reversed_numbering,
- const vector<unsigned int> &starting_indices)
+void DoFRenumbering::Cuthill_McKee (MGDoFHandler<dim> &dof_handler,
+ const unsigned int level,
+ const bool reversed_numbering,
+ const std::vector<unsigned int> &starting_indices)
{
// make the connection graph
SparsityPattern sparsity (dof_handler.n_dofs(level),
const unsigned int n_dofs = sparsity.n_rows();
// store the new dof numbers; invalid_dof_index means
// that no new number was chosen yet
- vector<unsigned int> new_number(n_dofs, DoFHandler<dim>::invalid_dof_index);
+ std::vector<unsigned int> new_number(n_dofs, DoFHandler<dim>::invalid_dof_index);
// store the indices of the dofs renumbered
// in the last round. Default to starting
// points
- vector<unsigned int> last_round_dofs (starting_indices);
+ std::vector<unsigned int> last_round_dofs (starting_indices);
// delete disallowed elements
for (unsigned int i=0; i<last_round_dofs.size(); ++i)
(last_round_dofs[i]>=n_dofs))
last_round_dofs[i] = DoFHandler<dim>::invalid_dof_index;
- remove_if (last_round_dofs.begin(), last_round_dofs.end(),
- bind2nd(equal_to<unsigned int>(), DoFHandler<dim>::invalid_dof_index));
+ std::remove_if (last_round_dofs.begin(), last_round_dofs.end(),
+ std::bind2nd(std::equal_to<unsigned int>(),
+ DoFHandler<dim>::invalid_dof_index));
// now if no valid points remain:
// find dof with lowest coordination
{
// store the indices of the dofs to be
// renumbered in the next round
- vector<unsigned int> next_round_dofs;
+ std::vector<unsigned int> next_round_dofs;
// find all neighbors of the
// dofs numbered in the last
sort (next_round_dofs.begin(), next_round_dofs.end());
// delete multiple entries
- vector<unsigned int>::iterator end_sorted;
- end_sorted = unique (next_round_dofs.begin(), next_round_dofs.end());
+ std::vector<unsigned int>::iterator end_sorted;
+ end_sorted = std::unique (next_round_dofs.begin(), next_round_dofs.end());
next_round_dofs.erase (end_sorted, next_round_dofs.end());
// eliminate dofs which are
// already numbered
for (int s=next_round_dofs.size()-1; s>=0; --s)
if (new_number[next_round_dofs[s]] != DoFHandler<dim>::invalid_dof_index)
- next_round_dofs.erase (&next_round_dofs[s]);
+ next_round_dofs.erase (next_round_dofs.begin() + s);
// check whether there are any new
// dofs
// store for each coordination
// number the dofs with these
// coordination number
- multimap<unsigned int, int> dofs_by_coordination;
+ std::multimap<unsigned int, int> dofs_by_coordination;
// find coordination number for
// each of these dofs
- for (vector<unsigned int>::iterator s=next_round_dofs.begin();
+ for (std::vector<unsigned int>::iterator s=next_round_dofs.begin();
s!=next_round_dofs.end(); ++s)
{
unsigned int coordination = 0;
// insert this dof at its
// coordination number
- const pair<const unsigned int, int> new_entry (coordination, *s);
+ const std::pair<const unsigned int, int> new_entry (coordination, *s);
dofs_by_coordination.insert (new_entry);
};
////
- multimap<unsigned int, int>::iterator i;
+ std::multimap<unsigned int, int>::iterator i;
for (i = dofs_by_coordination.begin(); i!=dofs_by_coordination.end(); ++i)
new_number[i->second] = next_free_number++;
#endif
if (reversed_numbering)
- for (vector<unsigned int>::iterator i=new_number.begin(); i!=new_number.end(); ++i)
+ for (std::vector<unsigned int>::iterator i=new_number.begin(); i!=new_number.end(); ++i)
*i = n_dofs-*i;
// actually perform renumbering;
template <int dim>
-void DoFRenumbering::component_wise (DoFHandler<dim> &dof_handler,
- const vector<unsigned int> &component_order_arg)
+void DoFRenumbering::component_wise (DoFHandler<dim> &dof_handler,
+ const std::vector<unsigned int> &component_order_arg)
{
const unsigned int dofs_per_cell = dof_handler.get_fe().dofs_per_cell;
if (dof_handler.get_fe().n_components() == 1)
return;
- vector<unsigned int> component_order (component_order_arg);
+ std::vector<unsigned int> component_order (component_order_arg);
if (component_order.size() == 0)
for (unsigned int i=0; i<dof_handler.get_fe().n_components(); ++i)
component_order.push_back (i);
// vector to hold the dof indices on
// the cell we visit at a time
- vector<unsigned int> local_dof_indices(dofs_per_cell);
+ std::vector<unsigned int> local_dof_indices(dofs_per_cell);
// prebuilt list to which component
// a given dof on a cell belongs
- vector<unsigned int> component_list (dofs_per_cell);
+ std::vector<unsigned int> component_list (dofs_per_cell);
for (unsigned int i=0; i<component_list.size(); ++i)
component_list[i] = dof_handler.get_fe().system_to_component_index(i).first;
// sorted by dof index. note also that some
// dof indices are entered multiply, so we
// will have to take care of that
- vector<vector<unsigned int> > component_to_dof_map (dof_handler.get_fe().n_components());
+ std::vector<std::vector<unsigned int> > component_to_dof_map (dof_handler.get_fe().n_components());
for (typename DoFHandler<dim>::active_cell_iterator cell=dof_handler.begin_active();
cell!=dof_handler.end(); ++cell)
{
};
unsigned int next_free_index = 0;
- vector<unsigned int> new_indices (dof_handler.n_dofs(), DoFHandler<dim>::invalid_dof_index);
+ std::vector<unsigned int> new_indices (dof_handler.n_dofs(),
+ DoFHandler<dim>::invalid_dof_index);
for (unsigned int component=0; component<dof_handler.get_fe().n_components(); ++component)
{
- const typename vector<unsigned int>::const_iterator
+ const typename std::vector<unsigned int>::const_iterator
begin_of_component = component_to_dof_map[component].begin(),
end_of_component = component_to_dof_map[component].end();
- for (typename vector<unsigned int>::const_iterator dof_index = begin_of_component;
+ for (typename std::vector<unsigned int>::const_iterator dof_index = begin_of_component;
dof_index != end_of_component; ++dof_index)
new_indices[*dof_index] = next_free_index++;
};
template <int dim>
void
-DoFRenumbering::sort_selected_dofs_back (DoFHandler<dim> &dof_handler,
- const vector<bool> &selected_dofs)
+DoFRenumbering::sort_selected_dofs_back (DoFHandler<dim> &dof_handler,
+ const std::vector<bool> &selected_dofs)
{
const unsigned int n_dofs = dof_handler.n_dofs();
Assert (selected_dofs.size() == n_dofs,
// re-sort the dofs according to
// their selection state
- vector<unsigned int> new_dof_indices (n_dofs);
+ std::vector<unsigned int> new_dof_indices (n_dofs);
const unsigned int n_selected_dofs = count (selected_dofs.begin(),
selected_dofs.end(),
false);
template <int dim>
void
DoFRenumbering::cell_wise_dg (DoFHandler<dim>& dof,
- const vector<typename DoFHandler<dim>::cell_iterator>& cells)
+ const std::vector<typename DoFHandler<dim>::cell_iterator>& cells)
{
Assert(cells.size() == dof.get_tria().n_active_cells(),
ExcDimensionMismatch(cells.size(),
unsigned int n_global_dofs = dof.n_dofs();
unsigned int n_cell_dofs = dof.get_fe().n_dofs_per_cell();
- vector<unsigned int> new_order(n_global_dofs);
- vector<unsigned int> cell_dofs(n_cell_dofs);
+ std::vector<unsigned int> new_order(n_global_dofs);
+ std::vector<unsigned int> cell_dofs(n_cell_dofs);
unsigned int global_index = 0;
- typename vector<typename DoFHandler<dim>::cell_iterator>::const_iterator cell;
+ typename std::vector<typename DoFHandler<dim>::cell_iterator>::const_iterator cell;
for(cell = cells.begin(); cell != cells.end(); ++cell)
{
}
Assert(global_index == n_global_dofs, ExcRenumberingIncomplete());
- vector<unsigned int> reverse(new_order.size());
+ std::vector<unsigned int> reverse(new_order.size());
for (unsigned int i=0;i<new_order.size(); ++i)
reverse[new_order[i]] = i;
void
DoFRenumbering::cell_wise_dg (MGDoFHandler<dim>& dof,
unsigned int level,
- const vector<typename MGDoFHandler<dim>::cell_iterator>& cells)
+ const std::vector<typename MGDoFHandler<dim>::cell_iterator>& cells)
{
Assert(cells.size() == dof.get_tria().n_cells(level),
ExcDimensionMismatch(cells.size(),
unsigned int n_global_dofs = dof.n_dofs(level);
unsigned int n_cell_dofs = dof.get_fe().n_dofs_per_cell();
- vector<unsigned int> new_order(n_global_dofs);
- vector<unsigned int> cell_dofs(n_cell_dofs);
+ std::vector<unsigned int> new_order(n_global_dofs);
+ std::vector<unsigned int> cell_dofs(n_cell_dofs);
unsigned int global_index = 0;
- typename vector<typename MGDoFHandler<dim>::cell_iterator>::const_iterator cell;
+ typename std::vector<typename MGDoFHandler<dim>::cell_iterator>::const_iterator cell;
for(cell = cells.begin(); cell != cells.end(); ++cell)
{
}
Assert(global_index == n_global_dofs, ExcRenumberingIncomplete());
- vector<unsigned int> reverse(new_order.size());
+ std::vector<unsigned int> reverse(new_order.size());
for (unsigned int i=0;i<new_order.size(); ++i)
reverse[new_order[i]] = i;
DoFRenumbering::downstream_dg (DoFHandler<dim>& dof,
const Point<dim>& direction)
{
- vector<typename DoFHandler<dim>::cell_iterator>
+ std::vector<typename DoFHandler<dim>::cell_iterator>
ordered_cells(dof.get_tria().n_active_cells());
CompCells<dim> comparator(direction);
const unsigned int level,
const Point<dim>& direction)
{
- vector<typename MGDoFHandler<dim>::cell_iterator>
+ std::vector<typename MGDoFHandler<dim>::cell_iterator>
ordered_cells(dof.get_tria().n_cells(level));
CompCells<dim> comparator(direction);
// lrand48 to be declared (rather than do so itself. however,
// inclusion of <cstdlib> or <stdlib.h> does not help, so we declare
// that function ourselves
-extern "C" long int lrand48 (void);
+extern "C" long int lrand48 (void) throw();
template <int dim>
{
const unsigned int n_dofs = dof_handler.n_dofs();
- vector<unsigned int> new_indices (n_dofs);
+ std::vector<unsigned int> new_indices (n_dofs);
for (unsigned i=0; i<n_dofs; ++i)
new_indices[i] = i;
void DoFRenumbering::Cuthill_McKee (DoFHandler<deal_II_dimension>&,
const bool,
const bool,
- const vector<unsigned int>&);
+ const std::vector<unsigned int>&);
template
void DoFRenumbering::Cuthill_McKee (MGDoFHandler<deal_II_dimension>&,
const unsigned int,
const bool,
- const vector<unsigned int>&);
+ const std::vector<unsigned int>&);
template
void DoFRenumbering::component_wise (DoFHandler<deal_II_dimension>&,
- const vector<unsigned int>&);
+ const std::vector<unsigned int>&);
template
void DoFRenumbering::cell_wise_dg (DoFHandler<deal_II_dimension>&,
- const vector<DoFHandler<deal_II_dimension>::cell_iterator>&);
+ const std::vector<DoFHandler<deal_II_dimension>::cell_iterator>&);
template
void DoFRenumbering::cell_wise_dg (MGDoFHandler<deal_II_dimension>&,
unsigned int,
- const vector<DoFHandler<deal_II_dimension>::cell_iterator>&);
+ const std::vector<DoFHandler<deal_II_dimension>::cell_iterator>&);
template
void DoFRenumbering::downstream_dg (DoFHandler<deal_II_dimension>&,
template
void DoFRenumbering::sort_selected_dofs_back (DoFHandler<deal_II_dimension> &,
- const vector<bool> &);
+ const std::vector<bool> &);
template
void DoFRenumbering::random (DoFHandler<deal_II_dimension> &);
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
ExcDimensionMismatch (sparsity.n_cols(), n_dofs));
const unsigned int dofs_per_cell = dof.get_fe().dofs_per_cell;
- vector<unsigned int> dofs_on_this_cell(dofs_per_cell);
+ std::vector<unsigned int> dofs_on_this_cell(dofs_per_cell);
DoFHandler<dim>::active_cell_iterator cell = dof.begin_active(),
endc = dof.end();
for (; cell!=endc; ++cell)
template <int dim, class SparsityPattern>
void
-DoFTools::make_sparsity_pattern (const DoFHandler<dim> &dof,
- const vector<vector<bool> > &mask,
- SparsityPattern &sparsity)
+DoFTools::make_sparsity_pattern (const DoFHandler<dim> &dof,
+ const std::vector<std::vector<bool> > &mask,
+ SparsityPattern &sparsity)
{
const unsigned int n_dofs = dof.n_dofs();
const unsigned int dofs_per_cell = dof.get_fe().dofs_per_cell;
// first build a mask for each dof,
// not like the one given which represents
// components
- vector<vector<bool> > dof_mask(dofs_per_cell,
- vector<bool>(dofs_per_cell, false));
+ std::vector<std::vector<bool> > dof_mask(dofs_per_cell,
+ std::vector<bool>(dofs_per_cell, false));
for (unsigned int i=0; i<dofs_per_cell; ++i)
for (unsigned int j=0; j<dofs_per_cell; ++j)
dof_mask[i][j] = mask
[dof.get_fe().system_to_component_index(j).first];
- vector<unsigned int> dofs_on_this_cell(dofs_per_cell);
+ std::vector<unsigned int> dofs_on_this_cell(dofs_per_cell);
DoFHandler<dim>::active_cell_iterator cell = dof.begin_active(),
- endc = dof.end();
+ endc = dof.end();
for (; cell!=endc; ++cell)
{
cell->get_dof_indices (dofs_on_this_cell);
template <>
void DoFTools::make_boundary_sparsity_pattern (const DoFHandler<1>&,
- const vector<unsigned int> &,
+ const std::vector<unsigned int> &,
SparsityPattern &)
{
- Assert (false, ExcInternalError());
+ Assert (false, ExcInternalError());
};
void
DoFTools::make_boundary_sparsity_pattern (const DoFHandler<1>&,
const DoFHandler<1>::FunctionMap &,
- const vector<unsigned int> &,
+ const std::vector<unsigned int> &,
SparsityPattern &)
{
Assert (false, ExcInternalError());
template <int dim>
void
DoFTools::make_boundary_sparsity_pattern (const DoFHandler<dim>& dof,
- const vector<unsigned int> &dof_to_boundary_mapping,
+ const std::vector<unsigned int> &dof_to_boundary_mapping,
SparsityPattern &sparsity)
{
const unsigned int n_dofs = dof.n_dofs();
ExcInternalError());
const unsigned int dofs_per_face = dof.get_fe().dofs_per_face;
- vector<unsigned int> dofs_on_this_face(dofs_per_face);
+ std::vector<unsigned int> dofs_on_this_face(dofs_per_face);
DoFHandler<dim>::active_face_iterator face = dof.begin_active_face(),
- endf = dof.end_face();
+ endf = dof.end_face();
for (; face!=endf; ++face)
if (face->at_boundary())
{
template <int dim>
void DoFTools::make_boundary_sparsity_pattern (const DoFHandler<dim>& dof,
const DoFHandler<dim>::FunctionMap &boundary_indicators,
- const vector<unsigned int> &dof_to_boundary_mapping,
+ const std::vector<unsigned int> &dof_to_boundary_mapping,
SparsityPattern &sparsity)
{
const unsigned int n_dofs = dof.n_dofs();
if (true)
{
unsigned int max_element = 0;
- for (vector<unsigned int>::const_iterator i=dof_to_boundary_mapping.begin();
+ for (std::vector<unsigned int>::const_iterator i=dof_to_boundary_mapping.begin();
i!=dof_to_boundary_mapping.end(); ++i)
if ((*i != DoFHandler<dim>::invalid_dof_index) &&
(*i > max_element))
#endif
const unsigned int dofs_per_face = dof.get_fe().dofs_per_face;
- vector<unsigned int> dofs_on_this_face(dofs_per_face);
+ std::vector<unsigned int> dofs_on_this_face(dofs_per_face);
DoFHandler<dim>::active_face_iterator face = dof.begin_active_face(),
- endf = dof.end_face();
+ endf = dof.end_face();
for (; face!=endf; ++face)
if (boundary_indicators.find(face->boundary_indicator()) !=
boundary_indicators.end())
ExcDimensionMismatch (sparsity.n_cols(), n_dofs));
const unsigned int total_dofs = dof.get_fe().dofs_per_cell;
- vector<unsigned int> dofs_on_this_cell(total_dofs);
- vector<unsigned int> dofs_on_other_cell(total_dofs);
+ std::vector<unsigned int> dofs_on_this_cell(total_dofs);
+ std::vector<unsigned int> dofs_on_other_cell(total_dofs);
DoFHandler<dim>::active_cell_iterator cell = dof.begin_active(),
endc = dof.end();
ExcDimensionMismatch (flux_mask.n(), n_comp));
const unsigned int total_dofs = dof.get_fe().dofs_per_cell;
- vector<unsigned int> dofs_on_this_cell(total_dofs);
- vector<unsigned int> dofs_on_other_cell(total_dofs);
+ std::vector<unsigned int> dofs_on_this_cell(total_dofs);
+ std::vector<unsigned int> dofs_on_other_cell(total_dofs);
DoFHandler<dim>::active_cell_iterator cell = dof.begin_active(),
endc = dof.end();
- vector<vector<bool> > int_dof_mask(total_dofs,
- vector<bool>(total_dofs, false));
- vector<vector<bool> > flux_dof_mask(total_dofs,
- vector<bool>(total_dofs, false));
+ std::vector<std::vector<bool> > int_dof_mask(total_dofs,
+ std::vector<bool>(total_dofs, false));
+ std::vector<std::vector<bool> > flux_dof_mask(total_dofs,
+ std::vector<bool>(total_dofs, false));
for (unsigned int i=0; i<total_dofs; ++i)
for (unsigned int j=0; j<total_dofs; ++j)
{
const unsigned int n_dofs_on_mother = 2*fe.dofs_per_vertex + fe.dofs_per_line,
n_dofs_on_children = fe.dofs_per_vertex + 2*fe.dofs_per_line;
- vector<unsigned int> dofs_on_mother(n_dofs_on_mother);
- vector<unsigned int> dofs_on_children(n_dofs_on_children);
+ std::vector<unsigned int> dofs_on_mother(n_dofs_on_mother);
+ std::vector<unsigned int> dofs_on_children(n_dofs_on_children);
Assert(n_dofs_on_mother == fe.constraints().n(),
ExcDimensionMismatch(n_dofs_on_mother,
12*fe.dofs_per_line+
4*fe.dofs_per_quad);
- vector<unsigned int> dofs_on_mother(n_dofs_on_mother);
- vector<unsigned int> dofs_on_children(n_dofs_on_children);
+ std::vector<unsigned int> dofs_on_mother(n_dofs_on_mother);
+ std::vector<unsigned int> dofs_on_children(n_dofs_on_children);
Assert(n_dofs_on_mother == fe.constraints().n(),
ExcDimensionMismatch(n_dofs_on_mother,
// count how often we have added a value
// in the sum for each dof
- vector<unsigned char> touch_count (dof_handler.n_dofs(), 0);
+ std::vector<unsigned char> touch_count (dof_handler.n_dofs(), 0);
DoFHandler<dim>::active_cell_iterator cell = dof_handler.begin_active(),
endc = dof_handler.end();
unsigned int present_cell = 0;
const unsigned int dofs_per_cell = fe.dofs_per_cell;
- vector<unsigned int> dof_indices (dofs_per_cell);
+ std::vector<unsigned int> dof_indices (dofs_per_cell);
for (; cell!=endc; ++cell, ++present_cell)
{
template<int dim>
void
-DoFTools::extract_dofs (const DoFHandler<dim> &dof,
- const vector<bool> &component_select,
- vector<bool> &selected_dofs)
+DoFTools::extract_dofs (const DoFHandler<dim> &dof,
+ const std::vector<bool> &component_select,
+ std::vector<bool> &selected_dofs)
{
const FiniteElement<dim> &fe = dof.get_fe();
Assert(component_select.size() == fe.n_components(),
// preset all values by false
fill_n (selected_dofs.begin(), dof.n_dofs(), false);
- vector<unsigned int> indices(fe.dofs_per_cell);
+ std::vector<unsigned int> indices(fe.dofs_per_cell);
DoFHandler<dim>::active_cell_iterator c;
for (c = dof.begin_active() ; c != dof.end() ; ++ c)
void
DoFTools::extract_level_dofs(const unsigned int level,
const MGDoFHandler<dim> &dof,
- const vector<bool> &component_select,
- vector<bool> &selected_dofs)
+ const std::vector<bool> &component_select,
+ std::vector<bool> &selected_dofs)
{
const FiniteElement<dim>& fe = dof.get_fe();
Assert(component_select.size() == fe.n_components(),
// preset all values by false
fill_n (selected_dofs.begin(), dof.n_dofs(level), false);
- vector<unsigned int> indices(fe.dofs_per_cell);
+ std::vector<unsigned int> indices(fe.dofs_per_cell);
MGDoFHandler<dim>::cell_iterator c;
for (c = dof.begin(level) ; c != dof.end(level) ; ++ c)
template <int dim>
void
-DoFTools::extract_boundary_dofs (const DoFHandler<dim> &dof_handler,
- const vector<bool> &component_select,
- vector<bool> &selected_dofs,
- const set<unsigned char> &boundary_indicators)
+DoFTools::extract_boundary_dofs (const DoFHandler<dim> &dof_handler,
+ const std::vector<bool> &component_select,
+ std::vector<bool> &selected_dofs,
+ const std::set<unsigned char> &boundary_indicators)
{
Assert (component_select.size() == dof_handler.get_fe().n_components(),
ExcWrongSize (component_select.size(),
// values
selected_dofs.clear ();
selected_dofs.resize (dof_handler.n_dofs(), false);
- vector<unsigned int> face_dof_indices (dof_handler.get_fe().dofs_per_face);
+ std::vector<unsigned int> face_dof_indices (dof_handler.get_fe().dofs_per_face);
for (DoFHandler<dim>::active_cell_iterator cell=dof_handler.begin_active();
cell!=dof_handler.end(); ++cell)
for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
if (! check_boundary_indicator ||
(boundary_indicators.find (cell->face(face)->boundary_indicator())
!= boundary_indicators.end()))
- {
- cell->face(face)->get_dof_indices (face_dof_indices);
- for (unsigned int i=0; i<dof_handler.get_fe().dofs_per_face; ++i)
- if (component_select[dof_handler.get_fe().
- face_system_to_component_index(i).first] == true)
- selected_dofs[face_dof_indices[i]] = true;
- };
+ {
+ cell->face(face)->get_dof_indices (face_dof_indices);
+ for (unsigned int i=0; i<dof_handler.get_fe().dofs_per_face; ++i)
+ if (component_select[dof_handler.get_fe().
+ face_system_to_component_index(i).first] == true)
+ selected_dofs[face_dof_indices[i]] = true;
+ };
};
template <>
void
-DoFTools::extract_boundary_dofs (const DoFHandler<1> &dof_handler,
- const vector<bool> &component_select,
- vector<bool> &selected_dofs)
+DoFTools::extract_boundary_dofs (const DoFHandler<1> &dof_handler,
+ const std::vector<bool> &component_select,
+ std::vector<bool> &selected_dofs)
{
Assert (component_select.size() == dof_handler.get_fe().n_components(),
ExcWrongSize (component_select.size(),
template <>
void
DoFTools::extract_hanging_node_dofs (const DoFHandler<1> &dof_handler,
- vector<bool> &selected_dofs)
+ std::vector<bool> &selected_dofs)
{
Assert(selected_dofs.size() == dof_handler.n_dofs(),
ExcDimensionMismatch(selected_dofs.size(), dof_handler.n_dofs()));
template <>
void
DoFTools::extract_hanging_node_dofs (const DoFHandler<2> &dof_handler,
- vector<bool> &selected_dofs)
+ std::vector<bool> &selected_dofs)
{
const unsigned int dim = 2;
template <>
void
DoFTools::extract_hanging_node_dofs (const DoFHandler<3> &dof_handler,
- vector<bool> &selected_dofs)
+ std::vector<bool> &selected_dofs)
{
const unsigned int dim = 3;
// degree of freedom of the
// coarse-grid variable in the
// fine-grid element
- vector<Vector<double> > parameter_dofs (coarse_dofs_per_cell_component,
- Vector<double>(fine_dofs_per_cell));
+ std::vector<Vector<double> > parameter_dofs (coarse_dofs_per_cell_component,
+ Vector<double>(fine_dofs_per_cell));
// for each coarse dof: find its
// position within the fine element
// and set this value to one in the
// to true if this is an
// interesting dof. finally count
// how many true's there
- vector<bool> dof_is_interesting (fine_grid.n_dofs(), false);
- vector<unsigned int> local_dof_indices (fine_fe.dofs_per_cell);
+ std::vector<bool> dof_is_interesting (fine_grid.n_dofs(), false);
+ std::vector<unsigned int> local_dof_indices (fine_fe.dofs_per_cell);
for (DoFHandler<dim>::active_cell_iterator cell=fine_grid.begin_active();
cell!=fine_grid.end(); ++cell)
// get an array in which we store
// which dof on the coarse grid is
// a parameter and which is not
- vector<bool> coarse_dof_is_parameter (coarse_grid.n_dofs());
+ std::vector<bool> coarse_dof_is_parameter (coarse_grid.n_dofs());
if (true)
{
- vector<bool> mask (coarse_grid.get_fe().n_components(),
- false);
+ std::vector<bool> mask (coarse_grid.get_fe().n_components(),
+ false);
mask[coarse_component] = true;
extract_dofs (coarse_grid, mask, coarse_dof_is_parameter);
};
// that parameter dof, if it is any
// other dof, then its value is -1,
// indicating an error
- vector<int> weight_mapping (n_fine_dofs, -1);
+ std::vector<int> weight_mapping (n_fine_dofs, -1);
// set up this mapping
if (true)
{
- vector<unsigned int> local_dof_indices(fine_fe.dofs_per_cell);
+ std::vector<unsigned int> local_dof_indices(fine_fe.dofs_per_cell);
unsigned int next_free_index=0;
for (typename DoFHandler<dim>::active_cell_iterator cell=fine_grid.begin_active();
cell != fine_grid.end(); ++cell)
// while all others will be
// constrained to this dof (and
// possibly others)
- vector<int> representants(weights.m(), -1);
+ std::vector<int> representants(weights.m(), -1);
for (unsigned int parameter_dof=0; parameter_dof<weights.m(); ++parameter_dof)
if (coarse_dof_is_parameter[parameter_dof] == true)
{
// which takes the bulk of the
// time, but it is not known to the
// author how to make it faster...
- vector<pair<unsigned int,double> > constraint_line;
+ std::vector<std::pair<unsigned int,double> > constraint_line;
for (unsigned int global_dof=0; global_dof<n_fine_dofs; ++global_dof)
if (weight_mapping[global_dof] != -1)
// this global dof is a parameter
constraint_line.clear ();
for (unsigned int row=first_used_row; row<weights.m(); ++row)
if (weights(row,weight_mapping[global_dof]) != 0)
- constraint_line.push_back (make_pair(representants[row],
- weights(row,weight_mapping[global_dof])));
+ constraint_line.push_back (std::make_pair(representants[row],
+ weights(row,weight_mapping[global_dof])));
constraints.add_entries (global_dof, constraint_line);
};
DoFTools::compute_intergrid_weights (const DoFHandler<dim> &coarse_grid,
const unsigned int coarse_component,
const InterGridMap<DoFHandler,dim> &coarse_to_fine_grid_map,
- const vector<Vector<double> > ¶meter_dofs,
- const vector<int> &weight_mapping,
+ const std::vector<Vector<double> > ¶meter_dofs,
+ const std::vector<int> &weight_mapping,
FullMatrix<float> &weights)
{
// simply distribute the range of
// cells to different threads
typedef typename DoFHandler<dim>::active_cell_iterator active_cell_iterator;
-
vector<pair<active_cell_iterator,active_cell_iterator> >
+
std::vector<std::pair<active_cell_iterator,active_cell_iterator> >
cell_intervals = Threads::split_range<active_cell_iterator> (coarse_grid.begin_active(),
coarse_grid.end(),
multithread_info.n_default_threads);
DoFTools::compute_intergrid_weights_1 (const DoFHandler<dim> &coarse_grid,
const unsigned int coarse_component,
const InterGridMap<DoFHandler,dim> &coarse_to_fine_grid_map,
- const vector<Vector<double> > ¶meter_dofs,
- const vector<int> &weight_mapping,
+ const std::vector<Vector<double> > ¶meter_dofs,
+ const std::vector<int> &weight_mapping,
FullMatrix<float> &weights,
const typename DoFHandler<dim>::active_cell_iterator &begin,
const typename DoFHandler<dim>::active_cell_iterator &end)
Vector<double> global_parameter_representation (n_fine_dofs);
typename DoFHandler<dim>::active_cell_iterator cell;
- vector<unsigned int> parameter_dof_indices (coarse_fe.dofs_per_cell);
+ std::vector<unsigned int> parameter_dof_indices (coarse_fe.dofs_per_cell);
for (cell=begin; cell!=end; ++cell)
{
template <>
void DoFTools::map_dof_to_boundary_indices (const DoFHandler<1> &dof_handler,
- vector<unsigned int> &)
+ std::vector<unsigned int> &)
{
Assert (&dof_handler.get_fe() != 0, ExcNoFESelected());
Assert (false, ExcNotImplemented());
template <>
void DoFTools::map_dof_to_boundary_indices (const DoFHandler<1> &dof_handler,
const set<unsigned char> &,
- vector<unsigned int> &)
+ std::vector<unsigned int> &)
{
Assert (&dof_handler.get_fe() != 0, ExcNoFESelected());
Assert (false, ExcNotImplemented());
template <int dim>
-void DoFTools::map_dof_to_boundary_indices (const DoFHandler<dim> &dof_handler,
- vector<unsigned int> &mapping)
+void DoFTools::map_dof_to_boundary_indices (const DoFHandler<dim> &dof_handler,
+ std::vector<unsigned int> &mapping)
{
Assert (&dof_handler.get_fe() != 0, ExcNoFESelected());
DoFHandler<dim>::invalid_dof_index);
const unsigned int dofs_per_face = dof_handler.get_fe().dofs_per_face;
- vector<unsigned int> dofs_on_face(dofs_per_face);
+ std::vector<unsigned int> dofs_on_face(dofs_per_face);
unsigned int next_boundary_index = 0;
typename DoFHandler<dim>::active_face_iterator face = dof_handler.begin_active_face(),
template <int dim>
-void DoFTools::map_dof_to_boundary_indices (const DoFHandler<dim> &dof_handler,
- const set<unsigned char> &boundary_indicators,
- vector<unsigned int> &mapping)
+void DoFTools::map_dof_to_boundary_indices (const DoFHandler<dim> &dof_handler,
+ const std::set<unsigned char> &boundary_indicators,
+ std::vector<unsigned int> &mapping)
{
Assert (&dof_handler.get_fe() != 0, ExcNoFESelected());
Assert (boundary_indicators.find (255) == boundary_indicators.end(),
return;
const unsigned int dofs_per_face = dof_handler.get_fe().dofs_per_face;
- vector<unsigned int> dofs_on_face(dofs_per_face);
+ std::vector<unsigned int> dofs_on_face(dofs_per_face);
unsigned int next_boundary_index = 0;
typename DoFHandler<dim>::active_face_iterator face = dof_handler.begin_active_face(),
const FullMatrix<double>&);
template void
DoFTools::make_boundary_sparsity_pattern (const DoFHandler<deal_II_dimension>& dof,
- const vector<unsigned int> &,
+ const std::vector<unsigned int> &,
SparsityPattern &);
template void
DoFTools::make_boundary_sparsity_pattern (const DoFHandler<deal_II_dimension>& dof,
const DoFHandler<deal_II_dimension>::FunctionMap &boundary_indicators,
- const vector<unsigned int> &dof_to_boundary_mapping,
+ const std::vector<unsigned int> &dof_to_boundary_mapping,
SparsityPattern &sparsity);
#endif
template void
DoFTools::make_sparsity_pattern (const DoFHandler<deal_II_dimension>& dof,
- const vector<vector<bool> > &mask,
+ const std::vector<std::vector<bool> > &mask,
SparsityPattern &sparsity);
template void
DoFTools::make_sparsity_pattern (const DoFHandler<deal_II_dimension>& dof,
- const vector<vector<bool> > &mask,
+ const std::vector<std::vector<bool> > &mask,
BlockSparsityPattern &sparsity);
template
template void DoFTools::extract_dofs(const DoFHandler<deal_II_dimension>& dof,
- const vector<bool>& component_select,
- vector<bool>& selected_dofs);
+ const std::vector<bool>& component_select,
+ std::vector<bool>& selected_dofs);
template void DoFTools::extract_level_dofs(unsigned int level,
const MGDoFHandler<deal_II_dimension>& dof,
- const vector<bool>& component_select,
- vector<bool>& selected_dofs);
+ const std::vector<bool>& component_select,
+ std::vector<bool>& selected_dofs);
#if deal_II_dimension != 1
template
void
DoFTools::extract_boundary_dofs (const DoFHandler<deal_II_dimension> &,
- const vector<bool> &,
- vector<bool> &);
+ const std::vector<bool> &,
+ std::vector<bool> &);
#endif
template
template
void
DoFTools::map_dof_to_boundary_indices (const DoFHandler<deal_II_dimension> &,
- vector<unsigned int> &);
+ std::vector<unsigned int> &);
template
void
DoFTools::map_dof_to_boundary_indices (const DoFHandler<deal_II_dimension> &,
- const set<unsigned char> &,
- vector<unsigned int> &);
+ const std::set<unsigned char> &,
+ std::vector<unsigned int> &);
#endif
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
template <int dim>
FiniteElementBase<dim>::FiniteElementBase (const FiniteElementData<dim> &fe_data,
- const vector<bool> &restriction_is_additive_flags) :
+ const std::vector<bool> &restriction_is_additive_flags) :
FiniteElementData<dim> (fe_data),
- system_to_component_table(dofs_per_cell),
- face_system_to_component_table(dofs_per_face),
- component_to_system_table(components, vector<unsigned>(dofs_per_cell)),
- face_component_to_system_table(components, vector<unsigned>(dofs_per_face)),
- component_to_base_table(components),
- restriction_is_additive_flags(restriction_is_additive_flags)
+ system_to_component_table(dofs_per_cell),
+ face_system_to_component_table(dofs_per_face),
+ component_to_system_table(components, std::vector<unsigned>(dofs_per_cell)),
+ face_component_to_system_table(components, std::vector<unsigned>(dofs_per_face)),
+ component_to_base_table(components),
+ restriction_is_additive_flags(restriction_is_additive_flags)
{
Assert(restriction_is_additive_flags.size()==fe_data.components,
ExcWrongFieldDimension(restriction_is_additive_flags.size(),fe_data.components));
// to fill these arrays
for (unsigned int j=0 ; j<dofs_per_cell ; ++j)
{
- system_to_component_table[j] = pair<unsigned,unsigned>(0,j);
+ system_to_component_table[j] = std::pair<unsigned,unsigned>(0,j);
component_to_system_table[0][j] = j;
}
for (unsigned int j=0 ; j<dofs_per_face ; ++j)
{
- face_system_to_component_table[j] = pair<unsigned,unsigned>(0,j);
+ face_system_to_component_table[j] = std::pair<unsigned,unsigned>(0,j);
face_component_to_system_table[0][j] = j;
}
};
template <int dim>
FiniteElement<dim>::FiniteElement (const FiniteElementData<dim> &fe_data,
- const vector<bool> &restriction_is_additive_flags) :
+ const std::vector<bool> &restriction_is_additive_flags) :
FiniteElementBase<dim> (fe_data,
restriction_is_additive_flags) {};
template <>
void FiniteElement<1>::get_support_points (const DoFHandler<1>::cell_iterator &cell,
- vector<Point<1> > &support_points) const;
+
std::vector<Point<1> > &support_points) const;
template <>
void FiniteElement<1>::fill_fe_values (const DoFHandler<1>::cell_iterator &cell,
- const vector<Point<1> > &unit_points,
- vector<Tensor<2,1> > &jacobians,
+ const
std::vector<Point<1> > &unit_points,
+ std::vector<Tensor<2,1> > &jacobians,
const bool compute_jacobians,
- vector<Tensor<3,1> > &jacobians_grad,
+ std::vector<Tensor<3,1> > &jacobians_grad,
const bool compute_jacobians_grad,
- vector<Point<1> > &support_points,
+
std::vector<Point<1> > &support_points,
const bool compute_support_points,
- vector<Point<1> > &q_points,
+
std::vector<Point<1> > &q_points,
const bool compute_q_points,
const FullMatrix<double> &,
- const vector<vector<Tensor<1,1> > > &) const {
+ const std::vector<std::vector<Tensor<1,1> > > &) const {
Assert ((!compute_jacobians) || (jacobians.size() == unit_points.size()),
ExcWrongFieldDimension(jacobians.size(), unit_points.size()));
Assert ((!compute_jacobians_grad) || (jacobians_grad.size() == unit_points.size()),
template <>
void FiniteElement<1>::fill_fe_face_values (const DoFHandler<1>::cell_iterator &,
const unsigned int ,
- const vector<Point<0> > &,
- const vector<Point<1> > &,
- vector<Tensor<2,1> > &,
+ const
std::vector<Point<0> > &,
+ const
std::vector<Point<1> > &,
+ std::vector<Tensor<2,1> > &,
const bool ,
- vector<Tensor<3,1> > &,
+ std::vector<Tensor<3,1> > &,
const bool ,
- vector<Point<1> > &,
+
std::vector<Point<1> > &,
const bool ,
- vector<Point<1> > &,
+
std::vector<Point<1> > &,
const bool ,
- vector<double> &,
+ std::vector<double> &,
const bool ,
- vector<Point<1> > &,
+
std::vector<Point<1> > &,
const bool,
const FullMatrix<double> &,
- const vector<vector<Tensor<1,1> > > &) const {
+ const std::vector<std::vector<Tensor<1,1> > > &) const {
Assert (false, ExcNotImplemented());
};
void FiniteElement<1>::fill_fe_subface_values (const DoFHandler<1>::cell_iterator &,
const unsigned int ,
const unsigned int ,
- const vector<Point<0> > &,
- const vector<Point<1> > &,
- vector<Tensor<2,1> > &,
+ const
std::vector<Point<0> > &,
+ const
std::vector<Point<1> > &,
+ std::vector<Tensor<2,1> > &,
const bool ,
- vector<Tensor<3,1> > &,
+ std::vector<Tensor<3,1> > &,
const bool ,
- vector<Point<1> > &,
+
std::vector<Point<1> > &,
const bool ,
- vector<double> &,
+ std::vector<double> &,
const bool ,
- vector<Point<1> > &,
+
std::vector<Point<1> > &,
const bool,
const FullMatrix<double> &,
- const vector<vector<Tensor<1,1> > > &) const {
+ const std::vector<std::vector<Tensor<1,1> > > &) const {
Assert (false, ExcNotImplemented());
};
template <>
-void FiniteElement<1>::get_unit_support_points (vector<Point<1> > &support_points) const {
+void FiniteElement<1>::get_unit_support_points (
std::vector<Point<1> > &support_points) const {
Assert (support_points.size() == dofs_per_cell,
ExcWrongFieldDimension(support_points.size(), dofs_per_cell));
// compute support points. The first ones
template <>
void FiniteElement<1>::get_support_points (const DoFHandler<1>::cell_iterator &cell,
- vector<Point<1> > &support_points) const {
+
std::vector<Point<1> > &support_points) const {
Assert (support_points.size() == dofs_per_cell,
ExcWrongFieldDimension(support_points.size(), dofs_per_cell));
// compute support points. The first ones
// now dofs on line
for (unsigned int i=0; i<dofs_per_line; ++i)
support_points[next++] = cell->vertex(0) +
- Point<1>((i+1.0)/(dofs_per_line+1.0)*h);
+ Point<1>((i+1.0)/(dofs_per_line+1.0)*h);
};
#endif
template <int dim>
void FiniteElement<dim>::fill_fe_values (const DoFHandler<dim>::cell_iterator &,
- const vector<Point<dim> > &,
- vector<Tensor<2,dim> > &,
+ const
std::vector<Point<dim> > &,
+ std::vector<Tensor<2,dim> > &,
const bool,
- vector<Tensor<3,dim> > &,
+ std::vector<Tensor<3,dim> > &,
const bool,
- vector<Point<dim> > &,
+
std::vector<Point<dim> > &,
const bool,
- vector<Point<dim> > &,
+
std::vector<Point<dim> > &,
const bool,
const FullMatrix<double> &,
- const vector<vector<Tensor<1,dim> > > &) const {
+ const std::vector<std::vector<Tensor<1,dim> > > &) const {
Assert (false, ExcPureFunctionCalled());
};
template <int dim>
void FiniteElement<dim>::fill_fe_face_values (const DoFHandler<dim>::cell_iterator &cell,
const unsigned int face_no,
- const vector<Point<dim-1> > &unit_points,
- const vector<Point<dim> > &global_unit_points,
- vector<Tensor<2,dim> > &jacobians,
+ const
std::vector<Point<dim-1> > &unit_points,
+ const
std::vector<Point<dim> > &global_unit_points,
+ std::vector<Tensor<2,dim> > &jacobians,
const bool compute_jacobians,
- vector<Tensor<3,dim> > &jacobians_grad,
+ std::vector<Tensor<3,dim> > &jacobians_grad,
const bool compute_jacobians_grad,
- vector<Point<dim> > &support_points,
+
std::vector<Point<dim> > &support_points,
const bool compute_support_points,
- vector<Point<dim> > &q_points,
+
std::vector<Point<dim> > &q_points,
const bool compute_q_points,
- vector<double> &face_jacobi_determinants,
+ std::vector<double> &face_jacobi_determinants,
const bool compute_face_jacobians,
- vector<Point<dim> > &normal_vectors,
+
std::vector<Point<dim> > &normal_vectors,
const bool compute_normal_vectors,
const FullMatrix<double> &shape_values_transform,
- const vector<vector<Tensor<1,dim> > > &shape_gradients_transform) const
+ const std::vector<std::vector<Tensor<1,dim> > > &shape_gradients_transform) const
{
Assert (jacobians.size() == unit_points.size(),
typename FiniteElementBase<dim>::ExcWrongFieldDimension(jacobians.size(),
dofs_per_face));
// size not checked since not used
- static vector<Point<dim> > dummy(0);
+ static
std::vector<Point<dim> > dummy(0);
fill_fe_values (cell, global_unit_points,
jacobians, compute_jacobians,
jacobians_grad, compute_jacobians_grad,
void FiniteElement<dim>::fill_fe_subface_values (const DoFHandler<dim>::cell_iterator &cell,
const unsigned int face_no,
const unsigned int subface_no,
- const vector<Point<dim-1> > &unit_points,
- const vector<Point<dim> > &global_unit_points,
- vector<Tensor<2,dim> > &jacobians,
+ const
std::vector<Point<dim-1> > &unit_points,
+ const
std::vector<Point<dim> > &global_unit_points,
+ std::vector<Tensor<2,dim> > &jacobians,
const bool compute_jacobians,
- vector<Tensor<3,dim> > &jacobians_grad,
+ std::vector<Tensor<3,dim> > &jacobians_grad,
const bool compute_jacobians_grad,
- vector<Point<dim> > &q_points,
+
std::vector<Point<dim> > &q_points,
const bool compute_q_points,
- vector<double> &face_jacobi_determinants,
+ std::vector<double> &face_jacobi_determinants,
const bool compute_face_jacobians,
- vector<Point<dim> > &normal_vectors,
+
std::vector<Point<dim> > &normal_vectors,
const bool compute_normal_vectors,
const FullMatrix<double> &shape_values_transform,
- const vector<vector<Tensor<1,dim> > > &shape_gradients_transform) const
+ const std::vector<std::vector<Tensor<1,dim> > > &shape_gradients_transform) const
{
Assert (jacobians.size() == unit_points.size(),
typename FiniteElementBase<dim>::ExcWrongFieldDimension(jacobians.size(),
typename FiniteElementBase<dim>::ExcWrongFieldDimension(global_unit_points.size(),
unit_points.size()));
- static vector<Point<dim> > dummy(0); // size not checked since not used
+ static
std::vector<Point<dim> > dummy(0); // size not checked since not used
fill_fe_values (cell, global_unit_points,
jacobians, compute_jacobians,
jacobians_grad, compute_jacobians_grad,
template <int dim>
void
-FiniteElement<dim>::get_unit_support_points (vector<Point<dim> > &) const
+FiniteElement<dim>::get_unit_support_points (
std::vector<Point<dim> > &) const
{
Assert (false, ExcPureFunctionCalled());
};
template <int dim>
void
FiniteElement<dim>::get_support_points (const DoFHandler<dim>::cell_iterator &,
-
vector<Point<dim> > &) const
+
std::vector<Point<dim> > &) const
{
Assert (false, ExcPureFunctionCalled());
};
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
n_functions := 5:
- # note: support_points[i] is a vector which is indexed from
+ # note: support_points[i] is a std::vector which is indexed from
# one and not from zero!
support_points[0] := [0,0]:
support_points[1] := [1,0]:
template <>
FECrissCross<1>::FECrissCross () :
- // set more or less invalid data
+ // set more or less invalid data
FiniteElement<1> (FiniteElementData<1> (0,0,0,0),
- vector<bool>())
+ std::vector<bool>())
{
Assert (false, ExcNotUseful());
};
template <>
-void FECrissCross<1>::get_unit_support_points (vector<Point<1> >&) const {
+void FECrissCross<1>::get_unit_support_points (
std::vector<Point<1> >&) const {
Assert (false, ExcNotUseful());
};
template <>
void FECrissCross<1>::get_support_points (const DoFHandler<1>::cell_iterator &,
- vector<Point<1> > &) const {
+
std::vector<Point<1> > &) const {
Assert (false, ExcNotUseful());
};
template <>
void FECrissCross<1>::get_face_support_points (const DoFHandler<1>::face_iterator &,
- vector<Point<1> > &) const {
+
std::vector<Point<1> > &) const {
Assert (false, ExcNotUseful());
};
template <>
void FECrissCross<1>::get_face_jacobians (const DoFHandler<1>::face_iterator &,
- const vector<Point<0> > &,
- vector<double> &) const {
+ const
std::vector<Point<0> > &,
+ std::vector<double> &) const {
Assert (false, ExcNotUseful());
};
template <>
void FECrissCross<1>::get_subface_jacobians (const DoFHandler<1>::face_iterator &,
const unsigned int,
- const vector<Point<0> > &,
- vector<double> &) const {
+ const
std::vector<Point<0> > &,
+ std::vector<double> &) const {
Assert (false, ExcNotUseful());
};
template <>
void FECrissCross<1>::get_normal_vectors (const DoFHandler<1>::cell_iterator &,
const unsigned int,
- const vector<Point<0> > &,
- vector<Point<1> > &) const {
+ const
std::vector<Point<0> > &,
+
std::vector<Point<1> > &) const {
Assert (false, ExcNotUseful());
};
void FECrissCross<1>::get_normal_vectors (const DoFHandler<1>::cell_iterator &,
const unsigned int,
const unsigned int,
- const vector<Point<0> > &,
- vector<Point<1> > &) const {
+ const
std::vector<Point<0> > &,
+
std::vector<Point<1> > &) const {
Assert (false, ExcNotUseful());
};
template <>
void FECrissCross<1>::fill_fe_values (const DoFHandler<1>::cell_iterator &,
-
const vector<Point<1> > &,
- vector<Tensor<2,1> > &,
- const bool ,
- vector<Tensor<3,1> > &,
- const bool ,
- const bool ,
- const bool ,
- const FullMatrix<double> &,
- const vector<vector<Tensor<1,1> > > &) const {
+
const std::vector<Point<1> > &,
+ std::vector<Tensor<2,1> > &,
+ const bool ,
+ std::vector<Tensor<3,1> > &,
+ const bool ,
+
std::vector<Point<1> > &,
+ const bool ,
+
std::vector<Point<1> > &,
+ const bool ,
+ const FullMatrix<double> &,
+ const std::vector<std::vector<Tensor<1,1> > > &) const {
Assert (false, ExcNotUseful());
};
template <>
FECrissCross<2>::FECrissCross () :
FiniteElement<2> (FiniteElementData<2> (1,0,1,5,1),
- vector<bool> (1, false))
+ std::vector<bool> (1, false))
{
interface_constraints(0,0) = 1./2.;
interface_constraints(0,1) = 1./2.;
template <>
-void FECrissCross<2>::get_unit_support_points (vector<Point<2> > &unit_points) const {
+void FECrissCross<2>::get_unit_support_points (
std::vector<Point<2> > &unit_points) const {
Assert(unit_points.size()==dofs_per_cell,
- ExcWrongFieldDimension (unit_points.size(), dofs_per_cell));
+ ExcWrongFieldDimension (unit_points.size(), dofs_per_cell));
unit_points[0] = Point<2> (0,0);
unit_points[1] = Point<2> (1,0);
template <>
void FECrissCross<2>::get_support_points (const DoFHandler<2>::cell_iterator &cell,
- vector<Point<2> > &support_points) const {
+
std::vector<Point<2> > &support_points) const {
const unsigned int dim = 2;
Assert (support_points.size() == dofs_per_cell,
template <>
void FECrissCross<2>::get_face_support_points (const DoFHandler<2>::face_iterator &face,
- vector<Point<2> > &support_points) const {
+
std::vector<Point<2> > &support_points) const {
const unsigned int dim = 2;
Assert ((support_points.size() == dofs_per_face) &&
template <>
void FECrissCross<2>::get_face_jacobians (const DoFHandler<2>::face_iterator &face,
- const vector<Point<1> > &unit_points,
- vector<double> &face_jacobians) const {
+ const
std::vector<Point<1> > &unit_points,
+ std::vector<double> &face_jacobians) const {
// more or less copied from the linear
// finite element
Assert (unit_points.size() == face_jacobians.size(),
template <>
void FECrissCross<2>::get_subface_jacobians (const DoFHandler<2>::face_iterator &face,
const unsigned int,
- const vector<Point<1> > &unit_points,
- vector<double> &face_jacobians) const {
+ const
std::vector<Point<1> > &unit_points,
+ std::vector<double> &face_jacobians) const {
// more or less copied from the linear
// finite element
Assert (unit_points.size() == face_jacobians.size(),
template <>
void FECrissCross<2>::get_normal_vectors (const DoFHandler<2>::cell_iterator &cell,
const unsigned int face_no,
- const vector<Point<1> > &unit_points,
- vector<Point<2> > &normal_vectors) const {
+ const
std::vector<Point<1> > &unit_points,
+
std::vector<Point<2> > &normal_vectors) const {
// more or less copied from the linear
// finite element
Assert (unit_points.size() == normal_vectors.size(),
void FECrissCross<2>::get_normal_vectors (const DoFHandler<2>::cell_iterator &cell,
const unsigned int face_no,
const unsigned int,
- const vector<Point<1> > &unit_points,
- vector<Point<2> > &normal_vectors) const {
+ const
std::vector<Point<1> > &unit_points,
+
std::vector<Point<2> > &normal_vectors) const {
// more or less copied from the linear
// finite element
// note, that in 2D the normal vectors to the
template <int dim>
void FECrissCross<dim>::fill_fe_values (const DoFHandler<dim>::cell_iterator &cell,
- const vector<Point<dim> > &unit_points,
- vector<Tensor<2,dim> > &jacobians,
+ const
std::vector<Point<dim> > &unit_points,
+ std::vector<Tensor<2,dim> > &jacobians,
const bool compute_jacobians,
- vector<Tensor<3,dim> > &jacobians_grad,
+ std::vector<Tensor<3,dim> > &jacobians_grad,
const bool compute_jacobians_grad,
- vector<Point<dim> > &support_points,
+
std::vector<Point<dim> > &support_points,
const bool compute_support_points,
- vector<Point<dim> > &q_points,
+
std::vector<Point<dim> > &q_points,
const bool compute_q_points,
const FullMatrix<double> &shape_values_transform,
- const vector<vector<Tensor<1,dim> > > &/*shape_grad_transform*/) const {
+ const std::vector<std::vector<Tensor<1,dim> > > &/*shape_grad_transform*/) const {
Assert (jacobians.size() == unit_points.size(),
typename FiniteElementBase<dim>::ExcWrongFieldDimension(jacobians.size(),
unit_points.size()));
/* jacobi matrices: compute d(x)/d(xi) and invert this
Let M(l) be the inverse of J at the quadrature point l, then
M_{ij}(l) = sum_s p_i(s) d(N_s(l))/d(xi_j)
- where p_i(s) is the i-th coordinate of the s-th vertex vector,
+ where p_i(s) is the i-th coordinate of the s-th vertex std::vector,
N_s(l) is the value of the s-th shape function at the
quadrature point l.
template <>
FECrissCross<3>::FECrissCross () :
- // set more or less invalid data
+ // set more or less invalid data
FiniteElement<3> (FiniteElementData<3> (0,0,0,0,0,0),
- vector<bool>())
+ std::vector<bool>())
{
Assert (false, ExcNotImplemented());
};
template <>
double
FECrissCross<3>::shape_value (const unsigned int,
- const Point<3> &) const
+ const Point<3> &) const
{
Assert (false, ExcNotImplemented());
return 0;
template <>
Tensor<1,3>
FECrissCross<3>::shape_grad (const unsigned int,
- const Point<3> &) const
+ const Point<3> &) const
{
Assert (false, ExcNotImplemented());
return Tensor<1,3>();
template <>
Tensor<2,3>
FECrissCross<3>::shape_grad_grad (const unsigned int,
- const Point<3> &) const
+ const Point<3> &) const
{
Assert (false, ExcNotImplemented());
return Tensor<2,3>();
template <>
void
FECrissCross<3>::get_local_mass_matrix (const DoFHandler<3>::cell_iterator &,
- FullMatrix<double> &) const
+ FullMatrix<double> &) const
{
Assert (false, ExcNotImplemented());
};
template <>
-void FECrissCross<3>::get_unit_support_points (vector<Point<3> > &) const
+void FECrissCross<3>::get_unit_support_points (
std::vector<Point<3> > &) const
{
Assert (false, ExcNotImplemented());
};
template <>
void FECrissCross<3>::get_support_points (const DoFHandler<3>::cell_iterator &,
- vector<Point<3> > &) const
+
std::vector<Point<3> > &) const
{
Assert (false, ExcNotImplemented());
};
template <>
void FECrissCross<3>::get_face_support_points (const DoFHandler<3>::face_iterator &,
- vector<Point<3> > &) const
+
std::vector<Point<3> > &) const
{
Assert (false, ExcNotImplemented());
};
template <>
void FECrissCross<3>::get_face_jacobians (const DoFHandler<3>::face_iterator &,
- const vector<Point<2> > &,
- vector<double> &) const {
+ const
std::vector<Point<2> > &,
+ std::vector<double> &) const {
Assert (false, ExcNotImplemented());
};
template <>
void FECrissCross<3>::get_subface_jacobians (const DoFHandler<3>::face_iterator &,
const unsigned int,
- const vector<Point<2> > &,
- vector<double> &) const {
+ const
std::vector<Point<2> > &,
+ std::vector<double> &) const {
Assert (false, ExcNotImplemented());
};
template <>
void FECrissCross<3>::get_normal_vectors (const DoFHandler<3>::cell_iterator &,
const unsigned int,
- const vector<Point<2> > &,
- vector<Point<3> > &) const {
+ const
std::vector<Point<2> > &,
+
std::vector<Point<3> > &) const {
Assert (false, ExcNotImplemented());
};
void FECrissCross<3>::get_normal_vectors (const DoFHandler<3>::cell_iterator &,
const unsigned int,
const unsigned int,
- const vector<Point<2> > &,
- vector<Point<3> > &) const {
+ const
std::vector<Point<2> > &,
+
std::vector<Point<3> > &) const {
Assert (false, ExcNotImplemented());
};
template <>
void FECrissCross<3>::fill_fe_values (const DoFHandler<3>::cell_iterator &,
- const vector<Point<3> > &,
- vector<Tensor<2,3> > &,
+ const
std::vector<Point<3> > &,
+ std::vector<Tensor<2,3> > &,
const bool ,
- vector<Tensor<3,3> > &,
+ std::vector<Tensor<3,3> > &,
const bool ,
- vector<Point<3> > &,
+
std::vector<Point<3> > &,
const bool ,
- vector<Point<3> > &,
+
std::vector<Point<3> > &,
const bool ,
const FullMatrix<double> &,
- const vector<vector<Tensor<1,3> > > &) const {
+ const std::vector<std::vector<Tensor<1,3> > > &) const {
Assert (false, ExcNotImplemented());
};
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
template <>
FEQ3<1>::FEQ3 () :
FEQ1Mapping<1> (1, 2, 0, 0, 1,
- vector<bool> (1, false))
+ std::vector<bool> (1, false))
{
initialize_matrices ();
};
template <>
FEQ3<1>::FEQ3 (const int) :
FEQ1Mapping<1> (0, 4, 0, 0, 1,
- vector<bool> (1, true))
+ std::vector<bool> (1, true))
{
initialize_matrices ();
};
template <>
double
FEQ3<1>::shape_value (const unsigned int i,
- const Point<1> &p) const
+ const Point<1> &p) const
{
Assert((i<dofs_per_cell), ExcIndexRange(i, 0, dofs_per_cell));
const double xi = p(0);
template <>
Tensor<1,1>
FEQ3<1>::shape_grad (const unsigned int i,
- const Point<1> &p) const
+ const Point<1> &p) const
{
Assert((i<dofs_per_cell), ExcIndexRange(i, 0, dofs_per_cell));
const double xi = p(0);
template <>
Tensor<2,1>
FEQ3<1>::shape_grad_grad (const unsigned int i,
- const Point<1> &p) const
+ const Point<1> &p) const
{
Assert (i<dofs_per_cell, ExcIndexRange(i, 0, dofs_per_cell));
template <>
-void FEQ3<1>::get_unit_support_points (vector<Point<1> > &unit_points) const {
+void FEQ3<1>::get_unit_support_points (
std::vector<Point<1> > &unit_points) const {
FiniteElement<1>::get_unit_support_points (unit_points);
};
template <>
void FEQ3<1>::get_support_points (const DoFHandler<1>::cell_iterator &cell,
- vector<Point<1> > &support_points) const {
+
std::vector<Point<1> > &support_points) const {
FiniteElement<1>::get_support_points (cell, support_points);
};
template <>
void FEQ3<1>::get_face_support_points (const DoFHandler<1>::face_iterator &,
- vector<Point<1> > &) const {
+
std::vector<Point<1> > &) const {
Assert (false, ExcInternalError());
};
template <>
FEQ3<2>::FEQ3 () :
FEQ1Mapping<2> (1, 2, 4, 0, 1,
- vector<bool> (1, false))
+ std::vector<bool> (1, false))
{
interface_constraints(0,0) = -1.0/16.0;
interface_constraints(0,1) = -1.0/16.0;
template <>
FEQ3<2>::FEQ3 (const int) :
FEQ1Mapping<2> (0, 0, 16, 0, 1,
- vector<bool> (1, true))
+ std::vector<bool> (1, true))
{
initialize_matrices ();
};
template <>
double
FEQ3<2>::shape_value (const unsigned int i,
- const Point<2> &p) const
+ const Point<2> &p) const
{
Assert (i<dofs_per_cell, ExcIndexRange(i, 0, dofs_per_cell));
switch (i)
{
case 0: return 1.0-11.0/2.0*xi+9.0*xi*xi-9.0/2.0*xi*xi*xi+(-11.0/2.0+
-121.0/4.0*xi-99.0/2.0*xi*xi+99.0/4.0*xi*xi*xi)*eta+(9.0-99.0/2.0*xi+81.0*xi*xi
--81.0/2.0*xi*xi*xi)*eta*eta+(-9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi
-*xi)*eta*eta*eta;
+ 121.0/4.0*xi-99.0/2.0*xi*xi+99.0/4.0*xi*xi*xi)*eta+(9.0-99.0/2.0*xi+81.0*xi*xi
+ -81.0/2.0*xi*xi*xi)*eta*eta+(-9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi
+ *xi)*eta*eta*eta;
case 1: return xi-9.0/2.0*xi*xi+9.0/2.0*xi*xi*xi+(-11.0/2.0*xi+99.0/4.0
-*xi*xi-99.0/4.0*xi*xi*xi)*eta+(9.0*xi-81.0/2.0*xi*xi+81.0/2.0*xi*xi*xi)*eta*eta
-+(-9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi)*eta*eta*eta;
+ *xi*xi-99.0/4.0*xi*xi*xi)*eta+(9.0*xi-81.0/2.0*xi*xi+81.0/2.0*xi*xi*xi)*eta*eta
+ +(-9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi)*eta*eta*eta;
case 2: return (xi-9.0/2.0*xi*xi+9.0/2.0*xi*xi*xi)*eta+(-9.0/2.0*xi+
-81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi)*eta*eta+(9.0/2.0*xi-81.0/4.0*xi*xi+81.0/4.0*
-xi*xi*xi)*eta*eta*eta;
+ 81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi)*eta*eta+(9.0/2.0*xi-81.0/4.0*xi*xi+81.0/4.0*
+ xi*xi*xi)*eta*eta*eta;
case 3: return (1.0-11.0/2.0*xi+9.0*xi*xi-9.0/2.0*xi*xi*xi)*eta+(-9.0/
-2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi)*eta*eta+(9.0/2.0-99.0/4.0*xi+
-81.0/2.0*xi*xi-81.0/4.0*xi*xi*xi)*eta*eta*eta;
+ 2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi)*eta*eta+(9.0/2.0-99.0/4.0*xi+
+ 81.0/2.0*xi*xi-81.0/4.0*xi*xi*xi)*eta*eta*eta;
case 4: return 9.0*xi-45.0/2.0*xi*xi+27.0/2.0*xi*xi*xi+(-99.0/2.0*xi+
-495.0/4.0*xi*xi-297.0/4.0*xi*xi*xi)*eta+(81.0*xi-405.0/2.0*xi*xi+243.0/2.0*xi*
-xi*xi)*eta*eta+(-81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi)*eta*eta*eta;
+ 495.0/4.0*xi*xi-297.0/4.0*xi*xi*xi)*eta+(81.0*xi-405.0/2.0*xi*xi+243.0/2.0*xi*
+ xi*xi)*eta*eta+(-81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi)*eta*eta*eta;
case 5: return -9.0/2.0*xi+18.0*xi*xi-27.0/2.0*xi*xi*xi+(99.0/4.0*xi
--99.0*xi*xi+297.0/4.0*xi*xi*xi)*eta+(-81.0/2.0*xi+162.0*xi*xi-243.0/2.0*xi*xi*
-xi)*eta*eta+(81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi)*eta*eta*eta;
+ -99.0*xi*xi+297.0/4.0*xi*xi*xi)*eta+(-81.0/2.0*xi+162.0*xi*xi-243.0/2.0*xi*xi*
+ xi)*eta*eta+(81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi)*eta*eta*eta;
case 6: return (9.0*xi-81.0/2.0*xi*xi+81.0/2.0*xi*xi*xi)*eta+(-45.0/2.0
-*xi+405.0/4.0*xi*xi-405.0/4.0*xi*xi*xi)*eta*eta+(27.0/2.0*xi-243.0/4.0*xi*xi+
-243.0/4.0*xi*xi*xi)*eta*eta*eta;
+ *xi+405.0/4.0*xi*xi-405.0/4.0*xi*xi*xi)*eta*eta+(27.0/2.0*xi-243.0/4.0*xi*xi+
+ 243.0/4.0*xi*xi*xi)*eta*eta*eta;
case 7: return (-9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi)*eta+(18.0
-*xi-81.0*xi*xi+81.0*xi*xi*xi)*eta*eta+(-27.0/2.0*xi+243.0/4.0*xi*xi-243.0/4.0*
-xi*xi*xi)*eta*eta*eta;
+ *xi-81.0*xi*xi+81.0*xi*xi*xi)*eta*eta+(-27.0/2.0*xi+243.0/4.0*xi*xi-243.0/4.0*
+ xi*xi*xi)*eta*eta*eta;
case 8: return (9.0*xi-45.0/2.0*xi*xi+27.0/2.0*xi*xi*xi)*eta+(-81.0/2.0
-*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi)*eta*eta+(81.0/2.0*xi-405.0/4.0*xi*xi+
-243.0/4.0*xi*xi*xi)*eta*eta*eta;
+ *xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi)*eta*eta+(81.0/2.0*xi-405.0/4.0*xi*xi+
+ 243.0/4.0*xi*xi*xi)*eta*eta*eta;
case 9: return (-9.0/2.0*xi+18.0*xi*xi-27.0/2.0*xi*xi*xi)*eta+(81.0/4.0
-*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi)*eta*eta+(-81.0/4.0*xi+81.0*xi*xi-243.0/4.0*
-xi*xi*xi)*eta*eta*eta;
+ *xi-81.0*xi*xi+243.0/4.0*xi*xi*xi)*eta*eta+(-81.0/4.0*xi+81.0*xi*xi-243.0/4.0*
+ xi*xi*xi)*eta*eta*eta;
case 10: return (9.0-99.0/2.0*xi+81.0*xi*xi-81.0/2.0*xi*xi*xi)*eta+(
--45.0/2.0+495.0/4.0*xi-405.0/2.0*xi*xi+405.0/4.0*xi*xi*xi)*eta*eta+(27.0/2.0
--297.0/4.0*xi+243.0/2.0*xi*xi-243.0/4.0*xi*xi*xi)*eta*eta*eta;
+ -45.0/2.0+495.0/4.0*xi-405.0/2.0*xi*xi+405.0/4.0*xi*xi*xi)*eta*eta+(27.0/2.0
+ -297.0/4.0*xi+243.0/2.0*xi*xi-243.0/4.0*xi*xi*xi)*eta*eta*eta;
case 11: return (-9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi)
-*eta+(18.0-99.0*xi+162.0*xi*xi-81.0*xi*xi*xi)*eta*eta+(-27.0/2.0+297.0/4.0*xi
--243.0/2.0*xi*xi+243.0/4.0*xi*xi*xi)*eta*eta*eta;
+ *eta+(18.0-99.0*xi+162.0*xi*xi-81.0*xi*xi*xi)*eta*eta+(-27.0/2.0+297.0/4.0*xi
+ -243.0/2.0*xi*xi+243.0/4.0*xi*xi*xi)*eta*eta*eta;
case 12: return (81.0*xi-405.0/2.0*xi*xi+243.0/2.0*xi*xi*xi)*eta+(
--405.0/2.0*xi+2025.0/4.0*xi*xi-1215.0/4.0*xi*xi*xi)*eta*eta+(243.0/2.0*xi
--1215.0/4.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta*eta;
+ -405.0/2.0*xi+2025.0/4.0*xi*xi-1215.0/4.0*xi*xi*xi)*eta*eta+(243.0/2.0*xi
+ -1215.0/4.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta*eta;
case 13: return (-81.0/2.0*xi+162.0*xi*xi-243.0/2.0*xi*xi*xi)*eta+(
-405.0/4.0*xi-405.0*xi*xi+1215.0/4.0*xi*xi*xi)*eta*eta+(-243.0/4.0*xi+243.0*xi*
-xi-729.0/4.0*xi*xi*xi)*eta*eta*eta;
+ 405.0/4.0*xi-405.0*xi*xi+1215.0/4.0*xi*xi*xi)*eta*eta+(-243.0/4.0*xi+243.0*xi*
+ xi-729.0/4.0*xi*xi*xi)*eta*eta*eta;
case 14: return (81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi)*eta+(-81.0*
-xi+324.0*xi*xi-243.0*xi*xi*xi)*eta*eta+(243.0/4.0*xi-243.0*xi*xi+729.0/4.0*xi*
-xi*xi)*eta*eta*eta;
+ xi+324.0*xi*xi-243.0*xi*xi*xi)*eta*eta+(243.0/4.0*xi-243.0*xi*xi+729.0/4.0*xi*
+ xi*xi)*eta*eta*eta;
case 15: return (-81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi)*eta+(
-162.0*xi-405.0*xi*xi+243.0*xi*xi*xi)*eta*eta+(-243.0/2.0*xi+1215.0/4.0*xi*xi
--729.0/4.0*xi*xi*xi)*eta*eta*eta;
+ 162.0*xi-405.0*xi*xi+243.0*xi*xi*xi)*eta*eta+(-243.0/2.0*xi+1215.0/4.0*xi*xi
+ -729.0/4.0*xi*xi*xi)*eta*eta*eta;
};
return 0;
};
template <>
Tensor<1,2>
FEQ3<2>::shape_grad (const unsigned int i,
- const Point<2> &p) const
+ const Point<2> &p) const
{
Assert (i<dofs_per_cell, ExcIndexRange(i, 0, dofs_per_cell));
switch (i)
{
case 0: return Point<2>(-11.0/2.0+18.0*xi-27.0/2.0*xi*xi+(121.0/4.0-99.0*xi+297.0/4.0*xi*xi)*eta+(-99.0/2.0+162.0*xi-243.0/2.0*xi*xi)*eta*eta+(99.0/4.0-81.0*xi+243.0/4.0*xi*xi)*eta*eta*eta,
- -11.0/2.0+121.0/4.0*xi-99.0/2.0*xi*xi+99.0/4.0*xi*xi*xi+2.0*(9.0-99.0/2.0*xi+81.0*xi*xi-81.0/2.0*xi*xi*xi)*eta+3.0*(-9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi)*eta*eta);
+ -11.0/2.0+121.0/4.0*xi-99.0/2.0*xi*xi+99.0/4.0*xi*xi*xi+2.0*(9.0-99.0/2.0*xi+81.0*xi*xi-81.0/2.0*xi*xi*xi)*eta+3.0*(-9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi)*eta*eta);
case 1: return Point<2>(1.0-9.0*xi+27.0/2.0*xi*xi+(-11.0/2.0+99.0/2.0*xi-297.0/4.0*xi*xi)*eta+(9.0-81.0*xi+243.0/2.0*xi*xi)*eta*eta+(-9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi)*eta*eta*eta,
- -11.0/2.0*xi+99.0/4.0*xi*xi-99.0/4.0*xi*xi*xi+2.0*(9.0*xi-81.0/2.0*xi*xi+81.0/2.0*xi*xi*xi)*eta+3.0*(-9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi)*eta*eta);
+ -11.0/2.0*xi+99.0/4.0*xi*xi-99.0/4.0*xi*xi*xi+2.0*(9.0*xi-81.0/2.0*xi*xi+81.0/2.0*xi*xi*xi)*eta+3.0*(-9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi)*eta*eta);
case 2: return Point<2>((1.0-9.0*xi+27.0/2.0*xi*xi)*eta+(-9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi)*eta*eta+(9.0/2.0-81.0/2.0*xi+243.0/4.0*xi*xi)*eta*eta*eta,
- xi-9.0/2.0*xi*xi+9.0/2.0*xi*xi*xi+2.0*(-9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi)*eta+3.0*(9.0/2.0*xi-81.0/4.0*xi*xi+81.0/4.0*xi*xi*xi)*eta*eta);
+ xi-9.0/2.0*xi*xi+9.0/2.0*xi*xi*xi+2.0*(-9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi)*eta+3.0*(9.0/2.0*xi-81.0/4.0*xi*xi+81.0/4.0*xi*xi*xi)*eta*eta);
case 3: return Point<2>((-11.0/2.0+18.0*xi-27.0/2.0*xi*xi)*eta+(99.0/4.0-81.0*xi+243.0/4.0*xi*xi)*eta*eta+(-99.0/4.0+81.0*xi-243.0/4.0*xi*xi)*eta*eta*eta,
- 1.0-11.0/2.0*xi+9.0*xi*xi-9.0/2.0*xi*xi*xi+2.0*(-9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi)*eta+3.0*(9.0/2.0-99.0/4.0*xi+81.0/2.0*xi*xi-81.0/4.0*xi*xi*xi)*eta*eta);
+ 1.0-11.0/2.0*xi+9.0*xi*xi-9.0/2.0*xi*xi*xi+2.0*(-9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi)*eta+3.0*(9.0/2.0-99.0/4.0*xi+81.0/2.0*xi*xi-81.0/4.0*xi*xi*xi)*eta*eta);
case 4: return Point<2>(9.0-45.0*xi+81.0/2.0*xi*xi+(-99.0/2.0+495.0/2.0*xi-891.0/4.0*xi*xi)*eta+(81.0-405.0*xi+729.0/2.0*xi*xi)*eta*eta+(-81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi)*eta*eta*eta,
- -99.0/2.0*xi+495.0/4.0*xi*xi-297.0/4.0*xi*xi*xi+2.0*(81.0*xi-405.0/2.0*xi*xi+243.0/2.0*xi*xi*xi)*eta+3.0*(-81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi)*eta*eta);
+ -99.0/2.0*xi+495.0/4.0*xi*xi-297.0/4.0*xi*xi*xi+2.0*(81.0*xi-405.0/2.0*xi*xi+243.0/2.0*xi*xi*xi)*eta+3.0*(-81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi)*eta*eta);
case 5: return Point<2>(-9.0/2.0+36.0*xi-81.0/2.0*xi*xi+(99.0/4.0-198.0*xi+891.0/4.0*xi*xi)*eta+(-81.0/2.0+324.0*xi-729.0/2.0*xi*xi)*eta*eta+(81.0/4.0-162.0*xi+729.0/4.0*xi*xi)*eta*eta*eta,
- 99.0/4.0*xi-99.0*xi*xi+297.0/4.0*xi*xi*xi+2.0*(-81.0/2.0*xi+162.0*xi*xi-243.0/2.0*xi*xi*xi)*eta+3.0*(81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi)*eta*eta);
+ 99.0/4.0*xi-99.0*xi*xi+297.0/4.0*xi*xi*xi+2.0*(-81.0/2.0*xi+162.0*xi*xi-243.0/2.0*xi*xi*xi)*eta+3.0*(81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi)*eta*eta);
case 6: return Point<2>((9.0-81.0*xi+243.0/2.0*xi*xi)*eta+(-45.0/2.0+405.0/2.0*xi-1215.0/4.0*xi*xi)*eta*eta+(27.0/2.0-243.0/2.0*xi+729.0/4.0*xi*xi)*eta*eta*eta,
- 9.0*xi-81.0/2.0*xi*xi+81.0/2.0*xi*xi*xi+2.0*(-45.0/2.0*xi+405.0/4.0*xi*xi-405.0/4.0*xi*xi*xi)*eta+3.0*(27.0/2.0*xi-243.0/4.0*xi*xi+243.0/4.0*xi*xi*xi)*eta*eta);
+ 9.0*xi-81.0/2.0*xi*xi+81.0/2.0*xi*xi*xi+2.0*(-45.0/2.0*xi+405.0/4.0*xi*xi-405.0/4.0*xi*xi*xi)*eta+3.0*(27.0/2.0*xi-243.0/4.0*xi*xi+243.0/4.0*xi*xi*xi)*eta*eta);
case 7: return Point<2>((-9.0/2.0+81.0/2.0*xi-243.0/4.0*xi*xi)*eta+(18.0-162.0*xi+243.0*xi*xi)*eta*eta+(-27.0/2.0+243.0/2.0*xi-729.0/4.0*xi*xi)*eta*eta*eta,
- -9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi+2.0*(18.0*xi-81.0*xi*xi+81.0*xi*xi*xi)*eta+3.0*(-27.0/2.0*xi+243.0/4.0*xi*xi-243.0/4.0*xi*xi*xi)*eta*eta);
+ -9.0/2.0*xi+81.0/4.0*xi*xi-81.0/4.0*xi*xi*xi+2.0*(18.0*xi-81.0*xi*xi+81.0*xi*xi*xi)*eta+3.0*(-27.0/2.0*xi+243.0/4.0*xi*xi-243.0/4.0*xi*xi*xi)*eta*eta);
case 8: return Point<2>((9.0-45.0*xi+81.0/2.0*xi*xi)*eta+(-81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi)*eta*eta+(81.0/2.0-405.0/2.0*xi+729.0/4.0*xi*xi)*eta*eta*eta,
- 9.0*xi-45.0/2.0*xi*xi+27.0/2.0*xi*xi*xi+2.0*(-81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi)*eta+3.0*(81.0/2.0*xi-405.0/4.0*xi*xi+243.0/4.0*xi*xi*xi)*eta*eta);
+ 9.0*xi-45.0/2.0*xi*xi+27.0/2.0*xi*xi*xi+2.0*(-81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi)*eta+3.0*(81.0/2.0*xi-405.0/4.0*xi*xi+243.0/4.0*xi*xi*xi)*eta*eta);
case 9: return Point<2>((-9.0/2.0+36.0*xi-81.0/2.0*xi*xi)*eta+(81.0/4.0-162.0*xi+729.0/4.0*xi*xi)*eta*eta+(-81.0/4.0+162.0*xi-729.0/4.0*xi*xi)*eta*eta*eta,
- -9.0/2.0*xi+18.0*xi*xi-27.0/2.0*xi*xi*xi+2.0*(81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi)*eta+3.0*(-81.0/4.0*xi+81.0*xi*xi-243.0/4.0*xi*xi*xi)*eta*eta);
+ -9.0/2.0*xi+18.0*xi*xi-27.0/2.0*xi*xi*xi+2.0*(81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi)*eta+3.0*(-81.0/4.0*xi+81.0*xi*xi-243.0/4.0*xi*xi*xi)*eta*eta);
case 10: return Point<2>((-99.0/2.0+162.0*xi-243.0/2.0*xi*xi)*eta+(495.0/4.0-405.0*xi+1215.0/4.0*xi*xi)*eta*eta+(-297.0/4.0+243.0*xi-729.0/4.0*xi*xi)*eta*eta*eta,
- 9.0-99.0/2.0*xi+81.0*xi*xi-81.0/2.0*xi*xi*xi+2.0*(-45.0/2.0+495.0/4.0*xi-405.0/2.0*xi*xi+405.0/4.0*xi*xi*xi)*eta+3.0*(27.0/2.0-297.0/4.0*xi+243.0/2.0*xi*xi-243.0/4.0*xi*xi*xi)*eta*eta);
+ 9.0-99.0/2.0*xi+81.0*xi*xi-81.0/2.0*xi*xi*xi+2.0*(-45.0/2.0+495.0/4.0*xi-405.0/2.0*xi*xi+405.0/4.0*xi*xi*xi)*eta+3.0*(27.0/2.0-297.0/4.0*xi+243.0/2.0*xi*xi-243.0/4.0*xi*xi*xi)*eta*eta);
case 11: return Point<2>((99.0/4.0-81.0*xi+243.0/4.0*xi*xi)*eta+(-99.0+324.0*xi-243.0*xi*xi)*eta*eta+(297.0/4.0-243.0*xi+729.0/4.0*xi*xi)*eta*eta*eta,
- -9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi+2.0*(18.0-99.0*xi+162.0*xi*xi-81.0*xi*xi*xi)*eta+3.0*(-27.0/2.0+297.0/4.0*xi-243.0/2.0*xi*xi+243.0/4.0*xi*xi*xi)*eta*eta);
+ -9.0/2.0+99.0/4.0*xi-81.0/2.0*xi*xi+81.0/4.0*xi*xi*xi+2.0*(18.0-99.0*xi+162.0*xi*xi-81.0*xi*xi*xi)*eta+3.0*(-27.0/2.0+297.0/4.0*xi-243.0/2.0*xi*xi+243.0/4.0*xi*xi*xi)*eta*eta);
case 12: return Point<2>((81.0-405.0*xi+729.0/2.0*xi*xi)*eta+(-405.0/2.0+2025.0/2.0*xi-3645.0/4.0*xi*xi)*eta*eta+(243.0/2.0-1215.0/2.0*xi+2187.0/4.0*xi*xi)*eta*eta*eta,
- 81.0*xi-405.0/2.0*xi*xi+243.0/2.0*xi*xi*xi+2.0*(-405.0/2.0*xi+2025.0/4.0*xi*xi-1215.0/4.0*xi*xi*xi)*eta+3.0*(243.0/2.0*xi-1215.0/4.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta);
+ 81.0*xi-405.0/2.0*xi*xi+243.0/2.0*xi*xi*xi+2.0*(-405.0/2.0*xi+2025.0/4.0*xi*xi-1215.0/4.0*xi*xi*xi)*eta+3.0*(243.0/2.0*xi-1215.0/4.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta);
case 13: return Point<2>((-81.0/2.0+324.0*xi-729.0/2.0*xi*xi)*eta+(405.0/4.0-810.0*xi+3645.0/4.0*xi*xi)*eta*eta+(-243.0/4.0+486.0*xi-2187.0/4.0*xi*xi)*eta*eta*eta,
- -81.0/2.0*xi+162.0*xi*xi-243.0/2.0*xi*xi*xi+2.0*(405.0/4.0*xi-405.0*xi*xi+1215.0/4.0*xi*xi*xi)*eta+3.0*(-243.0/4.0*xi+243.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta);
+ -81.0/2.0*xi+162.0*xi*xi-243.0/2.0*xi*xi*xi+2.0*(405.0/4.0*xi-405.0*xi*xi+1215.0/4.0*xi*xi*xi)*eta+3.0*(-243.0/4.0*xi+243.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta);
case 14: return Point<2>((81.0/4.0-162.0*xi+729.0/4.0*xi*xi)*eta+(-81.0+648.0*xi-729.0*xi*xi)*eta*eta+(243.0/4.0-486.0*xi+2187.0/4.0*xi*xi)*eta*eta*eta,
- 81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi+2.0*(-81.0*xi+324.0*xi*xi-243.0*xi*xi*xi)*eta+3.0*(243.0/4.0*xi-243.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta);
+ 81.0/4.0*xi-81.0*xi*xi+243.0/4.0*xi*xi*xi+2.0*(-81.0*xi+324.0*xi*xi-243.0*xi*xi*xi)*eta+3.0*(243.0/4.0*xi-243.0*xi*xi+729.0/4.0*xi*xi*xi)*eta*eta);
case 15: return Point<2>((-81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi)*eta+(162.0-810.0*xi+729.0*xi*xi)*eta*eta+(-243.0/2.0+1215.0/2.0*xi-2187.0/4.0*xi*xi)*eta*eta*eta,
- -81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi+2.0*(162.0*xi-405.0*xi*xi+243.0*xi*xi*xi)*eta+3.0*(-243.0/2.0*xi+1215.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta);
+ -81.0/2.0*xi+405.0/4.0*xi*xi-243.0/4.0*xi*xi*xi+2.0*(162.0*xi-405.0*xi*xi+243.0*xi*xi*xi)*eta+3.0*(-243.0/2.0*xi+1215.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta*eta);
};
return Point<2> ();
};
template <>
Tensor<2,2>
FEQ3<2>::shape_grad_grad (const unsigned int i,
- const Point<2> &p) const
+ const Point<2> &p) const
{
Assert (i<dofs_per_cell, ExcIndexRange(i, 0, dofs_per_cell));
return_value[0][1] = -81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi+2.0*(162.0-810.0*xi+729.0*xi*xi)*eta+3.0*(-243.0/2.0+1215.0/2.0*xi-2187.0/4.0*xi*xi)*eta*eta;
return_value[1][0] = -81.0/2.0+405.0/2.0*xi-729.0/4.0*xi*xi+2.0*(162.0-810.0*xi+729.0*xi*xi)*eta+3.0*(-243.0/2.0+1215.0/2.0*xi-2187.0/4.0*xi*xi)*eta*eta;
return_value[1][1] = 324.0*xi-810.0*xi*xi+486.0*xi*xi*xi+6.0*(-243.0/2.0*xi+1215.0/4.0*xi*xi-729.0/4.0*xi*xi*xi)*eta;
- break;
+ break;
};
return return_value;
};
template <>
void FEQ3<2>::get_local_mass_matrix (const DoFHandler<2>::cell_iterator &cell,
- FullMatrix<double> &local_mass_matrix) const {
+ FullMatrix<double> &local_mass_matrix) const {
Assert (local_mass_matrix.n() == dofs_per_cell,
ExcWrongFieldDimension(local_mass_matrix.n(),dofs_per_cell));
Assert (local_mass_matrix.m() == dofs_per_cell,
template <>
-void FEQ3<2>::get_unit_support_points (vector<Point<2> > &unit_points) const {
+void FEQ3<2>::get_unit_support_points (
std::vector<Point<2> > &unit_points) const {
Assert (unit_points.size() == dofs_per_cell,
ExcWrongFieldDimension (unit_points.size(), dofs_per_cell));
template <>
void FEQ3<2>::get_support_points (const DoFHandler<2>::cell_iterator &cell,
- vector<Point<2> > &support_points) const {
+
std::vector<Point<2> > &support_points) const {
Assert (support_points.size() == dofs_per_cell,
ExcWrongFieldDimension (support_points.size(), dofs_per_cell));
template <>
void FEQ3<2>::get_face_support_points (const DoFHandler<2>::face_iterator &face,
- vector<Point<2> > &support_points) const {
+
std::vector<Point<2> > &support_points) const {
Assert (support_points.size() == dofs_per_face,
ExcWrongFieldDimension (support_points.size(), dofs_per_face));
template <>
FEQ3<3>::FEQ3 () :
FEQ1Mapping<3> (1, 2, 4, 8, 1,
- vector<bool> (1, false))
+ std::vector<bool> (1, false))
{
- interface_constraints(0,0) = 1.0/256.0;
- interface_constraints(0,1) = 1.0/256.0;
- interface_constraints(0,2) = 1.0/256.0;
- interface_constraints(0,3) = 1.0/256.0;
- interface_constraints(0,4) = -9.0/256.0;
- interface_constraints(0,5) = -9.0/256.0;
- interface_constraints(0,6) = -9.0/256.0;
- interface_constraints(0,7) = -9.0/256.0;
- interface_constraints(0,8) = -9.0/256.0;
- interface_constraints(0,9) = -9.0/256.0;
- interface_constraints(0,10) = -9.0/256.0;
- interface_constraints(0,11) = -9.0/256.0;
- interface_constraints(0,12) = 81.0/256.0;
- interface_constraints(0,13) = 81.0/256.0;
- interface_constraints(0,14) = 81.0/256.0;
- interface_constraints(0,15) = 81.0/256.0;
- interface_constraints(1,0) = -1.0/16.0;
- interface_constraints(1,1) = -1.0/16.0;
- interface_constraints(1,4) = 9.0/16.0;
- interface_constraints(1,5) = 9.0/16.0;
- interface_constraints(2,1) = -1.0/16.0;
- interface_constraints(2,2) = -1.0/16.0;
- interface_constraints(2,6) = 9.0/16.0;
- interface_constraints(2,7) = 9.0/16.0;
- interface_constraints(3,2) = -1.0/16.0;
- interface_constraints(3,3) = -1.0/16.0;
- interface_constraints(3,8) = 9.0/16.0;
- interface_constraints(3,9) = 9.0/16.0;
- interface_constraints(4,0) = -1.0/16.0;
- interface_constraints(4,3) = -1.0/16.0;
- interface_constraints(4,10) = 9.0/16.0;
- interface_constraints(4,11) = 9.0/16.0;
- interface_constraints(5,0) = -5.0/256.0;
- interface_constraints(5,1) = -5.0/256.0;
- interface_constraints(5,2) = -1.0/256.0;
- interface_constraints(5,3) = -1.0/256.0;
- interface_constraints(5,4) = 45.0/256.0;
- interface_constraints(5,5) = 45.0/256.0;
- interface_constraints(5,6) = -15.0/256.0;
- interface_constraints(5,7) = 5.0/256.0;
- interface_constraints(5,8) = 9.0/256.0;
- interface_constraints(5,9) = 9.0/256.0;
- interface_constraints(5,10) = -15.0/256.0;
- interface_constraints(5,11) = 5.0/256.0;
- interface_constraints(5,12) = 135.0/256.0;
- interface_constraints(5,13) = 135.0/256.0;
- interface_constraints(5,14) = -45.0/256.0;
- interface_constraints(5,15) = -45.0/256.0;
- interface_constraints(6,6) = -1.0/16.0;
- interface_constraints(6,10) = -1.0/16.0;
- interface_constraints(6,12) = 9.0/16.0;
- interface_constraints(6,13) = 9.0/16.0;
- interface_constraints(7,5) = -1.0/16.0;
- interface_constraints(7,9) = -1.0/16.0;
- interface_constraints(7,13) = 9.0/16.0;
- interface_constraints(7,15) = 9.0/16.0;
- interface_constraints(8,0) = -1.0/256.0;
- interface_constraints(8,1) = -5.0/256.0;
- interface_constraints(8,2) = -5.0/256.0;
- interface_constraints(8,3) = -1.0/256.0;
- interface_constraints(8,4) = 5.0/256.0;
- interface_constraints(8,5) = -15.0/256.0;
- interface_constraints(8,6) = 45.0/256.0;
- interface_constraints(8,7) = 45.0/256.0;
- interface_constraints(8,8) = 5.0/256.0;
- interface_constraints(8,9) = -15.0/256.0;
- interface_constraints(8,10) = 9.0/256.0;
- interface_constraints(8,11) = 9.0/256.0;
- interface_constraints(8,12) = -45.0/256.0;
- interface_constraints(8,13) = 135.0/256.0;
- interface_constraints(8,14) = -45.0/256.0;
- interface_constraints(8,15) = 135.0/256.0;
- interface_constraints(9,7) = -1.0/16.0;
- interface_constraints(9,11) = -1.0/16.0;
- interface_constraints(9,14) = 9.0/16.0;
- interface_constraints(9,15) = 9.0/16.0;
- interface_constraints(10,0) = -1.0/256.0;
- interface_constraints(10,1) = -1.0/256.0;
- interface_constraints(10,2) = -5.0/256.0;
- interface_constraints(10,3) = -5.0/256.0;
- interface_constraints(10,4) = 9.0/256.0;
- interface_constraints(10,5) = 9.0/256.0;
- interface_constraints(10,6) = 5.0/256.0;
- interface_constraints(10,7) = -15.0/256.0;
- interface_constraints(10,8) = 45.0/256.0;
- interface_constraints(10,9) = 45.0/256.0;
- interface_constraints(10,10) = 5.0/256.0;
- interface_constraints(10,11) = -15.0/256.0;
- interface_constraints(10,12) = -45.0/256.0;
- interface_constraints(10,13) = -45.0/256.0;
- interface_constraints(10,14) = 135.0/256.0;
- interface_constraints(10,15) = 135.0/256.0;
- interface_constraints(11,0) = -5.0/256.0;
- interface_constraints(11,1) = -1.0/256.0;
- interface_constraints(11,2) = -1.0/256.0;
- interface_constraints(11,3) = -5.0/256.0;
- interface_constraints(11,4) = -15.0/256.0;
- interface_constraints(11,5) = 5.0/256.0;
- interface_constraints(11,6) = 9.0/256.0;
- interface_constraints(11,7) = 9.0/256.0;
- interface_constraints(11,8) = -15.0/256.0;
- interface_constraints(11,9) = 5.0/256.0;
- interface_constraints(11,10) = 45.0/256.0;
- interface_constraints(11,11) = 45.0/256.0;
- interface_constraints(11,12) = 135.0/256.0;
- interface_constraints(11,13) = -45.0/256.0;
- interface_constraints(11,14) = 135.0/256.0;
- interface_constraints(11,15) = -45.0/256.0;
- interface_constraints(12,4) = -1.0/16.0;
- interface_constraints(12,8) = -1.0/16.0;
- interface_constraints(12,12) = 9.0/16.0;
- interface_constraints(12,14) = 9.0/16.0;
- interface_constraints(13,0) = 5.0/16.0;
- interface_constraints(13,1) = 1.0/16.0;
- interface_constraints(13,4) = 15.0/16.0;
- interface_constraints(13,5) = -5.0/16.0;
- interface_constraints(14,4) = 1.0;
- interface_constraints(15,5) = 1.0;
- interface_constraints(16,0) = 1.0/16.0;
- interface_constraints(16,1) = 5.0/16.0;
- interface_constraints(16,4) = -5.0/16.0;
- interface_constraints(16,5) = 15.0/16.0;
- interface_constraints(17,1) = 5.0/16.0;
- interface_constraints(17,2) = 1.0/16.0;
- interface_constraints(17,6) = 15.0/16.0;
- interface_constraints(17,7) = -5.0/16.0;
- interface_constraints(18,6) = 1.0;
- interface_constraints(19,7) = 1.0;
- interface_constraints(20,1) = 1.0/16.0;
- interface_constraints(20,2) = 5.0/16.0;
- interface_constraints(20,6) = -5.0/16.0;
- interface_constraints(20,7) = 15.0/16.0;
- interface_constraints(21,2) = 1.0/16.0;
- interface_constraints(21,3) = 5.0/16.0;
- interface_constraints(21,8) = 15.0/16.0;
- interface_constraints(21,9) = -5.0/16.0;
- interface_constraints(22,8) = 1.0;
- interface_constraints(23,9) = 1.0;
- interface_constraints(24,2) = 5.0/16.0;
- interface_constraints(24,3) = 1.0/16.0;
- interface_constraints(24,8) = -5.0/16.0;
- interface_constraints(24,9) = 15.0/16.0;
- interface_constraints(25,0) = 5.0/16.0;
- interface_constraints(25,3) = 1.0/16.0;
- interface_constraints(25,10) = 15.0/16.0;
- interface_constraints(25,11) = -5.0/16.0;
- interface_constraints(26,10) = 1.0;
- interface_constraints(27,11) = 1.0;
- interface_constraints(28,0) = 1.0/16.0;
- interface_constraints(28,3) = 5.0/16.0;
- interface_constraints(28,10) = -5.0/16.0;
- interface_constraints(28,11) = 15.0/16.0;
- interface_constraints(29,0) = 25.0/256.0;
- interface_constraints(29,1) = 5.0/256.0;
- interface_constraints(29,2) = 1.0/256.0;
- interface_constraints(29,3) = 5.0/256.0;
- interface_constraints(29,4) = 75.0/256.0;
- interface_constraints(29,5) = -25.0/256.0;
- interface_constraints(29,6) = 15.0/256.0;
- interface_constraints(29,7) = -5.0/256.0;
- interface_constraints(29,8) = 15.0/256.0;
- interface_constraints(29,9) = -5.0/256.0;
- interface_constraints(29,10) = 75.0/256.0;
- interface_constraints(29,11) = -25.0/256.0;
- interface_constraints(29,12) = 225.0/256.0;
- interface_constraints(29,13) = -75.0/256.0;
- interface_constraints(29,14) = -75.0/256.0;
- interface_constraints(29,15) = 25.0/256.0;
- interface_constraints(30,4) = 5.0/16.0;
- interface_constraints(30,8) = 1.0/16.0;
- interface_constraints(30,12) = 15.0/16.0;
- interface_constraints(30,14) = -5.0/16.0;
- interface_constraints(31,6) = 1.0/16.0;
- interface_constraints(31,10) = 5.0/16.0;
- interface_constraints(31,12) = 15.0/16.0;
- interface_constraints(31,13) = -5.0/16.0;
- interface_constraints(32,12) = 1.0;
- interface_constraints(33,5) = 5.0/16.0;
- interface_constraints(33,9) = 1.0/16.0;
- interface_constraints(33,13) = 15.0/16.0;
- interface_constraints(33,15) = -5.0/16.0;
- interface_constraints(34,0) = 5.0/256.0;
- interface_constraints(34,1) = 25.0/256.0;
- interface_constraints(34,2) = 5.0/256.0;
- interface_constraints(34,3) = 1.0/256.0;
- interface_constraints(34,4) = -25.0/256.0;
- interface_constraints(34,5) = 75.0/256.0;
- interface_constraints(34,6) = 75.0/256.0;
- interface_constraints(34,7) = -25.0/256.0;
- interface_constraints(34,8) = -5.0/256.0;
- interface_constraints(34,9) = 15.0/256.0;
- interface_constraints(34,10) = 15.0/256.0;
- interface_constraints(34,11) = -5.0/256.0;
- interface_constraints(34,12) = -75.0/256.0;
- interface_constraints(34,13) = 225.0/256.0;
- interface_constraints(34,14) = 25.0/256.0;
- interface_constraints(34,15) = -75.0/256.0;
- interface_constraints(35,13) = 1.0;
- interface_constraints(36,6) = 5.0/16.0;
- interface_constraints(36,10) = 1.0/16.0;
- interface_constraints(36,12) = -5.0/16.0;
- interface_constraints(36,13) = 15.0/16.0;
- interface_constraints(37,15) = 1.0;
- interface_constraints(38,7) = 5.0/16.0;
- interface_constraints(38,11) = 1.0/16.0;
- interface_constraints(38,14) = -5.0/16.0;
- interface_constraints(38,15) = 15.0/16.0;
- interface_constraints(39,5) = 1.0/16.0;
- interface_constraints(39,9) = 5.0/16.0;
- interface_constraints(39,13) = -5.0/16.0;
- interface_constraints(39,15) = 15.0/16.0;
- interface_constraints(40,0) = 1.0/256.0;
- interface_constraints(40,1) = 5.0/256.0;
- interface_constraints(40,2) = 25.0/256.0;
- interface_constraints(40,3) = 5.0/256.0;
- interface_constraints(40,4) = -5.0/256.0;
- interface_constraints(40,5) = 15.0/256.0;
- interface_constraints(40,6) = -25.0/256.0;
- interface_constraints(40,7) = 75.0/256.0;
- interface_constraints(40,8) = -25.0/256.0;
- interface_constraints(40,9) = 75.0/256.0;
- interface_constraints(40,10) = -5.0/256.0;
- interface_constraints(40,11) = 15.0/256.0;
- interface_constraints(40,12) = 25.0/256.0;
- interface_constraints(40,13) = -75.0/256.0;
- interface_constraints(40,14) = -75.0/256.0;
- interface_constraints(40,15) = 225.0/256.0;
- interface_constraints(41,7) = 1.0/16.0;
- interface_constraints(41,11) = 5.0/16.0;
- interface_constraints(41,14) = 15.0/16.0;
- interface_constraints(41,15) = -5.0/16.0;
- interface_constraints(42,14) = 1.0;
- interface_constraints(43,0) = 5.0/256.0;
- interface_constraints(43,1) = 1.0/256.0;
- interface_constraints(43,2) = 5.0/256.0;
- interface_constraints(43,3) = 25.0/256.0;
- interface_constraints(43,4) = 15.0/256.0;
- interface_constraints(43,5) = -5.0/256.0;
- interface_constraints(43,6) = -5.0/256.0;
- interface_constraints(43,7) = 15.0/256.0;
- interface_constraints(43,8) = 75.0/256.0;
- interface_constraints(43,9) = -25.0/256.0;
- interface_constraints(43,10) = -25.0/256.0;
- interface_constraints(43,11) = 75.0/256.0;
- interface_constraints(43,12) = -75.0/256.0;
- interface_constraints(43,13) = 25.0/256.0;
- interface_constraints(43,14) = 225.0/256.0;
- interface_constraints(43,15) = -75.0/256.0;
- interface_constraints(44,4) = 1.0/16.0;
- interface_constraints(44,8) = 5.0/16.0;
- interface_constraints(44,12) = -5.0/16.0;
- interface_constraints(44,14) = 15.0/16.0;
+ interface_constraints(0,0) = 1.0/256.0;
+ interface_constraints(0,1) = 1.0/256.0;
+ interface_constraints(0,2) = 1.0/256.0;
+ interface_constraints(0,3) = 1.0/256.0;
+ interface_constraints(0,4) = -9.0/256.0;
+ interface_constraints(0,5) = -9.0/256.0;
+ interface_constraints(0,6) = -9.0/256.0;
+ interface_constraints(0,7) = -9.0/256.0;
+ interface_constraints(0,8) = -9.0/256.0;
+ interface_constraints(0,9) = -9.0/256.0;
+ interface_constraints(0,10) = -9.0/256.0;
+ interface_constraints(0,11) = -9.0/256.0;
+ interface_constraints(0,12) = 81.0/256.0;
+ interface_constraints(0,13) = 81.0/256.0;
+ interface_constraints(0,14) = 81.0/256.0;
+ interface_constraints(0,15) = 81.0/256.0;
+ interface_constraints(1,0) = -1.0/16.0;
+ interface_constraints(1,1) = -1.0/16.0;
+ interface_constraints(1,4) = 9.0/16.0;
+ interface_constraints(1,5) = 9.0/16.0;
+ interface_constraints(2,1) = -1.0/16.0;
+ interface_constraints(2,2) = -1.0/16.0;
+ interface_constraints(2,6) = 9.0/16.0;
+ interface_constraints(2,7) = 9.0/16.0;
+ interface_constraints(3,2) = -1.0/16.0;
+ interface_constraints(3,3) = -1.0/16.0;
+ interface_constraints(3,8) = 9.0/16.0;
+ interface_constraints(3,9) = 9.0/16.0;
+ interface_constraints(4,0) = -1.0/16.0;
+ interface_constraints(4,3) = -1.0/16.0;
+ interface_constraints(4,10) = 9.0/16.0;
+ interface_constraints(4,11) = 9.0/16.0;
+ interface_constraints(5,0) = -5.0/256.0;
+ interface_constraints(5,1) = -5.0/256.0;
+ interface_constraints(5,2) = -1.0/256.0;
+ interface_constraints(5,3) = -1.0/256.0;
+ interface_constraints(5,4) = 45.0/256.0;
+ interface_constraints(5,5) = 45.0/256.0;
+ interface_constraints(5,6) = -15.0/256.0;
+ interface_constraints(5,7) = 5.0/256.0;
+ interface_constraints(5,8) = 9.0/256.0;
+ interface_constraints(5,9) = 9.0/256.0;
+ interface_constraints(5,10) = -15.0/256.0;
+ interface_constraints(5,11) = 5.0/256.0;
+ interface_constraints(5,12) = 135.0/256.0;
+ interface_constraints(5,13) = 135.0/256.0;
+ interface_constraints(5,14) = -45.0/256.0;
+ interface_constraints(5,15) = -45.0/256.0;
+ interface_constraints(6,6) = -1.0/16.0;
+ interface_constraints(6,10) = -1.0/16.0;
+ interface_constraints(6,12) = 9.0/16.0;
+ interface_constraints(6,13) = 9.0/16.0;
+ interface_constraints(7,5) = -1.0/16.0;
+ interface_constraints(7,9) = -1.0/16.0;
+ interface_constraints(7,13) = 9.0/16.0;
+ interface_constraints(7,15) = 9.0/16.0;
+ interface_constraints(8,0) = -1.0/256.0;
+ interface_constraints(8,1) = -5.0/256.0;
+ interface_constraints(8,2) = -5.0/256.0;
+ interface_constraints(8,3) = -1.0/256.0;
+ interface_constraints(8,4) = 5.0/256.0;
+ interface_constraints(8,5) = -15.0/256.0;
+ interface_constraints(8,6) = 45.0/256.0;
+ interface_constraints(8,7) = 45.0/256.0;
+ interface_constraints(8,8) = 5.0/256.0;
+ interface_constraints(8,9) = -15.0/256.0;
+ interface_constraints(8,10) = 9.0/256.0;
+ interface_constraints(8,11) = 9.0/256.0;
+ interface_constraints(8,12) = -45.0/256.0;
+ interface_constraints(8,13) = 135.0/256.0;
+ interface_constraints(8,14) = -45.0/256.0;
+ interface_constraints(8,15) = 135.0/256.0;
+ interface_constraints(9,7) = -1.0/16.0;
+ interface_constraints(9,11) = -1.0/16.0;
+ interface_constraints(9,14) = 9.0/16.0;
+ interface_constraints(9,15) = 9.0/16.0;
+ interface_constraints(10,0) = -1.0/256.0;
+ interface_constraints(10,1) = -1.0/256.0;
+ interface_constraints(10,2) = -5.0/256.0;
+ interface_constraints(10,3) = -5.0/256.0;
+ interface_constraints(10,4) = 9.0/256.0;
+ interface_constraints(10,5) = 9.0/256.0;
+ interface_constraints(10,6) = 5.0/256.0;
+ interface_constraints(10,7) = -15.0/256.0;
+ interface_constraints(10,8) = 45.0/256.0;
+ interface_constraints(10,9) = 45.0/256.0;
+ interface_constraints(10,10) = 5.0/256.0;
+ interface_constraints(10,11) = -15.0/256.0;
+ interface_constraints(10,12) = -45.0/256.0;
+ interface_constraints(10,13) = -45.0/256.0;
+ interface_constraints(10,14) = 135.0/256.0;
+ interface_constraints(10,15) = 135.0/256.0;
+ interface_constraints(11,0) = -5.0/256.0;
+ interface_constraints(11,1) = -1.0/256.0;
+ interface_constraints(11,2) = -1.0/256.0;
+ interface_constraints(11,3) = -5.0/256.0;
+ interface_constraints(11,4) = -15.0/256.0;
+ interface_constraints(11,5) = 5.0/256.0;
+ interface_constraints(11,6) = 9.0/256.0;
+ interface_constraints(11,7) = 9.0/256.0;
+ interface_constraints(11,8) = -15.0/256.0;
+ interface_constraints(11,9) = 5.0/256.0;
+ interface_constraints(11,10) = 45.0/256.0;
+ interface_constraints(11,11) = 45.0/256.0;
+ interface_constraints(11,12) = 135.0/256.0;
+ interface_constraints(11,13) = -45.0/256.0;
+ interface_constraints(11,14) = 135.0/256.0;
+ interface_constraints(11,15) = -45.0/256.0;
+ interface_constraints(12,4) = -1.0/16.0;
+ interface_constraints(12,8) = -1.0/16.0;
+ interface_constraints(12,12) = 9.0/16.0;
+ interface_constraints(12,14) = 9.0/16.0;
+ interface_constraints(13,0) = 5.0/16.0;
+ interface_constraints(13,1) = 1.0/16.0;
+ interface_constraints(13,4) = 15.0/16.0;
+ interface_constraints(13,5) = -5.0/16.0;
+ interface_constraints(14,4) = 1.0;
+ interface_constraints(15,5) = 1.0;
+ interface_constraints(16,0) = 1.0/16.0;
+ interface_constraints(16,1) = 5.0/16.0;
+ interface_constraints(16,4) = -5.0/16.0;
+ interface_constraints(16,5) = 15.0/16.0;
+ interface_constraints(17,1) = 5.0/16.0;
+ interface_constraints(17,2) = 1.0/16.0;
+ interface_constraints(17,6) = 15.0/16.0;
+ interface_constraints(17,7) = -5.0/16.0;
+ interface_constraints(18,6) = 1.0;
+ interface_constraints(19,7) = 1.0;
+ interface_constraints(20,1) = 1.0/16.0;
+ interface_constraints(20,2) = 5.0/16.0;
+ interface_constraints(20,6) = -5.0/16.0;
+ interface_constraints(20,7) = 15.0/16.0;
+ interface_constraints(21,2) = 1.0/16.0;
+ interface_constraints(21,3) = 5.0/16.0;
+ interface_constraints(21,8) = 15.0/16.0;
+ interface_constraints(21,9) = -5.0/16.0;
+ interface_constraints(22,8) = 1.0;
+ interface_constraints(23,9) = 1.0;
+ interface_constraints(24,2) = 5.0/16.0;
+ interface_constraints(24,3) = 1.0/16.0;
+ interface_constraints(24,8) = -5.0/16.0;
+ interface_constraints(24,9) = 15.0/16.0;
+ interface_constraints(25,0) = 5.0/16.0;
+ interface_constraints(25,3) = 1.0/16.0;
+ interface_constraints(25,10) = 15.0/16.0;
+ interface_constraints(25,11) = -5.0/16.0;
+ interface_constraints(26,10) = 1.0;
+ interface_constraints(27,11) = 1.0;
+ interface_constraints(28,0) = 1.0/16.0;
+ interface_constraints(28,3) = 5.0/16.0;
+ interface_constraints(28,10) = -5.0/16.0;
+ interface_constraints(28,11) = 15.0/16.0;
+ interface_constraints(29,0) = 25.0/256.0;
+ interface_constraints(29,1) = 5.0/256.0;
+ interface_constraints(29,2) = 1.0/256.0;
+ interface_constraints(29,3) = 5.0/256.0;
+ interface_constraints(29,4) = 75.0/256.0;
+ interface_constraints(29,5) = -25.0/256.0;
+ interface_constraints(29,6) = 15.0/256.0;
+ interface_constraints(29,7) = -5.0/256.0;
+ interface_constraints(29,8) = 15.0/256.0;
+ interface_constraints(29,9) = -5.0/256.0;
+ interface_constraints(29,10) = 75.0/256.0;
+ interface_constraints(29,11) = -25.0/256.0;
+ interface_constraints(29,12) = 225.0/256.0;
+ interface_constraints(29,13) = -75.0/256.0;
+ interface_constraints(29,14) = -75.0/256.0;
+ interface_constraints(29,15) = 25.0/256.0;
+ interface_constraints(30,4) = 5.0/16.0;
+ interface_constraints(30,8) = 1.0/16.0;
+ interface_constraints(30,12) = 15.0/16.0;
+ interface_constraints(30,14) = -5.0/16.0;
+ interface_constraints(31,6) = 1.0/16.0;
+ interface_constraints(31,10) = 5.0/16.0;
+ interface_constraints(31,12) = 15.0/16.0;
+ interface_constraints(31,13) = -5.0/16.0;
+ interface_constraints(32,12) = 1.0;
+ interface_constraints(33,5) = 5.0/16.0;
+ interface_constraints(33,9) = 1.0/16.0;
+ interface_constraints(33,13) = 15.0/16.0;
+ interface_constraints(33,15) = -5.0/16.0;
+ interface_constraints(34,0) = 5.0/256.0;
+ interface_constraints(34,1) = 25.0/256.0;
+ interface_constraints(34,2) = 5.0/256.0;
+ interface_constraints(34,3) = 1.0/256.0;
+ interface_constraints(34,4) = -25.0/256.0;
+ interface_constraints(34,5) = 75.0/256.0;
+ interface_constraints(34,6) = 75.0/256.0;
+ interface_constraints(34,7) = -25.0/256.0;
+ interface_constraints(34,8) = -5.0/256.0;
+ interface_constraints(34,9) = 15.0/256.0;
+ interface_constraints(34,10) = 15.0/256.0;
+ interface_constraints(34,11) = -5.0/256.0;
+ interface_constraints(34,12) = -75.0/256.0;
+ interface_constraints(34,13) = 225.0/256.0;
+ interface_constraints(34,14) = 25.0/256.0;
+ interface_constraints(34,15) = -75.0/256.0;
+ interface_constraints(35,13) = 1.0;
+ interface_constraints(36,6) = 5.0/16.0;
+ interface_constraints(36,10) = 1.0/16.0;
+ interface_constraints(36,12) = -5.0/16.0;
+ interface_constraints(36,13) = 15.0/16.0;
+ interface_constraints(37,15) = 1.0;
+ interface_constraints(38,7) = 5.0/16.0;
+ interface_constraints(38,11) = 1.0/16.0;
+ interface_constraints(38,14) = -5.0/16.0;
+ interface_constraints(38,15) = 15.0/16.0;
+ interface_constraints(39,5) = 1.0/16.0;
+ interface_constraints(39,9) = 5.0/16.0;
+ interface_constraints(39,13) = -5.0/16.0;
+ interface_constraints(39,15) = 15.0/16.0;
+ interface_constraints(40,0) = 1.0/256.0;
+ interface_constraints(40,1) = 5.0/256.0;
+ interface_constraints(40,2) = 25.0/256.0;
+ interface_constraints(40,3) = 5.0/256.0;
+ interface_constraints(40,4) = -5.0/256.0;
+ interface_constraints(40,5) = 15.0/256.0;
+ interface_constraints(40,6) = -25.0/256.0;
+ interface_constraints(40,7) = 75.0/256.0;
+ interface_constraints(40,8) = -25.0/256.0;
+ interface_constraints(40,9) = 75.0/256.0;
+ interface_constraints(40,10) = -5.0/256.0;
+ interface_constraints(40,11) = 15.0/256.0;
+ interface_constraints(40,12) = 25.0/256.0;
+ interface_constraints(40,13) = -75.0/256.0;
+ interface_constraints(40,14) = -75.0/256.0;
+ interface_constraints(40,15) = 225.0/256.0;
+ interface_constraints(41,7) = 1.0/16.0;
+ interface_constraints(41,11) = 5.0/16.0;
+ interface_constraints(41,14) = 15.0/16.0;
+ interface_constraints(41,15) = -5.0/16.0;
+ interface_constraints(42,14) = 1.0;
+ interface_constraints(43,0) = 5.0/256.0;
+ interface_constraints(43,1) = 1.0/256.0;
+ interface_constraints(43,2) = 5.0/256.0;
+ interface_constraints(43,3) = 25.0/256.0;
+ interface_constraints(43,4) = 15.0/256.0;
+ interface_constraints(43,5) = -5.0/256.0;
+ interface_constraints(43,6) = -5.0/256.0;
+ interface_constraints(43,7) = 15.0/256.0;
+ interface_constraints(43,8) = 75.0/256.0;
+ interface_constraints(43,9) = -25.0/256.0;
+ interface_constraints(43,10) = -25.0/256.0;
+ interface_constraints(43,11) = 75.0/256.0;
+ interface_constraints(43,12) = -75.0/256.0;
+ interface_constraints(43,13) = 25.0/256.0;
+ interface_constraints(43,14) = 225.0/256.0;
+ interface_constraints(43,15) = -75.0/256.0;
+ interface_constraints(44,4) = 1.0/16.0;
+ interface_constraints(44,8) = 5.0/16.0;
+ interface_constraints(44,12) = -5.0/16.0;
+ interface_constraints(44,14) = 15.0/16.0;
initialize_matrices ();
};
template <>
FEQ3<3>::FEQ3 (const int) :
FEQ1Mapping<3> (0, 0, 0, 64, 1,
- vector<bool> (1, true))
+ std::vector<bool> (1, true))
{
initialize_matrices ();
};
template <>
void FEQ3<3>::initialize_matrices ()
{
- prolongation[0](0,0) = 1.0;
- prolongation[0](1,0) = -1.0/16.0;
- prolongation[0](1,1) = -1.0/16.0;
- prolongation[0](1,8) = 9.0/16.0;
- prolongation[0](1,9) = 9.0/16.0;
- prolongation[0](2,0) = 1.0/256.0;
- prolongation[0](2,1) = 1.0/256.0;
- prolongation[0](2,2) = 1.0/256.0;
- prolongation[0](2,3) = 1.0/256.0;
- prolongation[0](2,8) = -9.0/256.0;
- prolongation[0](2,9) = -9.0/256.0;
- prolongation[0](2,10) = -9.0/256.0;
- prolongation[0](2,11) = -9.0/256.0;
- prolongation[0](2,12) = -9.0/256.0;
- prolongation[0](2,13) = -9.0/256.0;
- prolongation[0](2,14) = -9.0/256.0;
- prolongation[0](2,15) = -9.0/256.0;
- prolongation[0](2,32) = 81.0/256.0;
- prolongation[0](2,33) = 81.0/256.0;
- prolongation[0](2,34) = 81.0/256.0;
- prolongation[0](2,35) = 81.0/256.0;
- prolongation[0](3,0) = -1.0/16.0;
- prolongation[0](3,3) = -1.0/16.0;
- prolongation[0](3,14) = 9.0/16.0;
- prolongation[0](3,15) = 9.0/16.0;
- prolongation[0](4,0) = -1.0/16.0;
- prolongation[0](4,4) = -1.0/16.0;
- prolongation[0](4,24) = 9.0/16.0;
- prolongation[0](4,25) = 9.0/16.0;
- prolongation[0](5,0) = 1.0/256.0;
- prolongation[0](5,1) = 1.0/256.0;
- prolongation[0](5,4) = 1.0/256.0;
- prolongation[0](5,5) = 1.0/256.0;
- prolongation[0](5,8) = -9.0/256.0;
- prolongation[0](5,9) = -9.0/256.0;
- prolongation[0](5,16) = -9.0/256.0;
- prolongation[0](5,17) = -9.0/256.0;
- prolongation[0](5,24) = -9.0/256.0;
- prolongation[0](5,25) = -9.0/256.0;
- prolongation[0](5,26) = -9.0/256.0;
- prolongation[0](5,27) = -9.0/256.0;
- prolongation[0](5,40) = 81.0/256.0;
- prolongation[0](5,41) = 81.0/256.0;
- prolongation[0](5,42) = 81.0/256.0;
- prolongation[0](5,43) = 81.0/256.0;
- prolongation[0](6,0) = -1.0/4096.0;
- prolongation[0](6,1) = -1.0/4096.0;
- prolongation[0](6,2) = -1.0/4096.0;
- prolongation[0](6,3) = -1.0/4096.0;
- prolongation[0](6,4) = -1.0/4096.0;
- prolongation[0](6,5) = -1.0/4096.0;
- prolongation[0](6,6) = -1.0/4096.0;
- prolongation[0](6,7) = -1.0/4096.0;
- prolongation[0](6,8) = 9.0/4096.0;
- prolongation[0](6,9) = 9.0/4096.0;
- prolongation[0](6,10) = 9.0/4096.0;
- prolongation[0](6,11) = 9.0/4096.0;
- prolongation[0](6,12) = 9.0/4096.0;
- prolongation[0](6,13) = 9.0/4096.0;
- prolongation[0](6,14) = 9.0/4096.0;
- prolongation[0](6,15) = 9.0/4096.0;
- prolongation[0](6,16) = 9.0/4096.0;
- prolongation[0](6,17) = 9.0/4096.0;
- prolongation[0](6,18) = 9.0/4096.0;
- prolongation[0](6,19) = 9.0/4096.0;
- prolongation[0](6,20) = 9.0/4096.0;
- prolongation[0](6,21) = 9.0/4096.0;
- prolongation[0](6,22) = 9.0/4096.0;
- prolongation[0](6,23) = 9.0/4096.0;
- prolongation[0](6,24) = 9.0/4096.0;
- prolongation[0](6,25) = 9.0/4096.0;
- prolongation[0](6,26) = 9.0/4096.0;
- prolongation[0](6,27) = 9.0/4096.0;
- prolongation[0](6,28) = 9.0/4096.0;
- prolongation[0](6,29) = 9.0/4096.0;
- prolongation[0](6,30) = 9.0/4096.0;
- prolongation[0](6,31) = 9.0/4096.0;
- prolongation[0](6,32) = -81.0/4096.0;
- prolongation[0](6,33) = -81.0/4096.0;
- prolongation[0](6,34) = -81.0/4096.0;
- prolongation[0](6,35) = -81.0/4096.0;
- prolongation[0](6,36) = -81.0/4096.0;
- prolongation[0](6,37) = -81.0/4096.0;
- prolongation[0](6,38) = -81.0/4096.0;
- prolongation[0](6,39) = -81.0/4096.0;
- prolongation[0](6,40) = -81.0/4096.0;
- prolongation[0](6,41) = -81.0/4096.0;
- prolongation[0](6,42) = -81.0/4096.0;
- prolongation[0](6,43) = -81.0/4096.0;
- prolongation[0](6,44) = -81.0/4096.0;
- prolongation[0](6,45) = -81.0/4096.0;
- prolongation[0](6,46) = -81.0/4096.0;
- prolongation[0](6,47) = -81.0/4096.0;
- prolongation[0](6,48) = -81.0/4096.0;
- prolongation[0](6,49) = -81.0/4096.0;
- prolongation[0](6,50) = -81.0/4096.0;
- prolongation[0](6,51) = -81.0/4096.0;
- prolongation[0](6,52) = -81.0/4096.0;
- prolongation[0](6,53) = -81.0/4096.0;
- prolongation[0](6,54) = -81.0/4096.0;
- prolongation[0](6,55) = -81.0/4096.0;
- prolongation[0](6,56) = 729.0/4096.0;
- prolongation[0](6,57) = 729.0/4096.0;
- prolongation[0](6,58) = 729.0/4096.0;
- prolongation[0](6,59) = 729.0/4096.0;
- prolongation[0](6,60) = 729.0/4096.0;
- prolongation[0](6,61) = 729.0/4096.0;
- prolongation[0](6,62) = 729.0/4096.0;
- prolongation[0](6,63) = 729.0/4096.0;
- prolongation[0](7,0) = 1.0/256.0;
- prolongation[0](7,3) = 1.0/256.0;
- prolongation[0](7,4) = 1.0/256.0;
- prolongation[0](7,7) = 1.0/256.0;
- prolongation[0](7,14) = -9.0/256.0;
- prolongation[0](7,15) = -9.0/256.0;
- prolongation[0](7,22) = -9.0/256.0;
- prolongation[0](7,23) = -9.0/256.0;
- prolongation[0](7,24) = -9.0/256.0;
- prolongation[0](7,25) = -9.0/256.0;
- prolongation[0](7,30) = -9.0/256.0;
- prolongation[0](7,31) = -9.0/256.0;
- prolongation[0](7,52) = 81.0/256.0;
- prolongation[0](7,53) = 81.0/256.0;
- prolongation[0](7,54) = 81.0/256.0;
- prolongation[0](7,55) = 81.0/256.0;
- prolongation[0](8,0) = 5.0/16.0;
- prolongation[0](8,1) = 1.0/16.0;
- prolongation[0](8,8) = 15.0/16.0;
- prolongation[0](8,9) = -5.0/16.0;
- prolongation[0](9,8) = 1.0;
- prolongation[0](10,0) = -5.0/256.0;
- prolongation[0](10,1) = -5.0/256.0;
- prolongation[0](10,2) = -1.0/256.0;
- prolongation[0](10,3) = -1.0/256.0;
- prolongation[0](10,8) = 45.0/256.0;
- prolongation[0](10,9) = 45.0/256.0;
- prolongation[0](10,10) = -15.0/256.0;
- prolongation[0](10,11) = 5.0/256.0;
- prolongation[0](10,12) = 9.0/256.0;
- prolongation[0](10,13) = 9.0/256.0;
- prolongation[0](10,14) = -15.0/256.0;
- prolongation[0](10,15) = 5.0/256.0;
- prolongation[0](10,32) = 135.0/256.0;
- prolongation[0](10,33) = 135.0/256.0;
- prolongation[0](10,34) = -45.0/256.0;
- prolongation[0](10,35) = -45.0/256.0;
- prolongation[0](11,10) = -1.0/16.0;
- prolongation[0](11,14) = -1.0/16.0;
- prolongation[0](11,32) = 9.0/16.0;
- prolongation[0](11,33) = 9.0/16.0;
- prolongation[0](12,0) = -5.0/256.0;
- prolongation[0](12,1) = -1.0/256.0;
- prolongation[0](12,2) = -1.0/256.0;
- prolongation[0](12,3) = -5.0/256.0;
- prolongation[0](12,8) = -15.0/256.0;
- prolongation[0](12,9) = 5.0/256.0;
- prolongation[0](12,10) = 9.0/256.0;
- prolongation[0](12,11) = 9.0/256.0;
- prolongation[0](12,12) = -15.0/256.0;
- prolongation[0](12,13) = 5.0/256.0;
- prolongation[0](12,14) = 45.0/256.0;
- prolongation[0](12,15) = 45.0/256.0;
- prolongation[0](12,32) = 135.0/256.0;
- prolongation[0](12,33) = -45.0/256.0;
- prolongation[0](12,34) = 135.0/256.0;
- prolongation[0](12,35) = -45.0/256.0;
- prolongation[0](13,8) = -1.0/16.0;
- prolongation[0](13,12) = -1.0/16.0;
- prolongation[0](13,32) = 9.0/16.0;
- prolongation[0](13,34) = 9.0/16.0;
- prolongation[0](14,0) = 5.0/16.0;
- prolongation[0](14,3) = 1.0/16.0;
- prolongation[0](14,14) = 15.0/16.0;
- prolongation[0](14,15) = -5.0/16.0;
- prolongation[0](15,14) = 1.0;
- prolongation[0](16,0) = -5.0/256.0;
- prolongation[0](16,1) = -1.0/256.0;
- prolongation[0](16,4) = -5.0/256.0;
- prolongation[0](16,5) = -1.0/256.0;
- prolongation[0](16,8) = -15.0/256.0;
- prolongation[0](16,9) = 5.0/256.0;
- prolongation[0](16,16) = -15.0/256.0;
- prolongation[0](16,17) = 5.0/256.0;
- prolongation[0](16,24) = 45.0/256.0;
- prolongation[0](16,25) = 45.0/256.0;
- prolongation[0](16,26) = 9.0/256.0;
- prolongation[0](16,27) = 9.0/256.0;
- prolongation[0](16,40) = 135.0/256.0;
- prolongation[0](16,41) = -45.0/256.0;
- prolongation[0](16,42) = 135.0/256.0;
- prolongation[0](16,43) = -45.0/256.0;
- prolongation[0](17,8) = -1.0/16.0;
- prolongation[0](17,16) = -1.0/16.0;
- prolongation[0](17,40) = 9.0/16.0;
- prolongation[0](17,42) = 9.0/16.0;
- prolongation[0](18,0) = 5.0/4096.0;
- prolongation[0](18,1) = 5.0/4096.0;
- prolongation[0](18,2) = 1.0/4096.0;
- prolongation[0](18,3) = 1.0/4096.0;
- prolongation[0](18,4) = 5.0/4096.0;
- prolongation[0](18,5) = 5.0/4096.0;
- prolongation[0](18,6) = 1.0/4096.0;
- prolongation[0](18,7) = 1.0/4096.0;
- prolongation[0](18,8) = -45.0/4096.0;
- prolongation[0](18,9) = -45.0/4096.0;
- prolongation[0](18,10) = 15.0/4096.0;
- prolongation[0](18,11) = -5.0/4096.0;
- prolongation[0](18,12) = -9.0/4096.0;
- prolongation[0](18,13) = -9.0/4096.0;
- prolongation[0](18,14) = 15.0/4096.0;
- prolongation[0](18,15) = -5.0/4096.0;
- prolongation[0](18,16) = -45.0/4096.0;
- prolongation[0](18,17) = -45.0/4096.0;
- prolongation[0](18,18) = 15.0/4096.0;
- prolongation[0](18,19) = -5.0/4096.0;
- prolongation[0](18,20) = -9.0/4096.0;
- prolongation[0](18,21) = -9.0/4096.0;
- prolongation[0](18,22) = 15.0/4096.0;
- prolongation[0](18,23) = -5.0/4096.0;
- prolongation[0](18,24) = -45.0/4096.0;
- prolongation[0](18,25) = -45.0/4096.0;
- prolongation[0](18,26) = -45.0/4096.0;
- prolongation[0](18,27) = -45.0/4096.0;
- prolongation[0](18,28) = -9.0/4096.0;
- prolongation[0](18,29) = -9.0/4096.0;
- prolongation[0](18,30) = -9.0/4096.0;
- prolongation[0](18,31) = -9.0/4096.0;
- prolongation[0](18,32) = -135.0/4096.0;
- prolongation[0](18,33) = -135.0/4096.0;
- prolongation[0](18,34) = 45.0/4096.0;
- prolongation[0](18,35) = 45.0/4096.0;
- prolongation[0](18,36) = -135.0/4096.0;
- prolongation[0](18,37) = -135.0/4096.0;
- prolongation[0](18,38) = 45.0/4096.0;
- prolongation[0](18,39) = 45.0/4096.0;
- prolongation[0](18,40) = 405.0/4096.0;
- prolongation[0](18,41) = 405.0/4096.0;
- prolongation[0](18,42) = 405.0/4096.0;
- prolongation[0](18,43) = 405.0/4096.0;
- prolongation[0](18,44) = -135.0/4096.0;
- prolongation[0](18,45) = -135.0/4096.0;
- prolongation[0](18,46) = 45.0/4096.0;
- prolongation[0](18,47) = 45.0/4096.0;
- prolongation[0](18,48) = 81.0/4096.0;
- prolongation[0](18,49) = 81.0/4096.0;
- prolongation[0](18,50) = 81.0/4096.0;
- prolongation[0](18,51) = 81.0/4096.0;
- prolongation[0](18,52) = -135.0/4096.0;
- prolongation[0](18,53) = -135.0/4096.0;
- prolongation[0](18,54) = 45.0/4096.0;
- prolongation[0](18,55) = 45.0/4096.0;
- prolongation[0](18,56) = 1215.0/4096.0;
- prolongation[0](18,57) = 1215.0/4096.0;
- prolongation[0](18,58) = 1215.0/4096.0;
- prolongation[0](18,59) = 1215.0/4096.0;
- prolongation[0](18,60) = -405.0/4096.0;
- prolongation[0](18,61) = -405.0/4096.0;
- prolongation[0](18,62) = -405.0/4096.0;
- prolongation[0](18,63) = -405.0/4096.0;
- prolongation[0](19,10) = 1.0/256.0;
- prolongation[0](19,14) = 1.0/256.0;
- prolongation[0](19,18) = 1.0/256.0;
- prolongation[0](19,22) = 1.0/256.0;
- prolongation[0](19,32) = -9.0/256.0;
- prolongation[0](19,33) = -9.0/256.0;
- prolongation[0](19,36) = -9.0/256.0;
- prolongation[0](19,37) = -9.0/256.0;
- prolongation[0](19,44) = -9.0/256.0;
- prolongation[0](19,45) = -9.0/256.0;
- prolongation[0](19,52) = -9.0/256.0;
- prolongation[0](19,53) = -9.0/256.0;
- prolongation[0](19,56) = 81.0/256.0;
- prolongation[0](19,57) = 81.0/256.0;
- prolongation[0](19,58) = 81.0/256.0;
- prolongation[0](19,59) = 81.0/256.0;
- prolongation[0](20,0) = 5.0/4096.0;
- prolongation[0](20,1) = 1.0/4096.0;
- prolongation[0](20,2) = 1.0/4096.0;
- prolongation[0](20,3) = 5.0/4096.0;
- prolongation[0](20,4) = 5.0/4096.0;
- prolongation[0](20,5) = 1.0/4096.0;
- prolongation[0](20,6) = 1.0/4096.0;
- prolongation[0](20,7) = 5.0/4096.0;
- prolongation[0](20,8) = 15.0/4096.0;
- prolongation[0](20,9) = -5.0/4096.0;
- prolongation[0](20,10) = -9.0/4096.0;
- prolongation[0](20,11) = -9.0/4096.0;
- prolongation[0](20,12) = 15.0/4096.0;
- prolongation[0](20,13) = -5.0/4096.0;
- prolongation[0](20,14) = -45.0/4096.0;
- prolongation[0](20,15) = -45.0/4096.0;
- prolongation[0](20,16) = 15.0/4096.0;
- prolongation[0](20,17) = -5.0/4096.0;
- prolongation[0](20,18) = -9.0/4096.0;
- prolongation[0](20,19) = -9.0/4096.0;
- prolongation[0](20,20) = 15.0/4096.0;
- prolongation[0](20,21) = -5.0/4096.0;
- prolongation[0](20,22) = -45.0/4096.0;
- prolongation[0](20,23) = -45.0/4096.0;
- prolongation[0](20,24) = -45.0/4096.0;
- prolongation[0](20,25) = -45.0/4096.0;
- prolongation[0](20,26) = -9.0/4096.0;
- prolongation[0](20,27) = -9.0/4096.0;
- prolongation[0](20,28) = -9.0/4096.0;
- prolongation[0](20,29) = -9.0/4096.0;
- prolongation[0](20,30) = -45.0/4096.0;
- prolongation[0](20,31) = -45.0/4096.0;
- prolongation[0](20,32) = -135.0/4096.0;
- prolongation[0](20,33) = 45.0/4096.0;
- prolongation[0](20,34) = -135.0/4096.0;
- prolongation[0](20,35) = 45.0/4096.0;
- prolongation[0](20,36) = -135.0/4096.0;
- prolongation[0](20,37) = 45.0/4096.0;
- prolongation[0](20,38) = -135.0/4096.0;
- prolongation[0](20,39) = 45.0/4096.0;
- prolongation[0](20,40) = -135.0/4096.0;
- prolongation[0](20,41) = 45.0/4096.0;
- prolongation[0](20,42) = -135.0/4096.0;
- prolongation[0](20,43) = 45.0/4096.0;
- prolongation[0](20,44) = 81.0/4096.0;
- prolongation[0](20,45) = 81.0/4096.0;
- prolongation[0](20,46) = 81.0/4096.0;
- prolongation[0](20,47) = 81.0/4096.0;
- prolongation[0](20,48) = -135.0/4096.0;
- prolongation[0](20,49) = 45.0/4096.0;
- prolongation[0](20,50) = -135.0/4096.0;
- prolongation[0](20,51) = 45.0/4096.0;
- prolongation[0](20,52) = 405.0/4096.0;
- prolongation[0](20,53) = 405.0/4096.0;
- prolongation[0](20,54) = 405.0/4096.0;
- prolongation[0](20,55) = 405.0/4096.0;
- prolongation[0](20,56) = 1215.0/4096.0;
- prolongation[0](20,57) = -405.0/4096.0;
- prolongation[0](20,58) = 1215.0/4096.0;
- prolongation[0](20,59) = -405.0/4096.0;
- prolongation[0](20,60) = 1215.0/4096.0;
- prolongation[0](20,61) = -405.0/4096.0;
- prolongation[0](20,62) = 1215.0/4096.0;
- prolongation[0](20,63) = -405.0/4096.0;
- prolongation[0](21,8) = 1.0/256.0;
- prolongation[0](21,12) = 1.0/256.0;
- prolongation[0](21,16) = 1.0/256.0;
- prolongation[0](21,20) = 1.0/256.0;
- prolongation[0](21,32) = -9.0/256.0;
- prolongation[0](21,34) = -9.0/256.0;
- prolongation[0](21,36) = -9.0/256.0;
- prolongation[0](21,38) = -9.0/256.0;
- prolongation[0](21,40) = -9.0/256.0;
- prolongation[0](21,42) = -9.0/256.0;
- prolongation[0](21,48) = -9.0/256.0;
- prolongation[0](21,50) = -9.0/256.0;
- prolongation[0](21,56) = 81.0/256.0;
- prolongation[0](21,58) = 81.0/256.0;
- prolongation[0](21,60) = 81.0/256.0;
- prolongation[0](21,62) = 81.0/256.0;
- prolongation[0](22,0) = -5.0/256.0;
- prolongation[0](22,3) = -1.0/256.0;
- prolongation[0](22,4) = -5.0/256.0;
- prolongation[0](22,7) = -1.0/256.0;
- prolongation[0](22,14) = -15.0/256.0;
- prolongation[0](22,15) = 5.0/256.0;
- prolongation[0](22,22) = -15.0/256.0;
- prolongation[0](22,23) = 5.0/256.0;
- prolongation[0](22,24) = 45.0/256.0;
- prolongation[0](22,25) = 45.0/256.0;
- prolongation[0](22,30) = 9.0/256.0;
- prolongation[0](22,31) = 9.0/256.0;
- prolongation[0](22,52) = 135.0/256.0;
- prolongation[0](22,53) = 135.0/256.0;
- prolongation[0](22,54) = -45.0/256.0;
- prolongation[0](22,55) = -45.0/256.0;
- prolongation[0](23,14) = -1.0/16.0;
- prolongation[0](23,22) = -1.0/16.0;
- prolongation[0](23,52) = 9.0/16.0;
- prolongation[0](23,53) = 9.0/16.0;
- prolongation[0](24,0) = 5.0/16.0;
- prolongation[0](24,4) = 1.0/16.0;
- prolongation[0](24,24) = 15.0/16.0;
- prolongation[0](24,25) = -5.0/16.0;
- prolongation[0](25,24) = 1.0;
- prolongation[0](26,0) = -5.0/256.0;
- prolongation[0](26,1) = -5.0/256.0;
- prolongation[0](26,4) = -1.0/256.0;
- prolongation[0](26,5) = -1.0/256.0;
- prolongation[0](26,8) = 45.0/256.0;
- prolongation[0](26,9) = 45.0/256.0;
- prolongation[0](26,16) = 9.0/256.0;
- prolongation[0](26,17) = 9.0/256.0;
- prolongation[0](26,24) = -15.0/256.0;
- prolongation[0](26,25) = 5.0/256.0;
- prolongation[0](26,26) = -15.0/256.0;
- prolongation[0](26,27) = 5.0/256.0;
- prolongation[0](26,40) = 135.0/256.0;
- prolongation[0](26,41) = 135.0/256.0;
- prolongation[0](26,42) = -45.0/256.0;
- prolongation[0](26,43) = -45.0/256.0;
- prolongation[0](27,24) = -1.0/16.0;
- prolongation[0](27,26) = -1.0/16.0;
- prolongation[0](27,40) = 9.0/16.0;
- prolongation[0](27,41) = 9.0/16.0;
- prolongation[0](28,0) = 5.0/4096.0;
- prolongation[0](28,1) = 5.0/4096.0;
- prolongation[0](28,2) = 5.0/4096.0;
- prolongation[0](28,3) = 5.0/4096.0;
- prolongation[0](28,4) = 1.0/4096.0;
- prolongation[0](28,5) = 1.0/4096.0;
- prolongation[0](28,6) = 1.0/4096.0;
- prolongation[0](28,7) = 1.0/4096.0;
- prolongation[0](28,8) = -45.0/4096.0;
- prolongation[0](28,9) = -45.0/4096.0;
- prolongation[0](28,10) = -45.0/4096.0;
- prolongation[0](28,11) = -45.0/4096.0;
- prolongation[0](28,12) = -45.0/4096.0;
- prolongation[0](28,13) = -45.0/4096.0;
- prolongation[0](28,14) = -45.0/4096.0;
- prolongation[0](28,15) = -45.0/4096.0;
- prolongation[0](28,16) = -9.0/4096.0;
- prolongation[0](28,17) = -9.0/4096.0;
- prolongation[0](28,18) = -9.0/4096.0;
- prolongation[0](28,19) = -9.0/4096.0;
- prolongation[0](28,20) = -9.0/4096.0;
- prolongation[0](28,21) = -9.0/4096.0;
- prolongation[0](28,22) = -9.0/4096.0;
- prolongation[0](28,23) = -9.0/4096.0;
- prolongation[0](28,24) = 15.0/4096.0;
- prolongation[0](28,25) = -5.0/4096.0;
- prolongation[0](28,26) = 15.0/4096.0;
- prolongation[0](28,27) = -5.0/4096.0;
- prolongation[0](28,28) = 15.0/4096.0;
- prolongation[0](28,29) = -5.0/4096.0;
- prolongation[0](28,30) = 15.0/4096.0;
- prolongation[0](28,31) = -5.0/4096.0;
- prolongation[0](28,32) = 405.0/4096.0;
- prolongation[0](28,33) = 405.0/4096.0;
- prolongation[0](28,34) = 405.0/4096.0;
- prolongation[0](28,35) = 405.0/4096.0;
- prolongation[0](28,36) = 81.0/4096.0;
- prolongation[0](28,37) = 81.0/4096.0;
- prolongation[0](28,38) = 81.0/4096.0;
- prolongation[0](28,39) = 81.0/4096.0;
- prolongation[0](28,40) = -135.0/4096.0;
- prolongation[0](28,41) = -135.0/4096.0;
- prolongation[0](28,42) = 45.0/4096.0;
- prolongation[0](28,43) = 45.0/4096.0;
- prolongation[0](28,44) = -135.0/4096.0;
- prolongation[0](28,45) = 45.0/4096.0;
- prolongation[0](28,46) = -135.0/4096.0;
- prolongation[0](28,47) = 45.0/4096.0;
- prolongation[0](28,48) = -135.0/4096.0;
- prolongation[0](28,49) = -135.0/4096.0;
- prolongation[0](28,50) = 45.0/4096.0;
- prolongation[0](28,51) = 45.0/4096.0;
- prolongation[0](28,52) = -135.0/4096.0;
- prolongation[0](28,53) = 45.0/4096.0;
- prolongation[0](28,54) = -135.0/4096.0;
- prolongation[0](28,55) = 45.0/4096.0;
- prolongation[0](28,56) = 1215.0/4096.0;
- prolongation[0](28,57) = 1215.0/4096.0;
- prolongation[0](28,58) = -405.0/4096.0;
- prolongation[0](28,59) = -405.0/4096.0;
- prolongation[0](28,60) = 1215.0/4096.0;
- prolongation[0](28,61) = 1215.0/4096.0;
- prolongation[0](28,62) = -405.0/4096.0;
- prolongation[0](28,63) = -405.0/4096.0;
- prolongation[0](29,24) = 1.0/256.0;
- prolongation[0](29,26) = 1.0/256.0;
- prolongation[0](29,28) = 1.0/256.0;
- prolongation[0](29,30) = 1.0/256.0;
- prolongation[0](29,40) = -9.0/256.0;
- prolongation[0](29,41) = -9.0/256.0;
- prolongation[0](29,44) = -9.0/256.0;
- prolongation[0](29,46) = -9.0/256.0;
- prolongation[0](29,48) = -9.0/256.0;
- prolongation[0](29,49) = -9.0/256.0;
- prolongation[0](29,52) = -9.0/256.0;
- prolongation[0](29,54) = -9.0/256.0;
- prolongation[0](29,56) = 81.0/256.0;
- prolongation[0](29,57) = 81.0/256.0;
- prolongation[0](29,60) = 81.0/256.0;
- prolongation[0](29,61) = 81.0/256.0;
- prolongation[0](30,0) = -5.0/256.0;
- prolongation[0](30,3) = -5.0/256.0;
- prolongation[0](30,4) = -1.0/256.0;
- prolongation[0](30,7) = -1.0/256.0;
- prolongation[0](30,14) = 45.0/256.0;
- prolongation[0](30,15) = 45.0/256.0;
- prolongation[0](30,22) = 9.0/256.0;
- prolongation[0](30,23) = 9.0/256.0;
- prolongation[0](30,24) = -15.0/256.0;
- prolongation[0](30,25) = 5.0/256.0;
- prolongation[0](30,30) = -15.0/256.0;
- prolongation[0](30,31) = 5.0/256.0;
- prolongation[0](30,52) = 135.0/256.0;
- prolongation[0](30,53) = -45.0/256.0;
- prolongation[0](30,54) = 135.0/256.0;
- prolongation[0](30,55) = -45.0/256.0;
- prolongation[0](31,24) = -1.0/16.0;
- prolongation[0](31,30) = -1.0/16.0;
- prolongation[0](31,52) = 9.0/16.0;
- prolongation[0](31,54) = 9.0/16.0;
- prolongation[0](32,0) = 25.0/256.0;
- prolongation[0](32,1) = 5.0/256.0;
- prolongation[0](32,2) = 1.0/256.0;
- prolongation[0](32,3) = 5.0/256.0;
- prolongation[0](32,8) = 75.0/256.0;
- prolongation[0](32,9) = -25.0/256.0;
- prolongation[0](32,10) = 15.0/256.0;
- prolongation[0](32,11) = -5.0/256.0;
- prolongation[0](32,12) = 15.0/256.0;
- prolongation[0](32,13) = -5.0/256.0;
- prolongation[0](32,14) = 75.0/256.0;
- prolongation[0](32,15) = -25.0/256.0;
- prolongation[0](32,32) = 225.0/256.0;
- prolongation[0](32,33) = -75.0/256.0;
- prolongation[0](32,34) = -75.0/256.0;
- prolongation[0](32,35) = 25.0/256.0;
- prolongation[0](33,8) = 5.0/16.0;
- prolongation[0](33,12) = 1.0/16.0;
- prolongation[0](33,32) = 15.0/16.0;
- prolongation[0](33,34) = -5.0/16.0;
- prolongation[0](34,10) = 1.0/16.0;
- prolongation[0](34,14) = 5.0/16.0;
- prolongation[0](34,32) = 15.0/16.0;
- prolongation[0](34,33) = -5.0/16.0;
- prolongation[0](35,32) = 1.0;
- prolongation[0](36,0) = -25.0/4096.0;
- prolongation[0](36,1) = -5.0/4096.0;
- prolongation[0](36,2) = -1.0/4096.0;
- prolongation[0](36,3) = -5.0/4096.0;
- prolongation[0](36,4) = -25.0/4096.0;
- prolongation[0](36,5) = -5.0/4096.0;
- prolongation[0](36,6) = -1.0/4096.0;
- prolongation[0](36,7) = -5.0/4096.0;
- prolongation[0](36,8) = -75.0/4096.0;
- prolongation[0](36,9) = 25.0/4096.0;
- prolongation[0](36,10) = -15.0/4096.0;
- prolongation[0](36,11) = 5.0/4096.0;
- prolongation[0](36,12) = -15.0/4096.0;
- prolongation[0](36,13) = 5.0/4096.0;
- prolongation[0](36,14) = -75.0/4096.0;
- prolongation[0](36,15) = 25.0/4096.0;
- prolongation[0](36,16) = -75.0/4096.0;
- prolongation[0](36,17) = 25.0/4096.0;
- prolongation[0](36,18) = -15.0/4096.0;
- prolongation[0](36,19) = 5.0/4096.0;
- prolongation[0](36,20) = -15.0/4096.0;
- prolongation[0](36,21) = 5.0/4096.0;
- prolongation[0](36,22) = -75.0/4096.0;
- prolongation[0](36,23) = 25.0/4096.0;
- prolongation[0](36,24) = 225.0/4096.0;
- prolongation[0](36,25) = 225.0/4096.0;
- prolongation[0](36,26) = 45.0/4096.0;
- prolongation[0](36,27) = 45.0/4096.0;
- prolongation[0](36,28) = 9.0/4096.0;
- prolongation[0](36,29) = 9.0/4096.0;
- prolongation[0](36,30) = 45.0/4096.0;
- prolongation[0](36,31) = 45.0/4096.0;
- prolongation[0](36,32) = -225.0/4096.0;
- prolongation[0](36,33) = 75.0/4096.0;
- prolongation[0](36,34) = 75.0/4096.0;
- prolongation[0](36,35) = -25.0/4096.0;
- prolongation[0](36,36) = -225.0/4096.0;
- prolongation[0](36,37) = 75.0/4096.0;
- prolongation[0](36,38) = 75.0/4096.0;
- prolongation[0](36,39) = -25.0/4096.0;
- prolongation[0](36,40) = 675.0/4096.0;
- prolongation[0](36,41) = -225.0/4096.0;
- prolongation[0](36,42) = 675.0/4096.0;
- prolongation[0](36,43) = -225.0/4096.0;
- prolongation[0](36,44) = 135.0/4096.0;
- prolongation[0](36,45) = 135.0/4096.0;
- prolongation[0](36,46) = -45.0/4096.0;
- prolongation[0](36,47) = -45.0/4096.0;
- prolongation[0](36,48) = 135.0/4096.0;
- prolongation[0](36,49) = -45.0/4096.0;
- prolongation[0](36,50) = 135.0/4096.0;
- prolongation[0](36,51) = -45.0/4096.0;
- prolongation[0](36,52) = 675.0/4096.0;
- prolongation[0](36,53) = 675.0/4096.0;
- prolongation[0](36,54) = -225.0/4096.0;
- prolongation[0](36,55) = -225.0/4096.0;
- prolongation[0](36,56) = 2025.0/4096.0;
- prolongation[0](36,57) = -675.0/4096.0;
- prolongation[0](36,58) = 2025.0/4096.0;
- prolongation[0](36,59) = -675.0/4096.0;
- prolongation[0](36,60) = -675.0/4096.0;
- prolongation[0](36,61) = 225.0/4096.0;
- prolongation[0](36,62) = -675.0/4096.0;
- prolongation[0](36,63) = 225.0/4096.0;
- prolongation[0](37,8) = -5.0/256.0;
- prolongation[0](37,12) = -1.0/256.0;
- prolongation[0](37,16) = -5.0/256.0;
- prolongation[0](37,20) = -1.0/256.0;
- prolongation[0](37,32) = -15.0/256.0;
- prolongation[0](37,34) = 5.0/256.0;
- prolongation[0](37,36) = -15.0/256.0;
- prolongation[0](37,38) = 5.0/256.0;
- prolongation[0](37,40) = 45.0/256.0;
- prolongation[0](37,42) = 45.0/256.0;
- prolongation[0](37,48) = 9.0/256.0;
- prolongation[0](37,50) = 9.0/256.0;
- prolongation[0](37,56) = 135.0/256.0;
- prolongation[0](37,58) = 135.0/256.0;
- prolongation[0](37,60) = -45.0/256.0;
- prolongation[0](37,62) = -45.0/256.0;
- prolongation[0](38,10) = -1.0/256.0;
- prolongation[0](38,14) = -5.0/256.0;
- prolongation[0](38,18) = -1.0/256.0;
- prolongation[0](38,22) = -5.0/256.0;
- prolongation[0](38,32) = -15.0/256.0;
- prolongation[0](38,33) = 5.0/256.0;
- prolongation[0](38,36) = -15.0/256.0;
- prolongation[0](38,37) = 5.0/256.0;
- prolongation[0](38,44) = 9.0/256.0;
- prolongation[0](38,45) = 9.0/256.0;
- prolongation[0](38,52) = 45.0/256.0;
- prolongation[0](38,53) = 45.0/256.0;
- prolongation[0](38,56) = 135.0/256.0;
- prolongation[0](38,57) = -45.0/256.0;
- prolongation[0](38,58) = 135.0/256.0;
- prolongation[0](38,59) = -45.0/256.0;
- prolongation[0](39,32) = -1.0/16.0;
- prolongation[0](39,36) = -1.0/16.0;
- prolongation[0](39,56) = 9.0/16.0;
- prolongation[0](39,58) = 9.0/16.0;
- prolongation[0](40,0) = 25.0/256.0;
- prolongation[0](40,1) = 5.0/256.0;
- prolongation[0](40,4) = 5.0/256.0;
- prolongation[0](40,5) = 1.0/256.0;
- prolongation[0](40,8) = 75.0/256.0;
- prolongation[0](40,9) = -25.0/256.0;
- prolongation[0](40,16) = 15.0/256.0;
- prolongation[0](40,17) = -5.0/256.0;
- prolongation[0](40,24) = 75.0/256.0;
- prolongation[0](40,25) = -25.0/256.0;
- prolongation[0](40,26) = 15.0/256.0;
- prolongation[0](40,27) = -5.0/256.0;
- prolongation[0](40,40) = 225.0/256.0;
- prolongation[0](40,41) = -75.0/256.0;
- prolongation[0](40,42) = -75.0/256.0;
- prolongation[0](40,43) = 25.0/256.0;
- prolongation[0](41,8) = 5.0/16.0;
- prolongation[0](41,16) = 1.0/16.0;
- prolongation[0](41,40) = 15.0/16.0;
- prolongation[0](41,42) = -5.0/16.0;
- prolongation[0](42,24) = 5.0/16.0;
- prolongation[0](42,26) = 1.0/16.0;
- prolongation[0](42,40) = 15.0/16.0;
- prolongation[0](42,41) = -5.0/16.0;
- prolongation[0](43,40) = 1.0;
- prolongation[0](44,0) = -25.0/4096.0;
- prolongation[0](44,1) = -25.0/4096.0;
- prolongation[0](44,2) = -5.0/4096.0;
- prolongation[0](44,3) = -5.0/4096.0;
- prolongation[0](44,4) = -5.0/4096.0;
- prolongation[0](44,5) = -5.0/4096.0;
- prolongation[0](44,6) = -1.0/4096.0;
- prolongation[0](44,7) = -1.0/4096.0;
- prolongation[0](44,8) = 225.0/4096.0;
- prolongation[0](44,9) = 225.0/4096.0;
- prolongation[0](44,10) = -75.0/4096.0;
- prolongation[0](44,11) = 25.0/4096.0;
- prolongation[0](44,12) = 45.0/4096.0;
- prolongation[0](44,13) = 45.0/4096.0;
- prolongation[0](44,14) = -75.0/4096.0;
- prolongation[0](44,15) = 25.0/4096.0;
- prolongation[0](44,16) = 45.0/4096.0;
- prolongation[0](44,17) = 45.0/4096.0;
- prolongation[0](44,18) = -15.0/4096.0;
- prolongation[0](44,19) = 5.0/4096.0;
- prolongation[0](44,20) = 9.0/4096.0;
- prolongation[0](44,21) = 9.0/4096.0;
- prolongation[0](44,22) = -15.0/4096.0;
- prolongation[0](44,23) = 5.0/4096.0;
- prolongation[0](44,24) = -75.0/4096.0;
- prolongation[0](44,25) = 25.0/4096.0;
- prolongation[0](44,26) = -75.0/4096.0;
- prolongation[0](44,27) = 25.0/4096.0;
- prolongation[0](44,28) = -15.0/4096.0;
- prolongation[0](44,29) = 5.0/4096.0;
- prolongation[0](44,30) = -15.0/4096.0;
- prolongation[0](44,31) = 5.0/4096.0;
- prolongation[0](44,32) = 675.0/4096.0;
- prolongation[0](44,33) = 675.0/4096.0;
- prolongation[0](44,34) = -225.0/4096.0;
- prolongation[0](44,35) = -225.0/4096.0;
- prolongation[0](44,36) = 135.0/4096.0;
- prolongation[0](44,37) = 135.0/4096.0;
- prolongation[0](44,38) = -45.0/4096.0;
- prolongation[0](44,39) = -45.0/4096.0;
- prolongation[0](44,40) = 675.0/4096.0;
- prolongation[0](44,41) = 675.0/4096.0;
- prolongation[0](44,42) = -225.0/4096.0;
- prolongation[0](44,43) = -225.0/4096.0;
- prolongation[0](44,44) = -225.0/4096.0;
- prolongation[0](44,45) = 75.0/4096.0;
- prolongation[0](44,46) = 75.0/4096.0;
- prolongation[0](44,47) = -25.0/4096.0;
- prolongation[0](44,48) = 135.0/4096.0;
- prolongation[0](44,49) = 135.0/4096.0;
- prolongation[0](44,50) = -45.0/4096.0;
- prolongation[0](44,51) = -45.0/4096.0;
- prolongation[0](44,52) = -225.0/4096.0;
- prolongation[0](44,53) = 75.0/4096.0;
- prolongation[0](44,54) = 75.0/4096.0;
- prolongation[0](44,55) = -25.0/4096.0;
- prolongation[0](44,56) = 2025.0/4096.0;
- prolongation[0](44,57) = 2025.0/4096.0;
- prolongation[0](44,58) = -675.0/4096.0;
- prolongation[0](44,59) = -675.0/4096.0;
- prolongation[0](44,60) = -675.0/4096.0;
- prolongation[0](44,61) = -675.0/4096.0;
- prolongation[0](44,62) = 225.0/4096.0;
- prolongation[0](44,63) = 225.0/4096.0;
- prolongation[0](45,24) = -5.0/256.0;
- prolongation[0](45,26) = -5.0/256.0;
- prolongation[0](45,28) = -1.0/256.0;
- prolongation[0](45,30) = -1.0/256.0;
- prolongation[0](45,40) = 45.0/256.0;
- prolongation[0](45,41) = 45.0/256.0;
- prolongation[0](45,44) = -15.0/256.0;
- prolongation[0](45,46) = 5.0/256.0;
- prolongation[0](45,48) = 9.0/256.0;
- prolongation[0](45,49) = 9.0/256.0;
- prolongation[0](45,52) = -15.0/256.0;
- prolongation[0](45,54) = 5.0/256.0;
- prolongation[0](45,56) = 135.0/256.0;
- prolongation[0](45,57) = 135.0/256.0;
- prolongation[0](45,60) = -45.0/256.0;
- prolongation[0](45,61) = -45.0/256.0;
- prolongation[0](46,10) = -5.0/256.0;
- prolongation[0](46,14) = -5.0/256.0;
- prolongation[0](46,18) = -1.0/256.0;
- prolongation[0](46,22) = -1.0/256.0;
- prolongation[0](46,32) = 45.0/256.0;
- prolongation[0](46,33) = 45.0/256.0;
- prolongation[0](46,36) = 9.0/256.0;
- prolongation[0](46,37) = 9.0/256.0;
- prolongation[0](46,44) = -15.0/256.0;
- prolongation[0](46,45) = 5.0/256.0;
- prolongation[0](46,52) = -15.0/256.0;
- prolongation[0](46,53) = 5.0/256.0;
- prolongation[0](46,56) = 135.0/256.0;
- prolongation[0](46,57) = 135.0/256.0;
- prolongation[0](46,58) = -45.0/256.0;
- prolongation[0](46,59) = -45.0/256.0;
- prolongation[0](47,44) = -1.0/16.0;
- prolongation[0](47,52) = -1.0/16.0;
- prolongation[0](47,56) = 9.0/16.0;
- prolongation[0](47,57) = 9.0/16.0;
- prolongation[0](48,0) = -25.0/4096.0;
- prolongation[0](48,1) = -5.0/4096.0;
- prolongation[0](48,2) = -5.0/4096.0;
- prolongation[0](48,3) = -25.0/4096.0;
- prolongation[0](48,4) = -5.0/4096.0;
- prolongation[0](48,5) = -1.0/4096.0;
- prolongation[0](48,6) = -1.0/4096.0;
- prolongation[0](48,7) = -5.0/4096.0;
- prolongation[0](48,8) = -75.0/4096.0;
- prolongation[0](48,9) = 25.0/4096.0;
- prolongation[0](48,10) = 45.0/4096.0;
- prolongation[0](48,11) = 45.0/4096.0;
- prolongation[0](48,12) = -75.0/4096.0;
- prolongation[0](48,13) = 25.0/4096.0;
- prolongation[0](48,14) = 225.0/4096.0;
- prolongation[0](48,15) = 225.0/4096.0;
- prolongation[0](48,16) = -15.0/4096.0;
- prolongation[0](48,17) = 5.0/4096.0;
- prolongation[0](48,18) = 9.0/4096.0;
- prolongation[0](48,19) = 9.0/4096.0;
- prolongation[0](48,20) = -15.0/4096.0;
- prolongation[0](48,21) = 5.0/4096.0;
- prolongation[0](48,22) = 45.0/4096.0;
- prolongation[0](48,23) = 45.0/4096.0;
- prolongation[0](48,24) = -75.0/4096.0;
- prolongation[0](48,25) = 25.0/4096.0;
- prolongation[0](48,26) = -15.0/4096.0;
- prolongation[0](48,27) = 5.0/4096.0;
- prolongation[0](48,28) = -15.0/4096.0;
- prolongation[0](48,29) = 5.0/4096.0;
- prolongation[0](48,30) = -75.0/4096.0;
- prolongation[0](48,31) = 25.0/4096.0;
- prolongation[0](48,32) = 675.0/4096.0;
- prolongation[0](48,33) = -225.0/4096.0;
- prolongation[0](48,34) = 675.0/4096.0;
- prolongation[0](48,35) = -225.0/4096.0;
- prolongation[0](48,36) = 135.0/4096.0;
- prolongation[0](48,37) = -45.0/4096.0;
- prolongation[0](48,38) = 135.0/4096.0;
- prolongation[0](48,39) = -45.0/4096.0;
- prolongation[0](48,40) = -225.0/4096.0;
- prolongation[0](48,41) = 75.0/4096.0;
- prolongation[0](48,42) = 75.0/4096.0;
- prolongation[0](48,43) = -25.0/4096.0;
- prolongation[0](48,44) = 135.0/4096.0;
- prolongation[0](48,45) = -45.0/4096.0;
- prolongation[0](48,46) = 135.0/4096.0;
- prolongation[0](48,47) = -45.0/4096.0;
- prolongation[0](48,48) = -225.0/4096.0;
- prolongation[0](48,49) = 75.0/4096.0;
- prolongation[0](48,50) = 75.0/4096.0;
- prolongation[0](48,51) = -25.0/4096.0;
- prolongation[0](48,52) = 675.0/4096.0;
- prolongation[0](48,53) = -225.0/4096.0;
- prolongation[0](48,54) = 675.0/4096.0;
- prolongation[0](48,55) = -225.0/4096.0;
- prolongation[0](48,56) = 2025.0/4096.0;
- prolongation[0](48,57) = -675.0/4096.0;
- prolongation[0](48,58) = -675.0/4096.0;
- prolongation[0](48,59) = 225.0/4096.0;
- prolongation[0](48,60) = 2025.0/4096.0;
- prolongation[0](48,61) = -675.0/4096.0;
- prolongation[0](48,62) = -675.0/4096.0;
- prolongation[0](48,63) = 225.0/4096.0;
- prolongation[0](49,8) = -5.0/256.0;
- prolongation[0](49,12) = -5.0/256.0;
- prolongation[0](49,16) = -1.0/256.0;
- prolongation[0](49,20) = -1.0/256.0;
- prolongation[0](49,32) = 45.0/256.0;
- prolongation[0](49,34) = 45.0/256.0;
- prolongation[0](49,36) = 9.0/256.0;
- prolongation[0](49,38) = 9.0/256.0;
- prolongation[0](49,40) = -15.0/256.0;
- prolongation[0](49,42) = 5.0/256.0;
- prolongation[0](49,48) = -15.0/256.0;
- prolongation[0](49,50) = 5.0/256.0;
- prolongation[0](49,56) = 135.0/256.0;
- prolongation[0](49,58) = -45.0/256.0;
- prolongation[0](49,60) = 135.0/256.0;
- prolongation[0](49,62) = -45.0/256.0;
- prolongation[0](50,24) = -5.0/256.0;
- prolongation[0](50,26) = -1.0/256.0;
- prolongation[0](50,28) = -1.0/256.0;
- prolongation[0](50,30) = -5.0/256.0;
- prolongation[0](50,40) = -15.0/256.0;
- prolongation[0](50,41) = 5.0/256.0;
- prolongation[0](50,44) = 9.0/256.0;
- prolongation[0](50,46) = 9.0/256.0;
- prolongation[0](50,48) = -15.0/256.0;
- prolongation[0](50,49) = 5.0/256.0;
- prolongation[0](50,52) = 45.0/256.0;
- prolongation[0](50,54) = 45.0/256.0;
- prolongation[0](50,56) = 135.0/256.0;
- prolongation[0](50,57) = -45.0/256.0;
- prolongation[0](50,60) = 135.0/256.0;
- prolongation[0](50,61) = -45.0/256.0;
- prolongation[0](51,40) = -1.0/16.0;
- prolongation[0](51,48) = -1.0/16.0;
- prolongation[0](51,56) = 9.0/16.0;
- prolongation[0](51,60) = 9.0/16.0;
- prolongation[0](52,0) = 25.0/256.0;
- prolongation[0](52,3) = 5.0/256.0;
- prolongation[0](52,4) = 5.0/256.0;
- prolongation[0](52,7) = 1.0/256.0;
- prolongation[0](52,14) = 75.0/256.0;
- prolongation[0](52,15) = -25.0/256.0;
- prolongation[0](52,22) = 15.0/256.0;
- prolongation[0](52,23) = -5.0/256.0;
- prolongation[0](52,24) = 75.0/256.0;
- prolongation[0](52,25) = -25.0/256.0;
- prolongation[0](52,30) = 15.0/256.0;
- prolongation[0](52,31) = -5.0/256.0;
- prolongation[0](52,52) = 225.0/256.0;
- prolongation[0](52,53) = -75.0/256.0;
- prolongation[0](52,54) = -75.0/256.0;
- prolongation[0](52,55) = 25.0/256.0;
- prolongation[0](53,24) = 5.0/16.0;
- prolongation[0](53,30) = 1.0/16.0;
- prolongation[0](53,52) = 15.0/16.0;
- prolongation[0](53,54) = -5.0/16.0;
- prolongation[0](54,14) = 5.0/16.0;
- prolongation[0](54,22) = 1.0/16.0;
- prolongation[0](54,52) = 15.0/16.0;
- prolongation[0](54,53) = -5.0/16.0;
- prolongation[0](55,52) = 1.0;
- prolongation[0](56,0) = 125.0/4096.0;
- prolongation[0](56,1) = 25.0/4096.0;
- prolongation[0](56,2) = 5.0/4096.0;
- prolongation[0](56,3) = 25.0/4096.0;
- prolongation[0](56,4) = 25.0/4096.0;
- prolongation[0](56,5) = 5.0/4096.0;
- prolongation[0](56,6) = 1.0/4096.0;
- prolongation[0](56,7) = 5.0/4096.0;
- prolongation[0](56,8) = 375.0/4096.0;
- prolongation[0](56,9) = -125.0/4096.0;
- prolongation[0](56,10) = 75.0/4096.0;
- prolongation[0](56,11) = -25.0/4096.0;
- prolongation[0](56,12) = 75.0/4096.0;
- prolongation[0](56,13) = -25.0/4096.0;
- prolongation[0](56,14) = 375.0/4096.0;
- prolongation[0](56,15) = -125.0/4096.0;
- prolongation[0](56,16) = 75.0/4096.0;
- prolongation[0](56,17) = -25.0/4096.0;
- prolongation[0](56,18) = 15.0/4096.0;
- prolongation[0](56,19) = -5.0/4096.0;
- prolongation[0](56,20) = 15.0/4096.0;
- prolongation[0](56,21) = -5.0/4096.0;
- prolongation[0](56,22) = 75.0/4096.0;
- prolongation[0](56,23) = -25.0/4096.0;
- prolongation[0](56,24) = 375.0/4096.0;
- prolongation[0](56,25) = -125.0/4096.0;
- prolongation[0](56,26) = 75.0/4096.0;
- prolongation[0](56,27) = -25.0/4096.0;
- prolongation[0](56,28) = 15.0/4096.0;
- prolongation[0](56,29) = -5.0/4096.0;
- prolongation[0](56,30) = 75.0/4096.0;
- prolongation[0](56,31) = -25.0/4096.0;
- prolongation[0](56,32) = 1125.0/4096.0;
- prolongation[0](56,33) = -375.0/4096.0;
- prolongation[0](56,34) = -375.0/4096.0;
- prolongation[0](56,35) = 125.0/4096.0;
- prolongation[0](56,36) = 225.0/4096.0;
- prolongation[0](56,37) = -75.0/4096.0;
- prolongation[0](56,38) = -75.0/4096.0;
- prolongation[0](56,39) = 25.0/4096.0;
- prolongation[0](56,40) = 1125.0/4096.0;
- prolongation[0](56,41) = -375.0/4096.0;
- prolongation[0](56,42) = -375.0/4096.0;
- prolongation[0](56,43) = 125.0/4096.0;
- prolongation[0](56,44) = 225.0/4096.0;
- prolongation[0](56,45) = -75.0/4096.0;
- prolongation[0](56,46) = -75.0/4096.0;
- prolongation[0](56,47) = 25.0/4096.0;
- prolongation[0](56,48) = 225.0/4096.0;
- prolongation[0](56,49) = -75.0/4096.0;
- prolongation[0](56,50) = -75.0/4096.0;
- prolongation[0](56,51) = 25.0/4096.0;
- prolongation[0](56,52) = 1125.0/4096.0;
- prolongation[0](56,53) = -375.0/4096.0;
- prolongation[0](56,54) = -375.0/4096.0;
- prolongation[0](56,55) = 125.0/4096.0;
- prolongation[0](56,56) = 3375.0/4096.0;
- prolongation[0](56,57) = -1125.0/4096.0;
- prolongation[0](56,58) = -1125.0/4096.0;
- prolongation[0](56,59) = 375.0/4096.0;
- prolongation[0](56,60) = -1125.0/4096.0;
- prolongation[0](56,61) = 375.0/4096.0;
- prolongation[0](56,62) = 375.0/4096.0;
- prolongation[0](56,63) = -125.0/4096.0;
- prolongation[0](57,8) = 25.0/256.0;
- prolongation[0](57,12) = 5.0/256.0;
- prolongation[0](57,16) = 5.0/256.0;
- prolongation[0](57,20) = 1.0/256.0;
- prolongation[0](57,32) = 75.0/256.0;
- prolongation[0](57,34) = -25.0/256.0;
- prolongation[0](57,36) = 15.0/256.0;
- prolongation[0](57,38) = -5.0/256.0;
- prolongation[0](57,40) = 75.0/256.0;
- prolongation[0](57,42) = -25.0/256.0;
- prolongation[0](57,48) = 15.0/256.0;
- prolongation[0](57,50) = -5.0/256.0;
- prolongation[0](57,56) = 225.0/256.0;
- prolongation[0](57,58) = -75.0/256.0;
- prolongation[0](57,60) = -75.0/256.0;
- prolongation[0](57,62) = 25.0/256.0;
- prolongation[0](58,24) = 25.0/256.0;
- prolongation[0](58,26) = 5.0/256.0;
- prolongation[0](58,28) = 1.0/256.0;
- prolongation[0](58,30) = 5.0/256.0;
- prolongation[0](58,40) = 75.0/256.0;
- prolongation[0](58,41) = -25.0/256.0;
- prolongation[0](58,44) = 15.0/256.0;
- prolongation[0](58,46) = -5.0/256.0;
- prolongation[0](58,48) = 15.0/256.0;
- prolongation[0](58,49) = -5.0/256.0;
- prolongation[0](58,52) = 75.0/256.0;
- prolongation[0](58,54) = -25.0/256.0;
- prolongation[0](58,56) = 225.0/256.0;
- prolongation[0](58,57) = -75.0/256.0;
- prolongation[0](58,60) = -75.0/256.0;
- prolongation[0](58,61) = 25.0/256.0;
- prolongation[0](59,40) = 5.0/16.0;
- prolongation[0](59,48) = 1.0/16.0;
- prolongation[0](59,56) = 15.0/16.0;
- prolongation[0](59,60) = -5.0/16.0;
- prolongation[0](60,10) = 5.0/256.0;
- prolongation[0](60,14) = 25.0/256.0;
- prolongation[0](60,18) = 1.0/256.0;
- prolongation[0](60,22) = 5.0/256.0;
- prolongation[0](60,32) = 75.0/256.0;
- prolongation[0](60,33) = -25.0/256.0;
- prolongation[0](60,36) = 15.0/256.0;
- prolongation[0](60,37) = -5.0/256.0;
- prolongation[0](60,44) = 15.0/256.0;
- prolongation[0](60,45) = -5.0/256.0;
- prolongation[0](60,52) = 75.0/256.0;
- prolongation[0](60,53) = -25.0/256.0;
- prolongation[0](60,56) = 225.0/256.0;
- prolongation[0](60,57) = -75.0/256.0;
- prolongation[0](60,58) = -75.0/256.0;
- prolongation[0](60,59) = 25.0/256.0;
- prolongation[0](61,32) = 5.0/16.0;
- prolongation[0](61,36) = 1.0/16.0;
- prolongation[0](61,56) = 15.0/16.0;
- prolongation[0](61,58) = -5.0/16.0;
- prolongation[0](62,44) = 1.0/16.0;
- prolongation[0](62,52) = 5.0/16.0;
- prolongation[0](62,56) = 15.0/16.0;
- prolongation[0](62,57) = -5.0/16.0;
- prolongation[0](63,56) = 1.0;
- prolongation[1](0,0) = -1.0/16.0;
- prolongation[1](0,1) = -1.0/16.0;
- prolongation[1](0,8) = 9.0/16.0;
- prolongation[1](0,9) = 9.0/16.0;
- prolongation[1](1,1) = 1.0;
- prolongation[1](2,1) = -1.0/16.0;
- prolongation[1](2,2) = -1.0/16.0;
- prolongation[1](2,10) = 9.0/16.0;
- prolongation[1](2,11) = 9.0/16.0;
- prolongation[1](3,0) = 1.0/256.0;
- prolongation[1](3,1) = 1.0/256.0;
- prolongation[1](3,2) = 1.0/256.0;
- prolongation[1](3,3) = 1.0/256.0;
- prolongation[1](3,8) = -9.0/256.0;
- prolongation[1](3,9) = -9.0/256.0;
- prolongation[1](3,10) = -9.0/256.0;
- prolongation[1](3,11) = -9.0/256.0;
- prolongation[1](3,12) = -9.0/256.0;
- prolongation[1](3,13) = -9.0/256.0;
- prolongation[1](3,14) = -9.0/256.0;
- prolongation[1](3,15) = -9.0/256.0;
- prolongation[1](3,32) = 81.0/256.0;
- prolongation[1](3,33) = 81.0/256.0;
- prolongation[1](3,34) = 81.0/256.0;
- prolongation[1](3,35) = 81.0/256.0;
- prolongation[1](4,0) = 1.0/256.0;
- prolongation[1](4,1) = 1.0/256.0;
- prolongation[1](4,4) = 1.0/256.0;
- prolongation[1](4,5) = 1.0/256.0;
- prolongation[1](4,8) = -9.0/256.0;
- prolongation[1](4,9) = -9.0/256.0;
- prolongation[1](4,16) = -9.0/256.0;
- prolongation[1](4,17) = -9.0/256.0;
- prolongation[1](4,24) = -9.0/256.0;
- prolongation[1](4,25) = -9.0/256.0;
- prolongation[1](4,26) = -9.0/256.0;
- prolongation[1](4,27) = -9.0/256.0;
- prolongation[1](4,40) = 81.0/256.0;
- prolongation[1](4,41) = 81.0/256.0;
- prolongation[1](4,42) = 81.0/256.0;
- prolongation[1](4,43) = 81.0/256.0;
- prolongation[1](5,1) = -1.0/16.0;
- prolongation[1](5,5) = -1.0/16.0;
- prolongation[1](5,26) = 9.0/16.0;
- prolongation[1](5,27) = 9.0/16.0;
- prolongation[1](6,1) = 1.0/256.0;
- prolongation[1](6,2) = 1.0/256.0;
- prolongation[1](6,5) = 1.0/256.0;
- prolongation[1](6,6) = 1.0/256.0;
- prolongation[1](6,10) = -9.0/256.0;
- prolongation[1](6,11) = -9.0/256.0;
- prolongation[1](6,18) = -9.0/256.0;
- prolongation[1](6,19) = -9.0/256.0;
- prolongation[1](6,26) = -9.0/256.0;
- prolongation[1](6,27) = -9.0/256.0;
- prolongation[1](6,28) = -9.0/256.0;
- prolongation[1](6,29) = -9.0/256.0;
- prolongation[1](6,44) = 81.0/256.0;
- prolongation[1](6,45) = 81.0/256.0;
- prolongation[1](6,46) = 81.0/256.0;
- prolongation[1](6,47) = 81.0/256.0;
- prolongation[1](7,0) = -1.0/4096.0;
- prolongation[1](7,1) = -1.0/4096.0;
- prolongation[1](7,2) = -1.0/4096.0;
- prolongation[1](7,3) = -1.0/4096.0;
- prolongation[1](7,4) = -1.0/4096.0;
- prolongation[1](7,5) = -1.0/4096.0;
- prolongation[1](7,6) = -1.0/4096.0;
- prolongation[1](7,7) = -1.0/4096.0;
- prolongation[1](7,8) = 9.0/4096.0;
- prolongation[1](7,9) = 9.0/4096.0;
- prolongation[1](7,10) = 9.0/4096.0;
- prolongation[1](7,11) = 9.0/4096.0;
- prolongation[1](7,12) = 9.0/4096.0;
- prolongation[1](7,13) = 9.0/4096.0;
- prolongation[1](7,14) = 9.0/4096.0;
- prolongation[1](7,15) = 9.0/4096.0;
- prolongation[1](7,16) = 9.0/4096.0;
- prolongation[1](7,17) = 9.0/4096.0;
- prolongation[1](7,18) = 9.0/4096.0;
- prolongation[1](7,19) = 9.0/4096.0;
- prolongation[1](7,20) = 9.0/4096.0;
- prolongation[1](7,21) = 9.0/4096.0;
- prolongation[1](7,22) = 9.0/4096.0;
- prolongation[1](7,23) = 9.0/4096.0;
- prolongation[1](7,24) = 9.0/4096.0;
- prolongation[1](7,25) = 9.0/4096.0;
- prolongation[1](7,26) = 9.0/4096.0;
- prolongation[1](7,27) = 9.0/4096.0;
- prolongation[1](7,28) = 9.0/4096.0;
- prolongation[1](7,29) = 9.0/4096.0;
- prolongation[1](7,30) = 9.0/4096.0;
- prolongation[1](7,31) = 9.0/4096.0;
- prolongation[1](7,32) = -81.0/4096.0;
- prolongation[1](7,33) = -81.0/4096.0;
- prolongation[1](7,34) = -81.0/4096.0;
- prolongation[1](7,35) = -81.0/4096.0;
- prolongation[1](7,36) = -81.0/4096.0;
- prolongation[1](7,37) = -81.0/4096.0;
- prolongation[1](7,38) = -81.0/4096.0;
- prolongation[1](7,39) = -81.0/4096.0;
- prolongation[1](7,40) = -81.0/4096.0;
- prolongation[1](7,41) = -81.0/4096.0;
- prolongation[1](7,42) = -81.0/4096.0;
- prolongation[1](7,43) = -81.0/4096.0;
- prolongation[1](7,44) = -81.0/4096.0;
- prolongation[1](7,45) = -81.0/4096.0;
- prolongation[1](7,46) = -81.0/4096.0;
- prolongation[1](7,47) = -81.0/4096.0;
- prolongation[1](7,48) = -81.0/4096.0;
- prolongation[1](7,49) = -81.0/4096.0;
- prolongation[1](7,50) = -81.0/4096.0;
- prolongation[1](7,51) = -81.0/4096.0;
- prolongation[1](7,52) = -81.0/4096.0;
- prolongation[1](7,53) = -81.0/4096.0;
- prolongation[1](7,54) = -81.0/4096.0;
- prolongation[1](7,55) = -81.0/4096.0;
- prolongation[1](7,56) = 729.0/4096.0;
- prolongation[1](7,57) = 729.0/4096.0;
- prolongation[1](7,58) = 729.0/4096.0;
- prolongation[1](7,59) = 729.0/4096.0;
- prolongation[1](7,60) = 729.0/4096.0;
- prolongation[1](7,61) = 729.0/4096.0;
- prolongation[1](7,62) = 729.0/4096.0;
- prolongation[1](7,63) = 729.0/4096.0;
- prolongation[1](8,9) = 1.0;
- prolongation[1](9,0) = 1.0/16.0;
- prolongation[1](9,1) = 5.0/16.0;
- prolongation[1](9,8) = -5.0/16.0;
- prolongation[1](9,9) = 15.0/16.0;
- prolongation[1](10,1) = 5.0/16.0;
- prolongation[1](10,2) = 1.0/16.0;
- prolongation[1](10,10) = 15.0/16.0;
- prolongation[1](10,11) = -5.0/16.0;
- prolongation[1](11,10) = 1.0;
- prolongation[1](12,9) = -1.0/16.0;
- prolongation[1](12,13) = -1.0/16.0;
- prolongation[1](12,33) = 9.0/16.0;
- prolongation[1](12,35) = 9.0/16.0;
- prolongation[1](13,0) = -1.0/256.0;
- prolongation[1](13,1) = -5.0/256.0;
- prolongation[1](13,2) = -5.0/256.0;
- prolongation[1](13,3) = -1.0/256.0;
- prolongation[1](13,8) = 5.0/256.0;
- prolongation[1](13,9) = -15.0/256.0;
- prolongation[1](13,10) = 45.0/256.0;
- prolongation[1](13,11) = 45.0/256.0;
- prolongation[1](13,12) = 5.0/256.0;
- prolongation[1](13,13) = -15.0/256.0;
- prolongation[1](13,14) = 9.0/256.0;
- prolongation[1](13,15) = 9.0/256.0;
- prolongation[1](13,32) = -45.0/256.0;
- prolongation[1](13,33) = 135.0/256.0;
- prolongation[1](13,34) = -45.0/256.0;
- prolongation[1](13,35) = 135.0/256.0;
- prolongation[1](14,0) = -5.0/256.0;
- prolongation[1](14,1) = -5.0/256.0;
- prolongation[1](14,2) = -1.0/256.0;
- prolongation[1](14,3) = -1.0/256.0;
- prolongation[1](14,8) = 45.0/256.0;
- prolongation[1](14,9) = 45.0/256.0;
- prolongation[1](14,10) = -15.0/256.0;
- prolongation[1](14,11) = 5.0/256.0;
- prolongation[1](14,12) = 9.0/256.0;
- prolongation[1](14,13) = 9.0/256.0;
- prolongation[1](14,14) = -15.0/256.0;
- prolongation[1](14,15) = 5.0/256.0;
- prolongation[1](14,32) = 135.0/256.0;
- prolongation[1](14,33) = 135.0/256.0;
- prolongation[1](14,34) = -45.0/256.0;
- prolongation[1](14,35) = -45.0/256.0;
- prolongation[1](15,10) = -1.0/16.0;
- prolongation[1](15,14) = -1.0/16.0;
- prolongation[1](15,32) = 9.0/16.0;
- prolongation[1](15,33) = 9.0/16.0;
- prolongation[1](16,9) = -1.0/16.0;
- prolongation[1](16,17) = -1.0/16.0;
- prolongation[1](16,41) = 9.0/16.0;
- prolongation[1](16,43) = 9.0/16.0;
- prolongation[1](17,0) = -1.0/256.0;
- prolongation[1](17,1) = -5.0/256.0;
- prolongation[1](17,4) = -1.0/256.0;
- prolongation[1](17,5) = -5.0/256.0;
- prolongation[1](17,8) = 5.0/256.0;
- prolongation[1](17,9) = -15.0/256.0;
- prolongation[1](17,16) = 5.0/256.0;
- prolongation[1](17,17) = -15.0/256.0;
- prolongation[1](17,24) = 9.0/256.0;
- prolongation[1](17,25) = 9.0/256.0;
- prolongation[1](17,26) = 45.0/256.0;
- prolongation[1](17,27) = 45.0/256.0;
- prolongation[1](17,40) = -45.0/256.0;
- prolongation[1](17,41) = 135.0/256.0;
- prolongation[1](17,42) = -45.0/256.0;
- prolongation[1](17,43) = 135.0/256.0;
- prolongation[1](18,1) = -5.0/256.0;
- prolongation[1](18,2) = -1.0/256.0;
- prolongation[1](18,5) = -5.0/256.0;
- prolongation[1](18,6) = -1.0/256.0;
- prolongation[1](18,10) = -15.0/256.0;
- prolongation[1](18,11) = 5.0/256.0;
- prolongation[1](18,18) = -15.0/256.0;
- prolongation[1](18,19) = 5.0/256.0;
- prolongation[1](18,26) = 45.0/256.0;
- prolongation[1](18,27) = 45.0/256.0;
- prolongation[1](18,28) = 9.0/256.0;
- prolongation[1](18,29) = 9.0/256.0;
- prolongation[1](18,44) = 135.0/256.0;
- prolongation[1](18,45) = 135.0/256.0;
- prolongation[1](18,46) = -45.0/256.0;
- prolongation[1](18,47) = -45.0/256.0;
- prolongation[1](19,10) = -1.0/16.0;
- prolongation[1](19,18) = -1.0/16.0;
- prolongation[1](19,44) = 9.0/16.0;
- prolongation[1](19,45) = 9.0/16.0;
- prolongation[1](20,9) = 1.0/256.0;
- prolongation[1](20,13) = 1.0/256.0;
- prolongation[1](20,17) = 1.0/256.0;
- prolongation[1](20,21) = 1.0/256.0;
- prolongation[1](20,33) = -9.0/256.0;
- prolongation[1](20,35) = -9.0/256.0;
- prolongation[1](20,37) = -9.0/256.0;
- prolongation[1](20,39) = -9.0/256.0;
- prolongation[1](20,41) = -9.0/256.0;
- prolongation[1](20,43) = -9.0/256.0;
- prolongation[1](20,49) = -9.0/256.0;
- prolongation[1](20,51) = -9.0/256.0;
- prolongation[1](20,57) = 81.0/256.0;
- prolongation[1](20,59) = 81.0/256.0;
- prolongation[1](20,61) = 81.0/256.0;
- prolongation[1](20,63) = 81.0/256.0;
- prolongation[1](21,0) = 1.0/4096.0;
- prolongation[1](21,1) = 5.0/4096.0;
- prolongation[1](21,2) = 5.0/4096.0;
- prolongation[1](21,3) = 1.0/4096.0;
- prolongation[1](21,4) = 1.0/4096.0;
- prolongation[1](21,5) = 5.0/4096.0;
- prolongation[1](21,6) = 5.0/4096.0;
- prolongation[1](21,7) = 1.0/4096.0;
- prolongation[1](21,8) = -5.0/4096.0;
- prolongation[1](21,9) = 15.0/4096.0;
- prolongation[1](21,10) = -45.0/4096.0;
- prolongation[1](21,11) = -45.0/4096.0;
- prolongation[1](21,12) = -5.0/4096.0;
- prolongation[1](21,13) = 15.0/4096.0;
- prolongation[1](21,14) = -9.0/4096.0;
- prolongation[1](21,15) = -9.0/4096.0;
- prolongation[1](21,16) = -5.0/4096.0;
- prolongation[1](21,17) = 15.0/4096.0;
- prolongation[1](21,18) = -45.0/4096.0;
- prolongation[1](21,19) = -45.0/4096.0;
- prolongation[1](21,20) = -5.0/4096.0;
- prolongation[1](21,21) = 15.0/4096.0;
- prolongation[1](21,22) = -9.0/4096.0;
- prolongation[1](21,23) = -9.0/4096.0;
- prolongation[1](21,24) = -9.0/4096.0;
- prolongation[1](21,25) = -9.0/4096.0;
- prolongation[1](21,26) = -45.0/4096.0;
- prolongation[1](21,27) = -45.0/4096.0;
- prolongation[1](21,28) = -45.0/4096.0;
- prolongation[1](21,29) = -45.0/4096.0;
- prolongation[1](21,30) = -9.0/4096.0;
- prolongation[1](21,31) = -9.0/4096.0;
- prolongation[1](21,32) = 45.0/4096.0;
- prolongation[1](21,33) = -135.0/4096.0;
- prolongation[1](21,34) = 45.0/4096.0;
- prolongation[1](21,35) = -135.0/4096.0;
- prolongation[1](21,36) = 45.0/4096.0;
- prolongation[1](21,37) = -135.0/4096.0;
- prolongation[1](21,38) = 45.0/4096.0;
- prolongation[1](21,39) = -135.0/4096.0;
- prolongation[1](21,40) = 45.0/4096.0;
- prolongation[1](21,41) = -135.0/4096.0;
- prolongation[1](21,42) = 45.0/4096.0;
- prolongation[1](21,43) = -135.0/4096.0;
- prolongation[1](21,44) = 405.0/4096.0;
- prolongation[1](21,45) = 405.0/4096.0;
- prolongation[1](21,46) = 405.0/4096.0;
- prolongation[1](21,47) = 405.0/4096.0;
- prolongation[1](21,48) = 45.0/4096.0;
- prolongation[1](21,49) = -135.0/4096.0;
- prolongation[1](21,50) = 45.0/4096.0;
- prolongation[1](21,51) = -135.0/4096.0;
- prolongation[1](21,52) = 81.0/4096.0;
- prolongation[1](21,53) = 81.0/4096.0;
- prolongation[1](21,54) = 81.0/4096.0;
- prolongation[1](21,55) = 81.0/4096.0;
- prolongation[1](21,56) = -405.0/4096.0;
- prolongation[1](21,57) = 1215.0/4096.0;
- prolongation[1](21,58) = -405.0/4096.0;
- prolongation[1](21,59) = 1215.0/4096.0;
- prolongation[1](21,60) = -405.0/4096.0;
- prolongation[1](21,61) = 1215.0/4096.0;
- prolongation[1](21,62) = -405.0/4096.0;
- prolongation[1](21,63) = 1215.0/4096.0;
- prolongation[1](22,0) = 5.0/4096.0;
- prolongation[1](22,1) = 5.0/4096.0;
- prolongation[1](22,2) = 1.0/4096.0;
- prolongation[1](22,3) = 1.0/4096.0;
- prolongation[1](22,4) = 5.0/4096.0;
- prolongation[1](22,5) = 5.0/4096.0;
- prolongation[1](22,6) = 1.0/4096.0;
- prolongation[1](22,7) = 1.0/4096.0;
- prolongation[1](22,8) = -45.0/4096.0;
- prolongation[1](22,9) = -45.0/4096.0;
- prolongation[1](22,10) = 15.0/4096.0;
- prolongation[1](22,11) = -5.0/4096.0;
- prolongation[1](22,12) = -9.0/4096.0;
- prolongation[1](22,13) = -9.0/4096.0;
- prolongation[1](22,14) = 15.0/4096.0;
- prolongation[1](22,15) = -5.0/4096.0;
- prolongation[1](22,16) = -45.0/4096.0;
- prolongation[1](22,17) = -45.0/4096.0;
- prolongation[1](22,18) = 15.0/4096.0;
- prolongation[1](22,19) = -5.0/4096.0;
- prolongation[1](22,20) = -9.0/4096.0;
- prolongation[1](22,21) = -9.0/4096.0;
- prolongation[1](22,22) = 15.0/4096.0;
- prolongation[1](22,23) = -5.0/4096.0;
- prolongation[1](22,24) = -45.0/4096.0;
- prolongation[1](22,25) = -45.0/4096.0;
- prolongation[1](22,26) = -45.0/4096.0;
- prolongation[1](22,27) = -45.0/4096.0;
- prolongation[1](22,28) = -9.0/4096.0;
- prolongation[1](22,29) = -9.0/4096.0;
- prolongation[1](22,30) = -9.0/4096.0;
- prolongation[1](22,31) = -9.0/4096.0;
- prolongation[1](22,32) = -135.0/4096.0;
- prolongation[1](22,33) = -135.0/4096.0;
- prolongation[1](22,34) = 45.0/4096.0;
- prolongation[1](22,35) = 45.0/4096.0;
- prolongation[1](22,36) = -135.0/4096.0;
- prolongation[1](22,37) = -135.0/4096.0;
- prolongation[1](22,38) = 45.0/4096.0;
- prolongation[1](22,39) = 45.0/4096.0;
- prolongation[1](22,40) = 405.0/4096.0;
- prolongation[1](22,41) = 405.0/4096.0;
- prolongation[1](22,42) = 405.0/4096.0;
- prolongation[1](22,43) = 405.0/4096.0;
- prolongation[1](22,44) = -135.0/4096.0;
- prolongation[1](22,45) = -135.0/4096.0;
- prolongation[1](22,46) = 45.0/4096.0;
- prolongation[1](22,47) = 45.0/4096.0;
- prolongation[1](22,48) = 81.0/4096.0;
- prolongation[1](22,49) = 81.0/4096.0;
- prolongation[1](22,50) = 81.0/4096.0;
- prolongation[1](22,51) = 81.0/4096.0;
- prolongation[1](22,52) = -135.0/4096.0;
- prolongation[1](22,53) = -135.0/4096.0;
- prolongation[1](22,54) = 45.0/4096.0;
- prolongation[1](22,55) = 45.0/4096.0;
- prolongation[1](22,56) = 1215.0/4096.0;
- prolongation[1](22,57) = 1215.0/4096.0;
- prolongation[1](22,58) = 1215.0/4096.0;
- prolongation[1](22,59) = 1215.0/4096.0;
- prolongation[1](22,60) = -405.0/4096.0;
- prolongation[1](22,61) = -405.0/4096.0;
- prolongation[1](22,62) = -405.0/4096.0;
- prolongation[1](22,63) = -405.0/4096.0;
- prolongation[1](23,10) = 1.0/256.0;
- prolongation[1](23,14) = 1.0/256.0;
- prolongation[1](23,18) = 1.0/256.0;
- prolongation[1](23,22) = 1.0/256.0;
- prolongation[1](23,32) = -9.0/256.0;
- prolongation[1](23,33) = -9.0/256.0;
- prolongation[1](23,36) = -9.0/256.0;
- prolongation[1](23,37) = -9.0/256.0;
- prolongation[1](23,44) = -9.0/256.0;
- prolongation[1](23,45) = -9.0/256.0;
- prolongation[1](23,52) = -9.0/256.0;
- prolongation[1](23,53) = -9.0/256.0;
- prolongation[1](23,56) = 81.0/256.0;
- prolongation[1](23,57) = 81.0/256.0;
- prolongation[1](23,58) = 81.0/256.0;
- prolongation[1](23,59) = 81.0/256.0;
- prolongation[1](24,0) = -5.0/256.0;
- prolongation[1](24,1) = -5.0/256.0;
- prolongation[1](24,4) = -1.0/256.0;
- prolongation[1](24,5) = -1.0/256.0;
- prolongation[1](24,8) = 45.0/256.0;
- prolongation[1](24,9) = 45.0/256.0;
- prolongation[1](24,16) = 9.0/256.0;
- prolongation[1](24,17) = 9.0/256.0;
- prolongation[1](24,24) = -15.0/256.0;
- prolongation[1](24,25) = 5.0/256.0;
- prolongation[1](24,26) = -15.0/256.0;
- prolongation[1](24,27) = 5.0/256.0;
- prolongation[1](24,40) = 135.0/256.0;
- prolongation[1](24,41) = 135.0/256.0;
- prolongation[1](24,42) = -45.0/256.0;
- prolongation[1](24,43) = -45.0/256.0;
- prolongation[1](25,24) = -1.0/16.0;
- prolongation[1](25,26) = -1.0/16.0;
- prolongation[1](25,40) = 9.0/16.0;
- prolongation[1](25,41) = 9.0/16.0;
- prolongation[1](26,1) = 5.0/16.0;
- prolongation[1](26,5) = 1.0/16.0;
- prolongation[1](26,26) = 15.0/16.0;
- prolongation[1](26,27) = -5.0/16.0;
- prolongation[1](27,26) = 1.0;
- prolongation[1](28,1) = -5.0/256.0;
- prolongation[1](28,2) = -5.0/256.0;
- prolongation[1](28,5) = -1.0/256.0;
- prolongation[1](28,6) = -1.0/256.0;
- prolongation[1](28,10) = 45.0/256.0;
- prolongation[1](28,11) = 45.0/256.0;
- prolongation[1](28,18) = 9.0/256.0;
- prolongation[1](28,19) = 9.0/256.0;
- prolongation[1](28,26) = -15.0/256.0;
- prolongation[1](28,27) = 5.0/256.0;
- prolongation[1](28,28) = -15.0/256.0;
- prolongation[1](28,29) = 5.0/256.0;
- prolongation[1](28,44) = 135.0/256.0;
- prolongation[1](28,45) = -45.0/256.0;
- prolongation[1](28,46) = 135.0/256.0;
- prolongation[1](28,47) = -45.0/256.0;
- prolongation[1](29,26) = -1.0/16.0;
- prolongation[1](29,28) = -1.0/16.0;
- prolongation[1](29,44) = 9.0/16.0;
- prolongation[1](29,46) = 9.0/16.0;
- prolongation[1](30,0) = 5.0/4096.0;
- prolongation[1](30,1) = 5.0/4096.0;
- prolongation[1](30,2) = 5.0/4096.0;
- prolongation[1](30,3) = 5.0/4096.0;
- prolongation[1](30,4) = 1.0/4096.0;
- prolongation[1](30,5) = 1.0/4096.0;
- prolongation[1](30,6) = 1.0/4096.0;
- prolongation[1](30,7) = 1.0/4096.0;
- prolongation[1](30,8) = -45.0/4096.0;
- prolongation[1](30,9) = -45.0/4096.0;
- prolongation[1](30,10) = -45.0/4096.0;
- prolongation[1](30,11) = -45.0/4096.0;
- prolongation[1](30,12) = -45.0/4096.0;
- prolongation[1](30,13) = -45.0/4096.0;
- prolongation[1](30,14) = -45.0/4096.0;
- prolongation[1](30,15) = -45.0/4096.0;
- prolongation[1](30,16) = -9.0/4096.0;
- prolongation[1](30,17) = -9.0/4096.0;
- prolongation[1](30,18) = -9.0/4096.0;
- prolongation[1](30,19) = -9.0/4096.0;
- prolongation[1](30,20) = -9.0/4096.0;
- prolongation[1](30,21) = -9.0/4096.0;
- prolongation[1](30,22) = -9.0/4096.0;
- prolongation[1](30,23) = -9.0/4096.0;
- prolongation[1](30,24) = 15.0/4096.0;
- prolongation[1](30,25) = -5.0/4096.0;
- prolongation[1](30,26) = 15.0/4096.0;
- prolongation[1](30,27) = -5.0/4096.0;
- prolongation[1](30,28) = 15.0/4096.0;
- prolongation[1](30,29) = -5.0/4096.0;
- prolongation[1](30,30) = 15.0/4096.0;
- prolongation[1](30,31) = -5.0/4096.0;
- prolongation[1](30,32) = 405.0/4096.0;
- prolongation[1](30,33) = 405.0/4096.0;
- prolongation[1](30,34) = 405.0/4096.0;
- prolongation[1](30,35) = 405.0/4096.0;
- prolongation[1](30,36) = 81.0/4096.0;
- prolongation[1](30,37) = 81.0/4096.0;
- prolongation[1](30,38) = 81.0/4096.0;
- prolongation[1](30,39) = 81.0/4096.0;
- prolongation[1](30,40) = -135.0/4096.0;
- prolongation[1](30,41) = -135.0/4096.0;
- prolongation[1](30,42) = 45.0/4096.0;
- prolongation[1](30,43) = 45.0/4096.0;
- prolongation[1](30,44) = -135.0/4096.0;
- prolongation[1](30,45) = 45.0/4096.0;
- prolongation[1](30,46) = -135.0/4096.0;
- prolongation[1](30,47) = 45.0/4096.0;
- prolongation[1](30,48) = -135.0/4096.0;
- prolongation[1](30,49) = -135.0/4096.0;
- prolongation[1](30,50) = 45.0/4096.0;
- prolongation[1](30,51) = 45.0/4096.0;
- prolongation[1](30,52) = -135.0/4096.0;
- prolongation[1](30,53) = 45.0/4096.0;
- prolongation[1](30,54) = -135.0/4096.0;
- prolongation[1](30,55) = 45.0/4096.0;
- prolongation[1](30,56) = 1215.0/4096.0;
- prolongation[1](30,57) = 1215.0/4096.0;
- prolongation[1](30,58) = -405.0/4096.0;
- prolongation[1](30,59) = -405.0/4096.0;
- prolongation[1](30,60) = 1215.0/4096.0;
- prolongation[1](30,61) = 1215.0/4096.0;
- prolongation[1](30,62) = -405.0/4096.0;
- prolongation[1](30,63) = -405.0/4096.0;
- prolongation[1](31,24) = 1.0/256.0;
- prolongation[1](31,26) = 1.0/256.0;
- prolongation[1](31,28) = 1.0/256.0;
- prolongation[1](31,30) = 1.0/256.0;
- prolongation[1](31,40) = -9.0/256.0;
- prolongation[1](31,41) = -9.0/256.0;
- prolongation[1](31,44) = -9.0/256.0;
- prolongation[1](31,46) = -9.0/256.0;
- prolongation[1](31,48) = -9.0/256.0;
- prolongation[1](31,49) = -9.0/256.0;
- prolongation[1](31,52) = -9.0/256.0;
- prolongation[1](31,54) = -9.0/256.0;
- prolongation[1](31,56) = 81.0/256.0;
- prolongation[1](31,57) = 81.0/256.0;
- prolongation[1](31,60) = 81.0/256.0;
- prolongation[1](31,61) = 81.0/256.0;
- prolongation[1](32,9) = 5.0/16.0;
- prolongation[1](32,13) = 1.0/16.0;
- prolongation[1](32,33) = 15.0/16.0;
- prolongation[1](32,35) = -5.0/16.0;
- prolongation[1](33,0) = 5.0/256.0;
- prolongation[1](33,1) = 25.0/256.0;
- prolongation[1](33,2) = 5.0/256.0;
- prolongation[1](33,3) = 1.0/256.0;
- prolongation[1](33,8) = -25.0/256.0;
- prolongation[1](33,9) = 75.0/256.0;
- prolongation[1](33,10) = 75.0/256.0;
- prolongation[1](33,11) = -25.0/256.0;
- prolongation[1](33,12) = -5.0/256.0;
- prolongation[1](33,13) = 15.0/256.0;
- prolongation[1](33,14) = 15.0/256.0;
- prolongation[1](33,15) = -5.0/256.0;
- prolongation[1](33,32) = -75.0/256.0;
- prolongation[1](33,33) = 225.0/256.0;
- prolongation[1](33,34) = 25.0/256.0;
- prolongation[1](33,35) = -75.0/256.0;
- prolongation[1](34,33) = 1.0;
- prolongation[1](35,10) = 5.0/16.0;
- prolongation[1](35,14) = 1.0/16.0;
- prolongation[1](35,32) = -5.0/16.0;
- prolongation[1](35,33) = 15.0/16.0;
- prolongation[1](36,9) = -5.0/256.0;
- prolongation[1](36,13) = -1.0/256.0;
- prolongation[1](36,17) = -5.0/256.0;
- prolongation[1](36,21) = -1.0/256.0;
- prolongation[1](36,33) = -15.0/256.0;
- prolongation[1](36,35) = 5.0/256.0;
- prolongation[1](36,37) = -15.0/256.0;
- prolongation[1](36,39) = 5.0/256.0;
- prolongation[1](36,41) = 45.0/256.0;
- prolongation[1](36,43) = 45.0/256.0;
- prolongation[1](36,49) = 9.0/256.0;
- prolongation[1](36,51) = 9.0/256.0;
- prolongation[1](36,57) = 135.0/256.0;
- prolongation[1](36,59) = 135.0/256.0;
- prolongation[1](36,61) = -45.0/256.0;
- prolongation[1](36,63) = -45.0/256.0;
- prolongation[1](37,0) = -5.0/4096.0;
- prolongation[1](37,1) = -25.0/4096.0;
- prolongation[1](37,2) = -5.0/4096.0;
- prolongation[1](37,3) = -1.0/4096.0;
- prolongation[1](37,4) = -5.0/4096.0;
- prolongation[1](37,5) = -25.0/4096.0;
- prolongation[1](37,6) = -5.0/4096.0;
- prolongation[1](37,7) = -1.0/4096.0;
- prolongation[1](37,8) = 25.0/4096.0;
- prolongation[1](37,9) = -75.0/4096.0;
- prolongation[1](37,10) = -75.0/4096.0;
- prolongation[1](37,11) = 25.0/4096.0;
- prolongation[1](37,12) = 5.0/4096.0;
- prolongation[1](37,13) = -15.0/4096.0;
- prolongation[1](37,14) = -15.0/4096.0;
- prolongation[1](37,15) = 5.0/4096.0;
- prolongation[1](37,16) = 25.0/4096.0;
- prolongation[1](37,17) = -75.0/4096.0;
- prolongation[1](37,18) = -75.0/4096.0;
- prolongation[1](37,19) = 25.0/4096.0;
- prolongation[1](37,20) = 5.0/4096.0;
- prolongation[1](37,21) = -15.0/4096.0;
- prolongation[1](37,22) = -15.0/4096.0;
- prolongation[1](37,23) = 5.0/4096.0;
- prolongation[1](37,24) = 45.0/4096.0;
- prolongation[1](37,25) = 45.0/4096.0;
- prolongation[1](37,26) = 225.0/4096.0;
- prolongation[1](37,27) = 225.0/4096.0;
- prolongation[1](37,28) = 45.0/4096.0;
- prolongation[1](37,29) = 45.0/4096.0;
- prolongation[1](37,30) = 9.0/4096.0;
- prolongation[1](37,31) = 9.0/4096.0;
- prolongation[1](37,32) = 75.0/4096.0;
- prolongation[1](37,33) = -225.0/4096.0;
- prolongation[1](37,34) = -25.0/4096.0;
- prolongation[1](37,35) = 75.0/4096.0;
- prolongation[1](37,36) = 75.0/4096.0;
- prolongation[1](37,37) = -225.0/4096.0;
- prolongation[1](37,38) = -25.0/4096.0;
- prolongation[1](37,39) = 75.0/4096.0;
- prolongation[1](37,40) = -225.0/4096.0;
- prolongation[1](37,41) = 675.0/4096.0;
- prolongation[1](37,42) = -225.0/4096.0;
- prolongation[1](37,43) = 675.0/4096.0;
- prolongation[1](37,44) = 675.0/4096.0;
- prolongation[1](37,45) = 675.0/4096.0;
- prolongation[1](37,46) = -225.0/4096.0;
- prolongation[1](37,47) = -225.0/4096.0;
- prolongation[1](37,48) = -45.0/4096.0;
- prolongation[1](37,49) = 135.0/4096.0;
- prolongation[1](37,50) = -45.0/4096.0;
- prolongation[1](37,51) = 135.0/4096.0;
- prolongation[1](37,52) = 135.0/4096.0;
- prolongation[1](37,53) = 135.0/4096.0;
- prolongation[1](37,54) = -45.0/4096.0;
- prolongation[1](37,55) = -45.0/4096.0;
- prolongation[1](37,56) = -675.0/4096.0;
- prolongation[1](37,57) = 2025.0/4096.0;
- prolongation[1](37,58) = -675.0/4096.0;
- prolongation[1](37,59) = 2025.0/4096.0;
- prolongation[1](37,60) = 225.0/4096.0;
- prolongation[1](37,61) = -675.0/4096.0;
- prolongation[1](37,62) = 225.0/4096.0;
- prolongation[1](37,63) = -675.0/4096.0;
- prolongation[1](38,33) = -1.0/16.0;
- prolongation[1](38,37) = -1.0/16.0;
- prolongation[1](38,57) = 9.0/16.0;
- prolongation[1](38,59) = 9.0/16.0;
- prolongation[1](39,10) = -5.0/256.0;
- prolongation[1](39,14) = -1.0/256.0;
- prolongation[1](39,18) = -5.0/256.0;
- prolongation[1](39,22) = -1.0/256.0;
- prolongation[1](39,32) = 5.0/256.0;
- prolongation[1](39,33) = -15.0/256.0;
- prolongation[1](39,36) = 5.0/256.0;
- prolongation[1](39,37) = -15.0/256.0;
- prolongation[1](39,44) = 45.0/256.0;
- prolongation[1](39,45) = 45.0/256.0;
- prolongation[1](39,52) = 9.0/256.0;
- prolongation[1](39,53) = 9.0/256.0;
- prolongation[1](39,56) = -45.0/256.0;
- prolongation[1](39,57) = 135.0/256.0;
- prolongation[1](39,58) = -45.0/256.0;
- prolongation[1](39,59) = 135.0/256.0;
- prolongation[1](40,9) = 5.0/16.0;
- prolongation[1](40,17) = 1.0/16.0;
- prolongation[1](40,41) = 15.0/16.0;
- prolongation[1](40,43) = -5.0/16.0;
- prolongation[1](41,0) = 5.0/256.0;
- prolongation[1](41,1) = 25.0/256.0;
- prolongation[1](41,4) = 1.0/256.0;
- prolongation[1](41,5) = 5.0/256.0;
- prolongation[1](41,8) = -25.0/256.0;
- prolongation[1](41,9) = 75.0/256.0;
- prolongation[1](41,16) = -5.0/256.0;
- prolongation[1](41,17) = 15.0/256.0;
- prolongation[1](41,24) = 15.0/256.0;
- prolongation[1](41,25) = -5.0/256.0;
- prolongation[1](41,26) = 75.0/256.0;
- prolongation[1](41,27) = -25.0/256.0;
- prolongation[1](41,40) = -75.0/256.0;
- prolongation[1](41,41) = 225.0/256.0;
- prolongation[1](41,42) = 25.0/256.0;
- prolongation[1](41,43) = -75.0/256.0;
- prolongation[1](42,41) = 1.0;
- prolongation[1](43,24) = 1.0/16.0;
- prolongation[1](43,26) = 5.0/16.0;
- prolongation[1](43,40) = -5.0/16.0;
- prolongation[1](43,41) = 15.0/16.0;
- prolongation[1](44,1) = 25.0/256.0;
- prolongation[1](44,2) = 5.0/256.0;
- prolongation[1](44,5) = 5.0/256.0;
- prolongation[1](44,6) = 1.0/256.0;
- prolongation[1](44,10) = 75.0/256.0;
- prolongation[1](44,11) = -25.0/256.0;
- prolongation[1](44,18) = 15.0/256.0;
- prolongation[1](44,19) = -5.0/256.0;
- prolongation[1](44,26) = 75.0/256.0;
- prolongation[1](44,27) = -25.0/256.0;
- prolongation[1](44,28) = 15.0/256.0;
- prolongation[1](44,29) = -5.0/256.0;
- prolongation[1](44,44) = 225.0/256.0;
- prolongation[1](44,45) = -75.0/256.0;
- prolongation[1](44,46) = -75.0/256.0;
- prolongation[1](44,47) = 25.0/256.0;
- prolongation[1](45,26) = 5.0/16.0;
- prolongation[1](45,28) = 1.0/16.0;
- prolongation[1](45,44) = 15.0/16.0;
- prolongation[1](45,46) = -5.0/16.0;
- prolongation[1](46,10) = 5.0/16.0;
- prolongation[1](46,18) = 1.0/16.0;
- prolongation[1](46,44) = 15.0/16.0;
- prolongation[1](46,45) = -5.0/16.0;
- prolongation[1](47,44) = 1.0;
- prolongation[1](48,9) = -5.0/256.0;
- prolongation[1](48,13) = -5.0/256.0;
- prolongation[1](48,17) = -1.0/256.0;
- prolongation[1](48,21) = -1.0/256.0;
- prolongation[1](48,33) = 45.0/256.0;
- prolongation[1](48,35) = 45.0/256.0;
- prolongation[1](48,37) = 9.0/256.0;
- prolongation[1](48,39) = 9.0/256.0;
- prolongation[1](48,41) = -15.0/256.0;
- prolongation[1](48,43) = 5.0/256.0;
- prolongation[1](48,49) = -15.0/256.0;
- prolongation[1](48,51) = 5.0/256.0;
- prolongation[1](48,57) = 135.0/256.0;
- prolongation[1](48,59) = -45.0/256.0;
- prolongation[1](48,61) = 135.0/256.0;
- prolongation[1](48,63) = -45.0/256.0;
- prolongation[1](49,0) = -5.0/4096.0;
- prolongation[1](49,1) = -25.0/4096.0;
- prolongation[1](49,2) = -25.0/4096.0;
- prolongation[1](49,3) = -5.0/4096.0;
- prolongation[1](49,4) = -1.0/4096.0;
- prolongation[1](49,5) = -5.0/4096.0;
- prolongation[1](49,6) = -5.0/4096.0;
- prolongation[1](49,7) = -1.0/4096.0;
- prolongation[1](49,8) = 25.0/4096.0;
- prolongation[1](49,9) = -75.0/4096.0;
- prolongation[1](49,10) = 225.0/4096.0;
- prolongation[1](49,11) = 225.0/4096.0;
- prolongation[1](49,12) = 25.0/4096.0;
- prolongation[1](49,13) = -75.0/4096.0;
- prolongation[1](49,14) = 45.0/4096.0;
- prolongation[1](49,15) = 45.0/4096.0;
- prolongation[1](49,16) = 5.0/4096.0;
- prolongation[1](49,17) = -15.0/4096.0;
- prolongation[1](49,18) = 45.0/4096.0;
- prolongation[1](49,19) = 45.0/4096.0;
- prolongation[1](49,20) = 5.0/4096.0;
- prolongation[1](49,21) = -15.0/4096.0;
- prolongation[1](49,22) = 9.0/4096.0;
- prolongation[1](49,23) = 9.0/4096.0;
- prolongation[1](49,24) = -15.0/4096.0;
- prolongation[1](49,25) = 5.0/4096.0;
- prolongation[1](49,26) = -75.0/4096.0;
- prolongation[1](49,27) = 25.0/4096.0;
- prolongation[1](49,28) = -75.0/4096.0;
- prolongation[1](49,29) = 25.0/4096.0;
- prolongation[1](49,30) = -15.0/4096.0;
- prolongation[1](49,31) = 5.0/4096.0;
- prolongation[1](49,32) = -225.0/4096.0;
- prolongation[1](49,33) = 675.0/4096.0;
- prolongation[1](49,34) = -225.0/4096.0;
- prolongation[1](49,35) = 675.0/4096.0;
- prolongation[1](49,36) = -45.0/4096.0;
- prolongation[1](49,37) = 135.0/4096.0;
- prolongation[1](49,38) = -45.0/4096.0;
- prolongation[1](49,39) = 135.0/4096.0;
- prolongation[1](49,40) = 75.0/4096.0;
- prolongation[1](49,41) = -225.0/4096.0;
- prolongation[1](49,42) = -25.0/4096.0;
- prolongation[1](49,43) = 75.0/4096.0;
- prolongation[1](49,44) = 675.0/4096.0;
- prolongation[1](49,45) = -225.0/4096.0;
- prolongation[1](49,46) = 675.0/4096.0;
- prolongation[1](49,47) = -225.0/4096.0;
- prolongation[1](49,48) = 75.0/4096.0;
- prolongation[1](49,49) = -225.0/4096.0;
- prolongation[1](49,50) = -25.0/4096.0;
- prolongation[1](49,51) = 75.0/4096.0;
- prolongation[1](49,52) = 135.0/4096.0;
- prolongation[1](49,53) = -45.0/4096.0;
- prolongation[1](49,54) = 135.0/4096.0;
- prolongation[1](49,55) = -45.0/4096.0;
- prolongation[1](49,56) = -675.0/4096.0;
- prolongation[1](49,57) = 2025.0/4096.0;
- prolongation[1](49,58) = 225.0/4096.0;
- prolongation[1](49,59) = -675.0/4096.0;
- prolongation[1](49,60) = -675.0/4096.0;
- prolongation[1](49,61) = 2025.0/4096.0;
- prolongation[1](49,62) = 225.0/4096.0;
- prolongation[1](49,63) = -675.0/4096.0;
- prolongation[1](50,41) = -1.0/16.0;
- prolongation[1](50,49) = -1.0/16.0;
- prolongation[1](50,57) = 9.0/16.0;
- prolongation[1](50,61) = 9.0/16.0;
- prolongation[1](51,24) = -1.0/256.0;
- prolongation[1](51,26) = -5.0/256.0;
- prolongation[1](51,28) = -5.0/256.0;
- prolongation[1](51,30) = -1.0/256.0;
- prolongation[1](51,40) = 5.0/256.0;
- prolongation[1](51,41) = -15.0/256.0;
- prolongation[1](51,44) = 45.0/256.0;
- prolongation[1](51,46) = 45.0/256.0;
- prolongation[1](51,48) = 5.0/256.0;
- prolongation[1](51,49) = -15.0/256.0;
- prolongation[1](51,52) = 9.0/256.0;
- prolongation[1](51,54) = 9.0/256.0;
- prolongation[1](51,56) = -45.0/256.0;
- prolongation[1](51,57) = 135.0/256.0;
- prolongation[1](51,60) = -45.0/256.0;
- prolongation[1](51,61) = 135.0/256.0;
- prolongation[1](52,0) = -25.0/4096.0;
- prolongation[1](52,1) = -25.0/4096.0;
- prolongation[1](52,2) = -5.0/4096.0;
- prolongation[1](52,3) = -5.0/4096.0;
- prolongation[1](52,4) = -5.0/4096.0;
- prolongation[1](52,5) = -5.0/4096.0;
- prolongation[1](52,6) = -1.0/4096.0;
- prolongation[1](52,7) = -1.0/4096.0;
- prolongation[1](52,8) = 225.0/4096.0;
- prolongation[1](52,9) = 225.0/4096.0;
- prolongation[1](52,10) = -75.0/4096.0;
- prolongation[1](52,11) = 25.0/4096.0;
- prolongation[1](52,12) = 45.0/4096.0;
- prolongation[1](52,13) = 45.0/4096.0;
- prolongation[1](52,14) = -75.0/4096.0;
- prolongation[1](52,15) = 25.0/4096.0;
- prolongation[1](52,16) = 45.0/4096.0;
- prolongation[1](52,17) = 45.0/4096.0;
- prolongation[1](52,18) = -15.0/4096.0;
- prolongation[1](52,19) = 5.0/4096.0;
- prolongation[1](52,20) = 9.0/4096.0;
- prolongation[1](52,21) = 9.0/4096.0;
- prolongation[1](52,22) = -15.0/4096.0;
- prolongation[1](52,23) = 5.0/4096.0;
- prolongation[1](52,24) = -75.0/4096.0;
- prolongation[1](52,25) = 25.0/4096.0;
- prolongation[1](52,26) = -75.0/4096.0;
- prolongation[1](52,27) = 25.0/4096.0;
- prolongation[1](52,28) = -15.0/4096.0;
- prolongation[1](52,29) = 5.0/4096.0;
- prolongation[1](52,30) = -15.0/4096.0;
- prolongation[1](52,31) = 5.0/4096.0;
- prolongation[1](52,32) = 675.0/4096.0;
- prolongation[1](52,33) = 675.0/4096.0;
- prolongation[1](52,34) = -225.0/4096.0;
- prolongation[1](52,35) = -225.0/4096.0;
- prolongation[1](52,36) = 135.0/4096.0;
- prolongation[1](52,37) = 135.0/4096.0;
- prolongation[1](52,38) = -45.0/4096.0;
- prolongation[1](52,39) = -45.0/4096.0;
- prolongation[1](52,40) = 675.0/4096.0;
- prolongation[1](52,41) = 675.0/4096.0;
- prolongation[1](52,42) = -225.0/4096.0;
- prolongation[1](52,43) = -225.0/4096.0;
- prolongation[1](52,44) = -225.0/4096.0;
- prolongation[1](52,45) = 75.0/4096.0;
- prolongation[1](52,46) = 75.0/4096.0;
- prolongation[1](52,47) = -25.0/4096.0;
- prolongation[1](52,48) = 135.0/4096.0;
- prolongation[1](52,49) = 135.0/4096.0;
- prolongation[1](52,50) = -45.0/4096.0;
- prolongation[1](52,51) = -45.0/4096.0;
- prolongation[1](52,52) = -225.0/4096.0;
- prolongation[1](52,53) = 75.0/4096.0;
- prolongation[1](52,54) = 75.0/4096.0;
- prolongation[1](52,55) = -25.0/4096.0;
- prolongation[1](52,56) = 2025.0/4096.0;
- prolongation[1](52,57) = 2025.0/4096.0;
- prolongation[1](52,58) = -675.0/4096.0;
- prolongation[1](52,59) = -675.0/4096.0;
- prolongation[1](52,60) = -675.0/4096.0;
- prolongation[1](52,61) = -675.0/4096.0;
- prolongation[1](52,62) = 225.0/4096.0;
- prolongation[1](52,63) = 225.0/4096.0;
- prolongation[1](53,24) = -5.0/256.0;
- prolongation[1](53,26) = -5.0/256.0;
- prolongation[1](53,28) = -1.0/256.0;
- prolongation[1](53,30) = -1.0/256.0;
- prolongation[1](53,40) = 45.0/256.0;
- prolongation[1](53,41) = 45.0/256.0;
- prolongation[1](53,44) = -15.0/256.0;
- prolongation[1](53,46) = 5.0/256.0;
- prolongation[1](53,48) = 9.0/256.0;
- prolongation[1](53,49) = 9.0/256.0;
- prolongation[1](53,52) = -15.0/256.0;
- prolongation[1](53,54) = 5.0/256.0;
- prolongation[1](53,56) = 135.0/256.0;
- prolongation[1](53,57) = 135.0/256.0;
- prolongation[1](53,60) = -45.0/256.0;
- prolongation[1](53,61) = -45.0/256.0;
- prolongation[1](54,10) = -5.0/256.0;
- prolongation[1](54,14) = -5.0/256.0;
- prolongation[1](54,18) = -1.0/256.0;
- prolongation[1](54,22) = -1.0/256.0;
- prolongation[1](54,32) = 45.0/256.0;
- prolongation[1](54,33) = 45.0/256.0;
- prolongation[1](54,36) = 9.0/256.0;
- prolongation[1](54,37) = 9.0/256.0;
- prolongation[1](54,44) = -15.0/256.0;
- prolongation[1](54,45) = 5.0/256.0;
- prolongation[1](54,52) = -15.0/256.0;
- prolongation[1](54,53) = 5.0/256.0;
- prolongation[1](54,56) = 135.0/256.0;
- prolongation[1](54,57) = 135.0/256.0;
- prolongation[1](54,58) = -45.0/256.0;
- prolongation[1](54,59) = -45.0/256.0;
- prolongation[1](55,44) = -1.0/16.0;
- prolongation[1](55,52) = -1.0/16.0;
- prolongation[1](55,56) = 9.0/16.0;
- prolongation[1](55,57) = 9.0/16.0;
- prolongation[1](56,9) = 25.0/256.0;
- prolongation[1](56,13) = 5.0/256.0;
- prolongation[1](56,17) = 5.0/256.0;
- prolongation[1](56,21) = 1.0/256.0;
- prolongation[1](56,33) = 75.0/256.0;
- prolongation[1](56,35) = -25.0/256.0;
- prolongation[1](56,37) = 15.0/256.0;
- prolongation[1](56,39) = -5.0/256.0;
- prolongation[1](56,41) = 75.0/256.0;
- prolongation[1](56,43) = -25.0/256.0;
- prolongation[1](56,49) = 15.0/256.0;
- prolongation[1](56,51) = -5.0/256.0;
- prolongation[1](56,57) = 225.0/256.0;
- prolongation[1](56,59) = -75.0/256.0;
- prolongation[1](56,61) = -75.0/256.0;
- prolongation[1](56,63) = 25.0/256.0;
- prolongation[1](57,0) = 25.0/4096.0;
- prolongation[1](57,1) = 125.0/4096.0;
- prolongation[1](57,2) = 25.0/4096.0;
- prolongation[1](57,3) = 5.0/4096.0;
- prolongation[1](57,4) = 5.0/4096.0;
- prolongation[1](57,5) = 25.0/4096.0;
- prolongation[1](57,6) = 5.0/4096.0;
- prolongation[1](57,7) = 1.0/4096.0;
- prolongation[1](57,8) = -125.0/4096.0;
- prolongation[1](57,9) = 375.0/4096.0;
- prolongation[1](57,10) = 375.0/4096.0;
- prolongation[1](57,11) = -125.0/4096.0;
- prolongation[1](57,12) = -25.0/4096.0;
- prolongation[1](57,13) = 75.0/4096.0;
- prolongation[1](57,14) = 75.0/4096.0;
- prolongation[1](57,15) = -25.0/4096.0;
- prolongation[1](57,16) = -25.0/4096.0;
- prolongation[1](57,17) = 75.0/4096.0;
- prolongation[1](57,18) = 75.0/4096.0;
- prolongation[1](57,19) = -25.0/4096.0;
- prolongation[1](57,20) = -5.0/4096.0;
- prolongation[1](57,21) = 15.0/4096.0;
- prolongation[1](57,22) = 15.0/4096.0;
- prolongation[1](57,23) = -5.0/4096.0;
- prolongation[1](57,24) = 75.0/4096.0;
- prolongation[1](57,25) = -25.0/4096.0;
- prolongation[1](57,26) = 375.0/4096.0;
- prolongation[1](57,27) = -125.0/4096.0;
- prolongation[1](57,28) = 75.0/4096.0;
- prolongation[1](57,29) = -25.0/4096.0;
- prolongation[1](57,30) = 15.0/4096.0;
- prolongation[1](57,31) = -5.0/4096.0;
- prolongation[1](57,32) = -375.0/4096.0;
- prolongation[1](57,33) = 1125.0/4096.0;
- prolongation[1](57,34) = 125.0/4096.0;
- prolongation[1](57,35) = -375.0/4096.0;
- prolongation[1](57,36) = -75.0/4096.0;
- prolongation[1](57,37) = 225.0/4096.0;
- prolongation[1](57,38) = 25.0/4096.0;
- prolongation[1](57,39) = -75.0/4096.0;
- prolongation[1](57,40) = -375.0/4096.0;
- prolongation[1](57,41) = 1125.0/4096.0;
- prolongation[1](57,42) = 125.0/4096.0;
- prolongation[1](57,43) = -375.0/4096.0;
- prolongation[1](57,44) = 1125.0/4096.0;
- prolongation[1](57,45) = -375.0/4096.0;
- prolongation[1](57,46) = -375.0/4096.0;
- prolongation[1](57,47) = 125.0/4096.0;
- prolongation[1](57,48) = -75.0/4096.0;
- prolongation[1](57,49) = 225.0/4096.0;
- prolongation[1](57,50) = 25.0/4096.0;
- prolongation[1](57,51) = -75.0/4096.0;
- prolongation[1](57,52) = 225.0/4096.0;
- prolongation[1](57,53) = -75.0/4096.0;
- prolongation[1](57,54) = -75.0/4096.0;
- prolongation[1](57,55) = 25.0/4096.0;
- prolongation[1](57,56) = -1125.0/4096.0;
- prolongation[1](57,57) = 3375.0/4096.0;
- prolongation[1](57,58) = 375.0/4096.0;
- prolongation[1](57,59) = -1125.0/4096.0;
- prolongation[1](57,60) = 375.0/4096.0;
- prolongation[1](57,61) = -1125.0/4096.0;
- prolongation[1](57,62) = -125.0/4096.0;
- prolongation[1](57,63) = 375.0/4096.0;
- prolongation[1](58,41) = 5.0/16.0;
- prolongation[1](58,49) = 1.0/16.0;
- prolongation[1](58,57) = 15.0/16.0;
- prolongation[1](58,61) = -5.0/16.0;
- prolongation[1](59,24) = 5.0/256.0;
- prolongation[1](59,26) = 25.0/256.0;
- prolongation[1](59,28) = 5.0/256.0;
- prolongation[1](59,30) = 1.0/256.0;
- prolongation[1](59,40) = -25.0/256.0;
- prolongation[1](59,41) = 75.0/256.0;
- prolongation[1](59,44) = 75.0/256.0;
- prolongation[1](59,46) = -25.0/256.0;
- prolongation[1](59,48) = -5.0/256.0;
- prolongation[1](59,49) = 15.0/256.0;
- prolongation[1](59,52) = 15.0/256.0;
- prolongation[1](59,54) = -5.0/256.0;
- prolongation[1](59,56) = -75.0/256.0;
- prolongation[1](59,57) = 225.0/256.0;
- prolongation[1](59,60) = 25.0/256.0;
- prolongation[1](59,61) = -75.0/256.0;
- prolongation[1](60,33) = 5.0/16.0;
- prolongation[1](60,37) = 1.0/16.0;
- prolongation[1](60,57) = 15.0/16.0;
- prolongation[1](60,59) = -5.0/16.0;
- prolongation[1](61,10) = 25.0/256.0;
- prolongation[1](61,14) = 5.0/256.0;
- prolongation[1](61,18) = 5.0/256.0;
- prolongation[1](61,22) = 1.0/256.0;
- prolongation[1](61,32) = -25.0/256.0;
- prolongation[1](61,33) = 75.0/256.0;
- prolongation[1](61,36) = -5.0/256.0;
- prolongation[1](61,37) = 15.0/256.0;
- prolongation[1](61,44) = 75.0/256.0;
- prolongation[1](61,45) = -25.0/256.0;
- prolongation[1](61,52) = 15.0/256.0;
- prolongation[1](61,53) = -5.0/256.0;
- prolongation[1](61,56) = -75.0/256.0;
- prolongation[1](61,57) = 225.0/256.0;
- prolongation[1](61,58) = 25.0/256.0;
- prolongation[1](61,59) = -75.0/256.0;
- prolongation[1](62,57) = 1.0;
- prolongation[1](63,44) = 5.0/16.0;
- prolongation[1](63,52) = 1.0/16.0;
- prolongation[1](63,56) = -5.0/16.0;
- prolongation[1](63,57) = 15.0/16.0;
- prolongation[2](0,0) = 1.0/256.0;
- prolongation[2](0,1) = 1.0/256.0;
- prolongation[2](0,2) = 1.0/256.0;
- prolongation[2](0,3) = 1.0/256.0;
- prolongation[2](0,8) = -9.0/256.0;
- prolongation[2](0,9) = -9.0/256.0;
- prolongation[2](0,10) = -9.0/256.0;
- prolongation[2](0,11) = -9.0/256.0;
- prolongation[2](0,12) = -9.0/256.0;
- prolongation[2](0,13) = -9.0/256.0;
- prolongation[2](0,14) = -9.0/256.0;
- prolongation[2](0,15) = -9.0/256.0;
- prolongation[2](0,32) = 81.0/256.0;
- prolongation[2](0,33) = 81.0/256.0;
- prolongation[2](0,34) = 81.0/256.0;
- prolongation[2](0,35) = 81.0/256.0;
- prolongation[2](1,1) = -1.0/16.0;
- prolongation[2](1,2) = -1.0/16.0;
- prolongation[2](1,10) = 9.0/16.0;
- prolongation[2](1,11) = 9.0/16.0;
- prolongation[2](2,2) = 1.0;
- prolongation[2](3,2) = -1.0/16.0;
- prolongation[2](3,3) = -1.0/16.0;
- prolongation[2](3,12) = 9.0/16.0;
- prolongation[2](3,13) = 9.0/16.0;
- prolongation[2](4,0) = -1.0/4096.0;
- prolongation[2](4,1) = -1.0/4096.0;
- prolongation[2](4,2) = -1.0/4096.0;
- prolongation[2](4,3) = -1.0/4096.0;
- prolongation[2](4,4) = -1.0/4096.0;
- prolongation[2](4,5) = -1.0/4096.0;
- prolongation[2](4,6) = -1.0/4096.0;
- prolongation[2](4,7) = -1.0/4096.0;
- prolongation[2](4,8) = 9.0/4096.0;
- prolongation[2](4,9) = 9.0/4096.0;
- prolongation[2](4,10) = 9.0/4096.0;
- prolongation[2](4,11) = 9.0/4096.0;
- prolongation[2](4,12) = 9.0/4096.0;
- prolongation[2](4,13) = 9.0/4096.0;
- prolongation[2](4,14) = 9.0/4096.0;
- prolongation[2](4,15) = 9.0/4096.0;
- prolongation[2](4,16) = 9.0/4096.0;
- prolongation[2](4,17) = 9.0/4096.0;
- prolongation[2](4,18) = 9.0/4096.0;
- prolongation[2](4,19) = 9.0/4096.0;
- prolongation[2](4,20) = 9.0/4096.0;
- prolongation[2](4,21) = 9.0/4096.0;
- prolongation[2](4,22) = 9.0/4096.0;
- prolongation[2](4,23) = 9.0/4096.0;
- prolongation[2](4,24) = 9.0/4096.0;
- prolongation[2](4,25) = 9.0/4096.0;
- prolongation[2](4,26) = 9.0/4096.0;
- prolongation[2](4,27) = 9.0/4096.0;
- prolongation[2](4,28) = 9.0/4096.0;
- prolongation[2](4,29) = 9.0/4096.0;
- prolongation[2](4,30) = 9.0/4096.0;
- prolongation[2](4,31) = 9.0/4096.0;
- prolongation[2](4,32) = -81.0/4096.0;
- prolongation[2](4,33) = -81.0/4096.0;
- prolongation[2](4,34) = -81.0/4096.0;
- prolongation[2](4,35) = -81.0/4096.0;
- prolongation[2](4,36) = -81.0/4096.0;
- prolongation[2](4,37) = -81.0/4096.0;
- prolongation[2](4,38) = -81.0/4096.0;
- prolongation[2](4,39) = -81.0/4096.0;
- prolongation[2](4,40) = -81.0/4096.0;
- prolongation[2](4,41) = -81.0/4096.0;
- prolongation[2](4,42) = -81.0/4096.0;
- prolongation[2](4,43) = -81.0/4096.0;
- prolongation[2](4,44) = -81.0/4096.0;
- prolongation[2](4,45) = -81.0/4096.0;
- prolongation[2](4,46) = -81.0/4096.0;
- prolongation[2](4,47) = -81.0/4096.0;
- prolongation[2](4,48) = -81.0/4096.0;
- prolongation[2](4,49) = -81.0/4096.0;
- prolongation[2](4,50) = -81.0/4096.0;
- prolongation[2](4,51) = -81.0/4096.0;
- prolongation[2](4,52) = -81.0/4096.0;
- prolongation[2](4,53) = -81.0/4096.0;
- prolongation[2](4,54) = -81.0/4096.0;
- prolongation[2](4,55) = -81.0/4096.0;
- prolongation[2](4,56) = 729.0/4096.0;
- prolongation[2](4,57) = 729.0/4096.0;
- prolongation[2](4,58) = 729.0/4096.0;
- prolongation[2](4,59) = 729.0/4096.0;
- prolongation[2](4,60) = 729.0/4096.0;
- prolongation[2](4,61) = 729.0/4096.0;
- prolongation[2](4,62) = 729.0/4096.0;
- prolongation[2](4,63) = 729.0/4096.0;
- prolongation[2](5,1) = 1.0/256.0;
- prolongation[2](5,2) = 1.0/256.0;
- prolongation[2](5,5) = 1.0/256.0;
- prolongation[2](5,6) = 1.0/256.0;
- prolongation[2](5,10) = -9.0/256.0;
- prolongation[2](5,11) = -9.0/256.0;
- prolongation[2](5,18) = -9.0/256.0;
- prolongation[2](5,19) = -9.0/256.0;
- prolongation[2](5,26) = -9.0/256.0;
- prolongation[2](5,27) = -9.0/256.0;
- prolongation[2](5,28) = -9.0/256.0;
- prolongation[2](5,29) = -9.0/256.0;
- prolongation[2](5,44) = 81.0/256.0;
- prolongation[2](5,45) = 81.0/256.0;
- prolongation[2](5,46) = 81.0/256.0;
- prolongation[2](5,47) = 81.0/256.0;
- prolongation[2](6,2) = -1.0/16.0;
- prolongation[2](6,6) = -1.0/16.0;
- prolongation[2](6,28) = 9.0/16.0;
- prolongation[2](6,29) = 9.0/16.0;
- prolongation[2](7,2) = 1.0/256.0;
- prolongation[2](7,3) = 1.0/256.0;
- prolongation[2](7,6) = 1.0/256.0;
- prolongation[2](7,7) = 1.0/256.0;
- prolongation[2](7,12) = -9.0/256.0;
- prolongation[2](7,13) = -9.0/256.0;
- prolongation[2](7,20) = -9.0/256.0;
- prolongation[2](7,21) = -9.0/256.0;
- prolongation[2](7,28) = -9.0/256.0;
- prolongation[2](7,29) = -9.0/256.0;
- prolongation[2](7,30) = -9.0/256.0;
- prolongation[2](7,31) = -9.0/256.0;
- prolongation[2](7,48) = 81.0/256.0;
- prolongation[2](7,49) = 81.0/256.0;
- prolongation[2](7,50) = 81.0/256.0;
- prolongation[2](7,51) = 81.0/256.0;
- prolongation[2](8,9) = -1.0/16.0;
- prolongation[2](8,13) = -1.0/16.0;
- prolongation[2](8,33) = 9.0/16.0;
- prolongation[2](8,35) = 9.0/16.0;
- prolongation[2](9,0) = -1.0/256.0;
- prolongation[2](9,1) = -5.0/256.0;
- prolongation[2](9,2) = -5.0/256.0;
- prolongation[2](9,3) = -1.0/256.0;
- prolongation[2](9,8) = 5.0/256.0;
- prolongation[2](9,9) = -15.0/256.0;
- prolongation[2](9,10) = 45.0/256.0;
- prolongation[2](9,11) = 45.0/256.0;
- prolongation[2](9,12) = 5.0/256.0;
- prolongation[2](9,13) = -15.0/256.0;
- prolongation[2](9,14) = 9.0/256.0;
- prolongation[2](9,15) = 9.0/256.0;
- prolongation[2](9,32) = -45.0/256.0;
- prolongation[2](9,33) = 135.0/256.0;
- prolongation[2](9,34) = -45.0/256.0;
- prolongation[2](9,35) = 135.0/256.0;
- prolongation[2](10,11) = 1.0;
- prolongation[2](11,1) = 1.0/16.0;
- prolongation[2](11,2) = 5.0/16.0;
- prolongation[2](11,10) = -5.0/16.0;
- prolongation[2](11,11) = 15.0/16.0;
- prolongation[2](12,13) = 1.0;
- prolongation[2](13,2) = 5.0/16.0;
- prolongation[2](13,3) = 1.0/16.0;
- prolongation[2](13,12) = -5.0/16.0;
- prolongation[2](13,13) = 15.0/16.0;
- prolongation[2](14,11) = -1.0/16.0;
- prolongation[2](14,15) = -1.0/16.0;
- prolongation[2](14,34) = 9.0/16.0;
- prolongation[2](14,35) = 9.0/16.0;
- prolongation[2](15,0) = -1.0/256.0;
- prolongation[2](15,1) = -1.0/256.0;
- prolongation[2](15,2) = -5.0/256.0;
- prolongation[2](15,3) = -5.0/256.0;
- prolongation[2](15,8) = 9.0/256.0;
- prolongation[2](15,9) = 9.0/256.0;
- prolongation[2](15,10) = 5.0/256.0;
- prolongation[2](15,11) = -15.0/256.0;
- prolongation[2](15,12) = 45.0/256.0;
- prolongation[2](15,13) = 45.0/256.0;
- prolongation[2](15,14) = 5.0/256.0;
- prolongation[2](15,15) = -15.0/256.0;
- prolongation[2](15,32) = -45.0/256.0;
- prolongation[2](15,33) = -45.0/256.0;
- prolongation[2](15,34) = 135.0/256.0;
- prolongation[2](15,35) = 135.0/256.0;
- prolongation[2](16,9) = 1.0/256.0;
- prolongation[2](16,13) = 1.0/256.0;
- prolongation[2](16,17) = 1.0/256.0;
- prolongation[2](16,21) = 1.0/256.0;
- prolongation[2](16,33) = -9.0/256.0;
- prolongation[2](16,35) = -9.0/256.0;
- prolongation[2](16,37) = -9.0/256.0;
- prolongation[2](16,39) = -9.0/256.0;
- prolongation[2](16,41) = -9.0/256.0;
- prolongation[2](16,43) = -9.0/256.0;
- prolongation[2](16,49) = -9.0/256.0;
- prolongation[2](16,51) = -9.0/256.0;
- prolongation[2](16,57) = 81.0/256.0;
- prolongation[2](16,59) = 81.0/256.0;
- prolongation[2](16,61) = 81.0/256.0;
- prolongation[2](16,63) = 81.0/256.0;
- prolongation[2](17,0) = 1.0/4096.0;
- prolongation[2](17,1) = 5.0/4096.0;
- prolongation[2](17,2) = 5.0/4096.0;
- prolongation[2](17,3) = 1.0/4096.0;
- prolongation[2](17,4) = 1.0/4096.0;
- prolongation[2](17,5) = 5.0/4096.0;
- prolongation[2](17,6) = 5.0/4096.0;
- prolongation[2](17,7) = 1.0/4096.0;
- prolongation[2](17,8) = -5.0/4096.0;
- prolongation[2](17,9) = 15.0/4096.0;
- prolongation[2](17,10) = -45.0/4096.0;
- prolongation[2](17,11) = -45.0/4096.0;
- prolongation[2](17,12) = -5.0/4096.0;
- prolongation[2](17,13) = 15.0/4096.0;
- prolongation[2](17,14) = -9.0/4096.0;
- prolongation[2](17,15) = -9.0/4096.0;
- prolongation[2](17,16) = -5.0/4096.0;
- prolongation[2](17,17) = 15.0/4096.0;
- prolongation[2](17,18) = -45.0/4096.0;
- prolongation[2](17,19) = -45.0/4096.0;
- prolongation[2](17,20) = -5.0/4096.0;
- prolongation[2](17,21) = 15.0/4096.0;
- prolongation[2](17,22) = -9.0/4096.0;
- prolongation[2](17,23) = -9.0/4096.0;
- prolongation[2](17,24) = -9.0/4096.0;
- prolongation[2](17,25) = -9.0/4096.0;
- prolongation[2](17,26) = -45.0/4096.0;
- prolongation[2](17,27) = -45.0/4096.0;
- prolongation[2](17,28) = -45.0/4096.0;
- prolongation[2](17,29) = -45.0/4096.0;
- prolongation[2](17,30) = -9.0/4096.0;
- prolongation[2](17,31) = -9.0/4096.0;
- prolongation[2](17,32) = 45.0/4096.0;
- prolongation[2](17,33) = -135.0/4096.0;
- prolongation[2](17,34) = 45.0/4096.0;
- prolongation[2](17,35) = -135.0/4096.0;
- prolongation[2](17,36) = 45.0/4096.0;
- prolongation[2](17,37) = -135.0/4096.0;
- prolongation[2](17,38) = 45.0/4096.0;
- prolongation[2](17,39) = -135.0/4096.0;
- prolongation[2](17,40) = 45.0/4096.0;
- prolongation[2](17,41) = -135.0/4096.0;
- prolongation[2](17,42) = 45.0/4096.0;
- prolongation[2](17,43) = -135.0/4096.0;
- prolongation[2](17,44) = 405.0/4096.0;
- prolongation[2](17,45) = 405.0/4096.0;
- prolongation[2](17,46) = 405.0/4096.0;
- prolongation[2](17,47) = 405.0/4096.0;
- prolongation[2](17,48) = 45.0/4096.0;
- prolongation[2](17,49) = -135.0/4096.0;
- prolongation[2](17,50) = 45.0/4096.0;
- prolongation[2](17,51) = -135.0/4096.0;
- prolongation[2](17,52) = 81.0/4096.0;
- prolongation[2](17,53) = 81.0/4096.0;
- prolongation[2](17,54) = 81.0/4096.0;
- prolongation[2](17,55) = 81.0/4096.0;
- prolongation[2](17,56) = -405.0/4096.0;
- prolongation[2](17,57) = 1215.0/4096.0;
- prolongation[2](17,58) = -405.0/4096.0;
- prolongation[2](17,59) = 1215.0/4096.0;
- prolongation[2](17,60) = -405.0/4096.0;
- prolongation[2](17,61) = 1215.0/4096.0;
- prolongation[2](17,62) = -405.0/4096.0;
- prolongation[2](17,63) = 1215.0/4096.0;
- prolongation[2](18,11) = -1.0/16.0;
- prolongation[2](18,19) = -1.0/16.0;
- prolongation[2](18,46) = 9.0/16.0;
- prolongation[2](18,47) = 9.0/16.0;
- prolongation[2](19,1) = -1.0/256.0;
- prolongation[2](19,2) = -5.0/256.0;
- prolongation[2](19,5) = -1.0/256.0;
- prolongation[2](19,6) = -5.0/256.0;
- prolongation[2](19,10) = 5.0/256.0;
- prolongation[2](19,11) = -15.0/256.0;
- prolongation[2](19,18) = 5.0/256.0;
- prolongation[2](19,19) = -15.0/256.0;
- prolongation[2](19,26) = 9.0/256.0;
- prolongation[2](19,27) = 9.0/256.0;
- prolongation[2](19,28) = 45.0/256.0;
- prolongation[2](19,29) = 45.0/256.0;
- prolongation[2](19,44) = -45.0/256.0;
- prolongation[2](19,45) = -45.0/256.0;
- prolongation[2](19,46) = 135.0/256.0;
- prolongation[2](19,47) = 135.0/256.0;
- prolongation[2](20,13) = -1.0/16.0;
- prolongation[2](20,21) = -1.0/16.0;
- prolongation[2](20,49) = 9.0/16.0;
- prolongation[2](20,51) = 9.0/16.0;
- prolongation[2](21,2) = -5.0/256.0;
- prolongation[2](21,3) = -1.0/256.0;
- prolongation[2](21,6) = -5.0/256.0;
- prolongation[2](21,7) = -1.0/256.0;
- prolongation[2](21,12) = 5.0/256.0;
- prolongation[2](21,13) = -15.0/256.0;
- prolongation[2](21,20) = 5.0/256.0;
- prolongation[2](21,21) = -15.0/256.0;
- prolongation[2](21,28) = 45.0/256.0;
- prolongation[2](21,29) = 45.0/256.0;
- prolongation[2](21,30) = 9.0/256.0;
- prolongation[2](21,31) = 9.0/256.0;
- prolongation[2](21,48) = -45.0/256.0;
- prolongation[2](21,49) = 135.0/256.0;
- prolongation[2](21,50) = -45.0/256.0;
- prolongation[2](21,51) = 135.0/256.0;
- prolongation[2](22,11) = 1.0/256.0;
- prolongation[2](22,15) = 1.0/256.0;
- prolongation[2](22,19) = 1.0/256.0;
- prolongation[2](22,23) = 1.0/256.0;
- prolongation[2](22,34) = -9.0/256.0;
- prolongation[2](22,35) = -9.0/256.0;
- prolongation[2](22,38) = -9.0/256.0;
- prolongation[2](22,39) = -9.0/256.0;
- prolongation[2](22,46) = -9.0/256.0;
- prolongation[2](22,47) = -9.0/256.0;
- prolongation[2](22,54) = -9.0/256.0;
- prolongation[2](22,55) = -9.0/256.0;
- prolongation[2](22,60) = 81.0/256.0;
- prolongation[2](22,61) = 81.0/256.0;
- prolongation[2](22,62) = 81.0/256.0;
- prolongation[2](22,63) = 81.0/256.0;
- prolongation[2](23,0) = 1.0/4096.0;
- prolongation[2](23,1) = 1.0/4096.0;
- prolongation[2](23,2) = 5.0/4096.0;
- prolongation[2](23,3) = 5.0/4096.0;
- prolongation[2](23,4) = 1.0/4096.0;
- prolongation[2](23,5) = 1.0/4096.0;
- prolongation[2](23,6) = 5.0/4096.0;
- prolongation[2](23,7) = 5.0/4096.0;
- prolongation[2](23,8) = -9.0/4096.0;
- prolongation[2](23,9) = -9.0/4096.0;
- prolongation[2](23,10) = -5.0/4096.0;
- prolongation[2](23,11) = 15.0/4096.0;
- prolongation[2](23,12) = -45.0/4096.0;
- prolongation[2](23,13) = -45.0/4096.0;
- prolongation[2](23,14) = -5.0/4096.0;
- prolongation[2](23,15) = 15.0/4096.0;
- prolongation[2](23,16) = -9.0/4096.0;
- prolongation[2](23,17) = -9.0/4096.0;
- prolongation[2](23,18) = -5.0/4096.0;
- prolongation[2](23,19) = 15.0/4096.0;
- prolongation[2](23,20) = -45.0/4096.0;
- prolongation[2](23,21) = -45.0/4096.0;
- prolongation[2](23,22) = -5.0/4096.0;
- prolongation[2](23,23) = 15.0/4096.0;
- prolongation[2](23,24) = -9.0/4096.0;
- prolongation[2](23,25) = -9.0/4096.0;
- prolongation[2](23,26) = -9.0/4096.0;
- prolongation[2](23,27) = -9.0/4096.0;
- prolongation[2](23,28) = -45.0/4096.0;
- prolongation[2](23,29) = -45.0/4096.0;
- prolongation[2](23,30) = -45.0/4096.0;
- prolongation[2](23,31) = -45.0/4096.0;
- prolongation[2](23,32) = 45.0/4096.0;
- prolongation[2](23,33) = 45.0/4096.0;
- prolongation[2](23,34) = -135.0/4096.0;
- prolongation[2](23,35) = -135.0/4096.0;
- prolongation[2](23,36) = 45.0/4096.0;
- prolongation[2](23,37) = 45.0/4096.0;
- prolongation[2](23,38) = -135.0/4096.0;
- prolongation[2](23,39) = -135.0/4096.0;
- prolongation[2](23,40) = 81.0/4096.0;
- prolongation[2](23,41) = 81.0/4096.0;
- prolongation[2](23,42) = 81.0/4096.0;
- prolongation[2](23,43) = 81.0/4096.0;
- prolongation[2](23,44) = 45.0/4096.0;
- prolongation[2](23,45) = 45.0/4096.0;
- prolongation[2](23,46) = -135.0/4096.0;
- prolongation[2](23,47) = -135.0/4096.0;
- prolongation[2](23,48) = 405.0/4096.0;
- prolongation[2](23,49) = 405.0/4096.0;
- prolongation[2](23,50) = 405.0/4096.0;
- prolongation[2](23,51) = 405.0/4096.0;
- prolongation[2](23,52) = 45.0/4096.0;
- prolongation[2](23,53) = 45.0/4096.0;
- prolongation[2](23,54) = -135.0/4096.0;
- prolongation[2](23,55) = -135.0/4096.0;
- prolongation[2](23,56) = -405.0/4096.0;
- prolongation[2](23,57) = -405.0/4096.0;
- prolongation[2](23,58) = -405.0/4096.0;
- prolongation[2](23,59) = -405.0/4096.0;
- prolongation[2](23,60) = 1215.0/4096.0;
- prolongation[2](23,61) = 1215.0/4096.0;
- prolongation[2](23,62) = 1215.0/4096.0;
- prolongation[2](23,63) = 1215.0/4096.0;
- prolongation[2](24,0) = 5.0/4096.0;
- prolongation[2](24,1) = 5.0/4096.0;
- prolongation[2](24,2) = 5.0/4096.0;
- prolongation[2](24,3) = 5.0/4096.0;
- prolongation[2](24,4) = 1.0/4096.0;
- prolongation[2](24,5) = 1.0/4096.0;
- prolongation[2](24,6) = 1.0/4096.0;
- prolongation[2](24,7) = 1.0/4096.0;
- prolongation[2](24,8) = -45.0/4096.0;
- prolongation[2](24,9) = -45.0/4096.0;
- prolongation[2](24,10) = -45.0/4096.0;
- prolongation[2](24,11) = -45.0/4096.0;
- prolongation[2](24,12) = -45.0/4096.0;
- prolongation[2](24,13) = -45.0/4096.0;
- prolongation[2](24,14) = -45.0/4096.0;
- prolongation[2](24,15) = -45.0/4096.0;
- prolongation[2](24,16) = -9.0/4096.0;
- prolongation[2](24,17) = -9.0/4096.0;
- prolongation[2](24,18) = -9.0/4096.0;
- prolongation[2](24,19) = -9.0/4096.0;
- prolongation[2](24,20) = -9.0/4096.0;
- prolongation[2](24,21) = -9.0/4096.0;
- prolongation[2](24,22) = -9.0/4096.0;
- prolongation[2](24,23) = -9.0/4096.0;
- prolongation[2](24,24) = 15.0/4096.0;
- prolongation[2](24,25) = -5.0/4096.0;
- prolongation[2](24,26) = 15.0/4096.0;
- prolongation[2](24,27) = -5.0/4096.0;
- prolongation[2](24,28) = 15.0/4096.0;
- prolongation[2](24,29) = -5.0/4096.0;
- prolongation[2](24,30) = 15.0/4096.0;
- prolongation[2](24,31) = -5.0/4096.0;
- prolongation[2](24,32) = 405.0/4096.0;
- prolongation[2](24,33) = 405.0/4096.0;
- prolongation[2](24,34) = 405.0/4096.0;
- prolongation[2](24,35) = 405.0/4096.0;
- prolongation[2](24,36) = 81.0/4096.0;
- prolongation[2](24,37) = 81.0/4096.0;
- prolongation[2](24,38) = 81.0/4096.0;
- prolongation[2](24,39) = 81.0/4096.0;
- prolongation[2](24,40) = -135.0/4096.0;
- prolongation[2](24,41) = -135.0/4096.0;
- prolongation[2](24,42) = 45.0/4096.0;
- prolongation[2](24,43) = 45.0/4096.0;
- prolongation[2](24,44) = -135.0/4096.0;
- prolongation[2](24,45) = 45.0/4096.0;
- prolongation[2](24,46) = -135.0/4096.0;
- prolongation[2](24,47) = 45.0/4096.0;
- prolongation[2](24,48) = -135.0/4096.0;
- prolongation[2](24,49) = -135.0/4096.0;
- prolongation[2](24,50) = 45.0/4096.0;
- prolongation[2](24,51) = 45.0/4096.0;
- prolongation[2](24,52) = -135.0/4096.0;
- prolongation[2](24,53) = 45.0/4096.0;
- prolongation[2](24,54) = -135.0/4096.0;
- prolongation[2](24,55) = 45.0/4096.0;
- prolongation[2](24,56) = 1215.0/4096.0;
- prolongation[2](24,57) = 1215.0/4096.0;
- prolongation[2](24,58) = -405.0/4096.0;
- prolongation[2](24,59) = -405.0/4096.0;
- prolongation[2](24,60) = 1215.0/4096.0;
- prolongation[2](24,61) = 1215.0/4096.0;
- prolongation[2](24,62) = -405.0/4096.0;
- prolongation[2](24,63) = -405.0/4096.0;
- prolongation[2](25,24) = 1.0/256.0;
- prolongation[2](25,26) = 1.0/256.0;
- prolongation[2](25,28) = 1.0/256.0;
- prolongation[2](25,30) = 1.0/256.0;
- prolongation[2](25,40) = -9.0/256.0;
- prolongation[2](25,41) = -9.0/256.0;
- prolongation[2](25,44) = -9.0/256.0;
- prolongation[2](25,46) = -9.0/256.0;
- prolongation[2](25,48) = -9.0/256.0;
- prolongation[2](25,49) = -9.0/256.0;
- prolongation[2](25,52) = -9.0/256.0;
- prolongation[2](25,54) = -9.0/256.0;
- prolongation[2](25,56) = 81.0/256.0;
- prolongation[2](25,57) = 81.0/256.0;
- prolongation[2](25,60) = 81.0/256.0;
- prolongation[2](25,61) = 81.0/256.0;
- prolongation[2](26,1) = -5.0/256.0;
- prolongation[2](26,2) = -5.0/256.0;
- prolongation[2](26,5) = -1.0/256.0;
- prolongation[2](26,6) = -1.0/256.0;
- prolongation[2](26,10) = 45.0/256.0;
- prolongation[2](26,11) = 45.0/256.0;
- prolongation[2](26,18) = 9.0/256.0;
- prolongation[2](26,19) = 9.0/256.0;
- prolongation[2](26,26) = -15.0/256.0;
- prolongation[2](26,27) = 5.0/256.0;
- prolongation[2](26,28) = -15.0/256.0;
- prolongation[2](26,29) = 5.0/256.0;
- prolongation[2](26,44) = 135.0/256.0;
- prolongation[2](26,45) = -45.0/256.0;
- prolongation[2](26,46) = 135.0/256.0;
- prolongation[2](26,47) = -45.0/256.0;
- prolongation[2](27,26) = -1.0/16.0;
- prolongation[2](27,28) = -1.0/16.0;
- prolongation[2](27,44) = 9.0/16.0;
- prolongation[2](27,46) = 9.0/16.0;
- prolongation[2](28,2) = 5.0/16.0;
- prolongation[2](28,6) = 1.0/16.0;
- prolongation[2](28,28) = 15.0/16.0;
- prolongation[2](28,29) = -5.0/16.0;
- prolongation[2](29,28) = 1.0;
- prolongation[2](30,2) = -5.0/256.0;
- prolongation[2](30,3) = -5.0/256.0;
- prolongation[2](30,6) = -1.0/256.0;
- prolongation[2](30,7) = -1.0/256.0;
- prolongation[2](30,12) = 45.0/256.0;
- prolongation[2](30,13) = 45.0/256.0;
- prolongation[2](30,20) = 9.0/256.0;
- prolongation[2](30,21) = 9.0/256.0;
- prolongation[2](30,28) = -15.0/256.0;
- prolongation[2](30,29) = 5.0/256.0;
- prolongation[2](30,30) = -15.0/256.0;
- prolongation[2](30,31) = 5.0/256.0;
- prolongation[2](30,48) = 135.0/256.0;
- prolongation[2](30,49) = 135.0/256.0;
- prolongation[2](30,50) = -45.0/256.0;
- prolongation[2](30,51) = -45.0/256.0;
- prolongation[2](31,28) = -1.0/16.0;
- prolongation[2](31,30) = -1.0/16.0;
- prolongation[2](31,48) = 9.0/16.0;
- prolongation[2](31,49) = 9.0/16.0;
- prolongation[2](32,35) = 1.0;
- prolongation[2](33,11) = 5.0/16.0;
- prolongation[2](33,15) = 1.0/16.0;
- prolongation[2](33,34) = -5.0/16.0;
- prolongation[2](33,35) = 15.0/16.0;
- prolongation[2](34,9) = 1.0/16.0;
- prolongation[2](34,13) = 5.0/16.0;
- prolongation[2](34,33) = -5.0/16.0;
- prolongation[2](34,35) = 15.0/16.0;
- prolongation[2](35,0) = 1.0/256.0;
- prolongation[2](35,1) = 5.0/256.0;
- prolongation[2](35,2) = 25.0/256.0;
- prolongation[2](35,3) = 5.0/256.0;
- prolongation[2](35,8) = -5.0/256.0;
- prolongation[2](35,9) = 15.0/256.0;
- prolongation[2](35,10) = -25.0/256.0;
- prolongation[2](35,11) = 75.0/256.0;
- prolongation[2](35,12) = -25.0/256.0;
- prolongation[2](35,13) = 75.0/256.0;
- prolongation[2](35,14) = -5.0/256.0;
- prolongation[2](35,15) = 15.0/256.0;
- prolongation[2](35,32) = 25.0/256.0;
- prolongation[2](35,33) = -75.0/256.0;
- prolongation[2](35,34) = -75.0/256.0;
- prolongation[2](35,35) = 225.0/256.0;
- prolongation[2](36,35) = -1.0/16.0;
- prolongation[2](36,39) = -1.0/16.0;
- prolongation[2](36,61) = 9.0/16.0;
- prolongation[2](36,63) = 9.0/16.0;
- prolongation[2](37,11) = -5.0/256.0;
- prolongation[2](37,15) = -1.0/256.0;
- prolongation[2](37,19) = -5.0/256.0;
- prolongation[2](37,23) = -1.0/256.0;
- prolongation[2](37,34) = 5.0/256.0;
- prolongation[2](37,35) = -15.0/256.0;
- prolongation[2](37,38) = 5.0/256.0;
- prolongation[2](37,39) = -15.0/256.0;
- prolongation[2](37,46) = 45.0/256.0;
- prolongation[2](37,47) = 45.0/256.0;
- prolongation[2](37,54) = 9.0/256.0;
- prolongation[2](37,55) = 9.0/256.0;
- prolongation[2](37,60) = -45.0/256.0;
- prolongation[2](37,61) = 135.0/256.0;
- prolongation[2](37,62) = -45.0/256.0;
- prolongation[2](37,63) = 135.0/256.0;
- prolongation[2](38,9) = -1.0/256.0;
- prolongation[2](38,13) = -5.0/256.0;
- prolongation[2](38,17) = -1.0/256.0;
- prolongation[2](38,21) = -5.0/256.0;
- prolongation[2](38,33) = 5.0/256.0;
- prolongation[2](38,35) = -15.0/256.0;
- prolongation[2](38,37) = 5.0/256.0;
- prolongation[2](38,39) = -15.0/256.0;
- prolongation[2](38,41) = 9.0/256.0;
- prolongation[2](38,43) = 9.0/256.0;
- prolongation[2](38,49) = 45.0/256.0;
- prolongation[2](38,51) = 45.0/256.0;
- prolongation[2](38,57) = -45.0/256.0;
- prolongation[2](38,59) = -45.0/256.0;
- prolongation[2](38,61) = 135.0/256.0;
- prolongation[2](38,63) = 135.0/256.0;
- prolongation[2](39,0) = -1.0/4096.0;
- prolongation[2](39,1) = -5.0/4096.0;
- prolongation[2](39,2) = -25.0/4096.0;
- prolongation[2](39,3) = -5.0/4096.0;
- prolongation[2](39,4) = -1.0/4096.0;
- prolongation[2](39,5) = -5.0/4096.0;
- prolongation[2](39,6) = -25.0/4096.0;
- prolongation[2](39,7) = -5.0/4096.0;
- prolongation[2](39,8) = 5.0/4096.0;
- prolongation[2](39,9) = -15.0/4096.0;
- prolongation[2](39,10) = 25.0/4096.0;
- prolongation[2](39,11) = -75.0/4096.0;
- prolongation[2](39,12) = 25.0/4096.0;
- prolongation[2](39,13) = -75.0/4096.0;
- prolongation[2](39,14) = 5.0/4096.0;
- prolongation[2](39,15) = -15.0/4096.0;
- prolongation[2](39,16) = 5.0/4096.0;
- prolongation[2](39,17) = -15.0/4096.0;
- prolongation[2](39,18) = 25.0/4096.0;
- prolongation[2](39,19) = -75.0/4096.0;
- prolongation[2](39,20) = 25.0/4096.0;
- prolongation[2](39,21) = -75.0/4096.0;
- prolongation[2](39,22) = 5.0/4096.0;
- prolongation[2](39,23) = -15.0/4096.0;
- prolongation[2](39,24) = 9.0/4096.0;
- prolongation[2](39,25) = 9.0/4096.0;
- prolongation[2](39,26) = 45.0/4096.0;
- prolongation[2](39,27) = 45.0/4096.0;
- prolongation[2](39,28) = 225.0/4096.0;
- prolongation[2](39,29) = 225.0/4096.0;
- prolongation[2](39,30) = 45.0/4096.0;
- prolongation[2](39,31) = 45.0/4096.0;
- prolongation[2](39,32) = -25.0/4096.0;
- prolongation[2](39,33) = 75.0/4096.0;
- prolongation[2](39,34) = 75.0/4096.0;
- prolongation[2](39,35) = -225.0/4096.0;
- prolongation[2](39,36) = -25.0/4096.0;
- prolongation[2](39,37) = 75.0/4096.0;
- prolongation[2](39,38) = 75.0/4096.0;
- prolongation[2](39,39) = -225.0/4096.0;
- prolongation[2](39,40) = -45.0/4096.0;
- prolongation[2](39,41) = 135.0/4096.0;
- prolongation[2](39,42) = -45.0/4096.0;
- prolongation[2](39,43) = 135.0/4096.0;
- prolongation[2](39,44) = -225.0/4096.0;
- prolongation[2](39,45) = -225.0/4096.0;
- prolongation[2](39,46) = 675.0/4096.0;
- prolongation[2](39,47) = 675.0/4096.0;
- prolongation[2](39,48) = -225.0/4096.0;
- prolongation[2](39,49) = 675.0/4096.0;
- prolongation[2](39,50) = -225.0/4096.0;
- prolongation[2](39,51) = 675.0/4096.0;
- prolongation[2](39,52) = -45.0/4096.0;
- prolongation[2](39,53) = -45.0/4096.0;
- prolongation[2](39,54) = 135.0/4096.0;
- prolongation[2](39,55) = 135.0/4096.0;
- prolongation[2](39,56) = 225.0/4096.0;
- prolongation[2](39,57) = -675.0/4096.0;
- prolongation[2](39,58) = 225.0/4096.0;
- prolongation[2](39,59) = -675.0/4096.0;
- prolongation[2](39,60) = -675.0/4096.0;
- prolongation[2](39,61) = 2025.0/4096.0;
- prolongation[2](39,62) = -675.0/4096.0;
- prolongation[2](39,63) = 2025.0/4096.0;
- prolongation[2](40,9) = -5.0/256.0;
- prolongation[2](40,13) = -5.0/256.0;
- prolongation[2](40,17) = -1.0/256.0;
- prolongation[2](40,21) = -1.0/256.0;
- prolongation[2](40,33) = 45.0/256.0;
- prolongation[2](40,35) = 45.0/256.0;
- prolongation[2](40,37) = 9.0/256.0;
- prolongation[2](40,39) = 9.0/256.0;
- prolongation[2](40,41) = -15.0/256.0;
- prolongation[2](40,43) = 5.0/256.0;
- prolongation[2](40,49) = -15.0/256.0;
- prolongation[2](40,51) = 5.0/256.0;
- prolongation[2](40,57) = 135.0/256.0;
- prolongation[2](40,59) = -45.0/256.0;
- prolongation[2](40,61) = 135.0/256.0;
- prolongation[2](40,63) = -45.0/256.0;
- prolongation[2](41,0) = -5.0/4096.0;
- prolongation[2](41,1) = -25.0/4096.0;
- prolongation[2](41,2) = -25.0/4096.0;
- prolongation[2](41,3) = -5.0/4096.0;
- prolongation[2](41,4) = -1.0/4096.0;
- prolongation[2](41,5) = -5.0/4096.0;
- prolongation[2](41,6) = -5.0/4096.0;
- prolongation[2](41,7) = -1.0/4096.0;
- prolongation[2](41,8) = 25.0/4096.0;
- prolongation[2](41,9) = -75.0/4096.0;
- prolongation[2](41,10) = 225.0/4096.0;
- prolongation[2](41,11) = 225.0/4096.0;
- prolongation[2](41,12) = 25.0/4096.0;
- prolongation[2](41,13) = -75.0/4096.0;
- prolongation[2](41,14) = 45.0/4096.0;
- prolongation[2](41,15) = 45.0/4096.0;
- prolongation[2](41,16) = 5.0/4096.0;
- prolongation[2](41,17) = -15.0/4096.0;
- prolongation[2](41,18) = 45.0/4096.0;
- prolongation[2](41,19) = 45.0/4096.0;
- prolongation[2](41,20) = 5.0/4096.0;
- prolongation[2](41,21) = -15.0/4096.0;
- prolongation[2](41,22) = 9.0/4096.0;
- prolongation[2](41,23) = 9.0/4096.0;
- prolongation[2](41,24) = -15.0/4096.0;
- prolongation[2](41,25) = 5.0/4096.0;
- prolongation[2](41,26) = -75.0/4096.0;
- prolongation[2](41,27) = 25.0/4096.0;
- prolongation[2](41,28) = -75.0/4096.0;
- prolongation[2](41,29) = 25.0/4096.0;
- prolongation[2](41,30) = -15.0/4096.0;
- prolongation[2](41,31) = 5.0/4096.0;
- prolongation[2](41,32) = -225.0/4096.0;
- prolongation[2](41,33) = 675.0/4096.0;
- prolongation[2](41,34) = -225.0/4096.0;
- prolongation[2](41,35) = 675.0/4096.0;
- prolongation[2](41,36) = -45.0/4096.0;
- prolongation[2](41,37) = 135.0/4096.0;
- prolongation[2](41,38) = -45.0/4096.0;
- prolongation[2](41,39) = 135.0/4096.0;
- prolongation[2](41,40) = 75.0/4096.0;
- prolongation[2](41,41) = -225.0/4096.0;
- prolongation[2](41,42) = -25.0/4096.0;
- prolongation[2](41,43) = 75.0/4096.0;
- prolongation[2](41,44) = 675.0/4096.0;
- prolongation[2](41,45) = -225.0/4096.0;
- prolongation[2](41,46) = 675.0/4096.0;
- prolongation[2](41,47) = -225.0/4096.0;
- prolongation[2](41,48) = 75.0/4096.0;
- prolongation[2](41,49) = -225.0/4096.0;
- prolongation[2](41,50) = -25.0/4096.0;
- prolongation[2](41,51) = 75.0/4096.0;
- prolongation[2](41,52) = 135.0/4096.0;
- prolongation[2](41,53) = -45.0/4096.0;
- prolongation[2](41,54) = 135.0/4096.0;
- prolongation[2](41,55) = -45.0/4096.0;
- prolongation[2](41,56) = -675.0/4096.0;
- prolongation[2](41,57) = 2025.0/4096.0;
- prolongation[2](41,58) = 225.0/4096.0;
- prolongation[2](41,59) = -675.0/4096.0;
- prolongation[2](41,60) = -675.0/4096.0;
- prolongation[2](41,61) = 2025.0/4096.0;
- prolongation[2](41,62) = 225.0/4096.0;
- prolongation[2](41,63) = -675.0/4096.0;
- prolongation[2](42,41) = -1.0/16.0;
- prolongation[2](42,49) = -1.0/16.0;
- prolongation[2](42,57) = 9.0/16.0;
- prolongation[2](42,61) = 9.0/16.0;
- prolongation[2](43,24) = -1.0/256.0;
- prolongation[2](43,26) = -5.0/256.0;
- prolongation[2](43,28) = -5.0/256.0;
- prolongation[2](43,30) = -1.0/256.0;
- prolongation[2](43,40) = 5.0/256.0;
- prolongation[2](43,41) = -15.0/256.0;
- prolongation[2](43,44) = 45.0/256.0;
- prolongation[2](43,46) = 45.0/256.0;
- prolongation[2](43,48) = 5.0/256.0;
- prolongation[2](43,49) = -15.0/256.0;
- prolongation[2](43,52) = 9.0/256.0;
- prolongation[2](43,54) = 9.0/256.0;
- prolongation[2](43,56) = -45.0/256.0;
- prolongation[2](43,57) = 135.0/256.0;
- prolongation[2](43,60) = -45.0/256.0;
- prolongation[2](43,61) = 135.0/256.0;
- prolongation[2](44,11) = 5.0/16.0;
- prolongation[2](44,19) = 1.0/16.0;
- prolongation[2](44,46) = 15.0/16.0;
- prolongation[2](44,47) = -5.0/16.0;
- prolongation[2](45,46) = 1.0;
- prolongation[2](46,1) = 5.0/256.0;
- prolongation[2](46,2) = 25.0/256.0;
- prolongation[2](46,5) = 1.0/256.0;
- prolongation[2](46,6) = 5.0/256.0;
- prolongation[2](46,10) = -25.0/256.0;
- prolongation[2](46,11) = 75.0/256.0;
- prolongation[2](46,18) = -5.0/256.0;
- prolongation[2](46,19) = 15.0/256.0;
- prolongation[2](46,26) = 15.0/256.0;
- prolongation[2](46,27) = -5.0/256.0;
- prolongation[2](46,28) = 75.0/256.0;
- prolongation[2](46,29) = -25.0/256.0;
- prolongation[2](46,44) = -75.0/256.0;
- prolongation[2](46,45) = 25.0/256.0;
- prolongation[2](46,46) = 225.0/256.0;
- prolongation[2](46,47) = -75.0/256.0;
- prolongation[2](47,26) = 1.0/16.0;
- prolongation[2](47,28) = 5.0/16.0;
- prolongation[2](47,44) = -5.0/16.0;
- prolongation[2](47,46) = 15.0/16.0;
- prolongation[2](48,13) = 5.0/16.0;
- prolongation[2](48,21) = 1.0/16.0;
- prolongation[2](48,49) = 15.0/16.0;
- prolongation[2](48,51) = -5.0/16.0;
- prolongation[2](49,2) = 25.0/256.0;
- prolongation[2](49,3) = 5.0/256.0;
- prolongation[2](49,6) = 5.0/256.0;
- prolongation[2](49,7) = 1.0/256.0;
- prolongation[2](49,12) = -25.0/256.0;
- prolongation[2](49,13) = 75.0/256.0;
- prolongation[2](49,20) = -5.0/256.0;
- prolongation[2](49,21) = 15.0/256.0;
- prolongation[2](49,28) = 75.0/256.0;
- prolongation[2](49,29) = -25.0/256.0;
- prolongation[2](49,30) = 15.0/256.0;
- prolongation[2](49,31) = -5.0/256.0;
- prolongation[2](49,48) = -75.0/256.0;
- prolongation[2](49,49) = 225.0/256.0;
- prolongation[2](49,50) = 25.0/256.0;
- prolongation[2](49,51) = -75.0/256.0;
- prolongation[2](50,49) = 1.0;
- prolongation[2](51,28) = 5.0/16.0;
- prolongation[2](51,30) = 1.0/16.0;
- prolongation[2](51,48) = -5.0/16.0;
- prolongation[2](51,49) = 15.0/16.0;
- prolongation[2](52,11) = -5.0/256.0;
- prolongation[2](52,15) = -5.0/256.0;
- prolongation[2](52,19) = -1.0/256.0;
- prolongation[2](52,23) = -1.0/256.0;
- prolongation[2](52,34) = 45.0/256.0;
- prolongation[2](52,35) = 45.0/256.0;
- prolongation[2](52,38) = 9.0/256.0;
- prolongation[2](52,39) = 9.0/256.0;
- prolongation[2](52,46) = -15.0/256.0;
- prolongation[2](52,47) = 5.0/256.0;
- prolongation[2](52,54) = -15.0/256.0;
- prolongation[2](52,55) = 5.0/256.0;
- prolongation[2](52,60) = 135.0/256.0;
- prolongation[2](52,61) = 135.0/256.0;
- prolongation[2](52,62) = -45.0/256.0;
- prolongation[2](52,63) = -45.0/256.0;
- prolongation[2](53,46) = -1.0/16.0;
- prolongation[2](53,54) = -1.0/16.0;
- prolongation[2](53,60) = 9.0/16.0;
- prolongation[2](53,61) = 9.0/16.0;
- prolongation[2](54,0) = -5.0/4096.0;
- prolongation[2](54,1) = -5.0/4096.0;
- prolongation[2](54,2) = -25.0/4096.0;
- prolongation[2](54,3) = -25.0/4096.0;
- prolongation[2](54,4) = -1.0/4096.0;
- prolongation[2](54,5) = -1.0/4096.0;
- prolongation[2](54,6) = -5.0/4096.0;
- prolongation[2](54,7) = -5.0/4096.0;
- prolongation[2](54,8) = 45.0/4096.0;
- prolongation[2](54,9) = 45.0/4096.0;
- prolongation[2](54,10) = 25.0/4096.0;
- prolongation[2](54,11) = -75.0/4096.0;
- prolongation[2](54,12) = 225.0/4096.0;
- prolongation[2](54,13) = 225.0/4096.0;
- prolongation[2](54,14) = 25.0/4096.0;
- prolongation[2](54,15) = -75.0/4096.0;
- prolongation[2](54,16) = 9.0/4096.0;
- prolongation[2](54,17) = 9.0/4096.0;
- prolongation[2](54,18) = 5.0/4096.0;
- prolongation[2](54,19) = -15.0/4096.0;
- prolongation[2](54,20) = 45.0/4096.0;
- prolongation[2](54,21) = 45.0/4096.0;
- prolongation[2](54,22) = 5.0/4096.0;
- prolongation[2](54,23) = -15.0/4096.0;
- prolongation[2](54,24) = -15.0/4096.0;
- prolongation[2](54,25) = 5.0/4096.0;
- prolongation[2](54,26) = -15.0/4096.0;
- prolongation[2](54,27) = 5.0/4096.0;
- prolongation[2](54,28) = -75.0/4096.0;
- prolongation[2](54,29) = 25.0/4096.0;
- prolongation[2](54,30) = -75.0/4096.0;
- prolongation[2](54,31) = 25.0/4096.0;
- prolongation[2](54,32) = -225.0/4096.0;
- prolongation[2](54,33) = -225.0/4096.0;
- prolongation[2](54,34) = 675.0/4096.0;
- prolongation[2](54,35) = 675.0/4096.0;
- prolongation[2](54,36) = -45.0/4096.0;
- prolongation[2](54,37) = -45.0/4096.0;
- prolongation[2](54,38) = 135.0/4096.0;
- prolongation[2](54,39) = 135.0/4096.0;
- prolongation[2](54,40) = 135.0/4096.0;
- prolongation[2](54,41) = 135.0/4096.0;
- prolongation[2](54,42) = -45.0/4096.0;
- prolongation[2](54,43) = -45.0/4096.0;
- prolongation[2](54,44) = 75.0/4096.0;
- prolongation[2](54,45) = -25.0/4096.0;
- prolongation[2](54,46) = -225.0/4096.0;
- prolongation[2](54,47) = 75.0/4096.0;
- prolongation[2](54,48) = 675.0/4096.0;
- prolongation[2](54,49) = 675.0/4096.0;
- prolongation[2](54,50) = -225.0/4096.0;
- prolongation[2](54,51) = -225.0/4096.0;
- prolongation[2](54,52) = 75.0/4096.0;
- prolongation[2](54,53) = -25.0/4096.0;
- prolongation[2](54,54) = -225.0/4096.0;
- prolongation[2](54,55) = 75.0/4096.0;
- prolongation[2](54,56) = -675.0/4096.0;
- prolongation[2](54,57) = -675.0/4096.0;
- prolongation[2](54,58) = 225.0/4096.0;
- prolongation[2](54,59) = 225.0/4096.0;
- prolongation[2](54,60) = 2025.0/4096.0;
- prolongation[2](54,61) = 2025.0/4096.0;
- prolongation[2](54,62) = -675.0/4096.0;
- prolongation[2](54,63) = -675.0/4096.0;
- prolongation[2](55,24) = -1.0/256.0;
- prolongation[2](55,26) = -1.0/256.0;
- prolongation[2](55,28) = -5.0/256.0;
- prolongation[2](55,30) = -5.0/256.0;
- prolongation[2](55,40) = 9.0/256.0;
- prolongation[2](55,41) = 9.0/256.0;
- prolongation[2](55,44) = 5.0/256.0;
- prolongation[2](55,46) = -15.0/256.0;
- prolongation[2](55,48) = 45.0/256.0;
- prolongation[2](55,49) = 45.0/256.0;
- prolongation[2](55,52) = 5.0/256.0;
- prolongation[2](55,54) = -15.0/256.0;
- prolongation[2](55,56) = -45.0/256.0;
- prolongation[2](55,57) = -45.0/256.0;
- prolongation[2](55,60) = 135.0/256.0;
- prolongation[2](55,61) = 135.0/256.0;
- prolongation[2](56,35) = 5.0/16.0;
- prolongation[2](56,39) = 1.0/16.0;
- prolongation[2](56,61) = 15.0/16.0;
- prolongation[2](56,63) = -5.0/16.0;
- prolongation[2](57,11) = 25.0/256.0;
- prolongation[2](57,15) = 5.0/256.0;
- prolongation[2](57,19) = 5.0/256.0;
- prolongation[2](57,23) = 1.0/256.0;
- prolongation[2](57,34) = -25.0/256.0;
- prolongation[2](57,35) = 75.0/256.0;
- prolongation[2](57,38) = -5.0/256.0;
- prolongation[2](57,39) = 15.0/256.0;
- prolongation[2](57,46) = 75.0/256.0;
- prolongation[2](57,47) = -25.0/256.0;
- prolongation[2](57,54) = 15.0/256.0;
- prolongation[2](57,55) = -5.0/256.0;
- prolongation[2](57,60) = -75.0/256.0;
- prolongation[2](57,61) = 225.0/256.0;
- prolongation[2](57,62) = 25.0/256.0;
- prolongation[2](57,63) = -75.0/256.0;
- prolongation[2](58,61) = 1.0;
- prolongation[2](59,46) = 5.0/16.0;
- prolongation[2](59,54) = 1.0/16.0;
- prolongation[2](59,60) = -5.0/16.0;
- prolongation[2](59,61) = 15.0/16.0;
- prolongation[2](60,9) = 5.0/256.0;
- prolongation[2](60,13) = 25.0/256.0;
- prolongation[2](60,17) = 1.0/256.0;
- prolongation[2](60,21) = 5.0/256.0;
- prolongation[2](60,33) = -25.0/256.0;
- prolongation[2](60,35) = 75.0/256.0;
- prolongation[2](60,37) = -5.0/256.0;
- prolongation[2](60,39) = 15.0/256.0;
- prolongation[2](60,41) = 15.0/256.0;
- prolongation[2](60,43) = -5.0/256.0;
- prolongation[2](60,49) = 75.0/256.0;
- prolongation[2](60,51) = -25.0/256.0;
- prolongation[2](60,57) = -75.0/256.0;
- prolongation[2](60,59) = 25.0/256.0;
- prolongation[2](60,61) = 225.0/256.0;
- prolongation[2](60,63) = -75.0/256.0;
- prolongation[2](61,0) = 5.0/4096.0;
- prolongation[2](61,1) = 25.0/4096.0;
- prolongation[2](61,2) = 125.0/4096.0;
- prolongation[2](61,3) = 25.0/4096.0;
- prolongation[2](61,4) = 1.0/4096.0;
- prolongation[2](61,5) = 5.0/4096.0;
- prolongation[2](61,6) = 25.0/4096.0;
- prolongation[2](61,7) = 5.0/4096.0;
- prolongation[2](61,8) = -25.0/4096.0;
- prolongation[2](61,9) = 75.0/4096.0;
- prolongation[2](61,10) = -125.0/4096.0;
- prolongation[2](61,11) = 375.0/4096.0;
- prolongation[2](61,12) = -125.0/4096.0;
- prolongation[2](61,13) = 375.0/4096.0;
- prolongation[2](61,14) = -25.0/4096.0;
- prolongation[2](61,15) = 75.0/4096.0;
- prolongation[2](61,16) = -5.0/4096.0;
- prolongation[2](61,17) = 15.0/4096.0;
- prolongation[2](61,18) = -25.0/4096.0;
- prolongation[2](61,19) = 75.0/4096.0;
- prolongation[2](61,20) = -25.0/4096.0;
- prolongation[2](61,21) = 75.0/4096.0;
- prolongation[2](61,22) = -5.0/4096.0;
- prolongation[2](61,23) = 15.0/4096.0;
- prolongation[2](61,24) = 15.0/4096.0;
- prolongation[2](61,25) = -5.0/4096.0;
- prolongation[2](61,26) = 75.0/4096.0;
- prolongation[2](61,27) = -25.0/4096.0;
- prolongation[2](61,28) = 375.0/4096.0;
- prolongation[2](61,29) = -125.0/4096.0;
- prolongation[2](61,30) = 75.0/4096.0;
- prolongation[2](61,31) = -25.0/4096.0;
- prolongation[2](61,32) = 125.0/4096.0;
- prolongation[2](61,33) = -375.0/4096.0;
- prolongation[2](61,34) = -375.0/4096.0;
- prolongation[2](61,35) = 1125.0/4096.0;
- prolongation[2](61,36) = 25.0/4096.0;
- prolongation[2](61,37) = -75.0/4096.0;
- prolongation[2](61,38) = -75.0/4096.0;
- prolongation[2](61,39) = 225.0/4096.0;
- prolongation[2](61,40) = -75.0/4096.0;
- prolongation[2](61,41) = 225.0/4096.0;
- prolongation[2](61,42) = 25.0/4096.0;
- prolongation[2](61,43) = -75.0/4096.0;
- prolongation[2](61,44) = -375.0/4096.0;
- prolongation[2](61,45) = 125.0/4096.0;
- prolongation[2](61,46) = 1125.0/4096.0;
- prolongation[2](61,47) = -375.0/4096.0;
- prolongation[2](61,48) = -375.0/4096.0;
- prolongation[2](61,49) = 1125.0/4096.0;
- prolongation[2](61,50) = 125.0/4096.0;
- prolongation[2](61,51) = -375.0/4096.0;
- prolongation[2](61,52) = -75.0/4096.0;
- prolongation[2](61,53) = 25.0/4096.0;
- prolongation[2](61,54) = 225.0/4096.0;
- prolongation[2](61,55) = -75.0/4096.0;
- prolongation[2](61,56) = 375.0/4096.0;
- prolongation[2](61,57) = -1125.0/4096.0;
- prolongation[2](61,58) = -125.0/4096.0;
- prolongation[2](61,59) = 375.0/4096.0;
- prolongation[2](61,60) = -1125.0/4096.0;
- prolongation[2](61,61) = 3375.0/4096.0;
- prolongation[2](61,62) = 375.0/4096.0;
- prolongation[2](61,63) = -1125.0/4096.0;
- prolongation[2](62,41) = 1.0/16.0;
- prolongation[2](62,49) = 5.0/16.0;
- prolongation[2](62,57) = -5.0/16.0;
- prolongation[2](62,61) = 15.0/16.0;
- prolongation[2](63,24) = 1.0/256.0;
- prolongation[2](63,26) = 5.0/256.0;
- prolongation[2](63,28) = 25.0/256.0;
- prolongation[2](63,30) = 5.0/256.0;
- prolongation[2](63,40) = -5.0/256.0;
- prolongation[2](63,41) = 15.0/256.0;
- prolongation[2](63,44) = -25.0/256.0;
- prolongation[2](63,46) = 75.0/256.0;
- prolongation[2](63,48) = -25.0/256.0;
- prolongation[2](63,49) = 75.0/256.0;
- prolongation[2](63,52) = -5.0/256.0;
- prolongation[2](63,54) = 15.0/256.0;
- prolongation[2](63,56) = 25.0/256.0;
- prolongation[2](63,57) = -75.0/256.0;
- prolongation[2](63,60) = -75.0/256.0;
- prolongation[2](63,61) = 225.0/256.0;
- prolongation[3](0,0) = -1.0/16.0;
- prolongation[3](0,3) = -1.0/16.0;
- prolongation[3](0,14) = 9.0/16.0;
- prolongation[3](0,15) = 9.0/16.0;
- prolongation[3](1,0) = 1.0/256.0;
- prolongation[3](1,1) = 1.0/256.0;
- prolongation[3](1,2) = 1.0/256.0;
- prolongation[3](1,3) = 1.0/256.0;
- prolongation[3](1,8) = -9.0/256.0;
- prolongation[3](1,9) = -9.0/256.0;
- prolongation[3](1,10) = -9.0/256.0;
- prolongation[3](1,11) = -9.0/256.0;
- prolongation[3](1,12) = -9.0/256.0;
- prolongation[3](1,13) = -9.0/256.0;
- prolongation[3](1,14) = -9.0/256.0;
- prolongation[3](1,15) = -9.0/256.0;
- prolongation[3](1,32) = 81.0/256.0;
- prolongation[3](1,33) = 81.0/256.0;
- prolongation[3](1,34) = 81.0/256.0;
- prolongation[3](1,35) = 81.0/256.0;
- prolongation[3](2,2) = -1.0/16.0;
- prolongation[3](2,3) = -1.0/16.0;
- prolongation[3](2,12) = 9.0/16.0;
- prolongation[3](2,13) = 9.0/16.0;
- prolongation[3](3,3) = 1.0;
- prolongation[3](4,0) = 1.0/256.0;
- prolongation[3](4,3) = 1.0/256.0;
- prolongation[3](4,4) = 1.0/256.0;
- prolongation[3](4,7) = 1.0/256.0;
- prolongation[3](4,14) = -9.0/256.0;
- prolongation[3](4,15) = -9.0/256.0;
- prolongation[3](4,22) = -9.0/256.0;
- prolongation[3](4,23) = -9.0/256.0;
- prolongation[3](4,24) = -9.0/256.0;
- prolongation[3](4,25) = -9.0/256.0;
- prolongation[3](4,30) = -9.0/256.0;
- prolongation[3](4,31) = -9.0/256.0;
- prolongation[3](4,52) = 81.0/256.0;
- prolongation[3](4,53) = 81.0/256.0;
- prolongation[3](4,54) = 81.0/256.0;
- prolongation[3](4,55) = 81.0/256.0;
- prolongation[3](5,0) = -1.0/4096.0;
- prolongation[3](5,1) = -1.0/4096.0;
- prolongation[3](5,2) = -1.0/4096.0;
- prolongation[3](5,3) = -1.0/4096.0;
- prolongation[3](5,4) = -1.0/4096.0;
- prolongation[3](5,5) = -1.0/4096.0;
- prolongation[3](5,6) = -1.0/4096.0;
- prolongation[3](5,7) = -1.0/4096.0;
- prolongation[3](5,8) = 9.0/4096.0;
- prolongation[3](5,9) = 9.0/4096.0;
- prolongation[3](5,10) = 9.0/4096.0;
- prolongation[3](5,11) = 9.0/4096.0;
- prolongation[3](5,12) = 9.0/4096.0;
- prolongation[3](5,13) = 9.0/4096.0;
- prolongation[3](5,14) = 9.0/4096.0;
- prolongation[3](5,15) = 9.0/4096.0;
- prolongation[3](5,16) = 9.0/4096.0;
- prolongation[3](5,17) = 9.0/4096.0;
- prolongation[3](5,18) = 9.0/4096.0;
- prolongation[3](5,19) = 9.0/4096.0;
- prolongation[3](5,20) = 9.0/4096.0;
- prolongation[3](5,21) = 9.0/4096.0;
- prolongation[3](5,22) = 9.0/4096.0;
- prolongation[3](5,23) = 9.0/4096.0;
- prolongation[3](5,24) = 9.0/4096.0;
- prolongation[3](5,25) = 9.0/4096.0;
- prolongation[3](5,26) = 9.0/4096.0;
- prolongation[3](5,27) = 9.0/4096.0;
- prolongation[3](5,28) = 9.0/4096.0;
- prolongation[3](5,29) = 9.0/4096.0;
- prolongation[3](5,30) = 9.0/4096.0;
- prolongation[3](5,31) = 9.0/4096.0;
- prolongation[3](5,32) = -81.0/4096.0;
- prolongation[3](5,33) = -81.0/4096.0;
- prolongation[3](5,34) = -81.0/4096.0;
- prolongation[3](5,35) = -81.0/4096.0;
- prolongation[3](5,36) = -81.0/4096.0;
- prolongation[3](5,37) = -81.0/4096.0;
- prolongation[3](5,38) = -81.0/4096.0;
- prolongation[3](5,39) = -81.0/4096.0;
- prolongation[3](5,40) = -81.0/4096.0;
- prolongation[3](5,41) = -81.0/4096.0;
- prolongation[3](5,42) = -81.0/4096.0;
- prolongation[3](5,43) = -81.0/4096.0;
- prolongation[3](5,44) = -81.0/4096.0;
- prolongation[3](5,45) = -81.0/4096.0;
- prolongation[3](5,46) = -81.0/4096.0;
- prolongation[3](5,47) = -81.0/4096.0;
- prolongation[3](5,48) = -81.0/4096.0;
- prolongation[3](5,49) = -81.0/4096.0;
- prolongation[3](5,50) = -81.0/4096.0;
- prolongation[3](5,51) = -81.0/4096.0;
- prolongation[3](5,52) = -81.0/4096.0;
- prolongation[3](5,53) = -81.0/4096.0;
- prolongation[3](5,54) = -81.0/4096.0;
- prolongation[3](5,55) = -81.0/4096.0;
- prolongation[3](5,56) = 729.0/4096.0;
- prolongation[3](5,57) = 729.0/4096.0;
- prolongation[3](5,58) = 729.0/4096.0;
- prolongation[3](5,59) = 729.0/4096.0;
- prolongation[3](5,60) = 729.0/4096.0;
- prolongation[3](5,61) = 729.0/4096.0;
- prolongation[3](5,62) = 729.0/4096.0;
- prolongation[3](5,63) = 729.0/4096.0;
- prolongation[3](6,2) = 1.0/256.0;
- prolongation[3](6,3) = 1.0/256.0;
- prolongation[3](6,6) = 1.0/256.0;
- prolongation[3](6,7) = 1.0/256.0;
- prolongation[3](6,12) = -9.0/256.0;
- prolongation[3](6,13) = -9.0/256.0;
- prolongation[3](6,20) = -9.0/256.0;
- prolongation[3](6,21) = -9.0/256.0;
- prolongation[3](6,28) = -9.0/256.0;
- prolongation[3](6,29) = -9.0/256.0;
- prolongation[3](6,30) = -9.0/256.0;
- prolongation[3](6,31) = -9.0/256.0;
- prolongation[3](6,48) = 81.0/256.0;
- prolongation[3](6,49) = 81.0/256.0;
- prolongation[3](6,50) = 81.0/256.0;
- prolongation[3](6,51) = 81.0/256.0;
- prolongation[3](7,3) = -1.0/16.0;
- prolongation[3](7,7) = -1.0/16.0;
- prolongation[3](7,30) = 9.0/16.0;
- prolongation[3](7,31) = 9.0/16.0;
- prolongation[3](8,0) = -5.0/256.0;
- prolongation[3](8,1) = -1.0/256.0;
- prolongation[3](8,2) = -1.0/256.0;
- prolongation[3](8,3) = -5.0/256.0;
- prolongation[3](8,8) = -15.0/256.0;
- prolongation[3](8,9) = 5.0/256.0;
- prolongation[3](8,10) = 9.0/256.0;
- prolongation[3](8,11) = 9.0/256.0;
- prolongation[3](8,12) = -15.0/256.0;
- prolongation[3](8,13) = 5.0/256.0;
- prolongation[3](8,14) = 45.0/256.0;
- prolongation[3](8,15) = 45.0/256.0;
- prolongation[3](8,32) = 135.0/256.0;
- prolongation[3](8,33) = -45.0/256.0;
- prolongation[3](8,34) = 135.0/256.0;
- prolongation[3](8,35) = -45.0/256.0;
- prolongation[3](9,8) = -1.0/16.0;
- prolongation[3](9,12) = -1.0/16.0;
- prolongation[3](9,32) = 9.0/16.0;
- prolongation[3](9,34) = 9.0/16.0;
- prolongation[3](10,11) = -1.0/16.0;
- prolongation[3](10,15) = -1.0/16.0;
- prolongation[3](10,34) = 9.0/16.0;
- prolongation[3](10,35) = 9.0/16.0;
- prolongation[3](11,0) = -1.0/256.0;
- prolongation[3](11,1) = -1.0/256.0;
- prolongation[3](11,2) = -5.0/256.0;
- prolongation[3](11,3) = -5.0/256.0;
- prolongation[3](11,8) = 9.0/256.0;
- prolongation[3](11,9) = 9.0/256.0;
- prolongation[3](11,10) = 5.0/256.0;
- prolongation[3](11,11) = -15.0/256.0;
- prolongation[3](11,12) = 45.0/256.0;
- prolongation[3](11,13) = 45.0/256.0;
- prolongation[3](11,14) = 5.0/256.0;
- prolongation[3](11,15) = -15.0/256.0;
- prolongation[3](11,32) = -45.0/256.0;
- prolongation[3](11,33) = -45.0/256.0;
- prolongation[3](11,34) = 135.0/256.0;
- prolongation[3](11,35) = 135.0/256.0;
- prolongation[3](12,2) = 1.0/16.0;
- prolongation[3](12,3) = 5.0/16.0;
- prolongation[3](12,12) = 15.0/16.0;
- prolongation[3](12,13) = -5.0/16.0;
- prolongation[3](13,12) = 1.0;
- prolongation[3](14,15) = 1.0;
- prolongation[3](15,0) = 1.0/16.0;
- prolongation[3](15,3) = 5.0/16.0;
- prolongation[3](15,14) = -5.0/16.0;
- prolongation[3](15,15) = 15.0/16.0;
- prolongation[3](16,0) = 5.0/4096.0;
- prolongation[3](16,1) = 1.0/4096.0;
- prolongation[3](16,2) = 1.0/4096.0;
- prolongation[3](16,3) = 5.0/4096.0;
- prolongation[3](16,4) = 5.0/4096.0;
- prolongation[3](16,5) = 1.0/4096.0;
- prolongation[3](16,6) = 1.0/4096.0;
- prolongation[3](16,7) = 5.0/4096.0;
- prolongation[3](16,8) = 15.0/4096.0;
- prolongation[3](16,9) = -5.0/4096.0;
- prolongation[3](16,10) = -9.0/4096.0;
- prolongation[3](16,11) = -9.0/4096.0;
- prolongation[3](16,12) = 15.0/4096.0;
- prolongation[3](16,13) = -5.0/4096.0;
- prolongation[3](16,14) = -45.0/4096.0;
- prolongation[3](16,15) = -45.0/4096.0;
- prolongation[3](16,16) = 15.0/4096.0;
- prolongation[3](16,17) = -5.0/4096.0;
- prolongation[3](16,18) = -9.0/4096.0;
- prolongation[3](16,19) = -9.0/4096.0;
- prolongation[3](16,20) = 15.0/4096.0;
- prolongation[3](16,21) = -5.0/4096.0;
- prolongation[3](16,22) = -45.0/4096.0;
- prolongation[3](16,23) = -45.0/4096.0;
- prolongation[3](16,24) = -45.0/4096.0;
- prolongation[3](16,25) = -45.0/4096.0;
- prolongation[3](16,26) = -9.0/4096.0;
- prolongation[3](16,27) = -9.0/4096.0;
- prolongation[3](16,28) = -9.0/4096.0;
- prolongation[3](16,29) = -9.0/4096.0;
- prolongation[3](16,30) = -45.0/4096.0;
- prolongation[3](16,31) = -45.0/4096.0;
- prolongation[3](16,32) = -135.0/4096.0;
- prolongation[3](16,33) = 45.0/4096.0;
- prolongation[3](16,34) = -135.0/4096.0;
- prolongation[3](16,35) = 45.0/4096.0;
- prolongation[3](16,36) = -135.0/4096.0;
- prolongation[3](16,37) = 45.0/4096.0;
- prolongation[3](16,38) = -135.0/4096.0;
- prolongation[3](16,39) = 45.0/4096.0;
- prolongation[3](16,40) = -135.0/4096.0;
- prolongation[3](16,41) = 45.0/4096.0;
- prolongation[3](16,42) = -135.0/4096.0;
- prolongation[3](16,43) = 45.0/4096.0;
- prolongation[3](16,44) = 81.0/4096.0;
- prolongation[3](16,45) = 81.0/4096.0;
- prolongation[3](16,46) = 81.0/4096.0;
- prolongation[3](16,47) = 81.0/4096.0;
- prolongation[3](16,48) = -135.0/4096.0;
- prolongation[3](16,49) = 45.0/4096.0;
- prolongation[3](16,50) = -135.0/4096.0;
- prolongation[3](16,51) = 45.0/4096.0;
- prolongation[3](16,52) = 405.0/4096.0;
- prolongation[3](16,53) = 405.0/4096.0;
- prolongation[3](16,54) = 405.0/4096.0;
- prolongation[3](16,55) = 405.0/4096.0;
- prolongation[3](16,56) = 1215.0/4096.0;
- prolongation[3](16,57) = -405.0/4096.0;
- prolongation[3](16,58) = 1215.0/4096.0;
- prolongation[3](16,59) = -405.0/4096.0;
- prolongation[3](16,60) = 1215.0/4096.0;
- prolongation[3](16,61) = -405.0/4096.0;
- prolongation[3](16,62) = 1215.0/4096.0;
- prolongation[3](16,63) = -405.0/4096.0;
- prolongation[3](17,8) = 1.0/256.0;
- prolongation[3](17,12) = 1.0/256.0;
- prolongation[3](17,16) = 1.0/256.0;
- prolongation[3](17,20) = 1.0/256.0;
- prolongation[3](17,32) = -9.0/256.0;
- prolongation[3](17,34) = -9.0/256.0;
- prolongation[3](17,36) = -9.0/256.0;
- prolongation[3](17,38) = -9.0/256.0;
- prolongation[3](17,40) = -9.0/256.0;
- prolongation[3](17,42) = -9.0/256.0;
- prolongation[3](17,48) = -9.0/256.0;
- prolongation[3](17,50) = -9.0/256.0;
- prolongation[3](17,56) = 81.0/256.0;
- prolongation[3](17,58) = 81.0/256.0;
- prolongation[3](17,60) = 81.0/256.0;
- prolongation[3](17,62) = 81.0/256.0;
- prolongation[3](18,11) = 1.0/256.0;
- prolongation[3](18,15) = 1.0/256.0;
- prolongation[3](18,19) = 1.0/256.0;
- prolongation[3](18,23) = 1.0/256.0;
- prolongation[3](18,34) = -9.0/256.0;
- prolongation[3](18,35) = -9.0/256.0;
- prolongation[3](18,38) = -9.0/256.0;
- prolongation[3](18,39) = -9.0/256.0;
- prolongation[3](18,46) = -9.0/256.0;
- prolongation[3](18,47) = -9.0/256.0;
- prolongation[3](18,54) = -9.0/256.0;
- prolongation[3](18,55) = -9.0/256.0;
- prolongation[3](18,60) = 81.0/256.0;
- prolongation[3](18,61) = 81.0/256.0;
- prolongation[3](18,62) = 81.0/256.0;
- prolongation[3](18,63) = 81.0/256.0;
- prolongation[3](19,0) = 1.0/4096.0;
- prolongation[3](19,1) = 1.0/4096.0;
- prolongation[3](19,2) = 5.0/4096.0;
- prolongation[3](19,3) = 5.0/4096.0;
- prolongation[3](19,4) = 1.0/4096.0;
- prolongation[3](19,5) = 1.0/4096.0;
- prolongation[3](19,6) = 5.0/4096.0;
- prolongation[3](19,7) = 5.0/4096.0;
- prolongation[3](19,8) = -9.0/4096.0;
- prolongation[3](19,9) = -9.0/4096.0;
- prolongation[3](19,10) = -5.0/4096.0;
- prolongation[3](19,11) = 15.0/4096.0;
- prolongation[3](19,12) = -45.0/4096.0;
- prolongation[3](19,13) = -45.0/4096.0;
- prolongation[3](19,14) = -5.0/4096.0;
- prolongation[3](19,15) = 15.0/4096.0;
- prolongation[3](19,16) = -9.0/4096.0;
- prolongation[3](19,17) = -9.0/4096.0;
- prolongation[3](19,18) = -5.0/4096.0;
- prolongation[3](19,19) = 15.0/4096.0;
- prolongation[3](19,20) = -45.0/4096.0;
- prolongation[3](19,21) = -45.0/4096.0;
- prolongation[3](19,22) = -5.0/4096.0;
- prolongation[3](19,23) = 15.0/4096.0;
- prolongation[3](19,24) = -9.0/4096.0;
- prolongation[3](19,25) = -9.0/4096.0;
- prolongation[3](19,26) = -9.0/4096.0;
- prolongation[3](19,27) = -9.0/4096.0;
- prolongation[3](19,28) = -45.0/4096.0;
- prolongation[3](19,29) = -45.0/4096.0;
- prolongation[3](19,30) = -45.0/4096.0;
- prolongation[3](19,31) = -45.0/4096.0;
- prolongation[3](19,32) = 45.0/4096.0;
- prolongation[3](19,33) = 45.0/4096.0;
- prolongation[3](19,34) = -135.0/4096.0;
- prolongation[3](19,35) = -135.0/4096.0;
- prolongation[3](19,36) = 45.0/4096.0;
- prolongation[3](19,37) = 45.0/4096.0;
- prolongation[3](19,38) = -135.0/4096.0;
- prolongation[3](19,39) = -135.0/4096.0;
- prolongation[3](19,40) = 81.0/4096.0;
- prolongation[3](19,41) = 81.0/4096.0;
- prolongation[3](19,42) = 81.0/4096.0;
- prolongation[3](19,43) = 81.0/4096.0;
- prolongation[3](19,44) = 45.0/4096.0;
- prolongation[3](19,45) = 45.0/4096.0;
- prolongation[3](19,46) = -135.0/4096.0;
- prolongation[3](19,47) = -135.0/4096.0;
- prolongation[3](19,48) = 405.0/4096.0;
- prolongation[3](19,49) = 405.0/4096.0;
- prolongation[3](19,50) = 405.0/4096.0;
- prolongation[3](19,51) = 405.0/4096.0;
- prolongation[3](19,52) = 45.0/4096.0;
- prolongation[3](19,53) = 45.0/4096.0;
- prolongation[3](19,54) = -135.0/4096.0;
- prolongation[3](19,55) = -135.0/4096.0;
- prolongation[3](19,56) = -405.0/4096.0;
- prolongation[3](19,57) = -405.0/4096.0;
- prolongation[3](19,58) = -405.0/4096.0;
- prolongation[3](19,59) = -405.0/4096.0;
- prolongation[3](19,60) = 1215.0/4096.0;
- prolongation[3](19,61) = 1215.0/4096.0;
- prolongation[3](19,62) = 1215.0/4096.0;
- prolongation[3](19,63) = 1215.0/4096.0;
- prolongation[3](20,2) = -1.0/256.0;
- prolongation[3](20,3) = -5.0/256.0;
- prolongation[3](20,6) = -1.0/256.0;
- prolongation[3](20,7) = -5.0/256.0;
- prolongation[3](20,12) = -15.0/256.0;
- prolongation[3](20,13) = 5.0/256.0;
- prolongation[3](20,20) = -15.0/256.0;
- prolongation[3](20,21) = 5.0/256.0;
- prolongation[3](20,28) = 9.0/256.0;
- prolongation[3](20,29) = 9.0/256.0;
- prolongation[3](20,30) = 45.0/256.0;
- prolongation[3](20,31) = 45.0/256.0;
- prolongation[3](20,48) = 135.0/256.0;
- prolongation[3](20,49) = -45.0/256.0;
- prolongation[3](20,50) = 135.0/256.0;
- prolongation[3](20,51) = -45.0/256.0;
- prolongation[3](21,12) = -1.0/16.0;
- prolongation[3](21,20) = -1.0/16.0;
- prolongation[3](21,48) = 9.0/16.0;
- prolongation[3](21,50) = 9.0/16.0;
- prolongation[3](22,15) = -1.0/16.0;
- prolongation[3](22,23) = -1.0/16.0;
- prolongation[3](22,54) = 9.0/16.0;
- prolongation[3](22,55) = 9.0/16.0;
- prolongation[3](23,0) = -1.0/256.0;
- prolongation[3](23,3) = -5.0/256.0;
- prolongation[3](23,4) = -1.0/256.0;
- prolongation[3](23,7) = -5.0/256.0;
- prolongation[3](23,14) = 5.0/256.0;
- prolongation[3](23,15) = -15.0/256.0;
- prolongation[3](23,22) = 5.0/256.0;
- prolongation[3](23,23) = -15.0/256.0;
- prolongation[3](23,24) = 9.0/256.0;
- prolongation[3](23,25) = 9.0/256.0;
- prolongation[3](23,30) = 45.0/256.0;
- prolongation[3](23,31) = 45.0/256.0;
- prolongation[3](23,52) = -45.0/256.0;
- prolongation[3](23,53) = -45.0/256.0;
- prolongation[3](23,54) = 135.0/256.0;
- prolongation[3](23,55) = 135.0/256.0;
- prolongation[3](24,0) = -5.0/256.0;
- prolongation[3](24,3) = -5.0/256.0;
- prolongation[3](24,4) = -1.0/256.0;
- prolongation[3](24,7) = -1.0/256.0;
- prolongation[3](24,14) = 45.0/256.0;
- prolongation[3](24,15) = 45.0/256.0;
- prolongation[3](24,22) = 9.0/256.0;
- prolongation[3](24,23) = 9.0/256.0;
- prolongation[3](24,24) = -15.0/256.0;
- prolongation[3](24,25) = 5.0/256.0;
- prolongation[3](24,30) = -15.0/256.0;
- prolongation[3](24,31) = 5.0/256.0;
- prolongation[3](24,52) = 135.0/256.0;
- prolongation[3](24,53) = -45.0/256.0;
- prolongation[3](24,54) = 135.0/256.0;
- prolongation[3](24,55) = -45.0/256.0;
- prolongation[3](25,24) = -1.0/16.0;
- prolongation[3](25,30) = -1.0/16.0;
- prolongation[3](25,52) = 9.0/16.0;
- prolongation[3](25,54) = 9.0/16.0;
- prolongation[3](26,0) = 5.0/4096.0;
- prolongation[3](26,1) = 5.0/4096.0;
- prolongation[3](26,2) = 5.0/4096.0;
- prolongation[3](26,3) = 5.0/4096.0;
- prolongation[3](26,4) = 1.0/4096.0;
- prolongation[3](26,5) = 1.0/4096.0;
- prolongation[3](26,6) = 1.0/4096.0;
- prolongation[3](26,7) = 1.0/4096.0;
- prolongation[3](26,8) = -45.0/4096.0;
- prolongation[3](26,9) = -45.0/4096.0;
- prolongation[3](26,10) = -45.0/4096.0;
- prolongation[3](26,11) = -45.0/4096.0;
- prolongation[3](26,12) = -45.0/4096.0;
- prolongation[3](26,13) = -45.0/4096.0;
- prolongation[3](26,14) = -45.0/4096.0;
- prolongation[3](26,15) = -45.0/4096.0;
- prolongation[3](26,16) = -9.0/4096.0;
- prolongation[3](26,17) = -9.0/4096.0;
- prolongation[3](26,18) = -9.0/4096.0;
- prolongation[3](26,19) = -9.0/4096.0;
- prolongation[3](26,20) = -9.0/4096.0;
- prolongation[3](26,21) = -9.0/4096.0;
- prolongation[3](26,22) = -9.0/4096.0;
- prolongation[3](26,23) = -9.0/4096.0;
- prolongation[3](26,24) = 15.0/4096.0;
- prolongation[3](26,25) = -5.0/4096.0;
- prolongation[3](26,26) = 15.0/4096.0;
- prolongation[3](26,27) = -5.0/4096.0;
- prolongation[3](26,28) = 15.0/4096.0;
- prolongation[3](26,29) = -5.0/4096.0;
- prolongation[3](26,30) = 15.0/4096.0;
- prolongation[3](26,31) = -5.0/4096.0;
- prolongation[3](26,32) = 405.0/4096.0;
- prolongation[3](26,33) = 405.0/4096.0;
- prolongation[3](26,34) = 405.0/4096.0;
- prolongation[3](26,35) = 405.0/4096.0;
- prolongation[3](26,36) = 81.0/4096.0;
- prolongation[3](26,37) = 81.0/4096.0;
- prolongation[3](26,38) = 81.0/4096.0;
- prolongation[3](26,39) = 81.0/4096.0;
- prolongation[3](26,40) = -135.0/4096.0;
- prolongation[3](26,41) = -135.0/4096.0;
- prolongation[3](26,42) = 45.0/4096.0;
- prolongation[3](26,43) = 45.0/4096.0;
- prolongation[3](26,44) = -135.0/4096.0;
- prolongation[3](26,45) = 45.0/4096.0;
- prolongation[3](26,46) = -135.0/4096.0;
- prolongation[3](26,47) = 45.0/4096.0;
- prolongation[3](26,48) = -135.0/4096.0;
- prolongation[3](26,49) = -135.0/4096.0;
- prolongation[3](26,50) = 45.0/4096.0;
- prolongation[3](26,51) = 45.0/4096.0;
- prolongation[3](26,52) = -135.0/4096.0;
- prolongation[3](26,53) = 45.0/4096.0;
- prolongation[3](26,54) = -135.0/4096.0;
- prolongation[3](26,55) = 45.0/4096.0;
- prolongation[3](26,56) = 1215.0/4096.0;
- prolongation[3](26,57) = 1215.0/4096.0;
- prolongation[3](26,58) = -405.0/4096.0;
- prolongation[3](26,59) = -405.0/4096.0;
- prolongation[3](26,60) = 1215.0/4096.0;
- prolongation[3](26,61) = 1215.0/4096.0;
- prolongation[3](26,62) = -405.0/4096.0;
- prolongation[3](26,63) = -405.0/4096.0;
- prolongation[3](27,24) = 1.0/256.0;
- prolongation[3](27,26) = 1.0/256.0;
- prolongation[3](27,28) = 1.0/256.0;
- prolongation[3](27,30) = 1.0/256.0;
- prolongation[3](27,40) = -9.0/256.0;
- prolongation[3](27,41) = -9.0/256.0;
- prolongation[3](27,44) = -9.0/256.0;
- prolongation[3](27,46) = -9.0/256.0;
- prolongation[3](27,48) = -9.0/256.0;
- prolongation[3](27,49) = -9.0/256.0;
- prolongation[3](27,52) = -9.0/256.0;
- prolongation[3](27,54) = -9.0/256.0;
- prolongation[3](27,56) = 81.0/256.0;
- prolongation[3](27,57) = 81.0/256.0;
- prolongation[3](27,60) = 81.0/256.0;
- prolongation[3](27,61) = 81.0/256.0;
- prolongation[3](28,2) = -5.0/256.0;
- prolongation[3](28,3) = -5.0/256.0;
- prolongation[3](28,6) = -1.0/256.0;
- prolongation[3](28,7) = -1.0/256.0;
- prolongation[3](28,12) = 45.0/256.0;
- prolongation[3](28,13) = 45.0/256.0;
- prolongation[3](28,20) = 9.0/256.0;
- prolongation[3](28,21) = 9.0/256.0;
- prolongation[3](28,28) = -15.0/256.0;
- prolongation[3](28,29) = 5.0/256.0;
- prolongation[3](28,30) = -15.0/256.0;
- prolongation[3](28,31) = 5.0/256.0;
- prolongation[3](28,48) = 135.0/256.0;
- prolongation[3](28,49) = 135.0/256.0;
- prolongation[3](28,50) = -45.0/256.0;
- prolongation[3](28,51) = -45.0/256.0;
- prolongation[3](29,28) = -1.0/16.0;
- prolongation[3](29,30) = -1.0/16.0;
- prolongation[3](29,48) = 9.0/16.0;
- prolongation[3](29,49) = 9.0/16.0;
- prolongation[3](30,3) = 5.0/16.0;
- prolongation[3](30,7) = 1.0/16.0;
- prolongation[3](30,30) = 15.0/16.0;
- prolongation[3](30,31) = -5.0/16.0;
- prolongation[3](31,30) = 1.0;
- prolongation[3](32,11) = 1.0/16.0;
- prolongation[3](32,15) = 5.0/16.0;
- prolongation[3](32,34) = 15.0/16.0;
- prolongation[3](32,35) = -5.0/16.0;
- prolongation[3](33,34) = 1.0;
- prolongation[3](34,0) = 5.0/256.0;
- prolongation[3](34,1) = 1.0/256.0;
- prolongation[3](34,2) = 5.0/256.0;
- prolongation[3](34,3) = 25.0/256.0;
- prolongation[3](34,8) = 15.0/256.0;
- prolongation[3](34,9) = -5.0/256.0;
- prolongation[3](34,10) = -5.0/256.0;
- prolongation[3](34,11) = 15.0/256.0;
- prolongation[3](34,12) = 75.0/256.0;
- prolongation[3](34,13) = -25.0/256.0;
- prolongation[3](34,14) = -25.0/256.0;
- prolongation[3](34,15) = 75.0/256.0;
- prolongation[3](34,32) = -75.0/256.0;
- prolongation[3](34,33) = 25.0/256.0;
- prolongation[3](34,34) = 225.0/256.0;
- prolongation[3](34,35) = -75.0/256.0;
- prolongation[3](35,8) = 1.0/16.0;
- prolongation[3](35,12) = 5.0/16.0;
- prolongation[3](35,32) = -5.0/16.0;
- prolongation[3](35,34) = 15.0/16.0;
- prolongation[3](36,11) = -1.0/256.0;
- prolongation[3](36,15) = -5.0/256.0;
- prolongation[3](36,19) = -1.0/256.0;
- prolongation[3](36,23) = -5.0/256.0;
- prolongation[3](36,34) = -15.0/256.0;
- prolongation[3](36,35) = 5.0/256.0;
- prolongation[3](36,38) = -15.0/256.0;
- prolongation[3](36,39) = 5.0/256.0;
- prolongation[3](36,46) = 9.0/256.0;
- prolongation[3](36,47) = 9.0/256.0;
- prolongation[3](36,54) = 45.0/256.0;
- prolongation[3](36,55) = 45.0/256.0;
- prolongation[3](36,60) = 135.0/256.0;
- prolongation[3](36,61) = -45.0/256.0;
- prolongation[3](36,62) = 135.0/256.0;
- prolongation[3](36,63) = -45.0/256.0;
- prolongation[3](37,34) = -1.0/16.0;
- prolongation[3](37,38) = -1.0/16.0;
- prolongation[3](37,60) = 9.0/16.0;
- prolongation[3](37,62) = 9.0/16.0;
- prolongation[3](38,0) = -5.0/4096.0;
- prolongation[3](38,1) = -1.0/4096.0;
- prolongation[3](38,2) = -5.0/4096.0;
- prolongation[3](38,3) = -25.0/4096.0;
- prolongation[3](38,4) = -5.0/4096.0;
- prolongation[3](38,5) = -1.0/4096.0;
- prolongation[3](38,6) = -5.0/4096.0;
- prolongation[3](38,7) = -25.0/4096.0;
- prolongation[3](38,8) = -15.0/4096.0;
- prolongation[3](38,9) = 5.0/4096.0;
- prolongation[3](38,10) = 5.0/4096.0;
- prolongation[3](38,11) = -15.0/4096.0;
- prolongation[3](38,12) = -75.0/4096.0;
- prolongation[3](38,13) = 25.0/4096.0;
- prolongation[3](38,14) = 25.0/4096.0;
- prolongation[3](38,15) = -75.0/4096.0;
- prolongation[3](38,16) = -15.0/4096.0;
- prolongation[3](38,17) = 5.0/4096.0;
- prolongation[3](38,18) = 5.0/4096.0;
- prolongation[3](38,19) = -15.0/4096.0;
- prolongation[3](38,20) = -75.0/4096.0;
- prolongation[3](38,21) = 25.0/4096.0;
- prolongation[3](38,22) = 25.0/4096.0;
- prolongation[3](38,23) = -75.0/4096.0;
- prolongation[3](38,24) = 45.0/4096.0;
- prolongation[3](38,25) = 45.0/4096.0;
- prolongation[3](38,26) = 9.0/4096.0;
- prolongation[3](38,27) = 9.0/4096.0;
- prolongation[3](38,28) = 45.0/4096.0;
- prolongation[3](38,29) = 45.0/4096.0;
- prolongation[3](38,30) = 225.0/4096.0;
- prolongation[3](38,31) = 225.0/4096.0;
- prolongation[3](38,32) = 75.0/4096.0;
- prolongation[3](38,33) = -25.0/4096.0;
- prolongation[3](38,34) = -225.0/4096.0;
- prolongation[3](38,35) = 75.0/4096.0;
- prolongation[3](38,36) = 75.0/4096.0;
- prolongation[3](38,37) = -25.0/4096.0;
- prolongation[3](38,38) = -225.0/4096.0;
- prolongation[3](38,39) = 75.0/4096.0;
- prolongation[3](38,40) = 135.0/4096.0;
- prolongation[3](38,41) = -45.0/4096.0;
- prolongation[3](38,42) = 135.0/4096.0;
- prolongation[3](38,43) = -45.0/4096.0;
- prolongation[3](38,44) = -45.0/4096.0;
- prolongation[3](38,45) = -45.0/4096.0;
- prolongation[3](38,46) = 135.0/4096.0;
- prolongation[3](38,47) = 135.0/4096.0;
- prolongation[3](38,48) = 675.0/4096.0;
- prolongation[3](38,49) = -225.0/4096.0;
- prolongation[3](38,50) = 675.0/4096.0;
- prolongation[3](38,51) = -225.0/4096.0;
- prolongation[3](38,52) = -225.0/4096.0;
- prolongation[3](38,53) = -225.0/4096.0;
- prolongation[3](38,54) = 675.0/4096.0;
- prolongation[3](38,55) = 675.0/4096.0;
- prolongation[3](38,56) = -675.0/4096.0;
- prolongation[3](38,57) = 225.0/4096.0;
- prolongation[3](38,58) = -675.0/4096.0;
- prolongation[3](38,59) = 225.0/4096.0;
- prolongation[3](38,60) = 2025.0/4096.0;
- prolongation[3](38,61) = -675.0/4096.0;
- prolongation[3](38,62) = 2025.0/4096.0;
- prolongation[3](38,63) = -675.0/4096.0;
- prolongation[3](39,8) = -1.0/256.0;
- prolongation[3](39,12) = -5.0/256.0;
- prolongation[3](39,16) = -1.0/256.0;
- prolongation[3](39,20) = -5.0/256.0;
- prolongation[3](39,32) = 5.0/256.0;
- prolongation[3](39,34) = -15.0/256.0;
- prolongation[3](39,36) = 5.0/256.0;
- prolongation[3](39,38) = -15.0/256.0;
- prolongation[3](39,40) = 9.0/256.0;
- prolongation[3](39,42) = 9.0/256.0;
- prolongation[3](39,48) = 45.0/256.0;
- prolongation[3](39,50) = 45.0/256.0;
- prolongation[3](39,56) = -45.0/256.0;
- prolongation[3](39,58) = -45.0/256.0;
- prolongation[3](39,60) = 135.0/256.0;
- prolongation[3](39,62) = 135.0/256.0;
- prolongation[3](40,0) = -25.0/4096.0;
- prolongation[3](40,1) = -5.0/4096.0;
- prolongation[3](40,2) = -5.0/4096.0;
- prolongation[3](40,3) = -25.0/4096.0;
- prolongation[3](40,4) = -5.0/4096.0;
- prolongation[3](40,5) = -1.0/4096.0;
- prolongation[3](40,6) = -1.0/4096.0;
- prolongation[3](40,7) = -5.0/4096.0;
- prolongation[3](40,8) = -75.0/4096.0;
- prolongation[3](40,9) = 25.0/4096.0;
- prolongation[3](40,10) = 45.0/4096.0;
- prolongation[3](40,11) = 45.0/4096.0;
- prolongation[3](40,12) = -75.0/4096.0;
- prolongation[3](40,13) = 25.0/4096.0;
- prolongation[3](40,14) = 225.0/4096.0;
- prolongation[3](40,15) = 225.0/4096.0;
- prolongation[3](40,16) = -15.0/4096.0;
- prolongation[3](40,17) = 5.0/4096.0;
- prolongation[3](40,18) = 9.0/4096.0;
- prolongation[3](40,19) = 9.0/4096.0;
- prolongation[3](40,20) = -15.0/4096.0;
- prolongation[3](40,21) = 5.0/4096.0;
- prolongation[3](40,22) = 45.0/4096.0;
- prolongation[3](40,23) = 45.0/4096.0;
- prolongation[3](40,24) = -75.0/4096.0;
- prolongation[3](40,25) = 25.0/4096.0;
- prolongation[3](40,26) = -15.0/4096.0;
- prolongation[3](40,27) = 5.0/4096.0;
- prolongation[3](40,28) = -15.0/4096.0;
- prolongation[3](40,29) = 5.0/4096.0;
- prolongation[3](40,30) = -75.0/4096.0;
- prolongation[3](40,31) = 25.0/4096.0;
- prolongation[3](40,32) = 675.0/4096.0;
- prolongation[3](40,33) = -225.0/4096.0;
- prolongation[3](40,34) = 675.0/4096.0;
- prolongation[3](40,35) = -225.0/4096.0;
- prolongation[3](40,36) = 135.0/4096.0;
- prolongation[3](40,37) = -45.0/4096.0;
- prolongation[3](40,38) = 135.0/4096.0;
- prolongation[3](40,39) = -45.0/4096.0;
- prolongation[3](40,40) = -225.0/4096.0;
- prolongation[3](40,41) = 75.0/4096.0;
- prolongation[3](40,42) = 75.0/4096.0;
- prolongation[3](40,43) = -25.0/4096.0;
- prolongation[3](40,44) = 135.0/4096.0;
- prolongation[3](40,45) = -45.0/4096.0;
- prolongation[3](40,46) = 135.0/4096.0;
- prolongation[3](40,47) = -45.0/4096.0;
- prolongation[3](40,48) = -225.0/4096.0;
- prolongation[3](40,49) = 75.0/4096.0;
- prolongation[3](40,50) = 75.0/4096.0;
- prolongation[3](40,51) = -25.0/4096.0;
- prolongation[3](40,52) = 675.0/4096.0;
- prolongation[3](40,53) = -225.0/4096.0;
- prolongation[3](40,54) = 675.0/4096.0;
- prolongation[3](40,55) = -225.0/4096.0;
- prolongation[3](40,56) = 2025.0/4096.0;
- prolongation[3](40,57) = -675.0/4096.0;
- prolongation[3](40,58) = -675.0/4096.0;
- prolongation[3](40,59) = 225.0/4096.0;
- prolongation[3](40,60) = 2025.0/4096.0;
- prolongation[3](40,61) = -675.0/4096.0;
- prolongation[3](40,62) = -675.0/4096.0;
- prolongation[3](40,63) = 225.0/4096.0;
- prolongation[3](41,8) = -5.0/256.0;
- prolongation[3](41,12) = -5.0/256.0;
- prolongation[3](41,16) = -1.0/256.0;
- prolongation[3](41,20) = -1.0/256.0;
- prolongation[3](41,32) = 45.0/256.0;
- prolongation[3](41,34) = 45.0/256.0;
- prolongation[3](41,36) = 9.0/256.0;
- prolongation[3](41,38) = 9.0/256.0;
- prolongation[3](41,40) = -15.0/256.0;
- prolongation[3](41,42) = 5.0/256.0;
- prolongation[3](41,48) = -15.0/256.0;
- prolongation[3](41,50) = 5.0/256.0;
- prolongation[3](41,56) = 135.0/256.0;
- prolongation[3](41,58) = -45.0/256.0;
- prolongation[3](41,60) = 135.0/256.0;
- prolongation[3](41,62) = -45.0/256.0;
- prolongation[3](42,24) = -5.0/256.0;
- prolongation[3](42,26) = -1.0/256.0;
- prolongation[3](42,28) = -1.0/256.0;
- prolongation[3](42,30) = -5.0/256.0;
- prolongation[3](42,40) = -15.0/256.0;
- prolongation[3](42,41) = 5.0/256.0;
- prolongation[3](42,44) = 9.0/256.0;
- prolongation[3](42,46) = 9.0/256.0;
- prolongation[3](42,48) = -15.0/256.0;
- prolongation[3](42,49) = 5.0/256.0;
- prolongation[3](42,52) = 45.0/256.0;
- prolongation[3](42,54) = 45.0/256.0;
- prolongation[3](42,56) = 135.0/256.0;
- prolongation[3](42,57) = -45.0/256.0;
- prolongation[3](42,60) = 135.0/256.0;
- prolongation[3](42,61) = -45.0/256.0;
- prolongation[3](43,40) = -1.0/16.0;
- prolongation[3](43,48) = -1.0/16.0;
- prolongation[3](43,56) = 9.0/16.0;
- prolongation[3](43,60) = 9.0/16.0;
- prolongation[3](44,11) = -5.0/256.0;
- prolongation[3](44,15) = -5.0/256.0;
- prolongation[3](44,19) = -1.0/256.0;
- prolongation[3](44,23) = -1.0/256.0;
- prolongation[3](44,34) = 45.0/256.0;
- prolongation[3](44,35) = 45.0/256.0;
- prolongation[3](44,38) = 9.0/256.0;
- prolongation[3](44,39) = 9.0/256.0;
- prolongation[3](44,46) = -15.0/256.0;
- prolongation[3](44,47) = 5.0/256.0;
- prolongation[3](44,54) = -15.0/256.0;
- prolongation[3](44,55) = 5.0/256.0;
- prolongation[3](44,60) = 135.0/256.0;
- prolongation[3](44,61) = 135.0/256.0;
- prolongation[3](44,62) = -45.0/256.0;
- prolongation[3](44,63) = -45.0/256.0;
- prolongation[3](45,46) = -1.0/16.0;
- prolongation[3](45,54) = -1.0/16.0;
- prolongation[3](45,60) = 9.0/16.0;
- prolongation[3](45,61) = 9.0/16.0;
- prolongation[3](46,0) = -5.0/4096.0;
- prolongation[3](46,1) = -5.0/4096.0;
- prolongation[3](46,2) = -25.0/4096.0;
- prolongation[3](46,3) = -25.0/4096.0;
- prolongation[3](46,4) = -1.0/4096.0;
- prolongation[3](46,5) = -1.0/4096.0;
- prolongation[3](46,6) = -5.0/4096.0;
- prolongation[3](46,7) = -5.0/4096.0;
- prolongation[3](46,8) = 45.0/4096.0;
- prolongation[3](46,9) = 45.0/4096.0;
- prolongation[3](46,10) = 25.0/4096.0;
- prolongation[3](46,11) = -75.0/4096.0;
- prolongation[3](46,12) = 225.0/4096.0;
- prolongation[3](46,13) = 225.0/4096.0;
- prolongation[3](46,14) = 25.0/4096.0;
- prolongation[3](46,15) = -75.0/4096.0;
- prolongation[3](46,16) = 9.0/4096.0;
- prolongation[3](46,17) = 9.0/4096.0;
- prolongation[3](46,18) = 5.0/4096.0;
- prolongation[3](46,19) = -15.0/4096.0;
- prolongation[3](46,20) = 45.0/4096.0;
- prolongation[3](46,21) = 45.0/4096.0;
- prolongation[3](46,22) = 5.0/4096.0;
- prolongation[3](46,23) = -15.0/4096.0;
- prolongation[3](46,24) = -15.0/4096.0;
- prolongation[3](46,25) = 5.0/4096.0;
- prolongation[3](46,26) = -15.0/4096.0;
- prolongation[3](46,27) = 5.0/4096.0;
- prolongation[3](46,28) = -75.0/4096.0;
- prolongation[3](46,29) = 25.0/4096.0;
- prolongation[3](46,30) = -75.0/4096.0;
- prolongation[3](46,31) = 25.0/4096.0;
- prolongation[3](46,32) = -225.0/4096.0;
- prolongation[3](46,33) = -225.0/4096.0;
- prolongation[3](46,34) = 675.0/4096.0;
- prolongation[3](46,35) = 675.0/4096.0;
- prolongation[3](46,36) = -45.0/4096.0;
- prolongation[3](46,37) = -45.0/4096.0;
- prolongation[3](46,38) = 135.0/4096.0;
- prolongation[3](46,39) = 135.0/4096.0;
- prolongation[3](46,40) = 135.0/4096.0;
- prolongation[3](46,41) = 135.0/4096.0;
- prolongation[3](46,42) = -45.0/4096.0;
- prolongation[3](46,43) = -45.0/4096.0;
- prolongation[3](46,44) = 75.0/4096.0;
- prolongation[3](46,45) = -25.0/4096.0;
- prolongation[3](46,46) = -225.0/4096.0;
- prolongation[3](46,47) = 75.0/4096.0;
- prolongation[3](46,48) = 675.0/4096.0;
- prolongation[3](46,49) = 675.0/4096.0;
- prolongation[3](46,50) = -225.0/4096.0;
- prolongation[3](46,51) = -225.0/4096.0;
- prolongation[3](46,52) = 75.0/4096.0;
- prolongation[3](46,53) = -25.0/4096.0;
- prolongation[3](46,54) = -225.0/4096.0;
- prolongation[3](46,55) = 75.0/4096.0;
- prolongation[3](46,56) = -675.0/4096.0;
- prolongation[3](46,57) = -675.0/4096.0;
- prolongation[3](46,58) = 225.0/4096.0;
- prolongation[3](46,59) = 225.0/4096.0;
- prolongation[3](46,60) = 2025.0/4096.0;
- prolongation[3](46,61) = 2025.0/4096.0;
- prolongation[3](46,62) = -675.0/4096.0;
- prolongation[3](46,63) = -675.0/4096.0;
- prolongation[3](47,24) = -1.0/256.0;
- prolongation[3](47,26) = -1.0/256.0;
- prolongation[3](47,28) = -5.0/256.0;
- prolongation[3](47,30) = -5.0/256.0;
- prolongation[3](47,40) = 9.0/256.0;
- prolongation[3](47,41) = 9.0/256.0;
- prolongation[3](47,44) = 5.0/256.0;
- prolongation[3](47,46) = -15.0/256.0;
- prolongation[3](47,48) = 45.0/256.0;
- prolongation[3](47,49) = 45.0/256.0;
- prolongation[3](47,52) = 5.0/256.0;
- prolongation[3](47,54) = -15.0/256.0;
- prolongation[3](47,56) = -45.0/256.0;
- prolongation[3](47,57) = -45.0/256.0;
- prolongation[3](47,60) = 135.0/256.0;
- prolongation[3](47,61) = 135.0/256.0;
- prolongation[3](48,2) = 5.0/256.0;
- prolongation[3](48,3) = 25.0/256.0;
- prolongation[3](48,6) = 1.0/256.0;
- prolongation[3](48,7) = 5.0/256.0;
- prolongation[3](48,12) = 75.0/256.0;
- prolongation[3](48,13) = -25.0/256.0;
- prolongation[3](48,20) = 15.0/256.0;
- prolongation[3](48,21) = -5.0/256.0;
- prolongation[3](48,28) = 15.0/256.0;
- prolongation[3](48,29) = -5.0/256.0;
- prolongation[3](48,30) = 75.0/256.0;
- prolongation[3](48,31) = -25.0/256.0;
- prolongation[3](48,48) = 225.0/256.0;
- prolongation[3](48,49) = -75.0/256.0;
- prolongation[3](48,50) = -75.0/256.0;
- prolongation[3](48,51) = 25.0/256.0;
- prolongation[3](49,12) = 5.0/16.0;
- prolongation[3](49,20) = 1.0/16.0;
- prolongation[3](49,48) = 15.0/16.0;
- prolongation[3](49,50) = -5.0/16.0;
- prolongation[3](50,28) = 1.0/16.0;
- prolongation[3](50,30) = 5.0/16.0;
- prolongation[3](50,48) = 15.0/16.0;
- prolongation[3](50,49) = -5.0/16.0;
- prolongation[3](51,48) = 1.0;
- prolongation[3](52,15) = 5.0/16.0;
- prolongation[3](52,23) = 1.0/16.0;
- prolongation[3](52,54) = 15.0/16.0;
- prolongation[3](52,55) = -5.0/16.0;
- prolongation[3](53,54) = 1.0;
- prolongation[3](54,0) = 5.0/256.0;
- prolongation[3](54,3) = 25.0/256.0;
- prolongation[3](54,4) = 1.0/256.0;
- prolongation[3](54,7) = 5.0/256.0;
- prolongation[3](54,14) = -25.0/256.0;
- prolongation[3](54,15) = 75.0/256.0;
- prolongation[3](54,22) = -5.0/256.0;
- prolongation[3](54,23) = 15.0/256.0;
- prolongation[3](54,24) = 15.0/256.0;
- prolongation[3](54,25) = -5.0/256.0;
- prolongation[3](54,30) = 75.0/256.0;
- prolongation[3](54,31) = -25.0/256.0;
- prolongation[3](54,52) = -75.0/256.0;
- prolongation[3](54,53) = 25.0/256.0;
- prolongation[3](54,54) = 225.0/256.0;
- prolongation[3](54,55) = -75.0/256.0;
- prolongation[3](55,24) = 1.0/16.0;
- prolongation[3](55,30) = 5.0/16.0;
- prolongation[3](55,52) = -5.0/16.0;
- prolongation[3](55,54) = 15.0/16.0;
- prolongation[3](56,11) = 5.0/256.0;
- prolongation[3](56,15) = 25.0/256.0;
- prolongation[3](56,19) = 1.0/256.0;
- prolongation[3](56,23) = 5.0/256.0;
- prolongation[3](56,34) = 75.0/256.0;
- prolongation[3](56,35) = -25.0/256.0;
- prolongation[3](56,38) = 15.0/256.0;
- prolongation[3](56,39) = -5.0/256.0;
- prolongation[3](56,46) = 15.0/256.0;
- prolongation[3](56,47) = -5.0/256.0;
- prolongation[3](56,54) = 75.0/256.0;
- prolongation[3](56,55) = -25.0/256.0;
- prolongation[3](56,60) = 225.0/256.0;
- prolongation[3](56,61) = -75.0/256.0;
- prolongation[3](56,62) = -75.0/256.0;
- prolongation[3](56,63) = 25.0/256.0;
- prolongation[3](57,34) = 5.0/16.0;
- prolongation[3](57,38) = 1.0/16.0;
- prolongation[3](57,60) = 15.0/16.0;
- prolongation[3](57,62) = -5.0/16.0;
- prolongation[3](58,46) = 1.0/16.0;
- prolongation[3](58,54) = 5.0/16.0;
- prolongation[3](58,60) = 15.0/16.0;
- prolongation[3](58,61) = -5.0/16.0;
- prolongation[3](59,60) = 1.0;
- prolongation[3](60,0) = 25.0/4096.0;
- prolongation[3](60,1) = 5.0/4096.0;
- prolongation[3](60,2) = 25.0/4096.0;
- prolongation[3](60,3) = 125.0/4096.0;
- prolongation[3](60,4) = 5.0/4096.0;
- prolongation[3](60,5) = 1.0/4096.0;
- prolongation[3](60,6) = 5.0/4096.0;
- prolongation[3](60,7) = 25.0/4096.0;
- prolongation[3](60,8) = 75.0/4096.0;
- prolongation[3](60,9) = -25.0/4096.0;
- prolongation[3](60,10) = -25.0/4096.0;
- prolongation[3](60,11) = 75.0/4096.0;
- prolongation[3](60,12) = 375.0/4096.0;
- prolongation[3](60,13) = -125.0/4096.0;
- prolongation[3](60,14) = -125.0/4096.0;
- prolongation[3](60,15) = 375.0/4096.0;
- prolongation[3](60,16) = 15.0/4096.0;
- prolongation[3](60,17) = -5.0/4096.0;
- prolongation[3](60,18) = -5.0/4096.0;
- prolongation[3](60,19) = 15.0/4096.0;
- prolongation[3](60,20) = 75.0/4096.0;
- prolongation[3](60,21) = -25.0/4096.0;
- prolongation[3](60,22) = -25.0/4096.0;
- prolongation[3](60,23) = 75.0/4096.0;
- prolongation[3](60,24) = 75.0/4096.0;
- prolongation[3](60,25) = -25.0/4096.0;
- prolongation[3](60,26) = 15.0/4096.0;
- prolongation[3](60,27) = -5.0/4096.0;
- prolongation[3](60,28) = 75.0/4096.0;
- prolongation[3](60,29) = -25.0/4096.0;
- prolongation[3](60,30) = 375.0/4096.0;
- prolongation[3](60,31) = -125.0/4096.0;
- prolongation[3](60,32) = -375.0/4096.0;
- prolongation[3](60,33) = 125.0/4096.0;
- prolongation[3](60,34) = 1125.0/4096.0;
- prolongation[3](60,35) = -375.0/4096.0;
- prolongation[3](60,36) = -75.0/4096.0;
- prolongation[3](60,37) = 25.0/4096.0;
- prolongation[3](60,38) = 225.0/4096.0;
- prolongation[3](60,39) = -75.0/4096.0;
- prolongation[3](60,40) = 225.0/4096.0;
- prolongation[3](60,41) = -75.0/4096.0;
- prolongation[3](60,42) = -75.0/4096.0;
- prolongation[3](60,43) = 25.0/4096.0;
- prolongation[3](60,44) = -75.0/4096.0;
- prolongation[3](60,45) = 25.0/4096.0;
- prolongation[3](60,46) = 225.0/4096.0;
- prolongation[3](60,47) = -75.0/4096.0;
- prolongation[3](60,48) = 1125.0/4096.0;
- prolongation[3](60,49) = -375.0/4096.0;
- prolongation[3](60,50) = -375.0/4096.0;
- prolongation[3](60,51) = 125.0/4096.0;
- prolongation[3](60,52) = -375.0/4096.0;
- prolongation[3](60,53) = 125.0/4096.0;
- prolongation[3](60,54) = 1125.0/4096.0;
- prolongation[3](60,55) = -375.0/4096.0;
- prolongation[3](60,56) = -1125.0/4096.0;
- prolongation[3](60,57) = 375.0/4096.0;
- prolongation[3](60,58) = 375.0/4096.0;
- prolongation[3](60,59) = -125.0/4096.0;
- prolongation[3](60,60) = 3375.0/4096.0;
- prolongation[3](60,61) = -1125.0/4096.0;
- prolongation[3](60,62) = -1125.0/4096.0;
- prolongation[3](60,63) = 375.0/4096.0;
- prolongation[3](61,8) = 5.0/256.0;
- prolongation[3](61,12) = 25.0/256.0;
- prolongation[3](61,16) = 1.0/256.0;
- prolongation[3](61,20) = 5.0/256.0;
- prolongation[3](61,32) = -25.0/256.0;
- prolongation[3](61,34) = 75.0/256.0;
- prolongation[3](61,36) = -5.0/256.0;
- prolongation[3](61,38) = 15.0/256.0;
- prolongation[3](61,40) = 15.0/256.0;
- prolongation[3](61,42) = -5.0/256.0;
- prolongation[3](61,48) = 75.0/256.0;
- prolongation[3](61,50) = -25.0/256.0;
- prolongation[3](61,56) = -75.0/256.0;
- prolongation[3](61,58) = 25.0/256.0;
- prolongation[3](61,60) = 225.0/256.0;
- prolongation[3](61,62) = -75.0/256.0;
- prolongation[3](62,24) = 5.0/256.0;
- prolongation[3](62,26) = 1.0/256.0;
- prolongation[3](62,28) = 5.0/256.0;
- prolongation[3](62,30) = 25.0/256.0;
- prolongation[3](62,40) = 15.0/256.0;
- prolongation[3](62,41) = -5.0/256.0;
- prolongation[3](62,44) = -5.0/256.0;
- prolongation[3](62,46) = 15.0/256.0;
- prolongation[3](62,48) = 75.0/256.0;
- prolongation[3](62,49) = -25.0/256.0;
- prolongation[3](62,52) = -25.0/256.0;
- prolongation[3](62,54) = 75.0/256.0;
- prolongation[3](62,56) = -75.0/256.0;
- prolongation[3](62,57) = 25.0/256.0;
- prolongation[3](62,60) = 225.0/256.0;
- prolongation[3](62,61) = -75.0/256.0;
- prolongation[3](63,40) = 1.0/16.0;
- prolongation[3](63,48) = 5.0/16.0;
- prolongation[3](63,56) = -5.0/16.0;
- prolongation[3](63,60) = 15.0/16.0;
- prolongation[4](0,0) = -1.0/16.0;
- prolongation[4](0,4) = -1.0/16.0;
- prolongation[4](0,24) = 9.0/16.0;
- prolongation[4](0,25) = 9.0/16.0;
- prolongation[4](1,0) = 1.0/256.0;
- prolongation[4](1,1) = 1.0/256.0;
- prolongation[4](1,4) = 1.0/256.0;
- prolongation[4](1,5) = 1.0/256.0;
- prolongation[4](1,8) = -9.0/256.0;
- prolongation[4](1,9) = -9.0/256.0;
- prolongation[4](1,16) = -9.0/256.0;
- prolongation[4](1,17) = -9.0/256.0;
- prolongation[4](1,24) = -9.0/256.0;
- prolongation[4](1,25) = -9.0/256.0;
- prolongation[4](1,26) = -9.0/256.0;
- prolongation[4](1,27) = -9.0/256.0;
- prolongation[4](1,40) = 81.0/256.0;
- prolongation[4](1,41) = 81.0/256.0;
- prolongation[4](1,42) = 81.0/256.0;
- prolongation[4](1,43) = 81.0/256.0;
- prolongation[4](2,0) = -1.0/4096.0;
- prolongation[4](2,1) = -1.0/4096.0;
- prolongation[4](2,2) = -1.0/4096.0;
- prolongation[4](2,3) = -1.0/4096.0;
- prolongation[4](2,4) = -1.0/4096.0;
- prolongation[4](2,5) = -1.0/4096.0;
- prolongation[4](2,6) = -1.0/4096.0;
- prolongation[4](2,7) = -1.0/4096.0;
- prolongation[4](2,8) = 9.0/4096.0;
- prolongation[4](2,9) = 9.0/4096.0;
- prolongation[4](2,10) = 9.0/4096.0;
- prolongation[4](2,11) = 9.0/4096.0;
- prolongation[4](2,12) = 9.0/4096.0;
- prolongation[4](2,13) = 9.0/4096.0;
- prolongation[4](2,14) = 9.0/4096.0;
- prolongation[4](2,15) = 9.0/4096.0;
- prolongation[4](2,16) = 9.0/4096.0;
- prolongation[4](2,17) = 9.0/4096.0;
- prolongation[4](2,18) = 9.0/4096.0;
- prolongation[4](2,19) = 9.0/4096.0;
- prolongation[4](2,20) = 9.0/4096.0;
- prolongation[4](2,21) = 9.0/4096.0;
- prolongation[4](2,22) = 9.0/4096.0;
- prolongation[4](2,23) = 9.0/4096.0;
- prolongation[4](2,24) = 9.0/4096.0;
- prolongation[4](2,25) = 9.0/4096.0;
- prolongation[4](2,26) = 9.0/4096.0;
- prolongation[4](2,27) = 9.0/4096.0;
- prolongation[4](2,28) = 9.0/4096.0;
- prolongation[4](2,29) = 9.0/4096.0;
- prolongation[4](2,30) = 9.0/4096.0;
- prolongation[4](2,31) = 9.0/4096.0;
- prolongation[4](2,32) = -81.0/4096.0;
- prolongation[4](2,33) = -81.0/4096.0;
- prolongation[4](2,34) = -81.0/4096.0;
- prolongation[4](2,35) = -81.0/4096.0;
- prolongation[4](2,36) = -81.0/4096.0;
- prolongation[4](2,37) = -81.0/4096.0;
- prolongation[4](2,38) = -81.0/4096.0;
- prolongation[4](2,39) = -81.0/4096.0;
- prolongation[4](2,40) = -81.0/4096.0;
- prolongation[4](2,41) = -81.0/4096.0;
- prolongation[4](2,42) = -81.0/4096.0;
- prolongation[4](2,43) = -81.0/4096.0;
- prolongation[4](2,44) = -81.0/4096.0;
- prolongation[4](2,45) = -81.0/4096.0;
- prolongation[4](2,46) = -81.0/4096.0;
- prolongation[4](2,47) = -81.0/4096.0;
- prolongation[4](2,48) = -81.0/4096.0;
- prolongation[4](2,49) = -81.0/4096.0;
- prolongation[4](2,50) = -81.0/4096.0;
- prolongation[4](2,51) = -81.0/4096.0;
- prolongation[4](2,52) = -81.0/4096.0;
- prolongation[4](2,53) = -81.0/4096.0;
- prolongation[4](2,54) = -81.0/4096.0;
- prolongation[4](2,55) = -81.0/4096.0;
- prolongation[4](2,56) = 729.0/4096.0;
- prolongation[4](2,57) = 729.0/4096.0;
- prolongation[4](2,58) = 729.0/4096.0;
- prolongation[4](2,59) = 729.0/4096.0;
- prolongation[4](2,60) = 729.0/4096.0;
- prolongation[4](2,61) = 729.0/4096.0;
- prolongation[4](2,62) = 729.0/4096.0;
- prolongation[4](2,63) = 729.0/4096.0;
- prolongation[4](3,0) = 1.0/256.0;
- prolongation[4](3,3) = 1.0/256.0;
- prolongation[4](3,4) = 1.0/256.0;
- prolongation[4](3,7) = 1.0/256.0;
- prolongation[4](3,14) = -9.0/256.0;
- prolongation[4](3,15) = -9.0/256.0;
- prolongation[4](3,22) = -9.0/256.0;
- prolongation[4](3,23) = -9.0/256.0;
- prolongation[4](3,24) = -9.0/256.0;
- prolongation[4](3,25) = -9.0/256.0;
- prolongation[4](3,30) = -9.0/256.0;
- prolongation[4](3,31) = -9.0/256.0;
- prolongation[4](3,52) = 81.0/256.0;
- prolongation[4](3,53) = 81.0/256.0;
- prolongation[4](3,54) = 81.0/256.0;
- prolongation[4](3,55) = 81.0/256.0;
- prolongation[4](4,4) = 1.0;
- prolongation[4](5,4) = -1.0/16.0;
- prolongation[4](5,5) = -1.0/16.0;
- prolongation[4](5,16) = 9.0/16.0;
- prolongation[4](5,17) = 9.0/16.0;
- prolongation[4](6,4) = 1.0/256.0;
- prolongation[4](6,5) = 1.0/256.0;
- prolongation[4](6,6) = 1.0/256.0;
- prolongation[4](6,7) = 1.0/256.0;
- prolongation[4](6,16) = -9.0/256.0;
- prolongation[4](6,17) = -9.0/256.0;
- prolongation[4](6,18) = -9.0/256.0;
- prolongation[4](6,19) = -9.0/256.0;
- prolongation[4](6,20) = -9.0/256.0;
- prolongation[4](6,21) = -9.0/256.0;
- prolongation[4](6,22) = -9.0/256.0;
- prolongation[4](6,23) = -9.0/256.0;
- prolongation[4](6,36) = 81.0/256.0;
- prolongation[4](6,37) = 81.0/256.0;
- prolongation[4](6,38) = 81.0/256.0;
- prolongation[4](6,39) = 81.0/256.0;
- prolongation[4](7,4) = -1.0/16.0;
- prolongation[4](7,7) = -1.0/16.0;
- prolongation[4](7,22) = 9.0/16.0;
- prolongation[4](7,23) = 9.0/16.0;
- prolongation[4](8,0) = -5.0/256.0;
- prolongation[4](8,1) = -1.0/256.0;
- prolongation[4](8,4) = -5.0/256.0;
- prolongation[4](8,5) = -1.0/256.0;
- prolongation[4](8,8) = -15.0/256.0;
- prolongation[4](8,9) = 5.0/256.0;
- prolongation[4](8,16) = -15.0/256.0;
- prolongation[4](8,17) = 5.0/256.0;
- prolongation[4](8,24) = 45.0/256.0;
- prolongation[4](8,25) = 45.0/256.0;
- prolongation[4](8,26) = 9.0/256.0;
- prolongation[4](8,27) = 9.0/256.0;
- prolongation[4](8,40) = 135.0/256.0;
- prolongation[4](8,41) = -45.0/256.0;
- prolongation[4](8,42) = 135.0/256.0;
- prolongation[4](8,43) = -45.0/256.0;
- prolongation[4](9,8) = -1.0/16.0;
- prolongation[4](9,16) = -1.0/16.0;
- prolongation[4](9,40) = 9.0/16.0;
- prolongation[4](9,42) = 9.0/16.0;
- prolongation[4](10,0) = 5.0/4096.0;
- prolongation[4](10,1) = 5.0/4096.0;
- prolongation[4](10,2) = 1.0/4096.0;
- prolongation[4](10,3) = 1.0/4096.0;
- prolongation[4](10,4) = 5.0/4096.0;
- prolongation[4](10,5) = 5.0/4096.0;
- prolongation[4](10,6) = 1.0/4096.0;
- prolongation[4](10,7) = 1.0/4096.0;
- prolongation[4](10,8) = -45.0/4096.0;
- prolongation[4](10,9) = -45.0/4096.0;
- prolongation[4](10,10) = 15.0/4096.0;
- prolongation[4](10,11) = -5.0/4096.0;
- prolongation[4](10,12) = -9.0/4096.0;
- prolongation[4](10,13) = -9.0/4096.0;
- prolongation[4](10,14) = 15.0/4096.0;
- prolongation[4](10,15) = -5.0/4096.0;
- prolongation[4](10,16) = -45.0/4096.0;
- prolongation[4](10,17) = -45.0/4096.0;
- prolongation[4](10,18) = 15.0/4096.0;
- prolongation[4](10,19) = -5.0/4096.0;
- prolongation[4](10,20) = -9.0/4096.0;
- prolongation[4](10,21) = -9.0/4096.0;
- prolongation[4](10,22) = 15.0/4096.0;
- prolongation[4](10,23) = -5.0/4096.0;
- prolongation[4](10,24) = -45.0/4096.0;
- prolongation[4](10,25) = -45.0/4096.0;
- prolongation[4](10,26) = -45.0/4096.0;
- prolongation[4](10,27) = -45.0/4096.0;
- prolongation[4](10,28) = -9.0/4096.0;
- prolongation[4](10,29) = -9.0/4096.0;
- prolongation[4](10,30) = -9.0/4096.0;
- prolongation[4](10,31) = -9.0/4096.0;
- prolongation[4](10,32) = -135.0/4096.0;
- prolongation[4](10,33) = -135.0/4096.0;
- prolongation[4](10,34) = 45.0/4096.0;
- prolongation[4](10,35) = 45.0/4096.0;
- prolongation[4](10,36) = -135.0/4096.0;
- prolongation[4](10,37) = -135.0/4096.0;
- prolongation[4](10,38) = 45.0/4096.0;
- prolongation[4](10,39) = 45.0/4096.0;
- prolongation[4](10,40) = 405.0/4096.0;
- prolongation[4](10,41) = 405.0/4096.0;
- prolongation[4](10,42) = 405.0/4096.0;
- prolongation[4](10,43) = 405.0/4096.0;
- prolongation[4](10,44) = -135.0/4096.0;
- prolongation[4](10,45) = -135.0/4096.0;
- prolongation[4](10,46) = 45.0/4096.0;
- prolongation[4](10,47) = 45.0/4096.0;
- prolongation[4](10,48) = 81.0/4096.0;
- prolongation[4](10,49) = 81.0/4096.0;
- prolongation[4](10,50) = 81.0/4096.0;
- prolongation[4](10,51) = 81.0/4096.0;
- prolongation[4](10,52) = -135.0/4096.0;
- prolongation[4](10,53) = -135.0/4096.0;
- prolongation[4](10,54) = 45.0/4096.0;
- prolongation[4](10,55) = 45.0/4096.0;
- prolongation[4](10,56) = 1215.0/4096.0;
- prolongation[4](10,57) = 1215.0/4096.0;
- prolongation[4](10,58) = 1215.0/4096.0;
- prolongation[4](10,59) = 1215.0/4096.0;
- prolongation[4](10,60) = -405.0/4096.0;
- prolongation[4](10,61) = -405.0/4096.0;
- prolongation[4](10,62) = -405.0/4096.0;
- prolongation[4](10,63) = -405.0/4096.0;
- prolongation[4](11,10) = 1.0/256.0;
- prolongation[4](11,14) = 1.0/256.0;
- prolongation[4](11,18) = 1.0/256.0;
- prolongation[4](11,22) = 1.0/256.0;
- prolongation[4](11,32) = -9.0/256.0;
- prolongation[4](11,33) = -9.0/256.0;
- prolongation[4](11,36) = -9.0/256.0;
- prolongation[4](11,37) = -9.0/256.0;
- prolongation[4](11,44) = -9.0/256.0;
- prolongation[4](11,45) = -9.0/256.0;
- prolongation[4](11,52) = -9.0/256.0;
- prolongation[4](11,53) = -9.0/256.0;
- prolongation[4](11,56) = 81.0/256.0;
- prolongation[4](11,57) = 81.0/256.0;
- prolongation[4](11,58) = 81.0/256.0;
- prolongation[4](11,59) = 81.0/256.0;
- prolongation[4](12,0) = 5.0/4096.0;
- prolongation[4](12,1) = 1.0/4096.0;
- prolongation[4](12,2) = 1.0/4096.0;
- prolongation[4](12,3) = 5.0/4096.0;
- prolongation[4](12,4) = 5.0/4096.0;
- prolongation[4](12,5) = 1.0/4096.0;
- prolongation[4](12,6) = 1.0/4096.0;
- prolongation[4](12,7) = 5.0/4096.0;
- prolongation[4](12,8) = 15.0/4096.0;
- prolongation[4](12,9) = -5.0/4096.0;
- prolongation[4](12,10) = -9.0/4096.0;
- prolongation[4](12,11) = -9.0/4096.0;
- prolongation[4](12,12) = 15.0/4096.0;
- prolongation[4](12,13) = -5.0/4096.0;
- prolongation[4](12,14) = -45.0/4096.0;
- prolongation[4](12,15) = -45.0/4096.0;
- prolongation[4](12,16) = 15.0/4096.0;
- prolongation[4](12,17) = -5.0/4096.0;
- prolongation[4](12,18) = -9.0/4096.0;
- prolongation[4](12,19) = -9.0/4096.0;
- prolongation[4](12,20) = 15.0/4096.0;
- prolongation[4](12,21) = -5.0/4096.0;
- prolongation[4](12,22) = -45.0/4096.0;
- prolongation[4](12,23) = -45.0/4096.0;
- prolongation[4](12,24) = -45.0/4096.0;
- prolongation[4](12,25) = -45.0/4096.0;
- prolongation[4](12,26) = -9.0/4096.0;
- prolongation[4](12,27) = -9.0/4096.0;
- prolongation[4](12,28) = -9.0/4096.0;
- prolongation[4](12,29) = -9.0/4096.0;
- prolongation[4](12,30) = -45.0/4096.0;
- prolongation[4](12,31) = -45.0/4096.0;
- prolongation[4](12,32) = -135.0/4096.0;
- prolongation[4](12,33) = 45.0/4096.0;
- prolongation[4](12,34) = -135.0/4096.0;
- prolongation[4](12,35) = 45.0/4096.0;
- prolongation[4](12,36) = -135.0/4096.0;
- prolongation[4](12,37) = 45.0/4096.0;
- prolongation[4](12,38) = -135.0/4096.0;
- prolongation[4](12,39) = 45.0/4096.0;
- prolongation[4](12,40) = -135.0/4096.0;
- prolongation[4](12,41) = 45.0/4096.0;
- prolongation[4](12,42) = -135.0/4096.0;
- prolongation[4](12,43) = 45.0/4096.0;
- prolongation[4](12,44) = 81.0/4096.0;
- prolongation[4](12,45) = 81.0/4096.0;
- prolongation[4](12,46) = 81.0/4096.0;
- prolongation[4](12,47) = 81.0/4096.0;
- prolongation[4](12,48) = -135.0/4096.0;
- prolongation[4](12,49) = 45.0/4096.0;
- prolongation[4](12,50) = -135.0/4096.0;
- prolongation[4](12,51) = 45.0/4096.0;
- prolongation[4](12,52) = 405.0/4096.0;
- prolongation[4](12,53) = 405.0/4096.0;
- prolongation[4](12,54) = 405.0/4096.0;
- prolongation[4](12,55) = 405.0/4096.0;
- prolongation[4](12,56) = 1215.0/4096.0;
- prolongation[4](12,57) = -405.0/4096.0;
- prolongation[4](12,58) = 1215.0/4096.0;
- prolongation[4](12,59) = -405.0/4096.0;
- prolongation[4](12,60) = 1215.0/4096.0;
- prolongation[4](12,61) = -405.0/4096.0;
- prolongation[4](12,62) = 1215.0/4096.0;
- prolongation[4](12,63) = -405.0/4096.0;
- prolongation[4](13,8) = 1.0/256.0;
- prolongation[4](13,12) = 1.0/256.0;
- prolongation[4](13,16) = 1.0/256.0;
- prolongation[4](13,20) = 1.0/256.0;
- prolongation[4](13,32) = -9.0/256.0;
- prolongation[4](13,34) = -9.0/256.0;
- prolongation[4](13,36) = -9.0/256.0;
- prolongation[4](13,38) = -9.0/256.0;
- prolongation[4](13,40) = -9.0/256.0;
- prolongation[4](13,42) = -9.0/256.0;
- prolongation[4](13,48) = -9.0/256.0;
- prolongation[4](13,50) = -9.0/256.0;
- prolongation[4](13,56) = 81.0/256.0;
- prolongation[4](13,58) = 81.0/256.0;
- prolongation[4](13,60) = 81.0/256.0;
- prolongation[4](13,62) = 81.0/256.0;
- prolongation[4](14,0) = -5.0/256.0;
- prolongation[4](14,3) = -1.0/256.0;
- prolongation[4](14,4) = -5.0/256.0;
- prolongation[4](14,7) = -1.0/256.0;
- prolongation[4](14,14) = -15.0/256.0;
- prolongation[4](14,15) = 5.0/256.0;
- prolongation[4](14,22) = -15.0/256.0;
- prolongation[4](14,23) = 5.0/256.0;
- prolongation[4](14,24) = 45.0/256.0;
- prolongation[4](14,25) = 45.0/256.0;
- prolongation[4](14,30) = 9.0/256.0;
- prolongation[4](14,31) = 9.0/256.0;
- prolongation[4](14,52) = 135.0/256.0;
- prolongation[4](14,53) = 135.0/256.0;
- prolongation[4](14,54) = -45.0/256.0;
- prolongation[4](14,55) = -45.0/256.0;
- prolongation[4](15,14) = -1.0/16.0;
- prolongation[4](15,22) = -1.0/16.0;
- prolongation[4](15,52) = 9.0/16.0;
- prolongation[4](15,53) = 9.0/16.0;
- prolongation[4](16,4) = 5.0/16.0;
- prolongation[4](16,5) = 1.0/16.0;
- prolongation[4](16,16) = 15.0/16.0;
- prolongation[4](16,17) = -5.0/16.0;
- prolongation[4](17,16) = 1.0;
- prolongation[4](18,4) = -5.0/256.0;
- prolongation[4](18,5) = -5.0/256.0;
- prolongation[4](18,6) = -1.0/256.0;
- prolongation[4](18,7) = -1.0/256.0;
- prolongation[4](18,16) = 45.0/256.0;
- prolongation[4](18,17) = 45.0/256.0;
- prolongation[4](18,18) = -15.0/256.0;
- prolongation[4](18,19) = 5.0/256.0;
- prolongation[4](18,20) = 9.0/256.0;
- prolongation[4](18,21) = 9.0/256.0;
- prolongation[4](18,22) = -15.0/256.0;
- prolongation[4](18,23) = 5.0/256.0;
- prolongation[4](18,36) = 135.0/256.0;
- prolongation[4](18,37) = 135.0/256.0;
- prolongation[4](18,38) = -45.0/256.0;
- prolongation[4](18,39) = -45.0/256.0;
- prolongation[4](19,18) = -1.0/16.0;
- prolongation[4](19,22) = -1.0/16.0;
- prolongation[4](19,36) = 9.0/16.0;
- prolongation[4](19,37) = 9.0/16.0;
- prolongation[4](20,4) = -5.0/256.0;
- prolongation[4](20,5) = -1.0/256.0;
- prolongation[4](20,6) = -1.0/256.0;
- prolongation[4](20,7) = -5.0/256.0;
- prolongation[4](20,16) = -15.0/256.0;
- prolongation[4](20,17) = 5.0/256.0;
- prolongation[4](20,18) = 9.0/256.0;
- prolongation[4](20,19) = 9.0/256.0;
- prolongation[4](20,20) = -15.0/256.0;
- prolongation[4](20,21) = 5.0/256.0;
- prolongation[4](20,22) = 45.0/256.0;
- prolongation[4](20,23) = 45.0/256.0;
- prolongation[4](20,36) = 135.0/256.0;
- prolongation[4](20,37) = -45.0/256.0;
- prolongation[4](20,38) = 135.0/256.0;
- prolongation[4](20,39) = -45.0/256.0;
- prolongation[4](21,16) = -1.0/16.0;
- prolongation[4](21,20) = -1.0/16.0;
- prolongation[4](21,36) = 9.0/16.0;
- prolongation[4](21,38) = 9.0/16.0;
- prolongation[4](22,4) = 5.0/16.0;
- prolongation[4](22,7) = 1.0/16.0;
- prolongation[4](22,22) = 15.0/16.0;
- prolongation[4](22,23) = -5.0/16.0;
- prolongation[4](23,22) = 1.0;
- prolongation[4](24,25) = 1.0;
- prolongation[4](25,0) = 1.0/16.0;
- prolongation[4](25,4) = 5.0/16.0;
- prolongation[4](25,24) = -5.0/16.0;
- prolongation[4](25,25) = 15.0/16.0;
- prolongation[4](26,25) = -1.0/16.0;
- prolongation[4](26,27) = -1.0/16.0;
- prolongation[4](26,42) = 9.0/16.0;
- prolongation[4](26,43) = 9.0/16.0;
- prolongation[4](27,0) = -1.0/256.0;
- prolongation[4](27,1) = -1.0/256.0;
- prolongation[4](27,4) = -5.0/256.0;
- prolongation[4](27,5) = -5.0/256.0;
- prolongation[4](27,8) = 9.0/256.0;
- prolongation[4](27,9) = 9.0/256.0;
- prolongation[4](27,16) = 45.0/256.0;
- prolongation[4](27,17) = 45.0/256.0;
- prolongation[4](27,24) = 5.0/256.0;
- prolongation[4](27,25) = -15.0/256.0;
- prolongation[4](27,26) = 5.0/256.0;
- prolongation[4](27,27) = -15.0/256.0;
- prolongation[4](27,40) = -45.0/256.0;
- prolongation[4](27,41) = -45.0/256.0;
- prolongation[4](27,42) = 135.0/256.0;
- prolongation[4](27,43) = 135.0/256.0;
- prolongation[4](28,25) = 1.0/256.0;
- prolongation[4](28,27) = 1.0/256.0;
- prolongation[4](28,29) = 1.0/256.0;
- prolongation[4](28,31) = 1.0/256.0;
- prolongation[4](28,42) = -9.0/256.0;
- prolongation[4](28,43) = -9.0/256.0;
- prolongation[4](28,45) = -9.0/256.0;
- prolongation[4](28,47) = -9.0/256.0;
- prolongation[4](28,50) = -9.0/256.0;
- prolongation[4](28,51) = -9.0/256.0;
- prolongation[4](28,53) = -9.0/256.0;
- prolongation[4](28,55) = -9.0/256.0;
- prolongation[4](28,58) = 81.0/256.0;
- prolongation[4](28,59) = 81.0/256.0;
- prolongation[4](28,62) = 81.0/256.0;
- prolongation[4](28,63) = 81.0/256.0;
- prolongation[4](29,0) = 1.0/4096.0;
- prolongation[4](29,1) = 1.0/4096.0;
- prolongation[4](29,2) = 1.0/4096.0;
- prolongation[4](29,3) = 1.0/4096.0;
- prolongation[4](29,4) = 5.0/4096.0;
- prolongation[4](29,5) = 5.0/4096.0;
- prolongation[4](29,6) = 5.0/4096.0;
- prolongation[4](29,7) = 5.0/4096.0;
- prolongation[4](29,8) = -9.0/4096.0;
- prolongation[4](29,9) = -9.0/4096.0;
- prolongation[4](29,10) = -9.0/4096.0;
- prolongation[4](29,11) = -9.0/4096.0;
- prolongation[4](29,12) = -9.0/4096.0;
- prolongation[4](29,13) = -9.0/4096.0;
- prolongation[4](29,14) = -9.0/4096.0;
- prolongation[4](29,15) = -9.0/4096.0;
- prolongation[4](29,16) = -45.0/4096.0;
- prolongation[4](29,17) = -45.0/4096.0;
- prolongation[4](29,18) = -45.0/4096.0;
- prolongation[4](29,19) = -45.0/4096.0;
- prolongation[4](29,20) = -45.0/4096.0;
- prolongation[4](29,21) = -45.0/4096.0;
- prolongation[4](29,22) = -45.0/4096.0;
- prolongation[4](29,23) = -45.0/4096.0;
- prolongation[4](29,24) = -5.0/4096.0;
- prolongation[4](29,25) = 15.0/4096.0;
- prolongation[4](29,26) = -5.0/4096.0;
- prolongation[4](29,27) = 15.0/4096.0;
- prolongation[4](29,28) = -5.0/4096.0;
- prolongation[4](29,29) = 15.0/4096.0;
- prolongation[4](29,30) = -5.0/4096.0;
- prolongation[4](29,31) = 15.0/4096.0;
- prolongation[4](29,32) = 81.0/4096.0;
- prolongation[4](29,33) = 81.0/4096.0;
- prolongation[4](29,34) = 81.0/4096.0;
- prolongation[4](29,35) = 81.0/4096.0;
- prolongation[4](29,36) = 405.0/4096.0;
- prolongation[4](29,37) = 405.0/4096.0;
- prolongation[4](29,38) = 405.0/4096.0;
- prolongation[4](29,39) = 405.0/4096.0;
- prolongation[4](29,40) = 45.0/4096.0;
- prolongation[4](29,41) = 45.0/4096.0;
- prolongation[4](29,42) = -135.0/4096.0;
- prolongation[4](29,43) = -135.0/4096.0;
- prolongation[4](29,44) = 45.0/4096.0;
- prolongation[4](29,45) = -135.0/4096.0;
- prolongation[4](29,46) = 45.0/4096.0;
- prolongation[4](29,47) = -135.0/4096.0;
- prolongation[4](29,48) = 45.0/4096.0;
- prolongation[4](29,49) = 45.0/4096.0;
- prolongation[4](29,50) = -135.0/4096.0;
- prolongation[4](29,51) = -135.0/4096.0;
- prolongation[4](29,52) = 45.0/4096.0;
- prolongation[4](29,53) = -135.0/4096.0;
- prolongation[4](29,54) = 45.0/4096.0;
- prolongation[4](29,55) = -135.0/4096.0;
- prolongation[4](29,56) = -405.0/4096.0;
- prolongation[4](29,57) = -405.0/4096.0;
- prolongation[4](29,58) = 1215.0/4096.0;
- prolongation[4](29,59) = 1215.0/4096.0;
- prolongation[4](29,60) = -405.0/4096.0;
- prolongation[4](29,61) = -405.0/4096.0;
- prolongation[4](29,62) = 1215.0/4096.0;
- prolongation[4](29,63) = 1215.0/4096.0;
- prolongation[4](30,25) = -1.0/16.0;
- prolongation[4](30,31) = -1.0/16.0;
- prolongation[4](30,53) = 9.0/16.0;
- prolongation[4](30,55) = 9.0/16.0;
- prolongation[4](31,0) = -1.0/256.0;
- prolongation[4](31,3) = -1.0/256.0;
- prolongation[4](31,4) = -5.0/256.0;
- prolongation[4](31,7) = -5.0/256.0;
- prolongation[4](31,14) = 9.0/256.0;
- prolongation[4](31,15) = 9.0/256.0;
- prolongation[4](31,22) = 45.0/256.0;
- prolongation[4](31,23) = 45.0/256.0;
- prolongation[4](31,24) = 5.0/256.0;
- prolongation[4](31,25) = -15.0/256.0;
- prolongation[4](31,30) = 5.0/256.0;
- prolongation[4](31,31) = -15.0/256.0;
- prolongation[4](31,52) = -45.0/256.0;
- prolongation[4](31,53) = 135.0/256.0;
- prolongation[4](31,54) = -45.0/256.0;
- prolongation[4](31,55) = 135.0/256.0;
- prolongation[4](32,0) = -25.0/4096.0;
- prolongation[4](32,1) = -5.0/4096.0;
- prolongation[4](32,2) = -1.0/4096.0;
- prolongation[4](32,3) = -5.0/4096.0;
- prolongation[4](32,4) = -25.0/4096.0;
- prolongation[4](32,5) = -5.0/4096.0;
- prolongation[4](32,6) = -1.0/4096.0;
- prolongation[4](32,7) = -5.0/4096.0;
- prolongation[4](32,8) = -75.0/4096.0;
- prolongation[4](32,9) = 25.0/4096.0;
- prolongation[4](32,10) = -15.0/4096.0;
- prolongation[4](32,11) = 5.0/4096.0;
- prolongation[4](32,12) = -15.0/4096.0;
- prolongation[4](32,13) = 5.0/4096.0;
- prolongation[4](32,14) = -75.0/4096.0;
- prolongation[4](32,15) = 25.0/4096.0;
- prolongation[4](32,16) = -75.0/4096.0;
- prolongation[4](32,17) = 25.0/4096.0;
- prolongation[4](32,18) = -15.0/4096.0;
- prolongation[4](32,19) = 5.0/4096.0;
- prolongation[4](32,20) = -15.0/4096.0;
- prolongation[4](32,21) = 5.0/4096.0;
- prolongation[4](32,22) = -75.0/4096.0;
- prolongation[4](32,23) = 25.0/4096.0;
- prolongation[4](32,24) = 225.0/4096.0;
- prolongation[4](32,25) = 225.0/4096.0;
- prolongation[4](32,26) = 45.0/4096.0;
- prolongation[4](32,27) = 45.0/4096.0;
- prolongation[4](32,28) = 9.0/4096.0;
- prolongation[4](32,29) = 9.0/4096.0;
- prolongation[4](32,30) = 45.0/4096.0;
- prolongation[4](32,31) = 45.0/4096.0;
- prolongation[4](32,32) = -225.0/4096.0;
- prolongation[4](32,33) = 75.0/4096.0;
- prolongation[4](32,34) = 75.0/4096.0;
- prolongation[4](32,35) = -25.0/4096.0;
- prolongation[4](32,36) = -225.0/4096.0;
- prolongation[4](32,37) = 75.0/4096.0;
- prolongation[4](32,38) = 75.0/4096.0;
- prolongation[4](32,39) = -25.0/4096.0;
- prolongation[4](32,40) = 675.0/4096.0;
- prolongation[4](32,41) = -225.0/4096.0;
- prolongation[4](32,42) = 675.0/4096.0;
- prolongation[4](32,43) = -225.0/4096.0;
- prolongation[4](32,44) = 135.0/4096.0;
- prolongation[4](32,45) = 135.0/4096.0;
- prolongation[4](32,46) = -45.0/4096.0;
- prolongation[4](32,47) = -45.0/4096.0;
- prolongation[4](32,48) = 135.0/4096.0;
- prolongation[4](32,49) = -45.0/4096.0;
- prolongation[4](32,50) = 135.0/4096.0;
- prolongation[4](32,51) = -45.0/4096.0;
- prolongation[4](32,52) = 675.0/4096.0;
- prolongation[4](32,53) = 675.0/4096.0;
- prolongation[4](32,54) = -225.0/4096.0;
- prolongation[4](32,55) = -225.0/4096.0;
- prolongation[4](32,56) = 2025.0/4096.0;
- prolongation[4](32,57) = -675.0/4096.0;
- prolongation[4](32,58) = 2025.0/4096.0;
- prolongation[4](32,59) = -675.0/4096.0;
- prolongation[4](32,60) = -675.0/4096.0;
- prolongation[4](32,61) = 225.0/4096.0;
- prolongation[4](32,62) = -675.0/4096.0;
- prolongation[4](32,63) = 225.0/4096.0;
- prolongation[4](33,8) = -5.0/256.0;
- prolongation[4](33,12) = -1.0/256.0;
- prolongation[4](33,16) = -5.0/256.0;
- prolongation[4](33,20) = -1.0/256.0;
- prolongation[4](33,32) = -15.0/256.0;
- prolongation[4](33,34) = 5.0/256.0;
- prolongation[4](33,36) = -15.0/256.0;
- prolongation[4](33,38) = 5.0/256.0;
- prolongation[4](33,40) = 45.0/256.0;
- prolongation[4](33,42) = 45.0/256.0;
- prolongation[4](33,48) = 9.0/256.0;
- prolongation[4](33,50) = 9.0/256.0;
- prolongation[4](33,56) = 135.0/256.0;
- prolongation[4](33,58) = 135.0/256.0;
- prolongation[4](33,60) = -45.0/256.0;
- prolongation[4](33,62) = -45.0/256.0;
- prolongation[4](34,10) = -1.0/256.0;
- prolongation[4](34,14) = -5.0/256.0;
- prolongation[4](34,18) = -1.0/256.0;
- prolongation[4](34,22) = -5.0/256.0;
- prolongation[4](34,32) = -15.0/256.0;
- prolongation[4](34,33) = 5.0/256.0;
- prolongation[4](34,36) = -15.0/256.0;
- prolongation[4](34,37) = 5.0/256.0;
- prolongation[4](34,44) = 9.0/256.0;
- prolongation[4](34,45) = 9.0/256.0;
- prolongation[4](34,52) = 45.0/256.0;
- prolongation[4](34,53) = 45.0/256.0;
- prolongation[4](34,56) = 135.0/256.0;
- prolongation[4](34,57) = -45.0/256.0;
- prolongation[4](34,58) = 135.0/256.0;
- prolongation[4](34,59) = -45.0/256.0;
- prolongation[4](35,32) = -1.0/16.0;
- prolongation[4](35,36) = -1.0/16.0;
- prolongation[4](35,56) = 9.0/16.0;
- prolongation[4](35,58) = 9.0/16.0;
- prolongation[4](36,4) = 25.0/256.0;
- prolongation[4](36,5) = 5.0/256.0;
- prolongation[4](36,6) = 1.0/256.0;
- prolongation[4](36,7) = 5.0/256.0;
- prolongation[4](36,16) = 75.0/256.0;
- prolongation[4](36,17) = -25.0/256.0;
- prolongation[4](36,18) = 15.0/256.0;
- prolongation[4](36,19) = -5.0/256.0;
- prolongation[4](36,20) = 15.0/256.0;
- prolongation[4](36,21) = -5.0/256.0;
- prolongation[4](36,22) = 75.0/256.0;
- prolongation[4](36,23) = -25.0/256.0;
- prolongation[4](36,36) = 225.0/256.0;
- prolongation[4](36,37) = -75.0/256.0;
- prolongation[4](36,38) = -75.0/256.0;
- prolongation[4](36,39) = 25.0/256.0;
- prolongation[4](37,16) = 5.0/16.0;
- prolongation[4](37,20) = 1.0/16.0;
- prolongation[4](37,36) = 15.0/16.0;
- prolongation[4](37,38) = -5.0/16.0;
- prolongation[4](38,18) = 1.0/16.0;
- prolongation[4](38,22) = 5.0/16.0;
- prolongation[4](38,36) = 15.0/16.0;
- prolongation[4](38,37) = -5.0/16.0;
- prolongation[4](39,36) = 1.0;
- prolongation[4](40,25) = 5.0/16.0;
- prolongation[4](40,27) = 1.0/16.0;
- prolongation[4](40,42) = 15.0/16.0;
- prolongation[4](40,43) = -5.0/16.0;
- prolongation[4](41,42) = 1.0;
- prolongation[4](42,0) = 5.0/256.0;
- prolongation[4](42,1) = 1.0/256.0;
- prolongation[4](42,4) = 25.0/256.0;
- prolongation[4](42,5) = 5.0/256.0;
- prolongation[4](42,8) = 15.0/256.0;
- prolongation[4](42,9) = -5.0/256.0;
- prolongation[4](42,16) = 75.0/256.0;
- prolongation[4](42,17) = -25.0/256.0;
- prolongation[4](42,24) = -25.0/256.0;
- prolongation[4](42,25) = 75.0/256.0;
- prolongation[4](42,26) = -5.0/256.0;
- prolongation[4](42,27) = 15.0/256.0;
- prolongation[4](42,40) = -75.0/256.0;
- prolongation[4](42,41) = 25.0/256.0;
- prolongation[4](42,42) = 225.0/256.0;
- prolongation[4](42,43) = -75.0/256.0;
- prolongation[4](43,8) = 1.0/16.0;
- prolongation[4](43,16) = 5.0/16.0;
- prolongation[4](43,40) = -5.0/16.0;
- prolongation[4](43,42) = 15.0/16.0;
- prolongation[4](44,25) = -5.0/256.0;
- prolongation[4](44,27) = -5.0/256.0;
- prolongation[4](44,29) = -1.0/256.0;
- prolongation[4](44,31) = -1.0/256.0;
- prolongation[4](44,42) = 45.0/256.0;
- prolongation[4](44,43) = 45.0/256.0;
- prolongation[4](44,45) = -15.0/256.0;
- prolongation[4](44,47) = 5.0/256.0;
- prolongation[4](44,50) = 9.0/256.0;
- prolongation[4](44,51) = 9.0/256.0;
- prolongation[4](44,53) = -15.0/256.0;
- prolongation[4](44,55) = 5.0/256.0;
- prolongation[4](44,58) = 135.0/256.0;
- prolongation[4](44,59) = 135.0/256.0;
- prolongation[4](44,62) = -45.0/256.0;
- prolongation[4](44,63) = -45.0/256.0;
- prolongation[4](45,0) = -5.0/4096.0;
- prolongation[4](45,1) = -5.0/4096.0;
- prolongation[4](45,2) = -1.0/4096.0;
- prolongation[4](45,3) = -1.0/4096.0;
- prolongation[4](45,4) = -25.0/4096.0;
- prolongation[4](45,5) = -25.0/4096.0;
- prolongation[4](45,6) = -5.0/4096.0;
- prolongation[4](45,7) = -5.0/4096.0;
- prolongation[4](45,8) = 45.0/4096.0;
- prolongation[4](45,9) = 45.0/4096.0;
- prolongation[4](45,10) = -15.0/4096.0;
- prolongation[4](45,11) = 5.0/4096.0;
- prolongation[4](45,12) = 9.0/4096.0;
- prolongation[4](45,13) = 9.0/4096.0;
- prolongation[4](45,14) = -15.0/4096.0;
- prolongation[4](45,15) = 5.0/4096.0;
- prolongation[4](45,16) = 225.0/4096.0;
- prolongation[4](45,17) = 225.0/4096.0;
- prolongation[4](45,18) = -75.0/4096.0;
- prolongation[4](45,19) = 25.0/4096.0;
- prolongation[4](45,20) = 45.0/4096.0;
- prolongation[4](45,21) = 45.0/4096.0;
- prolongation[4](45,22) = -75.0/4096.0;
- prolongation[4](45,23) = 25.0/4096.0;
- prolongation[4](45,24) = 25.0/4096.0;
- prolongation[4](45,25) = -75.0/4096.0;
- prolongation[4](45,26) = 25.0/4096.0;
- prolongation[4](45,27) = -75.0/4096.0;
- prolongation[4](45,28) = 5.0/4096.0;
- prolongation[4](45,29) = -15.0/4096.0;
- prolongation[4](45,30) = 5.0/4096.0;
- prolongation[4](45,31) = -15.0/4096.0;
- prolongation[4](45,32) = 135.0/4096.0;
- prolongation[4](45,33) = 135.0/4096.0;
- prolongation[4](45,34) = -45.0/4096.0;
- prolongation[4](45,35) = -45.0/4096.0;
- prolongation[4](45,36) = 675.0/4096.0;
- prolongation[4](45,37) = 675.0/4096.0;
- prolongation[4](45,38) = -225.0/4096.0;
- prolongation[4](45,39) = -225.0/4096.0;
- prolongation[4](45,40) = -225.0/4096.0;
- prolongation[4](45,41) = -225.0/4096.0;
- prolongation[4](45,42) = 675.0/4096.0;
- prolongation[4](45,43) = 675.0/4096.0;
- prolongation[4](45,44) = 75.0/4096.0;
- prolongation[4](45,45) = -225.0/4096.0;
- prolongation[4](45,46) = -25.0/4096.0;
- prolongation[4](45,47) = 75.0/4096.0;
- prolongation[4](45,48) = -45.0/4096.0;
- prolongation[4](45,49) = -45.0/4096.0;
- prolongation[4](45,50) = 135.0/4096.0;
- prolongation[4](45,51) = 135.0/4096.0;
- prolongation[4](45,52) = 75.0/4096.0;
- prolongation[4](45,53) = -225.0/4096.0;
- prolongation[4](45,54) = -25.0/4096.0;
- prolongation[4](45,55) = 75.0/4096.0;
- prolongation[4](45,56) = -675.0/4096.0;
- prolongation[4](45,57) = -675.0/4096.0;
- prolongation[4](45,58) = 2025.0/4096.0;
- prolongation[4](45,59) = 2025.0/4096.0;
- prolongation[4](45,60) = 225.0/4096.0;
- prolongation[4](45,61) = 225.0/4096.0;
- prolongation[4](45,62) = -675.0/4096.0;
- prolongation[4](45,63) = -675.0/4096.0;
- prolongation[4](46,45) = -1.0/16.0;
- prolongation[4](46,53) = -1.0/16.0;
- prolongation[4](46,58) = 9.0/16.0;
- prolongation[4](46,59) = 9.0/16.0;
- prolongation[4](47,10) = -1.0/256.0;
- prolongation[4](47,14) = -1.0/256.0;
- prolongation[4](47,18) = -5.0/256.0;
- prolongation[4](47,22) = -5.0/256.0;
- prolongation[4](47,32) = 9.0/256.0;
- prolongation[4](47,33) = 9.0/256.0;
- prolongation[4](47,36) = 45.0/256.0;
- prolongation[4](47,37) = 45.0/256.0;
- prolongation[4](47,44) = 5.0/256.0;
- prolongation[4](47,45) = -15.0/256.0;
- prolongation[4](47,52) = 5.0/256.0;
- prolongation[4](47,53) = -15.0/256.0;
- prolongation[4](47,56) = -45.0/256.0;
- prolongation[4](47,57) = -45.0/256.0;
- prolongation[4](47,58) = 135.0/256.0;
- prolongation[4](47,59) = 135.0/256.0;
- prolongation[4](48,25) = -5.0/256.0;
- prolongation[4](48,27) = -1.0/256.0;
- prolongation[4](48,29) = -1.0/256.0;
- prolongation[4](48,31) = -5.0/256.0;
- prolongation[4](48,42) = -15.0/256.0;
- prolongation[4](48,43) = 5.0/256.0;
- prolongation[4](48,45) = 9.0/256.0;
- prolongation[4](48,47) = 9.0/256.0;
- prolongation[4](48,50) = -15.0/256.0;
- prolongation[4](48,51) = 5.0/256.0;
- prolongation[4](48,53) = 45.0/256.0;
- prolongation[4](48,55) = 45.0/256.0;
- prolongation[4](48,58) = 135.0/256.0;
- prolongation[4](48,59) = -45.0/256.0;
- prolongation[4](48,62) = 135.0/256.0;
- prolongation[4](48,63) = -45.0/256.0;
- prolongation[4](49,42) = -1.0/16.0;
- prolongation[4](49,50) = -1.0/16.0;
- prolongation[4](49,58) = 9.0/16.0;
- prolongation[4](49,62) = 9.0/16.0;
- prolongation[4](50,0) = -5.0/4096.0;
- prolongation[4](50,1) = -1.0/4096.0;
- prolongation[4](50,2) = -1.0/4096.0;
- prolongation[4](50,3) = -5.0/4096.0;
- prolongation[4](50,4) = -25.0/4096.0;
- prolongation[4](50,5) = -5.0/4096.0;
- prolongation[4](50,6) = -5.0/4096.0;
- prolongation[4](50,7) = -25.0/4096.0;
- prolongation[4](50,8) = -15.0/4096.0;
- prolongation[4](50,9) = 5.0/4096.0;
- prolongation[4](50,10) = 9.0/4096.0;
- prolongation[4](50,11) = 9.0/4096.0;
- prolongation[4](50,12) = -15.0/4096.0;
- prolongation[4](50,13) = 5.0/4096.0;
- prolongation[4](50,14) = 45.0/4096.0;
- prolongation[4](50,15) = 45.0/4096.0;
- prolongation[4](50,16) = -75.0/4096.0;
- prolongation[4](50,17) = 25.0/4096.0;
- prolongation[4](50,18) = 45.0/4096.0;
- prolongation[4](50,19) = 45.0/4096.0;
- prolongation[4](50,20) = -75.0/4096.0;
- prolongation[4](50,21) = 25.0/4096.0;
- prolongation[4](50,22) = 225.0/4096.0;
- prolongation[4](50,23) = 225.0/4096.0;
- prolongation[4](50,24) = 25.0/4096.0;
- prolongation[4](50,25) = -75.0/4096.0;
- prolongation[4](50,26) = 5.0/4096.0;
- prolongation[4](50,27) = -15.0/4096.0;
- prolongation[4](50,28) = 5.0/4096.0;
- prolongation[4](50,29) = -15.0/4096.0;
- prolongation[4](50,30) = 25.0/4096.0;
- prolongation[4](50,31) = -75.0/4096.0;
- prolongation[4](50,32) = 135.0/4096.0;
- prolongation[4](50,33) = -45.0/4096.0;
- prolongation[4](50,34) = 135.0/4096.0;
- prolongation[4](50,35) = -45.0/4096.0;
- prolongation[4](50,36) = 675.0/4096.0;
- prolongation[4](50,37) = -225.0/4096.0;
- prolongation[4](50,38) = 675.0/4096.0;
- prolongation[4](50,39) = -225.0/4096.0;
- prolongation[4](50,40) = 75.0/4096.0;
- prolongation[4](50,41) = -25.0/4096.0;
- prolongation[4](50,42) = -225.0/4096.0;
- prolongation[4](50,43) = 75.0/4096.0;
- prolongation[4](50,44) = -45.0/4096.0;
- prolongation[4](50,45) = 135.0/4096.0;
- prolongation[4](50,46) = -45.0/4096.0;
- prolongation[4](50,47) = 135.0/4096.0;
- prolongation[4](50,48) = 75.0/4096.0;
- prolongation[4](50,49) = -25.0/4096.0;
- prolongation[4](50,50) = -225.0/4096.0;
- prolongation[4](50,51) = 75.0/4096.0;
- prolongation[4](50,52) = -225.0/4096.0;
- prolongation[4](50,53) = 675.0/4096.0;
- prolongation[4](50,54) = -225.0/4096.0;
- prolongation[4](50,55) = 675.0/4096.0;
- prolongation[4](50,56) = -675.0/4096.0;
- prolongation[4](50,57) = 225.0/4096.0;
- prolongation[4](50,58) = 2025.0/4096.0;
- prolongation[4](50,59) = -675.0/4096.0;
- prolongation[4](50,60) = -675.0/4096.0;
- prolongation[4](50,61) = 225.0/4096.0;
- prolongation[4](50,62) = 2025.0/4096.0;
- prolongation[4](50,63) = -675.0/4096.0;
- prolongation[4](51,8) = -1.0/256.0;
- prolongation[4](51,12) = -1.0/256.0;
- prolongation[4](51,16) = -5.0/256.0;
- prolongation[4](51,20) = -5.0/256.0;
- prolongation[4](51,32) = 9.0/256.0;
- prolongation[4](51,34) = 9.0/256.0;
- prolongation[4](51,36) = 45.0/256.0;
- prolongation[4](51,38) = 45.0/256.0;
- prolongation[4](51,40) = 5.0/256.0;
- prolongation[4](51,42) = -15.0/256.0;
- prolongation[4](51,48) = 5.0/256.0;
- prolongation[4](51,50) = -15.0/256.0;
- prolongation[4](51,56) = -45.0/256.0;
- prolongation[4](51,58) = 135.0/256.0;
- prolongation[4](51,60) = -45.0/256.0;
- prolongation[4](51,62) = 135.0/256.0;
- prolongation[4](52,25) = 5.0/16.0;
- prolongation[4](52,31) = 1.0/16.0;
- prolongation[4](52,53) = 15.0/16.0;
- prolongation[4](52,55) = -5.0/16.0;
- prolongation[4](53,0) = 5.0/256.0;
- prolongation[4](53,3) = 1.0/256.0;
- prolongation[4](53,4) = 25.0/256.0;
- prolongation[4](53,7) = 5.0/256.0;
- prolongation[4](53,14) = 15.0/256.0;
- prolongation[4](53,15) = -5.0/256.0;
- prolongation[4](53,22) = 75.0/256.0;
- prolongation[4](53,23) = -25.0/256.0;
- prolongation[4](53,24) = -25.0/256.0;
- prolongation[4](53,25) = 75.0/256.0;
- prolongation[4](53,30) = -5.0/256.0;
- prolongation[4](53,31) = 15.0/256.0;
- prolongation[4](53,52) = -75.0/256.0;
- prolongation[4](53,53) = 225.0/256.0;
- prolongation[4](53,54) = 25.0/256.0;
- prolongation[4](53,55) = -75.0/256.0;
- prolongation[4](54,53) = 1.0;
- prolongation[4](55,14) = 1.0/16.0;
- prolongation[4](55,22) = 5.0/16.0;
- prolongation[4](55,52) = -5.0/16.0;
- prolongation[4](55,53) = 15.0/16.0;
- prolongation[4](56,25) = 25.0/256.0;
- prolongation[4](56,27) = 5.0/256.0;
- prolongation[4](56,29) = 1.0/256.0;
- prolongation[4](56,31) = 5.0/256.0;
- prolongation[4](56,42) = 75.0/256.0;
- prolongation[4](56,43) = -25.0/256.0;
- prolongation[4](56,45) = 15.0/256.0;
- prolongation[4](56,47) = -5.0/256.0;
- prolongation[4](56,50) = 15.0/256.0;
- prolongation[4](56,51) = -5.0/256.0;
- prolongation[4](56,53) = 75.0/256.0;
- prolongation[4](56,55) = -25.0/256.0;
- prolongation[4](56,58) = 225.0/256.0;
- prolongation[4](56,59) = -75.0/256.0;
- prolongation[4](56,62) = -75.0/256.0;
- prolongation[4](56,63) = 25.0/256.0;
- prolongation[4](57,42) = 5.0/16.0;
- prolongation[4](57,50) = 1.0/16.0;
- prolongation[4](57,58) = 15.0/16.0;
- prolongation[4](57,62) = -5.0/16.0;
- prolongation[4](58,0) = 25.0/4096.0;
- prolongation[4](58,1) = 5.0/4096.0;
- prolongation[4](58,2) = 1.0/4096.0;
- prolongation[4](58,3) = 5.0/4096.0;
- prolongation[4](58,4) = 125.0/4096.0;
- prolongation[4](58,5) = 25.0/4096.0;
- prolongation[4](58,6) = 5.0/4096.0;
- prolongation[4](58,7) = 25.0/4096.0;
- prolongation[4](58,8) = 75.0/4096.0;
- prolongation[4](58,9) = -25.0/4096.0;
- prolongation[4](58,10) = 15.0/4096.0;
- prolongation[4](58,11) = -5.0/4096.0;
- prolongation[4](58,12) = 15.0/4096.0;
- prolongation[4](58,13) = -5.0/4096.0;
- prolongation[4](58,14) = 75.0/4096.0;
- prolongation[4](58,15) = -25.0/4096.0;
- prolongation[4](58,16) = 375.0/4096.0;
- prolongation[4](58,17) = -125.0/4096.0;
- prolongation[4](58,18) = 75.0/4096.0;
- prolongation[4](58,19) = -25.0/4096.0;
- prolongation[4](58,20) = 75.0/4096.0;
- prolongation[4](58,21) = -25.0/4096.0;
- prolongation[4](58,22) = 375.0/4096.0;
- prolongation[4](58,23) = -125.0/4096.0;
- prolongation[4](58,24) = -125.0/4096.0;
- prolongation[4](58,25) = 375.0/4096.0;
- prolongation[4](58,26) = -25.0/4096.0;
- prolongation[4](58,27) = 75.0/4096.0;
- prolongation[4](58,28) = -5.0/4096.0;
- prolongation[4](58,29) = 15.0/4096.0;
- prolongation[4](58,30) = -25.0/4096.0;
- prolongation[4](58,31) = 75.0/4096.0;
- prolongation[4](58,32) = 225.0/4096.0;
- prolongation[4](58,33) = -75.0/4096.0;
- prolongation[4](58,34) = -75.0/4096.0;
- prolongation[4](58,35) = 25.0/4096.0;
- prolongation[4](58,36) = 1125.0/4096.0;
- prolongation[4](58,37) = -375.0/4096.0;
- prolongation[4](58,38) = -375.0/4096.0;
- prolongation[4](58,39) = 125.0/4096.0;
- prolongation[4](58,40) = -375.0/4096.0;
- prolongation[4](58,41) = 125.0/4096.0;
- prolongation[4](58,42) = 1125.0/4096.0;
- prolongation[4](58,43) = -375.0/4096.0;
- prolongation[4](58,44) = -75.0/4096.0;
- prolongation[4](58,45) = 225.0/4096.0;
- prolongation[4](58,46) = 25.0/4096.0;
- prolongation[4](58,47) = -75.0/4096.0;
- prolongation[4](58,48) = -75.0/4096.0;
- prolongation[4](58,49) = 25.0/4096.0;
- prolongation[4](58,50) = 225.0/4096.0;
- prolongation[4](58,51) = -75.0/4096.0;
- prolongation[4](58,52) = -375.0/4096.0;
- prolongation[4](58,53) = 1125.0/4096.0;
- prolongation[4](58,54) = 125.0/4096.0;
- prolongation[4](58,55) = -375.0/4096.0;
- prolongation[4](58,56) = -1125.0/4096.0;
- prolongation[4](58,57) = 375.0/4096.0;
- prolongation[4](58,58) = 3375.0/4096.0;
- prolongation[4](58,59) = -1125.0/4096.0;
- prolongation[4](58,60) = 375.0/4096.0;
- prolongation[4](58,61) = -125.0/4096.0;
- prolongation[4](58,62) = -1125.0/4096.0;
- prolongation[4](58,63) = 375.0/4096.0;
- prolongation[4](59,8) = 5.0/256.0;
- prolongation[4](59,12) = 1.0/256.0;
- prolongation[4](59,16) = 25.0/256.0;
- prolongation[4](59,20) = 5.0/256.0;
- prolongation[4](59,32) = 15.0/256.0;
- prolongation[4](59,34) = -5.0/256.0;
- prolongation[4](59,36) = 75.0/256.0;
- prolongation[4](59,38) = -25.0/256.0;
- prolongation[4](59,40) = -25.0/256.0;
- prolongation[4](59,42) = 75.0/256.0;
- prolongation[4](59,48) = -5.0/256.0;
- prolongation[4](59,50) = 15.0/256.0;
- prolongation[4](59,56) = -75.0/256.0;
- prolongation[4](59,58) = 225.0/256.0;
- prolongation[4](59,60) = 25.0/256.0;
- prolongation[4](59,62) = -75.0/256.0;
- prolongation[4](60,45) = 1.0/16.0;
- prolongation[4](60,53) = 5.0/16.0;
- prolongation[4](60,58) = 15.0/16.0;
- prolongation[4](60,59) = -5.0/16.0;
- prolongation[4](61,58) = 1.0;
- prolongation[4](62,10) = 1.0/256.0;
- prolongation[4](62,14) = 5.0/256.0;
- prolongation[4](62,18) = 5.0/256.0;
- prolongation[4](62,22) = 25.0/256.0;
- prolongation[4](62,32) = 15.0/256.0;
- prolongation[4](62,33) = -5.0/256.0;
- prolongation[4](62,36) = 75.0/256.0;
- prolongation[4](62,37) = -25.0/256.0;
- prolongation[4](62,44) = -5.0/256.0;
- prolongation[4](62,45) = 15.0/256.0;
- prolongation[4](62,52) = -25.0/256.0;
- prolongation[4](62,53) = 75.0/256.0;
- prolongation[4](62,56) = -75.0/256.0;
- prolongation[4](62,57) = 25.0/256.0;
- prolongation[4](62,58) = 225.0/256.0;
- prolongation[4](62,59) = -75.0/256.0;
- prolongation[4](63,32) = 1.0/16.0;
- prolongation[4](63,36) = 5.0/16.0;
- prolongation[4](63,56) = -5.0/16.0;
- prolongation[4](63,58) = 15.0/16.0;
- prolongation[5](0,0) = 1.0/256.0;
- prolongation[5](0,1) = 1.0/256.0;
- prolongation[5](0,4) = 1.0/256.0;
- prolongation[5](0,5) = 1.0/256.0;
- prolongation[5](0,8) = -9.0/256.0;
- prolongation[5](0,9) = -9.0/256.0;
- prolongation[5](0,16) = -9.0/256.0;
- prolongation[5](0,17) = -9.0/256.0;
- prolongation[5](0,24) = -9.0/256.0;
- prolongation[5](0,25) = -9.0/256.0;
- prolongation[5](0,26) = -9.0/256.0;
- prolongation[5](0,27) = -9.0/256.0;
- prolongation[5](0,40) = 81.0/256.0;
- prolongation[5](0,41) = 81.0/256.0;
- prolongation[5](0,42) = 81.0/256.0;
- prolongation[5](0,43) = 81.0/256.0;
- prolongation[5](1,1) = -1.0/16.0;
- prolongation[5](1,5) = -1.0/16.0;
- prolongation[5](1,26) = 9.0/16.0;
- prolongation[5](1,27) = 9.0/16.0;
- prolongation[5](2,1) = 1.0/256.0;
- prolongation[5](2,2) = 1.0/256.0;
- prolongation[5](2,5) = 1.0/256.0;
- prolongation[5](2,6) = 1.0/256.0;
- prolongation[5](2,10) = -9.0/256.0;
- prolongation[5](2,11) = -9.0/256.0;
- prolongation[5](2,18) = -9.0/256.0;
- prolongation[5](2,19) = -9.0/256.0;
- prolongation[5](2,26) = -9.0/256.0;
- prolongation[5](2,27) = -9.0/256.0;
- prolongation[5](2,28) = -9.0/256.0;
- prolongation[5](2,29) = -9.0/256.0;
- prolongation[5](2,44) = 81.0/256.0;
- prolongation[5](2,45) = 81.0/256.0;
- prolongation[5](2,46) = 81.0/256.0;
- prolongation[5](2,47) = 81.0/256.0;
- prolongation[5](3,0) = -1.0/4096.0;
- prolongation[5](3,1) = -1.0/4096.0;
- prolongation[5](3,2) = -1.0/4096.0;
- prolongation[5](3,3) = -1.0/4096.0;
- prolongation[5](3,4) = -1.0/4096.0;
- prolongation[5](3,5) = -1.0/4096.0;
- prolongation[5](3,6) = -1.0/4096.0;
- prolongation[5](3,7) = -1.0/4096.0;
- prolongation[5](3,8) = 9.0/4096.0;
- prolongation[5](3,9) = 9.0/4096.0;
- prolongation[5](3,10) = 9.0/4096.0;
- prolongation[5](3,11) = 9.0/4096.0;
- prolongation[5](3,12) = 9.0/4096.0;
- prolongation[5](3,13) = 9.0/4096.0;
- prolongation[5](3,14) = 9.0/4096.0;
- prolongation[5](3,15) = 9.0/4096.0;
- prolongation[5](3,16) = 9.0/4096.0;
- prolongation[5](3,17) = 9.0/4096.0;
- prolongation[5](3,18) = 9.0/4096.0;
- prolongation[5](3,19) = 9.0/4096.0;
- prolongation[5](3,20) = 9.0/4096.0;
- prolongation[5](3,21) = 9.0/4096.0;
- prolongation[5](3,22) = 9.0/4096.0;
- prolongation[5](3,23) = 9.0/4096.0;
- prolongation[5](3,24) = 9.0/4096.0;
- prolongation[5](3,25) = 9.0/4096.0;
- prolongation[5](3,26) = 9.0/4096.0;
- prolongation[5](3,27) = 9.0/4096.0;
- prolongation[5](3,28) = 9.0/4096.0;
- prolongation[5](3,29) = 9.0/4096.0;
- prolongation[5](3,30) = 9.0/4096.0;
- prolongation[5](3,31) = 9.0/4096.0;
- prolongation[5](3,32) = -81.0/4096.0;
- prolongation[5](3,33) = -81.0/4096.0;
- prolongation[5](3,34) = -81.0/4096.0;
- prolongation[5](3,35) = -81.0/4096.0;
- prolongation[5](3,36) = -81.0/4096.0;
- prolongation[5](3,37) = -81.0/4096.0;
- prolongation[5](3,38) = -81.0/4096.0;
- prolongation[5](3,39) = -81.0/4096.0;
- prolongation[5](3,40) = -81.0/4096.0;
- prolongation[5](3,41) = -81.0/4096.0;
- prolongation[5](3,42) = -81.0/4096.0;
- prolongation[5](3,43) = -81.0/4096.0;
- prolongation[5](3,44) = -81.0/4096.0;
- prolongation[5](3,45) = -81.0/4096.0;
- prolongation[5](3,46) = -81.0/4096.0;
- prolongation[5](3,47) = -81.0/4096.0;
- prolongation[5](3,48) = -81.0/4096.0;
- prolongation[5](3,49) = -81.0/4096.0;
- prolongation[5](3,50) = -81.0/4096.0;
- prolongation[5](3,51) = -81.0/4096.0;
- prolongation[5](3,52) = -81.0/4096.0;
- prolongation[5](3,53) = -81.0/4096.0;
- prolongation[5](3,54) = -81.0/4096.0;
- prolongation[5](3,55) = -81.0/4096.0;
- prolongation[5](3,56) = 729.0/4096.0;
- prolongation[5](3,57) = 729.0/4096.0;
- prolongation[5](3,58) = 729.0/4096.0;
- prolongation[5](3,59) = 729.0/4096.0;
- prolongation[5](3,60) = 729.0/4096.0;
- prolongation[5](3,61) = 729.0/4096.0;
- prolongation[5](3,62) = 729.0/4096.0;
- prolongation[5](3,63) = 729.0/4096.0;
- prolongation[5](4,4) = -1.0/16.0;
- prolongation[5](4,5) = -1.0/16.0;
- prolongation[5](4,16) = 9.0/16.0;
- prolongation[5](4,17) = 9.0/16.0;
- prolongation[5](5,5) = 1.0;
- prolongation[5](6,5) = -1.0/16.0;
- prolongation[5](6,6) = -1.0/16.0;
- prolongation[5](6,18) = 9.0/16.0;
- prolongation[5](6,19) = 9.0/16.0;
- prolongation[5](7,4) = 1.0/256.0;
- prolongation[5](7,5) = 1.0/256.0;
- prolongation[5](7,6) = 1.0/256.0;
- prolongation[5](7,7) = 1.0/256.0;
- prolongation[5](7,16) = -9.0/256.0;
- prolongation[5](7,17) = -9.0/256.0;
- prolongation[5](7,18) = -9.0/256.0;
- prolongation[5](7,19) = -9.0/256.0;
- prolongation[5](7,20) = -9.0/256.0;
- prolongation[5](7,21) = -9.0/256.0;
- prolongation[5](7,22) = -9.0/256.0;
- prolongation[5](7,23) = -9.0/256.0;
- prolongation[5](7,36) = 81.0/256.0;
- prolongation[5](7,37) = 81.0/256.0;
- prolongation[5](7,38) = 81.0/256.0;
- prolongation[5](7,39) = 81.0/256.0;
- prolongation[5](8,9) = -1.0/16.0;
- prolongation[5](8,17) = -1.0/16.0;
- prolongation[5](8,41) = 9.0/16.0;
- prolongation[5](8,43) = 9.0/16.0;
- prolongation[5](9,0) = -1.0/256.0;
- prolongation[5](9,1) = -5.0/256.0;
- prolongation[5](9,4) = -1.0/256.0;
- prolongation[5](9,5) = -5.0/256.0;
- prolongation[5](9,8) = 5.0/256.0;
- prolongation[5](9,9) = -15.0/256.0;
- prolongation[5](9,16) = 5.0/256.0;
- prolongation[5](9,17) = -15.0/256.0;
- prolongation[5](9,24) = 9.0/256.0;
- prolongation[5](9,25) = 9.0/256.0;
- prolongation[5](9,26) = 45.0/256.0;
- prolongation[5](9,27) = 45.0/256.0;
- prolongation[5](9,40) = -45.0/256.0;
- prolongation[5](9,41) = 135.0/256.0;
- prolongation[5](9,42) = -45.0/256.0;
- prolongation[5](9,43) = 135.0/256.0;
- prolongation[5](10,1) = -5.0/256.0;
- prolongation[5](10,2) = -1.0/256.0;
- prolongation[5](10,5) = -5.0/256.0;
- prolongation[5](10,6) = -1.0/256.0;
- prolongation[5](10,10) = -15.0/256.0;
- prolongation[5](10,11) = 5.0/256.0;
- prolongation[5](10,18) = -15.0/256.0;
- prolongation[5](10,19) = 5.0/256.0;
- prolongation[5](10,26) = 45.0/256.0;
- prolongation[5](10,27) = 45.0/256.0;
- prolongation[5](10,28) = 9.0/256.0;
- prolongation[5](10,29) = 9.0/256.0;
- prolongation[5](10,44) = 135.0/256.0;
- prolongation[5](10,45) = 135.0/256.0;
- prolongation[5](10,46) = -45.0/256.0;
- prolongation[5](10,47) = -45.0/256.0;
- prolongation[5](11,10) = -1.0/16.0;
- prolongation[5](11,18) = -1.0/16.0;
- prolongation[5](11,44) = 9.0/16.0;
- prolongation[5](11,45) = 9.0/16.0;
- prolongation[5](12,9) = 1.0/256.0;
- prolongation[5](12,13) = 1.0/256.0;
- prolongation[5](12,17) = 1.0/256.0;
- prolongation[5](12,21) = 1.0/256.0;
- prolongation[5](12,33) = -9.0/256.0;
- prolongation[5](12,35) = -9.0/256.0;
- prolongation[5](12,37) = -9.0/256.0;
- prolongation[5](12,39) = -9.0/256.0;
- prolongation[5](12,41) = -9.0/256.0;
- prolongation[5](12,43) = -9.0/256.0;
- prolongation[5](12,49) = -9.0/256.0;
- prolongation[5](12,51) = -9.0/256.0;
- prolongation[5](12,57) = 81.0/256.0;
- prolongation[5](12,59) = 81.0/256.0;
- prolongation[5](12,61) = 81.0/256.0;
- prolongation[5](12,63) = 81.0/256.0;
- prolongation[5](13,0) = 1.0/4096.0;
- prolongation[5](13,1) = 5.0/4096.0;
- prolongation[5](13,2) = 5.0/4096.0;
- prolongation[5](13,3) = 1.0/4096.0;
- prolongation[5](13,4) = 1.0/4096.0;
- prolongation[5](13,5) = 5.0/4096.0;
- prolongation[5](13,6) = 5.0/4096.0;
- prolongation[5](13,7) = 1.0/4096.0;
- prolongation[5](13,8) = -5.0/4096.0;
- prolongation[5](13,9) = 15.0/4096.0;
- prolongation[5](13,10) = -45.0/4096.0;
- prolongation[5](13,11) = -45.0/4096.0;
- prolongation[5](13,12) = -5.0/4096.0;
- prolongation[5](13,13) = 15.0/4096.0;
- prolongation[5](13,14) = -9.0/4096.0;
- prolongation[5](13,15) = -9.0/4096.0;
- prolongation[5](13,16) = -5.0/4096.0;
- prolongation[5](13,17) = 15.0/4096.0;
- prolongation[5](13,18) = -45.0/4096.0;
- prolongation[5](13,19) = -45.0/4096.0;
- prolongation[5](13,20) = -5.0/4096.0;
- prolongation[5](13,21) = 15.0/4096.0;
- prolongation[5](13,22) = -9.0/4096.0;
- prolongation[5](13,23) = -9.0/4096.0;
- prolongation[5](13,24) = -9.0/4096.0;
- prolongation[5](13,25) = -9.0/4096.0;
- prolongation[5](13,26) = -45.0/4096.0;
- prolongation[5](13,27) = -45.0/4096.0;
- prolongation[5](13,28) = -45.0/4096.0;
- prolongation[5](13,29) = -45.0/4096.0;
- prolongation[5](13,30) = -9.0/4096.0;
- prolongation[5](13,31) = -9.0/4096.0;
- prolongation[5](13,32) = 45.0/4096.0;
- prolongation[5](13,33) = -135.0/4096.0;
- prolongation[5](13,34) = 45.0/4096.0;
- prolongation[5](13,35) = -135.0/4096.0;
- prolongation[5](13,36) = 45.0/4096.0;
- prolongation[5](13,37) = -135.0/4096.0;
- prolongation[5](13,38) = 45.0/4096.0;
- prolongation[5](13,39) = -135.0/4096.0;
- prolongation[5](13,40) = 45.0/4096.0;
- prolongation[5](13,41) = -135.0/4096.0;
- prolongation[5](13,42) = 45.0/4096.0;
- prolongation[5](13,43) = -135.0/4096.0;
- prolongation[5](13,44) = 405.0/4096.0;
- prolongation[5](13,45) = 405.0/4096.0;
- prolongation[5](13,46) = 405.0/4096.0;
- prolongation[5](13,47) = 405.0/4096.0;
- prolongation[5](13,48) = 45.0/4096.0;
- prolongation[5](13,49) = -135.0/4096.0;
- prolongation[5](13,50) = 45.0/4096.0;
- prolongation[5](13,51) = -135.0/4096.0;
- prolongation[5](13,52) = 81.0/4096.0;
- prolongation[5](13,53) = 81.0/4096.0;
- prolongation[5](13,54) = 81.0/4096.0;
- prolongation[5](13,55) = 81.0/4096.0;
- prolongation[5](13,56) = -405.0/4096.0;
- prolongation[5](13,57) = 1215.0/4096.0;
- prolongation[5](13,58) = -405.0/4096.0;
- prolongation[5](13,59) = 1215.0/4096.0;
- prolongation[5](13,60) = -405.0/4096.0;
- prolongation[5](13,61) = 1215.0/4096.0;
- prolongation[5](13,62) = -405.0/4096.0;
- prolongation[5](13,63) = 1215.0/4096.0;
- prolongation[5](14,0) = 5.0/4096.0;
- prolongation[5](14,1) = 5.0/4096.0;
- prolongation[5](14,2) = 1.0/4096.0;
- prolongation[5](14,3) = 1.0/4096.0;
- prolongation[5](14,4) = 5.0/4096.0;
- prolongation[5](14,5) = 5.0/4096.0;
- prolongation[5](14,6) = 1.0/4096.0;
- prolongation[5](14,7) = 1.0/4096.0;
- prolongation[5](14,8) = -45.0/4096.0;
- prolongation[5](14,9) = -45.0/4096.0;
- prolongation[5](14,10) = 15.0/4096.0;
- prolongation[5](14,11) = -5.0/4096.0;
- prolongation[5](14,12) = -9.0/4096.0;
- prolongation[5](14,13) = -9.0/4096.0;
- prolongation[5](14,14) = 15.0/4096.0;
- prolongation[5](14,15) = -5.0/4096.0;
- prolongation[5](14,16) = -45.0/4096.0;
- prolongation[5](14,17) = -45.0/4096.0;
- prolongation[5](14,18) = 15.0/4096.0;
- prolongation[5](14,19) = -5.0/4096.0;
- prolongation[5](14,20) = -9.0/4096.0;
- prolongation[5](14,21) = -9.0/4096.0;
- prolongation[5](14,22) = 15.0/4096.0;
- prolongation[5](14,23) = -5.0/4096.0;
- prolongation[5](14,24) = -45.0/4096.0;
- prolongation[5](14,25) = -45.0/4096.0;
- prolongation[5](14,26) = -45.0/4096.0;
- prolongation[5](14,27) = -45.0/4096.0;
- prolongation[5](14,28) = -9.0/4096.0;
- prolongation[5](14,29) = -9.0/4096.0;
- prolongation[5](14,30) = -9.0/4096.0;
- prolongation[5](14,31) = -9.0/4096.0;
- prolongation[5](14,32) = -135.0/4096.0;
- prolongation[5](14,33) = -135.0/4096.0;
- prolongation[5](14,34) = 45.0/4096.0;
- prolongation[5](14,35) = 45.0/4096.0;
- prolongation[5](14,36) = -135.0/4096.0;
- prolongation[5](14,37) = -135.0/4096.0;
- prolongation[5](14,38) = 45.0/4096.0;
- prolongation[5](14,39) = 45.0/4096.0;
- prolongation[5](14,40) = 405.0/4096.0;
- prolongation[5](14,41) = 405.0/4096.0;
- prolongation[5](14,42) = 405.0/4096.0;
- prolongation[5](14,43) = 405.0/4096.0;
- prolongation[5](14,44) = -135.0/4096.0;
- prolongation[5](14,45) = -135.0/4096.0;
- prolongation[5](14,46) = 45.0/4096.0;
- prolongation[5](14,47) = 45.0/4096.0;
- prolongation[5](14,48) = 81.0/4096.0;
- prolongation[5](14,49) = 81.0/4096.0;
- prolongation[5](14,50) = 81.0/4096.0;
- prolongation[5](14,51) = 81.0/4096.0;
- prolongation[5](14,52) = -135.0/4096.0;
- prolongation[5](14,53) = -135.0/4096.0;
- prolongation[5](14,54) = 45.0/4096.0;
- prolongation[5](14,55) = 45.0/4096.0;
- prolongation[5](14,56) = 1215.0/4096.0;
- prolongation[5](14,57) = 1215.0/4096.0;
- prolongation[5](14,58) = 1215.0/4096.0;
- prolongation[5](14,59) = 1215.0/4096.0;
- prolongation[5](14,60) = -405.0/4096.0;
- prolongation[5](14,61) = -405.0/4096.0;
- prolongation[5](14,62) = -405.0/4096.0;
- prolongation[5](14,63) = -405.0/4096.0;
- prolongation[5](15,10) = 1.0/256.0;
- prolongation[5](15,14) = 1.0/256.0;
- prolongation[5](15,18) = 1.0/256.0;
- prolongation[5](15,22) = 1.0/256.0;
- prolongation[5](15,32) = -9.0/256.0;
- prolongation[5](15,33) = -9.0/256.0;
- prolongation[5](15,36) = -9.0/256.0;
- prolongation[5](15,37) = -9.0/256.0;
- prolongation[5](15,44) = -9.0/256.0;
- prolongation[5](15,45) = -9.0/256.0;
- prolongation[5](15,52) = -9.0/256.0;
- prolongation[5](15,53) = -9.0/256.0;
- prolongation[5](15,56) = 81.0/256.0;
- prolongation[5](15,57) = 81.0/256.0;
- prolongation[5](15,58) = 81.0/256.0;
- prolongation[5](15,59) = 81.0/256.0;
- prolongation[5](16,17) = 1.0;
- prolongation[5](17,4) = 1.0/16.0;
- prolongation[5](17,5) = 5.0/16.0;
- prolongation[5](17,16) = -5.0/16.0;
- prolongation[5](17,17) = 15.0/16.0;
- prolongation[5](18,5) = 5.0/16.0;
- prolongation[5](18,6) = 1.0/16.0;
- prolongation[5](18,18) = 15.0/16.0;
- prolongation[5](18,19) = -5.0/16.0;
- prolongation[5](19,18) = 1.0;
- prolongation[5](20,17) = -1.0/16.0;
- prolongation[5](20,21) = -1.0/16.0;
- prolongation[5](20,37) = 9.0/16.0;
- prolongation[5](20,39) = 9.0/16.0;
- prolongation[5](21,4) = -1.0/256.0;
- prolongation[5](21,5) = -5.0/256.0;
- prolongation[5](21,6) = -5.0/256.0;
- prolongation[5](21,7) = -1.0/256.0;
- prolongation[5](21,16) = 5.0/256.0;
- prolongation[5](21,17) = -15.0/256.0;
- prolongation[5](21,18) = 45.0/256.0;
- prolongation[5](21,19) = 45.0/256.0;
- prolongation[5](21,20) = 5.0/256.0;
- prolongation[5](21,21) = -15.0/256.0;
- prolongation[5](21,22) = 9.0/256.0;
- prolongation[5](21,23) = 9.0/256.0;
- prolongation[5](21,36) = -45.0/256.0;
- prolongation[5](21,37) = 135.0/256.0;
- prolongation[5](21,38) = -45.0/256.0;
- prolongation[5](21,39) = 135.0/256.0;
- prolongation[5](22,4) = -5.0/256.0;
- prolongation[5](22,5) = -5.0/256.0;
- prolongation[5](22,6) = -1.0/256.0;
- prolongation[5](22,7) = -1.0/256.0;
- prolongation[5](22,16) = 45.0/256.0;
- prolongation[5](22,17) = 45.0/256.0;
- prolongation[5](22,18) = -15.0/256.0;
- prolongation[5](22,19) = 5.0/256.0;
- prolongation[5](22,20) = 9.0/256.0;
- prolongation[5](22,21) = 9.0/256.0;
- prolongation[5](22,22) = -15.0/256.0;
- prolongation[5](22,23) = 5.0/256.0;
- prolongation[5](22,36) = 135.0/256.0;
- prolongation[5](22,37) = 135.0/256.0;
- prolongation[5](22,38) = -45.0/256.0;
- prolongation[5](22,39) = -45.0/256.0;
- prolongation[5](23,18) = -1.0/16.0;
- prolongation[5](23,22) = -1.0/16.0;
- prolongation[5](23,36) = 9.0/16.0;
- prolongation[5](23,37) = 9.0/16.0;
- prolongation[5](24,25) = -1.0/16.0;
- prolongation[5](24,27) = -1.0/16.0;
- prolongation[5](24,42) = 9.0/16.0;
- prolongation[5](24,43) = 9.0/16.0;
- prolongation[5](25,0) = -1.0/256.0;
- prolongation[5](25,1) = -1.0/256.0;
- prolongation[5](25,4) = -5.0/256.0;
- prolongation[5](25,5) = -5.0/256.0;
- prolongation[5](25,8) = 9.0/256.0;
- prolongation[5](25,9) = 9.0/256.0;
- prolongation[5](25,16) = 45.0/256.0;
- prolongation[5](25,17) = 45.0/256.0;
- prolongation[5](25,24) = 5.0/256.0;
- prolongation[5](25,25) = -15.0/256.0;
- prolongation[5](25,26) = 5.0/256.0;
- prolongation[5](25,27) = -15.0/256.0;
- prolongation[5](25,40) = -45.0/256.0;
- prolongation[5](25,41) = -45.0/256.0;
- prolongation[5](25,42) = 135.0/256.0;
- prolongation[5](25,43) = 135.0/256.0;
- prolongation[5](26,27) = 1.0;
- prolongation[5](27,1) = 1.0/16.0;
- prolongation[5](27,5) = 5.0/16.0;
- prolongation[5](27,26) = -5.0/16.0;
- prolongation[5](27,27) = 15.0/16.0;
- prolongation[5](28,27) = -1.0/16.0;
- prolongation[5](28,29) = -1.0/16.0;
- prolongation[5](28,45) = 9.0/16.0;
- prolongation[5](28,47) = 9.0/16.0;
- prolongation[5](29,1) = -1.0/256.0;
- prolongation[5](29,2) = -1.0/256.0;
- prolongation[5](29,5) = -5.0/256.0;
- prolongation[5](29,6) = -5.0/256.0;
- prolongation[5](29,10) = 9.0/256.0;
- prolongation[5](29,11) = 9.0/256.0;
- prolongation[5](29,18) = 45.0/256.0;
- prolongation[5](29,19) = 45.0/256.0;
- prolongation[5](29,26) = 5.0/256.0;
- prolongation[5](29,27) = -15.0/256.0;
- prolongation[5](29,28) = 5.0/256.0;
- prolongation[5](29,29) = -15.0/256.0;
- prolongation[5](29,44) = -45.0/256.0;
- prolongation[5](29,45) = 135.0/256.0;
- prolongation[5](29,46) = -45.0/256.0;
- prolongation[5](29,47) = 135.0/256.0;
- prolongation[5](30,25) = 1.0/256.0;
- prolongation[5](30,27) = 1.0/256.0;
- prolongation[5](30,29) = 1.0/256.0;
- prolongation[5](30,31) = 1.0/256.0;
- prolongation[5](30,42) = -9.0/256.0;
- prolongation[5](30,43) = -9.0/256.0;
- prolongation[5](30,45) = -9.0/256.0;
- prolongation[5](30,47) = -9.0/256.0;
- prolongation[5](30,50) = -9.0/256.0;
- prolongation[5](30,51) = -9.0/256.0;
- prolongation[5](30,53) = -9.0/256.0;
- prolongation[5](30,55) = -9.0/256.0;
- prolongation[5](30,58) = 81.0/256.0;
- prolongation[5](30,59) = 81.0/256.0;
- prolongation[5](30,62) = 81.0/256.0;
- prolongation[5](30,63) = 81.0/256.0;
- prolongation[5](31,0) = 1.0/4096.0;
- prolongation[5](31,1) = 1.0/4096.0;
- prolongation[5](31,2) = 1.0/4096.0;
- prolongation[5](31,3) = 1.0/4096.0;
- prolongation[5](31,4) = 5.0/4096.0;
- prolongation[5](31,5) = 5.0/4096.0;
- prolongation[5](31,6) = 5.0/4096.0;
- prolongation[5](31,7) = 5.0/4096.0;
- prolongation[5](31,8) = -9.0/4096.0;
- prolongation[5](31,9) = -9.0/4096.0;
- prolongation[5](31,10) = -9.0/4096.0;
- prolongation[5](31,11) = -9.0/4096.0;
- prolongation[5](31,12) = -9.0/4096.0;
- prolongation[5](31,13) = -9.0/4096.0;
- prolongation[5](31,14) = -9.0/4096.0;
- prolongation[5](31,15) = -9.0/4096.0;
- prolongation[5](31,16) = -45.0/4096.0;
- prolongation[5](31,17) = -45.0/4096.0;
- prolongation[5](31,18) = -45.0/4096.0;
- prolongation[5](31,19) = -45.0/4096.0;
- prolongation[5](31,20) = -45.0/4096.0;
- prolongation[5](31,21) = -45.0/4096.0;
- prolongation[5](31,22) = -45.0/4096.0;
- prolongation[5](31,23) = -45.0/4096.0;
- prolongation[5](31,24) = -5.0/4096.0;
- prolongation[5](31,25) = 15.0/4096.0;
- prolongation[5](31,26) = -5.0/4096.0;
- prolongation[5](31,27) = 15.0/4096.0;
- prolongation[5](31,28) = -5.0/4096.0;
- prolongation[5](31,29) = 15.0/4096.0;
- prolongation[5](31,30) = -5.0/4096.0;
- prolongation[5](31,31) = 15.0/4096.0;
- prolongation[5](31,32) = 81.0/4096.0;
- prolongation[5](31,33) = 81.0/4096.0;
- prolongation[5](31,34) = 81.0/4096.0;
- prolongation[5](31,35) = 81.0/4096.0;
- prolongation[5](31,36) = 405.0/4096.0;
- prolongation[5](31,37) = 405.0/4096.0;
- prolongation[5](31,38) = 405.0/4096.0;
- prolongation[5](31,39) = 405.0/4096.0;
- prolongation[5](31,40) = 45.0/4096.0;
- prolongation[5](31,41) = 45.0/4096.0;
- prolongation[5](31,42) = -135.0/4096.0;
- prolongation[5](31,43) = -135.0/4096.0;
- prolongation[5](31,44) = 45.0/4096.0;
- prolongation[5](31,45) = -135.0/4096.0;
- prolongation[5](31,46) = 45.0/4096.0;
- prolongation[5](31,47) = -135.0/4096.0;
- prolongation[5](31,48) = 45.0/4096.0;
- prolongation[5](31,49) = 45.0/4096.0;
- prolongation[5](31,50) = -135.0/4096.0;
- prolongation[5](31,51) = -135.0/4096.0;
- prolongation[5](31,52) = 45.0/4096.0;
- prolongation[5](31,53) = -135.0/4096.0;
- prolongation[5](31,54) = 45.0/4096.0;
- prolongation[5](31,55) = -135.0/4096.0;
- prolongation[5](31,56) = -405.0/4096.0;
- prolongation[5](31,57) = -405.0/4096.0;
- prolongation[5](31,58) = 1215.0/4096.0;
- prolongation[5](31,59) = 1215.0/4096.0;
- prolongation[5](31,60) = -405.0/4096.0;
- prolongation[5](31,61) = -405.0/4096.0;
- prolongation[5](31,62) = 1215.0/4096.0;
- prolongation[5](31,63) = 1215.0/4096.0;
- prolongation[5](32,9) = -5.0/256.0;
- prolongation[5](32,13) = -1.0/256.0;
- prolongation[5](32,17) = -5.0/256.0;
- prolongation[5](32,21) = -1.0/256.0;
- prolongation[5](32,33) = -15.0/256.0;
- prolongation[5](32,35) = 5.0/256.0;
- prolongation[5](32,37) = -15.0/256.0;
- prolongation[5](32,39) = 5.0/256.0;
- prolongation[5](32,41) = 45.0/256.0;
- prolongation[5](32,43) = 45.0/256.0;
- prolongation[5](32,49) = 9.0/256.0;
- prolongation[5](32,51) = 9.0/256.0;
- prolongation[5](32,57) = 135.0/256.0;
- prolongation[5](32,59) = 135.0/256.0;
- prolongation[5](32,61) = -45.0/256.0;
- prolongation[5](32,63) = -45.0/256.0;
- prolongation[5](33,0) = -5.0/4096.0;
- prolongation[5](33,1) = -25.0/4096.0;
- prolongation[5](33,2) = -5.0/4096.0;
- prolongation[5](33,3) = -1.0/4096.0;
- prolongation[5](33,4) = -5.0/4096.0;
- prolongation[5](33,5) = -25.0/4096.0;
- prolongation[5](33,6) = -5.0/4096.0;
- prolongation[5](33,7) = -1.0/4096.0;
- prolongation[5](33,8) = 25.0/4096.0;
- prolongation[5](33,9) = -75.0/4096.0;
- prolongation[5](33,10) = -75.0/4096.0;
- prolongation[5](33,11) = 25.0/4096.0;
- prolongation[5](33,12) = 5.0/4096.0;
- prolongation[5](33,13) = -15.0/4096.0;
- prolongation[5](33,14) = -15.0/4096.0;
- prolongation[5](33,15) = 5.0/4096.0;
- prolongation[5](33,16) = 25.0/4096.0;
- prolongation[5](33,17) = -75.0/4096.0;
- prolongation[5](33,18) = -75.0/4096.0;
- prolongation[5](33,19) = 25.0/4096.0;
- prolongation[5](33,20) = 5.0/4096.0;
- prolongation[5](33,21) = -15.0/4096.0;
- prolongation[5](33,22) = -15.0/4096.0;
- prolongation[5](33,23) = 5.0/4096.0;
- prolongation[5](33,24) = 45.0/4096.0;
- prolongation[5](33,25) = 45.0/4096.0;
- prolongation[5](33,26) = 225.0/4096.0;
- prolongation[5](33,27) = 225.0/4096.0;
- prolongation[5](33,28) = 45.0/4096.0;
- prolongation[5](33,29) = 45.0/4096.0;
- prolongation[5](33,30) = 9.0/4096.0;
- prolongation[5](33,31) = 9.0/4096.0;
- prolongation[5](33,32) = 75.0/4096.0;
- prolongation[5](33,33) = -225.0/4096.0;
- prolongation[5](33,34) = -25.0/4096.0;
- prolongation[5](33,35) = 75.0/4096.0;
- prolongation[5](33,36) = 75.0/4096.0;
- prolongation[5](33,37) = -225.0/4096.0;
- prolongation[5](33,38) = -25.0/4096.0;
- prolongation[5](33,39) = 75.0/4096.0;
- prolongation[5](33,40) = -225.0/4096.0;
- prolongation[5](33,41) = 675.0/4096.0;
- prolongation[5](33,42) = -225.0/4096.0;
- prolongation[5](33,43) = 675.0/4096.0;
- prolongation[5](33,44) = 675.0/4096.0;
- prolongation[5](33,45) = 675.0/4096.0;
- prolongation[5](33,46) = -225.0/4096.0;
- prolongation[5](33,47) = -225.0/4096.0;
- prolongation[5](33,48) = -45.0/4096.0;
- prolongation[5](33,49) = 135.0/4096.0;
- prolongation[5](33,50) = -45.0/4096.0;
- prolongation[5](33,51) = 135.0/4096.0;
- prolongation[5](33,52) = 135.0/4096.0;
- prolongation[5](33,53) = 135.0/4096.0;
- prolongation[5](33,54) = -45.0/4096.0;
- prolongation[5](33,55) = -45.0/4096.0;
- prolongation[5](33,56) = -675.0/4096.0;
- prolongation[5](33,57) = 2025.0/4096.0;
- prolongation[5](33,58) = -675.0/4096.0;
+ prolongation[0](0,0) = 1.0;
+ prolongation[0](1,0) = -1.0/16.0;
+ prolongation[0](1,1) = -1.0/16.0;
+ prolongation[0](1,8) = 9.0/16.0;
+ prolongation[0](1,9) = 9.0/16.0;
+ prolongation[0](2,0) = 1.0/256.0;
+ prolongation[0](2,1) = 1.0/256.0;
+ prolongation[0](2,2) = 1.0/256.0;
+ prolongation[0](2,3) = 1.0/256.0;
+ prolongation[0](2,8) = -9.0/256.0;
+ prolongation[0](2,9) = -9.0/256.0;
+ prolongation[0](2,10) = -9.0/256.0;
+ prolongation[0](2,11) = -9.0/256.0;
+ prolongation[0](2,12) = -9.0/256.0;
+ prolongation[0](2,13) = -9.0/256.0;
+ prolongation[0](2,14) = -9.0/256.0;
+ prolongation[0](2,15) = -9.0/256.0;
+ prolongation[0](2,32) = 81.0/256.0;
+ prolongation[0](2,33) = 81.0/256.0;
+ prolongation[0](2,34) = 81.0/256.0;
+ prolongation[0](2,35) = 81.0/256.0;
+ prolongation[0](3,0) = -1.0/16.0;
+ prolongation[0](3,3) = -1.0/16.0;
+ prolongation[0](3,14) = 9.0/16.0;
+ prolongation[0](3,15) = 9.0/16.0;
+ prolongation[0](4,0) = -1.0/16.0;
+ prolongation[0](4,4) = -1.0/16.0;
+ prolongation[0](4,24) = 9.0/16.0;
+ prolongation[0](4,25) = 9.0/16.0;
+ prolongation[0](5,0) = 1.0/256.0;
+ prolongation[0](5,1) = 1.0/256.0;
+ prolongation[0](5,4) = 1.0/256.0;
+ prolongation[0](5,5) = 1.0/256.0;
+ prolongation[0](5,8) = -9.0/256.0;
+ prolongation[0](5,9) = -9.0/256.0;
+ prolongation[0](5,16) = -9.0/256.0;
+ prolongation[0](5,17) = -9.0/256.0;
+ prolongation[0](5,24) = -9.0/256.0;
+ prolongation[0](5,25) = -9.0/256.0;
+ prolongation[0](5,26) = -9.0/256.0;
+ prolongation[0](5,27) = -9.0/256.0;
+ prolongation[0](5,40) = 81.0/256.0;
+ prolongation[0](5,41) = 81.0/256.0;
+ prolongation[0](5,42) = 81.0/256.0;
+ prolongation[0](5,43) = 81.0/256.0;
+ prolongation[0](6,0) = -1.0/4096.0;
+ prolongation[0](6,1) = -1.0/4096.0;
+ prolongation[0](6,2) = -1.0/4096.0;
+ prolongation[0](6,3) = -1.0/4096.0;
+ prolongation[0](6,4) = -1.0/4096.0;
+ prolongation[0](6,5) = -1.0/4096.0;
+ prolongation[0](6,6) = -1.0/4096.0;
+ prolongation[0](6,7) = -1.0/4096.0;
+ prolongation[0](6,8) = 9.0/4096.0;
+ prolongation[0](6,9) = 9.0/4096.0;
+ prolongation[0](6,10) = 9.0/4096.0;
+ prolongation[0](6,11) = 9.0/4096.0;
+ prolongation[0](6,12) = 9.0/4096.0;
+ prolongation[0](6,13) = 9.0/4096.0;
+ prolongation[0](6,14) = 9.0/4096.0;
+ prolongation[0](6,15) = 9.0/4096.0;
+ prolongation[0](6,16) = 9.0/4096.0;
+ prolongation[0](6,17) = 9.0/4096.0;
+ prolongation[0](6,18) = 9.0/4096.0;
+ prolongation[0](6,19) = 9.0/4096.0;
+ prolongation[0](6,20) = 9.0/4096.0;
+ prolongation[0](6,21) = 9.0/4096.0;
+ prolongation[0](6,22) = 9.0/4096.0;
+ prolongation[0](6,23) = 9.0/4096.0;
+ prolongation[0](6,24) = 9.0/4096.0;
+ prolongation[0](6,25) = 9.0/4096.0;
+ prolongation[0](6,26) = 9.0/4096.0;
+ prolongation[0](6,27) = 9.0/4096.0;
+ prolongation[0](6,28) = 9.0/4096.0;
+ prolongation[0](6,29) = 9.0/4096.0;
+ prolongation[0](6,30) = 9.0/4096.0;
+ prolongation[0](6,31) = 9.0/4096.0;
+ prolongation[0](6,32) = -81.0/4096.0;
+ prolongation[0](6,33) = -81.0/4096.0;
+ prolongation[0](6,34) = -81.0/4096.0;
+ prolongation[0](6,35) = -81.0/4096.0;
+ prolongation[0](6,36) = -81.0/4096.0;
+ prolongation[0](6,37) = -81.0/4096.0;
+ prolongation[0](6,38) = -81.0/4096.0;
+ prolongation[0](6,39) = -81.0/4096.0;
+ prolongation[0](6,40) = -81.0/4096.0;
+ prolongation[0](6,41) = -81.0/4096.0;
+ prolongation[0](6,42) = -81.0/4096.0;
+ prolongation[0](6,43) = -81.0/4096.0;
+ prolongation[0](6,44) = -81.0/4096.0;
+ prolongation[0](6,45) = -81.0/4096.0;
+ prolongation[0](6,46) = -81.0/4096.0;
+ prolongation[0](6,47) = -81.0/4096.0;
+ prolongation[0](6,48) = -81.0/4096.0;
+ prolongation[0](6,49) = -81.0/4096.0;
+ prolongation[0](6,50) = -81.0/4096.0;
+ prolongation[0](6,51) = -81.0/4096.0;
+ prolongation[0](6,52) = -81.0/4096.0;
+ prolongation[0](6,53) = -81.0/4096.0;
+ prolongation[0](6,54) = -81.0/4096.0;
+ prolongation[0](6,55) = -81.0/4096.0;
+ prolongation[0](6,56) = 729.0/4096.0;
+ prolongation[0](6,57) = 729.0/4096.0;
+ prolongation[0](6,58) = 729.0/4096.0;
+ prolongation[0](6,59) = 729.0/4096.0;
+ prolongation[0](6,60) = 729.0/4096.0;
+ prolongation[0](6,61) = 729.0/4096.0;
+ prolongation[0](6,62) = 729.0/4096.0;
+ prolongation[0](6,63) = 729.0/4096.0;
+ prolongation[0](7,0) = 1.0/256.0;
+ prolongation[0](7,3) = 1.0/256.0;
+ prolongation[0](7,4) = 1.0/256.0;
+ prolongation[0](7,7) = 1.0/256.0;
+ prolongation[0](7,14) = -9.0/256.0;
+ prolongation[0](7,15) = -9.0/256.0;
+ prolongation[0](7,22) = -9.0/256.0;
+ prolongation[0](7,23) = -9.0/256.0;
+ prolongation[0](7,24) = -9.0/256.0;
+ prolongation[0](7,25) = -9.0/256.0;
+ prolongation[0](7,30) = -9.0/256.0;
+ prolongation[0](7,31) = -9.0/256.0;
+ prolongation[0](7,52) = 81.0/256.0;
+ prolongation[0](7,53) = 81.0/256.0;
+ prolongation[0](7,54) = 81.0/256.0;
+ prolongation[0](7,55) = 81.0/256.0;
+ prolongation[0](8,0) = 5.0/16.0;
+ prolongation[0](8,1) = 1.0/16.0;
+ prolongation[0](8,8) = 15.0/16.0;
+ prolongation[0](8,9) = -5.0/16.0;
+ prolongation[0](9,8) = 1.0;
+ prolongation[0](10,0) = -5.0/256.0;
+ prolongation[0](10,1) = -5.0/256.0;
+ prolongation[0](10,2) = -1.0/256.0;
+ prolongation[0](10,3) = -1.0/256.0;
+ prolongation[0](10,8) = 45.0/256.0;
+ prolongation[0](10,9) = 45.0/256.0;
+ prolongation[0](10,10) = -15.0/256.0;
+ prolongation[0](10,11) = 5.0/256.0;
+ prolongation[0](10,12) = 9.0/256.0;
+ prolongation[0](10,13) = 9.0/256.0;
+ prolongation[0](10,14) = -15.0/256.0;
+ prolongation[0](10,15) = 5.0/256.0;
+ prolongation[0](10,32) = 135.0/256.0;
+ prolongation[0](10,33) = 135.0/256.0;
+ prolongation[0](10,34) = -45.0/256.0;
+ prolongation[0](10,35) = -45.0/256.0;
+ prolongation[0](11,10) = -1.0/16.0;
+ prolongation[0](11,14) = -1.0/16.0;
+ prolongation[0](11,32) = 9.0/16.0;
+ prolongation[0](11,33) = 9.0/16.0;
+ prolongation[0](12,0) = -5.0/256.0;
+ prolongation[0](12,1) = -1.0/256.0;
+ prolongation[0](12,2) = -1.0/256.0;
+ prolongation[0](12,3) = -5.0/256.0;
+ prolongation[0](12,8) = -15.0/256.0;
+ prolongation[0](12,9) = 5.0/256.0;
+ prolongation[0](12,10) = 9.0/256.0;
+ prolongation[0](12,11) = 9.0/256.0;
+ prolongation[0](12,12) = -15.0/256.0;
+ prolongation[0](12,13) = 5.0/256.0;
+ prolongation[0](12,14) = 45.0/256.0;
+ prolongation[0](12,15) = 45.0/256.0;
+ prolongation[0](12,32) = 135.0/256.0;
+ prolongation[0](12,33) = -45.0/256.0;
+ prolongation[0](12,34) = 135.0/256.0;
+ prolongation[0](12,35) = -45.0/256.0;
+ prolongation[0](13,8) = -1.0/16.0;
+ prolongation[0](13,12) = -1.0/16.0;
+ prolongation[0](13,32) = 9.0/16.0;
+ prolongation[0](13,34) = 9.0/16.0;
+ prolongation[0](14,0) = 5.0/16.0;
+ prolongation[0](14,3) = 1.0/16.0;
+ prolongation[0](14,14) = 15.0/16.0;
+ prolongation[0](14,15) = -5.0/16.0;
+ prolongation[0](15,14) = 1.0;
+ prolongation[0](16,0) = -5.0/256.0;
+ prolongation[0](16,1) = -1.0/256.0;
+ prolongation[0](16,4) = -5.0/256.0;
+ prolongation[0](16,5) = -1.0/256.0;
+ prolongation[0](16,8) = -15.0/256.0;
+ prolongation[0](16,9) = 5.0/256.0;
+ prolongation[0](16,16) = -15.0/256.0;
+ prolongation[0](16,17) = 5.0/256.0;
+ prolongation[0](16,24) = 45.0/256.0;
+ prolongation[0](16,25) = 45.0/256.0;
+ prolongation[0](16,26) = 9.0/256.0;
+ prolongation[0](16,27) = 9.0/256.0;
+ prolongation[0](16,40) = 135.0/256.0;
+ prolongation[0](16,41) = -45.0/256.0;
+ prolongation[0](16,42) = 135.0/256.0;
+ prolongation[0](16,43) = -45.0/256.0;
+ prolongation[0](17,8) = -1.0/16.0;
+ prolongation[0](17,16) = -1.0/16.0;
+ prolongation[0](17,40) = 9.0/16.0;
+ prolongation[0](17,42) = 9.0/16.0;
+ prolongation[0](18,0) = 5.0/4096.0;
+ prolongation[0](18,1) = 5.0/4096.0;
+ prolongation[0](18,2) = 1.0/4096.0;
+ prolongation[0](18,3) = 1.0/4096.0;
+ prolongation[0](18,4) = 5.0/4096.0;
+ prolongation[0](18,5) = 5.0/4096.0;
+ prolongation[0](18,6) = 1.0/4096.0;
+ prolongation[0](18,7) = 1.0/4096.0;
+ prolongation[0](18,8) = -45.0/4096.0;
+ prolongation[0](18,9) = -45.0/4096.0;
+ prolongation[0](18,10) = 15.0/4096.0;
+ prolongation[0](18,11) = -5.0/4096.0;
+ prolongation[0](18,12) = -9.0/4096.0;
+ prolongation[0](18,13) = -9.0/4096.0;
+ prolongation[0](18,14) = 15.0/4096.0;
+ prolongation[0](18,15) = -5.0/4096.0;
+ prolongation[0](18,16) = -45.0/4096.0;
+ prolongation[0](18,17) = -45.0/4096.0;
+ prolongation[0](18,18) = 15.0/4096.0;
+ prolongation[0](18,19) = -5.0/4096.0;
+ prolongation[0](18,20) = -9.0/4096.0;
+ prolongation[0](18,21) = -9.0/4096.0;
+ prolongation[0](18,22) = 15.0/4096.0;
+ prolongation[0](18,23) = -5.0/4096.0;
+ prolongation[0](18,24) = -45.0/4096.0;
+ prolongation[0](18,25) = -45.0/4096.0;
+ prolongation[0](18,26) = -45.0/4096.0;
+ prolongation[0](18,27) = -45.0/4096.0;
+ prolongation[0](18,28) = -9.0/4096.0;
+ prolongation[0](18,29) = -9.0/4096.0;
+ prolongation[0](18,30) = -9.0/4096.0;
+ prolongation[0](18,31) = -9.0/4096.0;
+ prolongation[0](18,32) = -135.0/4096.0;
+ prolongation[0](18,33) = -135.0/4096.0;
+ prolongation[0](18,34) = 45.0/4096.0;
+ prolongation[0](18,35) = 45.0/4096.0;
+ prolongation[0](18,36) = -135.0/4096.0;
+ prolongation[0](18,37) = -135.0/4096.0;
+ prolongation[0](18,38) = 45.0/4096.0;
+ prolongation[0](18,39) = 45.0/4096.0;
+ prolongation[0](18,40) = 405.0/4096.0;
+ prolongation[0](18,41) = 405.0/4096.0;
+ prolongation[0](18,42) = 405.0/4096.0;
+ prolongation[0](18,43) = 405.0/4096.0;
+ prolongation[0](18,44) = -135.0/4096.0;
+ prolongation[0](18,45) = -135.0/4096.0;
+ prolongation[0](18,46) = 45.0/4096.0;
+ prolongation[0](18,47) = 45.0/4096.0;
+ prolongation[0](18,48) = 81.0/4096.0;
+ prolongation[0](18,49) = 81.0/4096.0;
+ prolongation[0](18,50) = 81.0/4096.0;
+ prolongation[0](18,51) = 81.0/4096.0;
+ prolongation[0](18,52) = -135.0/4096.0;
+ prolongation[0](18,53) = -135.0/4096.0;
+ prolongation[0](18,54) = 45.0/4096.0;
+ prolongation[0](18,55) = 45.0/4096.0;
+ prolongation[0](18,56) = 1215.0/4096.0;
+ prolongation[0](18,57) = 1215.0/4096.0;
+ prolongation[0](18,58) = 1215.0/4096.0;
+ prolongation[0](18,59) = 1215.0/4096.0;
+ prolongation[0](18,60) = -405.0/4096.0;
+ prolongation[0](18,61) = -405.0/4096.0;
+ prolongation[0](18,62) = -405.0/4096.0;
+ prolongation[0](18,63) = -405.0/4096.0;
+ prolongation[0](19,10) = 1.0/256.0;
+ prolongation[0](19,14) = 1.0/256.0;
+ prolongation[0](19,18) = 1.0/256.0;
+ prolongation[0](19,22) = 1.0/256.0;
+ prolongation[0](19,32) = -9.0/256.0;
+ prolongation[0](19,33) = -9.0/256.0;
+ prolongation[0](19,36) = -9.0/256.0;
+ prolongation[0](19,37) = -9.0/256.0;
+ prolongation[0](19,44) = -9.0/256.0;
+ prolongation[0](19,45) = -9.0/256.0;
+ prolongation[0](19,52) = -9.0/256.0;
+ prolongation[0](19,53) = -9.0/256.0;
+ prolongation[0](19,56) = 81.0/256.0;
+ prolongation[0](19,57) = 81.0/256.0;
+ prolongation[0](19,58) = 81.0/256.0;
+ prolongation[0](19,59) = 81.0/256.0;
+ prolongation[0](20,0) = 5.0/4096.0;
+ prolongation[0](20,1) = 1.0/4096.0;
+ prolongation[0](20,2) = 1.0/4096.0;
+ prolongation[0](20,3) = 5.0/4096.0;
+ prolongation[0](20,4) = 5.0/4096.0;
+ prolongation[0](20,5) = 1.0/4096.0;
+ prolongation[0](20,6) = 1.0/4096.0;
+ prolongation[0](20,7) = 5.0/4096.0;
+ prolongation[0](20,8) = 15.0/4096.0;
+ prolongation[0](20,9) = -5.0/4096.0;
+ prolongation[0](20,10) = -9.0/4096.0;
+ prolongation[0](20,11) = -9.0/4096.0;
+ prolongation[0](20,12) = 15.0/4096.0;
+ prolongation[0](20,13) = -5.0/4096.0;
+ prolongation[0](20,14) = -45.0/4096.0;
+ prolongation[0](20,15) = -45.0/4096.0;
+ prolongation[0](20,16) = 15.0/4096.0;
+ prolongation[0](20,17) = -5.0/4096.0;
+ prolongation[0](20,18) = -9.0/4096.0;
+ prolongation[0](20,19) = -9.0/4096.0;
+ prolongation[0](20,20) = 15.0/4096.0;
+ prolongation[0](20,21) = -5.0/4096.0;
+ prolongation[0](20,22) = -45.0/4096.0;
+ prolongation[0](20,23) = -45.0/4096.0;
+ prolongation[0](20,24) = -45.0/4096.0;
+ prolongation[0](20,25) = -45.0/4096.0;
+ prolongation[0](20,26) = -9.0/4096.0;
+ prolongation[0](20,27) = -9.0/4096.0;
+ prolongation[0](20,28) = -9.0/4096.0;
+ prolongation[0](20,29) = -9.0/4096.0;
+ prolongation[0](20,30) = -45.0/4096.0;
+ prolongation[0](20,31) = -45.0/4096.0;
+ prolongation[0](20,32) = -135.0/4096.0;
+ prolongation[0](20,33) = 45.0/4096.0;
+ prolongation[0](20,34) = -135.0/4096.0;
+ prolongation[0](20,35) = 45.0/4096.0;
+ prolongation[0](20,36) = -135.0/4096.0;
+ prolongation[0](20,37) = 45.0/4096.0;
+ prolongation[0](20,38) = -135.0/4096.0;
+ prolongation[0](20,39) = 45.0/4096.0;
+ prolongation[0](20,40) = -135.0/4096.0;
+ prolongation[0](20,41) = 45.0/4096.0;
+ prolongation[0](20,42) = -135.0/4096.0;
+ prolongation[0](20,43) = 45.0/4096.0;
+ prolongation[0](20,44) = 81.0/4096.0;
+ prolongation[0](20,45) = 81.0/4096.0;
+ prolongation[0](20,46) = 81.0/4096.0;
+ prolongation[0](20,47) = 81.0/4096.0;
+ prolongation[0](20,48) = -135.0/4096.0;
+ prolongation[0](20,49) = 45.0/4096.0;
+ prolongation[0](20,50) = -135.0/4096.0;
+ prolongation[0](20,51) = 45.0/4096.0;
+ prolongation[0](20,52) = 405.0/4096.0;
+ prolongation[0](20,53) = 405.0/4096.0;
+ prolongation[0](20,54) = 405.0/4096.0;
+ prolongation[0](20,55) = 405.0/4096.0;
+ prolongation[0](20,56) = 1215.0/4096.0;
+ prolongation[0](20,57) = -405.0/4096.0;
+ prolongation[0](20,58) = 1215.0/4096.0;
+ prolongation[0](20,59) = -405.0/4096.0;
+ prolongation[0](20,60) = 1215.0/4096.0;
+ prolongation[0](20,61) = -405.0/4096.0;
+ prolongation[0](20,62) = 1215.0/4096.0;
+ prolongation[0](20,63) = -405.0/4096.0;
+ prolongation[0](21,8) = 1.0/256.0;
+ prolongation[0](21,12) = 1.0/256.0;
+ prolongation[0](21,16) = 1.0/256.0;
+ prolongation[0](21,20) = 1.0/256.0;
+ prolongation[0](21,32) = -9.0/256.0;
+ prolongation[0](21,34) = -9.0/256.0;
+ prolongation[0](21,36) = -9.0/256.0;
+ prolongation[0](21,38) = -9.0/256.0;
+ prolongation[0](21,40) = -9.0/256.0;
+ prolongation[0](21,42) = -9.0/256.0;
+ prolongation[0](21,48) = -9.0/256.0;
+ prolongation[0](21,50) = -9.0/256.0;
+ prolongation[0](21,56) = 81.0/256.0;
+ prolongation[0](21,58) = 81.0/256.0;
+ prolongation[0](21,60) = 81.0/256.0;
+ prolongation[0](21,62) = 81.0/256.0;
+ prolongation[0](22,0) = -5.0/256.0;
+ prolongation[0](22,3) = -1.0/256.0;
+ prolongation[0](22,4) = -5.0/256.0;
+ prolongation[0](22,7) = -1.0/256.0;
+ prolongation[0](22,14) = -15.0/256.0;
+ prolongation[0](22,15) = 5.0/256.0;
+ prolongation[0](22,22) = -15.0/256.0;
+ prolongation[0](22,23) = 5.0/256.0;
+ prolongation[0](22,24) = 45.0/256.0;
+ prolongation[0](22,25) = 45.0/256.0;
+ prolongation[0](22,30) = 9.0/256.0;
+ prolongation[0](22,31) = 9.0/256.0;
+ prolongation[0](22,52) = 135.0/256.0;
+ prolongation[0](22,53) = 135.0/256.0;
+ prolongation[0](22,54) = -45.0/256.0;
+ prolongation[0](22,55) = -45.0/256.0;
+ prolongation[0](23,14) = -1.0/16.0;
+ prolongation[0](23,22) = -1.0/16.0;
+ prolongation[0](23,52) = 9.0/16.0;
+ prolongation[0](23,53) = 9.0/16.0;
+ prolongation[0](24,0) = 5.0/16.0;
+ prolongation[0](24,4) = 1.0/16.0;
+ prolongation[0](24,24) = 15.0/16.0;
+ prolongation[0](24,25) = -5.0/16.0;
+ prolongation[0](25,24) = 1.0;
+ prolongation[0](26,0) = -5.0/256.0;
+ prolongation[0](26,1) = -5.0/256.0;
+ prolongation[0](26,4) = -1.0/256.0;
+ prolongation[0](26,5) = -1.0/256.0;
+ prolongation[0](26,8) = 45.0/256.0;
+ prolongation[0](26,9) = 45.0/256.0;
+ prolongation[0](26,16) = 9.0/256.0;
+ prolongation[0](26,17) = 9.0/256.0;
+ prolongation[0](26,24) = -15.0/256.0;
+ prolongation[0](26,25) = 5.0/256.0;
+ prolongation[0](26,26) = -15.0/256.0;
+ prolongation[0](26,27) = 5.0/256.0;
+ prolongation[0](26,40) = 135.0/256.0;
+ prolongation[0](26,41) = 135.0/256.0;
+ prolongation[0](26,42) = -45.0/256.0;
+ prolongation[0](26,43) = -45.0/256.0;
+ prolongation[0](27,24) = -1.0/16.0;
+ prolongation[0](27,26) = -1.0/16.0;
+ prolongation[0](27,40) = 9.0/16.0;
+ prolongation[0](27,41) = 9.0/16.0;
+ prolongation[0](28,0) = 5.0/4096.0;
+ prolongation[0](28,1) = 5.0/4096.0;
+ prolongation[0](28,2) = 5.0/4096.0;
+ prolongation[0](28,3) = 5.0/4096.0;
+ prolongation[0](28,4) = 1.0/4096.0;
+ prolongation[0](28,5) = 1.0/4096.0;
+ prolongation[0](28,6) = 1.0/4096.0;
+ prolongation[0](28,7) = 1.0/4096.0;
+ prolongation[0](28,8) = -45.0/4096.0;
+ prolongation[0](28,9) = -45.0/4096.0;
+ prolongation[0](28,10) = -45.0/4096.0;
+ prolongation[0](28,11) = -45.0/4096.0;
+ prolongation[0](28,12) = -45.0/4096.0;
+ prolongation[0](28,13) = -45.0/4096.0;
+ prolongation[0](28,14) = -45.0/4096.0;
+ prolongation[0](28,15) = -45.0/4096.0;
+ prolongation[0](28,16) = -9.0/4096.0;
+ prolongation[0](28,17) = -9.0/4096.0;
+ prolongation[0](28,18) = -9.0/4096.0;
+ prolongation[0](28,19) = -9.0/4096.0;
+ prolongation[0](28,20) = -9.0/4096.0;
+ prolongation[0](28,21) = -9.0/4096.0;
+ prolongation[0](28,22) = -9.0/4096.0;
+ prolongation[0](28,23) = -9.0/4096.0;
+ prolongation[0](28,24) = 15.0/4096.0;
+ prolongation[0](28,25) = -5.0/4096.0;
+ prolongation[0](28,26) = 15.0/4096.0;
+ prolongation[0](28,27) = -5.0/4096.0;
+ prolongation[0](28,28) = 15.0/4096.0;
+ prolongation[0](28,29) = -5.0/4096.0;
+ prolongation[0](28,30) = 15.0/4096.0;
+ prolongation[0](28,31) = -5.0/4096.0;
+ prolongation[0](28,32) = 405.0/4096.0;
+ prolongation[0](28,33) = 405.0/4096.0;
+ prolongation[0](28,34) = 405.0/4096.0;
+ prolongation[0](28,35) = 405.0/4096.0;
+ prolongation[0](28,36) = 81.0/4096.0;
+ prolongation[0](28,37) = 81.0/4096.0;
+ prolongation[0](28,38) = 81.0/4096.0;
+ prolongation[0](28,39) = 81.0/4096.0;
+ prolongation[0](28,40) = -135.0/4096.0;
+ prolongation[0](28,41) = -135.0/4096.0;
+ prolongation[0](28,42) = 45.0/4096.0;
+ prolongation[0](28,43) = 45.0/4096.0;
+ prolongation[0](28,44) = -135.0/4096.0;
+ prolongation[0](28,45) = 45.0/4096.0;
+ prolongation[0](28,46) = -135.0/4096.0;
+ prolongation[0](28,47) = 45.0/4096.0;
+ prolongation[0](28,48) = -135.0/4096.0;
+ prolongation[0](28,49) = -135.0/4096.0;
+ prolongation[0](28,50) = 45.0/4096.0;
+ prolongation[0](28,51) = 45.0/4096.0;
+ prolongation[0](28,52) = -135.0/4096.0;
+ prolongation[0](28,53) = 45.0/4096.0;
+ prolongation[0](28,54) = -135.0/4096.0;
+ prolongation[0](28,55) = 45.0/4096.0;
+ prolongation[0](28,56) = 1215.0/4096.0;
+ prolongation[0](28,57) = 1215.0/4096.0;
+ prolongation[0](28,58) = -405.0/4096.0;
+ prolongation[0](28,59) = -405.0/4096.0;
+ prolongation[0](28,60) = 1215.0/4096.0;
+ prolongation[0](28,61) = 1215.0/4096.0;
+ prolongation[0](28,62) = -405.0/4096.0;
+ prolongation[0](28,63) = -405.0/4096.0;
+ prolongation[0](29,24) = 1.0/256.0;
+ prolongation[0](29,26) = 1.0/256.0;
+ prolongation[0](29,28) = 1.0/256.0;
+ prolongation[0](29,30) = 1.0/256.0;
+ prolongation[0](29,40) = -9.0/256.0;
+ prolongation[0](29,41) = -9.0/256.0;
+ prolongation[0](29,44) = -9.0/256.0;
+ prolongation[0](29,46) = -9.0/256.0;
+ prolongation[0](29,48) = -9.0/256.0;
+ prolongation[0](29,49) = -9.0/256.0;
+ prolongation[0](29,52) = -9.0/256.0;
+ prolongation[0](29,54) = -9.0/256.0;
+ prolongation[0](29,56) = 81.0/256.0;
+ prolongation[0](29,57) = 81.0/256.0;
+ prolongation[0](29,60) = 81.0/256.0;
+ prolongation[0](29,61) = 81.0/256.0;
+ prolongation[0](30,0) = -5.0/256.0;
+ prolongation[0](30,3) = -5.0/256.0;
+ prolongation[0](30,4) = -1.0/256.0;
+ prolongation[0](30,7) = -1.0/256.0;
+ prolongation[0](30,14) = 45.0/256.0;
+ prolongation[0](30,15) = 45.0/256.0;
+ prolongation[0](30,22) = 9.0/256.0;
+ prolongation[0](30,23) = 9.0/256.0;
+ prolongation[0](30,24) = -15.0/256.0;
+ prolongation[0](30,25) = 5.0/256.0;
+ prolongation[0](30,30) = -15.0/256.0;
+ prolongation[0](30,31) = 5.0/256.0;
+ prolongation[0](30,52) = 135.0/256.0;
+ prolongation[0](30,53) = -45.0/256.0;
+ prolongation[0](30,54) = 135.0/256.0;
+ prolongation[0](30,55) = -45.0/256.0;
+ prolongation[0](31,24) = -1.0/16.0;
+ prolongation[0](31,30) = -1.0/16.0;
+ prolongation[0](31,52) = 9.0/16.0;
+ prolongation[0](31,54) = 9.0/16.0;
+ prolongation[0](32,0) = 25.0/256.0;
+ prolongation[0](32,1) = 5.0/256.0;
+ prolongation[0](32,2) = 1.0/256.0;
+ prolongation[0](32,3) = 5.0/256.0;
+ prolongation[0](32,8) = 75.0/256.0;
+ prolongation[0](32,9) = -25.0/256.0;
+ prolongation[0](32,10) = 15.0/256.0;
+ prolongation[0](32,11) = -5.0/256.0;
+ prolongation[0](32,12) = 15.0/256.0;
+ prolongation[0](32,13) = -5.0/256.0;
+ prolongation[0](32,14) = 75.0/256.0;
+ prolongation[0](32,15) = -25.0/256.0;
+ prolongation[0](32,32) = 225.0/256.0;
+ prolongation[0](32,33) = -75.0/256.0;
+ prolongation[0](32,34) = -75.0/256.0;
+ prolongation[0](32,35) = 25.0/256.0;
+ prolongation[0](33,8) = 5.0/16.0;
+ prolongation[0](33,12) = 1.0/16.0;
+ prolongation[0](33,32) = 15.0/16.0;
+ prolongation[0](33,34) = -5.0/16.0;
+ prolongation[0](34,10) = 1.0/16.0;
+ prolongation[0](34,14) = 5.0/16.0;
+ prolongation[0](34,32) = 15.0/16.0;
+ prolongation[0](34,33) = -5.0/16.0;
+ prolongation[0](35,32) = 1.0;
+ prolongation[0](36,0) = -25.0/4096.0;
+ prolongation[0](36,1) = -5.0/4096.0;
+ prolongation[0](36,2) = -1.0/4096.0;
+ prolongation[0](36,3) = -5.0/4096.0;
+ prolongation[0](36,4) = -25.0/4096.0;
+ prolongation[0](36,5) = -5.0/4096.0;
+ prolongation[0](36,6) = -1.0/4096.0;
+ prolongation[0](36,7) = -5.0/4096.0;
+ prolongation[0](36,8) = -75.0/4096.0;
+ prolongation[0](36,9) = 25.0/4096.0;
+ prolongation[0](36,10) = -15.0/4096.0;
+ prolongation[0](36,11) = 5.0/4096.0;
+ prolongation[0](36,12) = -15.0/4096.0;
+ prolongation[0](36,13) = 5.0/4096.0;
+ prolongation[0](36,14) = -75.0/4096.0;
+ prolongation[0](36,15) = 25.0/4096.0;
+ prolongation[0](36,16) = -75.0/4096.0;
+ prolongation[0](36,17) = 25.0/4096.0;
+ prolongation[0](36,18) = -15.0/4096.0;
+ prolongation[0](36,19) = 5.0/4096.0;
+ prolongation[0](36,20) = -15.0/4096.0;
+ prolongation[0](36,21) = 5.0/4096.0;
+ prolongation[0](36,22) = -75.0/4096.0;
+ prolongation[0](36,23) = 25.0/4096.0;
+ prolongation[0](36,24) = 225.0/4096.0;
+ prolongation[0](36,25) = 225.0/4096.0;
+ prolongation[0](36,26) = 45.0/4096.0;
+ prolongation[0](36,27) = 45.0/4096.0;
+ prolongation[0](36,28) = 9.0/4096.0;
+ prolongation[0](36,29) = 9.0/4096.0;
+ prolongation[0](36,30) = 45.0/4096.0;
+ prolongation[0](36,31) = 45.0/4096.0;
+ prolongation[0](36,32) = -225.0/4096.0;
+ prolongation[0](36,33) = 75.0/4096.0;
+ prolongation[0](36,34) = 75.0/4096.0;
+ prolongation[0](36,35) = -25.0/4096.0;
+ prolongation[0](36,36) = -225.0/4096.0;
+ prolongation[0](36,37) = 75.0/4096.0;
+ prolongation[0](36,38) = 75.0/4096.0;
+ prolongation[0](36,39) = -25.0/4096.0;
+ prolongation[0](36,40) = 675.0/4096.0;
+ prolongation[0](36,41) = -225.0/4096.0;
+ prolongation[0](36,42) = 675.0/4096.0;
+ prolongation[0](36,43) = -225.0/4096.0;
+ prolongation[0](36,44) = 135.0/4096.0;
+ prolongation[0](36,45) = 135.0/4096.0;
+ prolongation[0](36,46) = -45.0/4096.0;
+ prolongation[0](36,47) = -45.0/4096.0;
+ prolongation[0](36,48) = 135.0/4096.0;
+ prolongation[0](36,49) = -45.0/4096.0;
+ prolongation[0](36,50) = 135.0/4096.0;
+ prolongation[0](36,51) = -45.0/4096.0;
+ prolongation[0](36,52) = 675.0/4096.0;
+ prolongation[0](36,53) = 675.0/4096.0;
+ prolongation[0](36,54) = -225.0/4096.0;
+ prolongation[0](36,55) = -225.0/4096.0;
+ prolongation[0](36,56) = 2025.0/4096.0;
+ prolongation[0](36,57) = -675.0/4096.0;
+ prolongation[0](36,58) = 2025.0/4096.0;
+ prolongation[0](36,59) = -675.0/4096.0;
+ prolongation[0](36,60) = -675.0/4096.0;
+ prolongation[0](36,61) = 225.0/4096.0;
+ prolongation[0](36,62) = -675.0/4096.0;
+ prolongation[0](36,63) = 225.0/4096.0;
+ prolongation[0](37,8) = -5.0/256.0;
+ prolongation[0](37,12) = -1.0/256.0;
+ prolongation[0](37,16) = -5.0/256.0;
+ prolongation[0](37,20) = -1.0/256.0;
+ prolongation[0](37,32) = -15.0/256.0;
+ prolongation[0](37,34) = 5.0/256.0;
+ prolongation[0](37,36) = -15.0/256.0;
+ prolongation[0](37,38) = 5.0/256.0;
+ prolongation[0](37,40) = 45.0/256.0;
+ prolongation[0](37,42) = 45.0/256.0;
+ prolongation[0](37,48) = 9.0/256.0;
+ prolongation[0](37,50) = 9.0/256.0;
+ prolongation[0](37,56) = 135.0/256.0;
+ prolongation[0](37,58) = 135.0/256.0;
+ prolongation[0](37,60) = -45.0/256.0;
+ prolongation[0](37,62) = -45.0/256.0;
+ prolongation[0](38,10) = -1.0/256.0;
+ prolongation[0](38,14) = -5.0/256.0;
+ prolongation[0](38,18) = -1.0/256.0;
+ prolongation[0](38,22) = -5.0/256.0;
+ prolongation[0](38,32) = -15.0/256.0;
+ prolongation[0](38,33) = 5.0/256.0;
+ prolongation[0](38,36) = -15.0/256.0;
+ prolongation[0](38,37) = 5.0/256.0;
+ prolongation[0](38,44) = 9.0/256.0;
+ prolongation[0](38,45) = 9.0/256.0;
+ prolongation[0](38,52) = 45.0/256.0;
+ prolongation[0](38,53) = 45.0/256.0;
+ prolongation[0](38,56) = 135.0/256.0;
+ prolongation[0](38,57) = -45.0/256.0;
+ prolongation[0](38,58) = 135.0/256.0;
+ prolongation[0](38,59) = -45.0/256.0;
+ prolongation[0](39,32) = -1.0/16.0;
+ prolongation[0](39,36) = -1.0/16.0;
+ prolongation[0](39,56) = 9.0/16.0;
+ prolongation[0](39,58) = 9.0/16.0;
+ prolongation[0](40,0) = 25.0/256.0;
+ prolongation[0](40,1) = 5.0/256.0;
+ prolongation[0](40,4) = 5.0/256.0;
+ prolongation[0](40,5) = 1.0/256.0;
+ prolongation[0](40,8) = 75.0/256.0;
+ prolongation[0](40,9) = -25.0/256.0;
+ prolongation[0](40,16) = 15.0/256.0;
+ prolongation[0](40,17) = -5.0/256.0;
+ prolongation[0](40,24) = 75.0/256.0;
+ prolongation[0](40,25) = -25.0/256.0;
+ prolongation[0](40,26) = 15.0/256.0;
+ prolongation[0](40,27) = -5.0/256.0;
+ prolongation[0](40,40) = 225.0/256.0;
+ prolongation[0](40,41) = -75.0/256.0;
+ prolongation[0](40,42) = -75.0/256.0;
+ prolongation[0](40,43) = 25.0/256.0;
+ prolongation[0](41,8) = 5.0/16.0;
+ prolongation[0](41,16) = 1.0/16.0;
+ prolongation[0](41,40) = 15.0/16.0;
+ prolongation[0](41,42) = -5.0/16.0;
+ prolongation[0](42,24) = 5.0/16.0;
+ prolongation[0](42,26) = 1.0/16.0;
+ prolongation[0](42,40) = 15.0/16.0;
+ prolongation[0](42,41) = -5.0/16.0;
+ prolongation[0](43,40) = 1.0;
+ prolongation[0](44,0) = -25.0/4096.0;
+ prolongation[0](44,1) = -25.0/4096.0;
+ prolongation[0](44,2) = -5.0/4096.0;
+ prolongation[0](44,3) = -5.0/4096.0;
+ prolongation[0](44,4) = -5.0/4096.0;
+ prolongation[0](44,5) = -5.0/4096.0;
+ prolongation[0](44,6) = -1.0/4096.0;
+ prolongation[0](44,7) = -1.0/4096.0;
+ prolongation[0](44,8) = 225.0/4096.0;
+ prolongation[0](44,9) = 225.0/4096.0;
+ prolongation[0](44,10) = -75.0/4096.0;
+ prolongation[0](44,11) = 25.0/4096.0;
+ prolongation[0](44,12) = 45.0/4096.0;
+ prolongation[0](44,13) = 45.0/4096.0;
+ prolongation[0](44,14) = -75.0/4096.0;
+ prolongation[0](44,15) = 25.0/4096.0;
+ prolongation[0](44,16) = 45.0/4096.0;
+ prolongation[0](44,17) = 45.0/4096.0;
+ prolongation[0](44,18) = -15.0/4096.0;
+ prolongation[0](44,19) = 5.0/4096.0;
+ prolongation[0](44,20) = 9.0/4096.0;
+ prolongation[0](44,21) = 9.0/4096.0;
+ prolongation[0](44,22) = -15.0/4096.0;
+ prolongation[0](44,23) = 5.0/4096.0;
+ prolongation[0](44,24) = -75.0/4096.0;
+ prolongation[0](44,25) = 25.0/4096.0;
+ prolongation[0](44,26) = -75.0/4096.0;
+ prolongation[0](44,27) = 25.0/4096.0;
+ prolongation[0](44,28) = -15.0/4096.0;
+ prolongation[0](44,29) = 5.0/4096.0;
+ prolongation[0](44,30) = -15.0/4096.0;
+ prolongation[0](44,31) = 5.0/4096.0;
+ prolongation[0](44,32) = 675.0/4096.0;
+ prolongation[0](44,33) = 675.0/4096.0;
+ prolongation[0](44,34) = -225.0/4096.0;
+ prolongation[0](44,35) = -225.0/4096.0;
+ prolongation[0](44,36) = 135.0/4096.0;
+ prolongation[0](44,37) = 135.0/4096.0;
+ prolongation[0](44,38) = -45.0/4096.0;
+ prolongation[0](44,39) = -45.0/4096.0;
+ prolongation[0](44,40) = 675.0/4096.0;
+ prolongation[0](44,41) = 675.0/4096.0;
+ prolongation[0](44,42) = -225.0/4096.0;
+ prolongation[0](44,43) = -225.0/4096.0;
+ prolongation[0](44,44) = -225.0/4096.0;
+ prolongation[0](44,45) = 75.0/4096.0;
+ prolongation[0](44,46) = 75.0/4096.0;
+ prolongation[0](44,47) = -25.0/4096.0;
+ prolongation[0](44,48) = 135.0/4096.0;
+ prolongation[0](44,49) = 135.0/4096.0;
+ prolongation[0](44,50) = -45.0/4096.0;
+ prolongation[0](44,51) = -45.0/4096.0;
+ prolongation[0](44,52) = -225.0/4096.0;
+ prolongation[0](44,53) = 75.0/4096.0;
+ prolongation[0](44,54) = 75.0/4096.0;
+ prolongation[0](44,55) = -25.0/4096.0;
+ prolongation[0](44,56) = 2025.0/4096.0;
+ prolongation[0](44,57) = 2025.0/4096.0;
+ prolongation[0](44,58) = -675.0/4096.0;
+ prolongation[0](44,59) = -675.0/4096.0;
+ prolongation[0](44,60) = -675.0/4096.0;
+ prolongation[0](44,61) = -675.0/4096.0;
+ prolongation[0](44,62) = 225.0/4096.0;
+ prolongation[0](44,63) = 225.0/4096.0;
+ prolongation[0](45,24) = -5.0/256.0;
+ prolongation[0](45,26) = -5.0/256.0;
+ prolongation[0](45,28) = -1.0/256.0;
+ prolongation[0](45,30) = -1.0/256.0;
+ prolongation[0](45,40) = 45.0/256.0;
+ prolongation[0](45,41) = 45.0/256.0;
+ prolongation[0](45,44) = -15.0/256.0;
+ prolongation[0](45,46) = 5.0/256.0;
+ prolongation[0](45,48) = 9.0/256.0;
+ prolongation[0](45,49) = 9.0/256.0;
+ prolongation[0](45,52) = -15.0/256.0;
+ prolongation[0](45,54) = 5.0/256.0;
+ prolongation[0](45,56) = 135.0/256.0;
+ prolongation[0](45,57) = 135.0/256.0;
+ prolongation[0](45,60) = -45.0/256.0;
+ prolongation[0](45,61) = -45.0/256.0;
+ prolongation[0](46,10) = -5.0/256.0;
+ prolongation[0](46,14) = -5.0/256.0;
+ prolongation[0](46,18) = -1.0/256.0;
+ prolongation[0](46,22) = -1.0/256.0;
+ prolongation[0](46,32) = 45.0/256.0;
+ prolongation[0](46,33) = 45.0/256.0;
+ prolongation[0](46,36) = 9.0/256.0;
+ prolongation[0](46,37) = 9.0/256.0;
+ prolongation[0](46,44) = -15.0/256.0;
+ prolongation[0](46,45) = 5.0/256.0;
+ prolongation[0](46,52) = -15.0/256.0;
+ prolongation[0](46,53) = 5.0/256.0;
+ prolongation[0](46,56) = 135.0/256.0;
+ prolongation[0](46,57) = 135.0/256.0;
+ prolongation[0](46,58) = -45.0/256.0;
+ prolongation[0](46,59) = -45.0/256.0;
+ prolongation[0](47,44) = -1.0/16.0;
+ prolongation[0](47,52) = -1.0/16.0;
+ prolongation[0](47,56) = 9.0/16.0;
+ prolongation[0](47,57) = 9.0/16.0;
+ prolongation[0](48,0) = -25.0/4096.0;
+ prolongation[0](48,1) = -5.0/4096.0;
+ prolongation[0](48,2) = -5.0/4096.0;
+ prolongation[0](48,3) = -25.0/4096.0;
+ prolongation[0](48,4) = -5.0/4096.0;
+ prolongation[0](48,5) = -1.0/4096.0;
+ prolongation[0](48,6) = -1.0/4096.0;
+ prolongation[0](48,7) = -5.0/4096.0;
+ prolongation[0](48,8) = -75.0/4096.0;
+ prolongation[0](48,9) = 25.0/4096.0;
+ prolongation[0](48,10) = 45.0/4096.0;
+ prolongation[0](48,11) = 45.0/4096.0;
+ prolongation[0](48,12) = -75.0/4096.0;
+ prolongation[0](48,13) = 25.0/4096.0;
+ prolongation[0](48,14) = 225.0/4096.0;
+ prolongation[0](48,15) = 225.0/4096.0;
+ prolongation[0](48,16) = -15.0/4096.0;
+ prolongation[0](48,17) = 5.0/4096.0;
+ prolongation[0](48,18) = 9.0/4096.0;
+ prolongation[0](48,19) = 9.0/4096.0;
+ prolongation[0](48,20) = -15.0/4096.0;
+ prolongation[0](48,21) = 5.0/4096.0;
+ prolongation[0](48,22) = 45.0/4096.0;
+ prolongation[0](48,23) = 45.0/4096.0;
+ prolongation[0](48,24) = -75.0/4096.0;
+ prolongation[0](48,25) = 25.0/4096.0;
+ prolongation[0](48,26) = -15.0/4096.0;
+ prolongation[0](48,27) = 5.0/4096.0;
+ prolongation[0](48,28) = -15.0/4096.0;
+ prolongation[0](48,29) = 5.0/4096.0;
+ prolongation[0](48,30) = -75.0/4096.0;
+ prolongation[0](48,31) = 25.0/4096.0;
+ prolongation[0](48,32) = 675.0/4096.0;
+ prolongation[0](48,33) = -225.0/4096.0;
+ prolongation[0](48,34) = 675.0/4096.0;
+ prolongation[0](48,35) = -225.0/4096.0;
+ prolongation[0](48,36) = 135.0/4096.0;
+ prolongation[0](48,37) = -45.0/4096.0;
+ prolongation[0](48,38) = 135.0/4096.0;
+ prolongation[0](48,39) = -45.0/4096.0;
+ prolongation[0](48,40) = -225.0/4096.0;
+ prolongation[0](48,41) = 75.0/4096.0;
+ prolongation[0](48,42) = 75.0/4096.0;
+ prolongation[0](48,43) = -25.0/4096.0;
+ prolongation[0](48,44) = 135.0/4096.0;
+ prolongation[0](48,45) = -45.0/4096.0;
+ prolongation[0](48,46) = 135.0/4096.0;
+ prolongation[0](48,47) = -45.0/4096.0;
+ prolongation[0](48,48) = -225.0/4096.0;
+ prolongation[0](48,49) = 75.0/4096.0;
+ prolongation[0](48,50) = 75.0/4096.0;
+ prolongation[0](48,51) = -25.0/4096.0;
+ prolongation[0](48,52) = 675.0/4096.0;
+ prolongation[0](48,53) = -225.0/4096.0;
+ prolongation[0](48,54) = 675.0/4096.0;
+ prolongation[0](48,55) = -225.0/4096.0;
+ prolongation[0](48,56) = 2025.0/4096.0;
+ prolongation[0](48,57) = -675.0/4096.0;
+ prolongation[0](48,58) = -675.0/4096.0;
+ prolongation[0](48,59) = 225.0/4096.0;
+ prolongation[0](48,60) = 2025.0/4096.0;
+ prolongation[0](48,61) = -675.0/4096.0;
+ prolongation[0](48,62) = -675.0/4096.0;
+ prolongation[0](48,63) = 225.0/4096.0;
+ prolongation[0](49,8) = -5.0/256.0;
+ prolongation[0](49,12) = -5.0/256.0;
+ prolongation[0](49,16) = -1.0/256.0;
+ prolongation[0](49,20) = -1.0/256.0;
+ prolongation[0](49,32) = 45.0/256.0;
+ prolongation[0](49,34) = 45.0/256.0;
+ prolongation[0](49,36) = 9.0/256.0;
+ prolongation[0](49,38) = 9.0/256.0;
+ prolongation[0](49,40) = -15.0/256.0;
+ prolongation[0](49,42) = 5.0/256.0;
+ prolongation[0](49,48) = -15.0/256.0;
+ prolongation[0](49,50) = 5.0/256.0;
+ prolongation[0](49,56) = 135.0/256.0;
+ prolongation[0](49,58) = -45.0/256.0;
+ prolongation[0](49,60) = 135.0/256.0;
+ prolongation[0](49,62) = -45.0/256.0;
+ prolongation[0](50,24) = -5.0/256.0;
+ prolongation[0](50,26) = -1.0/256.0;
+ prolongation[0](50,28) = -1.0/256.0;
+ prolongation[0](50,30) = -5.0/256.0;
+ prolongation[0](50,40) = -15.0/256.0;
+ prolongation[0](50,41) = 5.0/256.0;
+ prolongation[0](50,44) = 9.0/256.0;
+ prolongation[0](50,46) = 9.0/256.0;
+ prolongation[0](50,48) = -15.0/256.0;
+ prolongation[0](50,49) = 5.0/256.0;
+ prolongation[0](50,52) = 45.0/256.0;
+ prolongation[0](50,54) = 45.0/256.0;
+ prolongation[0](50,56) = 135.0/256.0;
+ prolongation[0](50,57) = -45.0/256.0;
+ prolongation[0](50,60) = 135.0/256.0;
+ prolongation[0](50,61) = -45.0/256.0;
+ prolongation[0](51,40) = -1.0/16.0;
+ prolongation[0](51,48) = -1.0/16.0;
+ prolongation[0](51,56) = 9.0/16.0;
+ prolongation[0](51,60) = 9.0/16.0;
+ prolongation[0](52,0) = 25.0/256.0;
+ prolongation[0](52,3) = 5.0/256.0;
+ prolongation[0](52,4) = 5.0/256.0;
+ prolongation[0](52,7) = 1.0/256.0;
+ prolongation[0](52,14) = 75.0/256.0;
+ prolongation[0](52,15) = -25.0/256.0;
+ prolongation[0](52,22) = 15.0/256.0;
+ prolongation[0](52,23) = -5.0/256.0;
+ prolongation[0](52,24) = 75.0/256.0;
+ prolongation[0](52,25) = -25.0/256.0;
+ prolongation[0](52,30) = 15.0/256.0;
+ prolongation[0](52,31) = -5.0/256.0;
+ prolongation[0](52,52) = 225.0/256.0;
+ prolongation[0](52,53) = -75.0/256.0;
+ prolongation[0](52,54) = -75.0/256.0;
+ prolongation[0](52,55) = 25.0/256.0;
+ prolongation[0](53,24) = 5.0/16.0;
+ prolongation[0](53,30) = 1.0/16.0;
+ prolongation[0](53,52) = 15.0/16.0;
+ prolongation[0](53,54) = -5.0/16.0;
+ prolongation[0](54,14) = 5.0/16.0;
+ prolongation[0](54,22) = 1.0/16.0;
+ prolongation[0](54,52) = 15.0/16.0;
+ prolongation[0](54,53) = -5.0/16.0;
+ prolongation[0](55,52) = 1.0;
+ prolongation[0](56,0) = 125.0/4096.0;
+ prolongation[0](56,1) = 25.0/4096.0;
+ prolongation[0](56,2) = 5.0/4096.0;
+ prolongation[0](56,3) = 25.0/4096.0;
+ prolongation[0](56,4) = 25.0/4096.0;
+ prolongation[0](56,5) = 5.0/4096.0;
+ prolongation[0](56,6) = 1.0/4096.0;
+ prolongation[0](56,7) = 5.0/4096.0;
+ prolongation[0](56,8) = 375.0/4096.0;
+ prolongation[0](56,9) = -125.0/4096.0;
+ prolongation[0](56,10) = 75.0/4096.0;
+ prolongation[0](56,11) = -25.0/4096.0;
+ prolongation[0](56,12) = 75.0/4096.0;
+ prolongation[0](56,13) = -25.0/4096.0;
+ prolongation[0](56,14) = 375.0/4096.0;
+ prolongation[0](56,15) = -125.0/4096.0;
+ prolongation[0](56,16) = 75.0/4096.0;
+ prolongation[0](56,17) = -25.0/4096.0;
+ prolongation[0](56,18) = 15.0/4096.0;
+ prolongation[0](56,19) = -5.0/4096.0;
+ prolongation[0](56,20) = 15.0/4096.0;
+ prolongation[0](56,21) = -5.0/4096.0;
+ prolongation[0](56,22) = 75.0/4096.0;
+ prolongation[0](56,23) = -25.0/4096.0;
+ prolongation[0](56,24) = 375.0/4096.0;
+ prolongation[0](56,25) = -125.0/4096.0;
+ prolongation[0](56,26) = 75.0/4096.0;
+ prolongation[0](56,27) = -25.0/4096.0;
+ prolongation[0](56,28) = 15.0/4096.0;
+ prolongation[0](56,29) = -5.0/4096.0;
+ prolongation[0](56,30) = 75.0/4096.0;
+ prolongation[0](56,31) = -25.0/4096.0;
+ prolongation[0](56,32) = 1125.0/4096.0;
+ prolongation[0](56,33) = -375.0/4096.0;
+ prolongation[0](56,34) = -375.0/4096.0;
+ prolongation[0](56,35) = 125.0/4096.0;
+ prolongation[0](56,36) = 225.0/4096.0;
+ prolongation[0](56,37) = -75.0/4096.0;
+ prolongation[0](56,38) = -75.0/4096.0;
+ prolongation[0](56,39) = 25.0/4096.0;
+ prolongation[0](56,40) = 1125.0/4096.0;
+ prolongation[0](56,41) = -375.0/4096.0;
+ prolongation[0](56,42) = -375.0/4096.0;
+ prolongation[0](56,43) = 125.0/4096.0;
+ prolongation[0](56,44) = 225.0/4096.0;
+ prolongation[0](56,45) = -75.0/4096.0;
+ prolongation[0](56,46) = -75.0/4096.0;
+ prolongation[0](56,47) = 25.0/4096.0;
+ prolongation[0](56,48) = 225.0/4096.0;
+ prolongation[0](56,49) = -75.0/4096.0;
+ prolongation[0](56,50) = -75.0/4096.0;
+ prolongation[0](56,51) = 25.0/4096.0;
+ prolongation[0](56,52) = 1125.0/4096.0;
+ prolongation[0](56,53) = -375.0/4096.0;
+ prolongation[0](56,54) = -375.0/4096.0;
+ prolongation[0](56,55) = 125.0/4096.0;
+ prolongation[0](56,56) = 3375.0/4096.0;
+ prolongation[0](56,57) = -1125.0/4096.0;
+ prolongation[0](56,58) = -1125.0/4096.0;
+ prolongation[0](56,59) = 375.0/4096.0;
+ prolongation[0](56,60) = -1125.0/4096.0;
+ prolongation[0](56,61) = 375.0/4096.0;
+ prolongation[0](56,62) = 375.0/4096.0;
+ prolongation[0](56,63) = -125.0/4096.0;
+ prolongation[0](57,8) = 25.0/256.0;
+ prolongation[0](57,12) = 5.0/256.0;
+ prolongation[0](57,16) = 5.0/256.0;
+ prolongation[0](57,20) = 1.0/256.0;
+ prolongation[0](57,32) = 75.0/256.0;
+ prolongation[0](57,34) = -25.0/256.0;
+ prolongation[0](57,36) = 15.0/256.0;
+ prolongation[0](57,38) = -5.0/256.0;
+ prolongation[0](57,40) = 75.0/256.0;
+ prolongation[0](57,42) = -25.0/256.0;
+ prolongation[0](57,48) = 15.0/256.0;
+ prolongation[0](57,50) = -5.0/256.0;
+ prolongation[0](57,56) = 225.0/256.0;
+ prolongation[0](57,58) = -75.0/256.0;
+ prolongation[0](57,60) = -75.0/256.0;
+ prolongation[0](57,62) = 25.0/256.0;
+ prolongation[0](58,24) = 25.0/256.0;
+ prolongation[0](58,26) = 5.0/256.0;
+ prolongation[0](58,28) = 1.0/256.0;
+ prolongation[0](58,30) = 5.0/256.0;
+ prolongation[0](58,40) = 75.0/256.0;
+ prolongation[0](58,41) = -25.0/256.0;
+ prolongation[0](58,44) = 15.0/256.0;
+ prolongation[0](58,46) = -5.0/256.0;
+ prolongation[0](58,48) = 15.0/256.0;
+ prolongation[0](58,49) = -5.0/256.0;
+ prolongation[0](58,52) = 75.0/256.0;
+ prolongation[0](58,54) = -25.0/256.0;
+ prolongation[0](58,56) = 225.0/256.0;
+ prolongation[0](58,57) = -75.0/256.0;
+ prolongation[0](58,60) = -75.0/256.0;
+ prolongation[0](58,61) = 25.0/256.0;
+ prolongation[0](59,40) = 5.0/16.0;
+ prolongation[0](59,48) = 1.0/16.0;
+ prolongation[0](59,56) = 15.0/16.0;
+ prolongation[0](59,60) = -5.0/16.0;
+ prolongation[0](60,10) = 5.0/256.0;
+ prolongation[0](60,14) = 25.0/256.0;
+ prolongation[0](60,18) = 1.0/256.0;
+ prolongation[0](60,22) = 5.0/256.0;
+ prolongation[0](60,32) = 75.0/256.0;
+ prolongation[0](60,33) = -25.0/256.0;
+ prolongation[0](60,36) = 15.0/256.0;
+ prolongation[0](60,37) = -5.0/256.0;
+ prolongation[0](60,44) = 15.0/256.0;
+ prolongation[0](60,45) = -5.0/256.0;
+ prolongation[0](60,52) = 75.0/256.0;
+ prolongation[0](60,53) = -25.0/256.0;
+ prolongation[0](60,56) = 225.0/256.0;
+ prolongation[0](60,57) = -75.0/256.0;
+ prolongation[0](60,58) = -75.0/256.0;
+ prolongation[0](60,59) = 25.0/256.0;
+ prolongation[0](61,32) = 5.0/16.0;
+ prolongation[0](61,36) = 1.0/16.0;
+ prolongation[0](61,56) = 15.0/16.0;
+ prolongation[0](61,58) = -5.0/16.0;
+ prolongation[0](62,44) = 1.0/16.0;
+ prolongation[0](62,52) = 5.0/16.0;
+ prolongation[0](62,56) = 15.0/16.0;
+ prolongation[0](62,57) = -5.0/16.0;
+ prolongation[0](63,56) = 1.0;
+ prolongation[1](0,0) = -1.0/16.0;
+ prolongation[1](0,1) = -1.0/16.0;
+ prolongation[1](0,8) = 9.0/16.0;
+ prolongation[1](0,9) = 9.0/16.0;
+ prolongation[1](1,1) = 1.0;
+ prolongation[1](2,1) = -1.0/16.0;
+ prolongation[1](2,2) = -1.0/16.0;
+ prolongation[1](2,10) = 9.0/16.0;
+ prolongation[1](2,11) = 9.0/16.0;
+ prolongation[1](3,0) = 1.0/256.0;
+ prolongation[1](3,1) = 1.0/256.0;
+ prolongation[1](3,2) = 1.0/256.0;
+ prolongation[1](3,3) = 1.0/256.0;
+ prolongation[1](3,8) = -9.0/256.0;
+ prolongation[1](3,9) = -9.0/256.0;
+ prolongation[1](3,10) = -9.0/256.0;
+ prolongation[1](3,11) = -9.0/256.0;
+ prolongation[1](3,12) = -9.0/256.0;
+ prolongation[1](3,13) = -9.0/256.0;
+ prolongation[1](3,14) = -9.0/256.0;
+ prolongation[1](3,15) = -9.0/256.0;
+ prolongation[1](3,32) = 81.0/256.0;
+ prolongation[1](3,33) = 81.0/256.0;
+ prolongation[1](3,34) = 81.0/256.0;
+ prolongation[1](3,35) = 81.0/256.0;
+ prolongation[1](4,0) = 1.0/256.0;
+ prolongation[1](4,1) = 1.0/256.0;
+ prolongation[1](4,4) = 1.0/256.0;
+ prolongation[1](4,5) = 1.0/256.0;
+ prolongation[1](4,8) = -9.0/256.0;
+ prolongation[1](4,9) = -9.0/256.0;
+ prolongation[1](4,16) = -9.0/256.0;
+ prolongation[1](4,17) = -9.0/256.0;
+ prolongation[1](4,24) = -9.0/256.0;
+ prolongation[1](4,25) = -9.0/256.0;
+ prolongation[1](4,26) = -9.0/256.0;
+ prolongation[1](4,27) = -9.0/256.0;
+ prolongation[1](4,40) = 81.0/256.0;
+ prolongation[1](4,41) = 81.0/256.0;
+ prolongation[1](4,42) = 81.0/256.0;
+ prolongation[1](4,43) = 81.0/256.0;
+ prolongation[1](5,1) = -1.0/16.0;
+ prolongation[1](5,5) = -1.0/16.0;
+ prolongation[1](5,26) = 9.0/16.0;
+ prolongation[1](5,27) = 9.0/16.0;
+ prolongation[1](6,1) = 1.0/256.0;
+ prolongation[1](6,2) = 1.0/256.0;
+ prolongation[1](6,5) = 1.0/256.0;
+ prolongation[1](6,6) = 1.0/256.0;
+ prolongation[1](6,10) = -9.0/256.0;
+ prolongation[1](6,11) = -9.0/256.0;
+ prolongation[1](6,18) = -9.0/256.0;
+ prolongation[1](6,19) = -9.0/256.0;
+ prolongation[1](6,26) = -9.0/256.0;
+ prolongation[1](6,27) = -9.0/256.0;
+ prolongation[1](6,28) = -9.0/256.0;
+ prolongation[1](6,29) = -9.0/256.0;
+ prolongation[1](6,44) = 81.0/256.0;
+ prolongation[1](6,45) = 81.0/256.0;
+ prolongation[1](6,46) = 81.0/256.0;
+ prolongation[1](6,47) = 81.0/256.0;
+ prolongation[1](7,0) = -1.0/4096.0;
+ prolongation[1](7,1) = -1.0/4096.0;
+ prolongation[1](7,2) = -1.0/4096.0;
+ prolongation[1](7,3) = -1.0/4096.0;
+ prolongation[1](7,4) = -1.0/4096.0;
+ prolongation[1](7,5) = -1.0/4096.0;
+ prolongation[1](7,6) = -1.0/4096.0;
+ prolongation[1](7,7) = -1.0/4096.0;
+ prolongation[1](7,8) = 9.0/4096.0;
+ prolongation[1](7,9) = 9.0/4096.0;
+ prolongation[1](7,10) = 9.0/4096.0;
+ prolongation[1](7,11) = 9.0/4096.0;
+ prolongation[1](7,12) = 9.0/4096.0;
+ prolongation[1](7,13) = 9.0/4096.0;
+ prolongation[1](7,14) = 9.0/4096.0;
+ prolongation[1](7,15) = 9.0/4096.0;
+ prolongation[1](7,16) = 9.0/4096.0;
+ prolongation[1](7,17) = 9.0/4096.0;
+ prolongation[1](7,18) = 9.0/4096.0;
+ prolongation[1](7,19) = 9.0/4096.0;
+ prolongation[1](7,20) = 9.0/4096.0;
+ prolongation[1](7,21) = 9.0/4096.0;
+ prolongation[1](7,22) = 9.0/4096.0;
+ prolongation[1](7,23) = 9.0/4096.0;
+ prolongation[1](7,24) = 9.0/4096.0;
+ prolongation[1](7,25) = 9.0/4096.0;
+ prolongation[1](7,26) = 9.0/4096.0;
+ prolongation[1](7,27) = 9.0/4096.0;
+ prolongation[1](7,28) = 9.0/4096.0;
+ prolongation[1](7,29) = 9.0/4096.0;
+ prolongation[1](7,30) = 9.0/4096.0;
+ prolongation[1](7,31) = 9.0/4096.0;
+ prolongation[1](7,32) = -81.0/4096.0;
+ prolongation[1](7,33) = -81.0/4096.0;
+ prolongation[1](7,34) = -81.0/4096.0;
+ prolongation[1](7,35) = -81.0/4096.0;
+ prolongation[1](7,36) = -81.0/4096.0;
+ prolongation[1](7,37) = -81.0/4096.0;
+ prolongation[1](7,38) = -81.0/4096.0;
+ prolongation[1](7,39) = -81.0/4096.0;
+ prolongation[1](7,40) = -81.0/4096.0;
+ prolongation[1](7,41) = -81.0/4096.0;
+ prolongation[1](7,42) = -81.0/4096.0;
+ prolongation[1](7,43) = -81.0/4096.0;
+ prolongation[1](7,44) = -81.0/4096.0;
+ prolongation[1](7,45) = -81.0/4096.0;
+ prolongation[1](7,46) = -81.0/4096.0;
+ prolongation[1](7,47) = -81.0/4096.0;
+ prolongation[1](7,48) = -81.0/4096.0;
+ prolongation[1](7,49) = -81.0/4096.0;
+ prolongation[1](7,50) = -81.0/4096.0;
+ prolongation[1](7,51) = -81.0/4096.0;
+ prolongation[1](7,52) = -81.0/4096.0;
+ prolongation[1](7,53) = -81.0/4096.0;
+ prolongation[1](7,54) = -81.0/4096.0;
+ prolongation[1](7,55) = -81.0/4096.0;
+ prolongation[1](7,56) = 729.0/4096.0;
+ prolongation[1](7,57) = 729.0/4096.0;
+ prolongation[1](7,58) = 729.0/4096.0;
+ prolongation[1](7,59) = 729.0/4096.0;
+ prolongation[1](7,60) = 729.0/4096.0;
+ prolongation[1](7,61) = 729.0/4096.0;
+ prolongation[1](7,62) = 729.0/4096.0;
+ prolongation[1](7,63) = 729.0/4096.0;
+ prolongation[1](8,9) = 1.0;
+ prolongation[1](9,0) = 1.0/16.0;
+ prolongation[1](9,1) = 5.0/16.0;
+ prolongation[1](9,8) = -5.0/16.0;
+ prolongation[1](9,9) = 15.0/16.0;
+ prolongation[1](10,1) = 5.0/16.0;
+ prolongation[1](10,2) = 1.0/16.0;
+ prolongation[1](10,10) = 15.0/16.0;
+ prolongation[1](10,11) = -5.0/16.0;
+ prolongation[1](11,10) = 1.0;
+ prolongation[1](12,9) = -1.0/16.0;
+ prolongation[1](12,13) = -1.0/16.0;
+ prolongation[1](12,33) = 9.0/16.0;
+ prolongation[1](12,35) = 9.0/16.0;
+ prolongation[1](13,0) = -1.0/256.0;
+ prolongation[1](13,1) = -5.0/256.0;
+ prolongation[1](13,2) = -5.0/256.0;
+ prolongation[1](13,3) = -1.0/256.0;
+ prolongation[1](13,8) = 5.0/256.0;
+ prolongation[1](13,9) = -15.0/256.0;
+ prolongation[1](13,10) = 45.0/256.0;
+ prolongation[1](13,11) = 45.0/256.0;
+ prolongation[1](13,12) = 5.0/256.0;
+ prolongation[1](13,13) = -15.0/256.0;
+ prolongation[1](13,14) = 9.0/256.0;
+ prolongation[1](13,15) = 9.0/256.0;
+ prolongation[1](13,32) = -45.0/256.0;
+ prolongation[1](13,33) = 135.0/256.0;
+ prolongation[1](13,34) = -45.0/256.0;
+ prolongation[1](13,35) = 135.0/256.0;
+ prolongation[1](14,0) = -5.0/256.0;
+ prolongation[1](14,1) = -5.0/256.0;
+ prolongation[1](14,2) = -1.0/256.0;
+ prolongation[1](14,3) = -1.0/256.0;
+ prolongation[1](14,8) = 45.0/256.0;
+ prolongation[1](14,9) = 45.0/256.0;
+ prolongation[1](14,10) = -15.0/256.0;
+ prolongation[1](14,11) = 5.0/256.0;
+ prolongation[1](14,12) = 9.0/256.0;
+ prolongation[1](14,13) = 9.0/256.0;
+ prolongation[1](14,14) = -15.0/256.0;
+ prolongation[1](14,15) = 5.0/256.0;
+ prolongation[1](14,32) = 135.0/256.0;
+ prolongation[1](14,33) = 135.0/256.0;
+ prolongation[1](14,34) = -45.0/256.0;
+ prolongation[1](14,35) = -45.0/256.0;
+ prolongation[1](15,10) = -1.0/16.0;
+ prolongation[1](15,14) = -1.0/16.0;
+ prolongation[1](15,32) = 9.0/16.0;
+ prolongation[1](15,33) = 9.0/16.0;
+ prolongation[1](16,9) = -1.0/16.0;
+ prolongation[1](16,17) = -1.0/16.0;
+ prolongation[1](16,41) = 9.0/16.0;
+ prolongation[1](16,43) = 9.0/16.0;
+ prolongation[1](17,0) = -1.0/256.0;
+ prolongation[1](17,1) = -5.0/256.0;
+ prolongation[1](17,4) = -1.0/256.0;
+ prolongation[1](17,5) = -5.0/256.0;
+ prolongation[1](17,8) = 5.0/256.0;
+ prolongation[1](17,9) = -15.0/256.0;
+ prolongation[1](17,16) = 5.0/256.0;
+ prolongation[1](17,17) = -15.0/256.0;
+ prolongation[1](17,24) = 9.0/256.0;
+ prolongation[1](17,25) = 9.0/256.0;
+ prolongation[1](17,26) = 45.0/256.0;
+ prolongation[1](17,27) = 45.0/256.0;
+ prolongation[1](17,40) = -45.0/256.0;
+ prolongation[1](17,41) = 135.0/256.0;
+ prolongation[1](17,42) = -45.0/256.0;
+ prolongation[1](17,43) = 135.0/256.0;
+ prolongation[1](18,1) = -5.0/256.0;
+ prolongation[1](18,2) = -1.0/256.0;
+ prolongation[1](18,5) = -5.0/256.0;
+ prolongation[1](18,6) = -1.0/256.0;
+ prolongation[1](18,10) = -15.0/256.0;
+ prolongation[1](18,11) = 5.0/256.0;
+ prolongation[1](18,18) = -15.0/256.0;
+ prolongation[1](18,19) = 5.0/256.0;
+ prolongation[1](18,26) = 45.0/256.0;
+ prolongation[1](18,27) = 45.0/256.0;
+ prolongation[1](18,28) = 9.0/256.0;
+ prolongation[1](18,29) = 9.0/256.0;
+ prolongation[1](18,44) = 135.0/256.0;
+ prolongation[1](18,45) = 135.0/256.0;
+ prolongation[1](18,46) = -45.0/256.0;
+ prolongation[1](18,47) = -45.0/256.0;
+ prolongation[1](19,10) = -1.0/16.0;
+ prolongation[1](19,18) = -1.0/16.0;
+ prolongation[1](19,44) = 9.0/16.0;
+ prolongation[1](19,45) = 9.0/16.0;
+ prolongation[1](20,9) = 1.0/256.0;
+ prolongation[1](20,13) = 1.0/256.0;
+ prolongation[1](20,17) = 1.0/256.0;
+ prolongation[1](20,21) = 1.0/256.0;
+ prolongation[1](20,33) = -9.0/256.0;
+ prolongation[1](20,35) = -9.0/256.0;
+ prolongation[1](20,37) = -9.0/256.0;
+ prolongation[1](20,39) = -9.0/256.0;
+ prolongation[1](20,41) = -9.0/256.0;
+ prolongation[1](20,43) = -9.0/256.0;
+ prolongation[1](20,49) = -9.0/256.0;
+ prolongation[1](20,51) = -9.0/256.0;
+ prolongation[1](20,57) = 81.0/256.0;
+ prolongation[1](20,59) = 81.0/256.0;
+ prolongation[1](20,61) = 81.0/256.0;
+ prolongation[1](20,63) = 81.0/256.0;
+ prolongation[1](21,0) = 1.0/4096.0;
+ prolongation[1](21,1) = 5.0/4096.0;
+ prolongation[1](21,2) = 5.0/4096.0;
+ prolongation[1](21,3) = 1.0/4096.0;
+ prolongation[1](21,4) = 1.0/4096.0;
+ prolongation[1](21,5) = 5.0/4096.0;
+ prolongation[1](21,6) = 5.0/4096.0;
+ prolongation[1](21,7) = 1.0/4096.0;
+ prolongation[1](21,8) = -5.0/4096.0;
+ prolongation[1](21,9) = 15.0/4096.0;
+ prolongation[1](21,10) = -45.0/4096.0;
+ prolongation[1](21,11) = -45.0/4096.0;
+ prolongation[1](21,12) = -5.0/4096.0;
+ prolongation[1](21,13) = 15.0/4096.0;
+ prolongation[1](21,14) = -9.0/4096.0;
+ prolongation[1](21,15) = -9.0/4096.0;
+ prolongation[1](21,16) = -5.0/4096.0;
+ prolongation[1](21,17) = 15.0/4096.0;
+ prolongation[1](21,18) = -45.0/4096.0;
+ prolongation[1](21,19) = -45.0/4096.0;
+ prolongation[1](21,20) = -5.0/4096.0;
+ prolongation[1](21,21) = 15.0/4096.0;
+ prolongation[1](21,22) = -9.0/4096.0;
+ prolongation[1](21,23) = -9.0/4096.0;
+ prolongation[1](21,24) = -9.0/4096.0;
+ prolongation[1](21,25) = -9.0/4096.0;
+ prolongation[1](21,26) = -45.0/4096.0;
+ prolongation[1](21,27) = -45.0/4096.0;
+ prolongation[1](21,28) = -45.0/4096.0;
+ prolongation[1](21,29) = -45.0/4096.0;
+ prolongation[1](21,30) = -9.0/4096.0;
+ prolongation[1](21,31) = -9.0/4096.0;
+ prolongation[1](21,32) = 45.0/4096.0;
+ prolongation[1](21,33) = -135.0/4096.0;
+ prolongation[1](21,34) = 45.0/4096.0;
+ prolongation[1](21,35) = -135.0/4096.0;
+ prolongation[1](21,36) = 45.0/4096.0;
+ prolongation[1](21,37) = -135.0/4096.0;
+ prolongation[1](21,38) = 45.0/4096.0;
+ prolongation[1](21,39) = -135.0/4096.0;
+ prolongation[1](21,40) = 45.0/4096.0;
+ prolongation[1](21,41) = -135.0/4096.0;
+ prolongation[1](21,42) = 45.0/4096.0;
+ prolongation[1](21,43) = -135.0/4096.0;
+ prolongation[1](21,44) = 405.0/4096.0;
+ prolongation[1](21,45) = 405.0/4096.0;
+ prolongation[1](21,46) = 405.0/4096.0;
+ prolongation[1](21,47) = 405.0/4096.0;
+ prolongation[1](21,48) = 45.0/4096.0;
+ prolongation[1](21,49) = -135.0/4096.0;
+ prolongation[1](21,50) = 45.0/4096.0;
+ prolongation[1](21,51) = -135.0/4096.0;
+ prolongation[1](21,52) = 81.0/4096.0;
+ prolongation[1](21,53) = 81.0/4096.0;
+ prolongation[1](21,54) = 81.0/4096.0;
+ prolongation[1](21,55) = 81.0/4096.0;
+ prolongation[1](21,56) = -405.0/4096.0;
+ prolongation[1](21,57) = 1215.0/4096.0;
+ prolongation[1](21,58) = -405.0/4096.0;
+ prolongation[1](21,59) = 1215.0/4096.0;
+ prolongation[1](21,60) = -405.0/4096.0;
+ prolongation[1](21,61) = 1215.0/4096.0;
+ prolongation[1](21,62) = -405.0/4096.0;
+ prolongation[1](21,63) = 1215.0/4096.0;
+ prolongation[1](22,0) = 5.0/4096.0;
+ prolongation[1](22,1) = 5.0/4096.0;
+ prolongation[1](22,2) = 1.0/4096.0;
+ prolongation[1](22,3) = 1.0/4096.0;
+ prolongation[1](22,4) = 5.0/4096.0;
+ prolongation[1](22,5) = 5.0/4096.0;
+ prolongation[1](22,6) = 1.0/4096.0;
+ prolongation[1](22,7) = 1.0/4096.0;
+ prolongation[1](22,8) = -45.0/4096.0;
+ prolongation[1](22,9) = -45.0/4096.0;
+ prolongation[1](22,10) = 15.0/4096.0;
+ prolongation[1](22,11) = -5.0/4096.0;
+ prolongation[1](22,12) = -9.0/4096.0;
+ prolongation[1](22,13) = -9.0/4096.0;
+ prolongation[1](22,14) = 15.0/4096.0;
+ prolongation[1](22,15) = -5.0/4096.0;
+ prolongation[1](22,16) = -45.0/4096.0;
+ prolongation[1](22,17) = -45.0/4096.0;
+ prolongation[1](22,18) = 15.0/4096.0;
+ prolongation[1](22,19) = -5.0/4096.0;
+ prolongation[1](22,20) = -9.0/4096.0;
+ prolongation[1](22,21) = -9.0/4096.0;
+ prolongation[1](22,22) = 15.0/4096.0;
+ prolongation[1](22,23) = -5.0/4096.0;
+ prolongation[1](22,24) = -45.0/4096.0;
+ prolongation[1](22,25) = -45.0/4096.0;
+ prolongation[1](22,26) = -45.0/4096.0;
+ prolongation[1](22,27) = -45.0/4096.0;
+ prolongation[1](22,28) = -9.0/4096.0;
+ prolongation[1](22,29) = -9.0/4096.0;
+ prolongation[1](22,30) = -9.0/4096.0;
+ prolongation[1](22,31) = -9.0/4096.0;
+ prolongation[1](22,32) = -135.0/4096.0;
+ prolongation[1](22,33) = -135.0/4096.0;
+ prolongation[1](22,34) = 45.0/4096.0;
+ prolongation[1](22,35) = 45.0/4096.0;
+ prolongation[1](22,36) = -135.0/4096.0;
+ prolongation[1](22,37) = -135.0/4096.0;
+ prolongation[1](22,38) = 45.0/4096.0;
+ prolongation[1](22,39) = 45.0/4096.0;
+ prolongation[1](22,40) = 405.0/4096.0;
+ prolongation[1](22,41) = 405.0/4096.0;
+ prolongation[1](22,42) = 405.0/4096.0;
+ prolongation[1](22,43) = 405.0/4096.0;
+ prolongation[1](22,44) = -135.0/4096.0;
+ prolongation[1](22,45) = -135.0/4096.0;
+ prolongation[1](22,46) = 45.0/4096.0;
+ prolongation[1](22,47) = 45.0/4096.0;
+ prolongation[1](22,48) = 81.0/4096.0;
+ prolongation[1](22,49) = 81.0/4096.0;
+ prolongation[1](22,50) = 81.0/4096.0;
+ prolongation[1](22,51) = 81.0/4096.0;
+ prolongation[1](22,52) = -135.0/4096.0;
+ prolongation[1](22,53) = -135.0/4096.0;
+ prolongation[1](22,54) = 45.0/4096.0;
+ prolongation[1](22,55) = 45.0/4096.0;
+ prolongation[1](22,56) = 1215.0/4096.0;
+ prolongation[1](22,57) = 1215.0/4096.0;
+ prolongation[1](22,58) = 1215.0/4096.0;
+ prolongation[1](22,59) = 1215.0/4096.0;
+ prolongation[1](22,60) = -405.0/4096.0;
+ prolongation[1](22,61) = -405.0/4096.0;
+ prolongation[1](22,62) = -405.0/4096.0;
+ prolongation[1](22,63) = -405.0/4096.0;
+ prolongation[1](23,10) = 1.0/256.0;
+ prolongation[1](23,14) = 1.0/256.0;
+ prolongation[1](23,18) = 1.0/256.0;
+ prolongation[1](23,22) = 1.0/256.0;
+ prolongation[1](23,32) = -9.0/256.0;
+ prolongation[1](23,33) = -9.0/256.0;
+ prolongation[1](23,36) = -9.0/256.0;
+ prolongation[1](23,37) = -9.0/256.0;
+ prolongation[1](23,44) = -9.0/256.0;
+ prolongation[1](23,45) = -9.0/256.0;
+ prolongation[1](23,52) = -9.0/256.0;
+ prolongation[1](23,53) = -9.0/256.0;
+ prolongation[1](23,56) = 81.0/256.0;
+ prolongation[1](23,57) = 81.0/256.0;
+ prolongation[1](23,58) = 81.0/256.0;
+ prolongation[1](23,59) = 81.0/256.0;
+ prolongation[1](24,0) = -5.0/256.0;
+ prolongation[1](24,1) = -5.0/256.0;
+ prolongation[1](24,4) = -1.0/256.0;
+ prolongation[1](24,5) = -1.0/256.0;
+ prolongation[1](24,8) = 45.0/256.0;
+ prolongation[1](24,9) = 45.0/256.0;
+ prolongation[1](24,16) = 9.0/256.0;
+ prolongation[1](24,17) = 9.0/256.0;
+ prolongation[1](24,24) = -15.0/256.0;
+ prolongation[1](24,25) = 5.0/256.0;
+ prolongation[1](24,26) = -15.0/256.0;
+ prolongation[1](24,27) = 5.0/256.0;
+ prolongation[1](24,40) = 135.0/256.0;
+ prolongation[1](24,41) = 135.0/256.0;
+ prolongation[1](24,42) = -45.0/256.0;
+ prolongation[1](24,43) = -45.0/256.0;
+ prolongation[1](25,24) = -1.0/16.0;
+ prolongation[1](25,26) = -1.0/16.0;
+ prolongation[1](25,40) = 9.0/16.0;
+ prolongation[1](25,41) = 9.0/16.0;
+ prolongation[1](26,1) = 5.0/16.0;
+ prolongation[1](26,5) = 1.0/16.0;
+ prolongation[1](26,26) = 15.0/16.0;
+ prolongation[1](26,27) = -5.0/16.0;
+ prolongation[1](27,26) = 1.0;
+ prolongation[1](28,1) = -5.0/256.0;
+ prolongation[1](28,2) = -5.0/256.0;
+ prolongation[1](28,5) = -1.0/256.0;
+ prolongation[1](28,6) = -1.0/256.0;
+ prolongation[1](28,10) = 45.0/256.0;
+ prolongation[1](28,11) = 45.0/256.0;
+ prolongation[1](28,18) = 9.0/256.0;
+ prolongation[1](28,19) = 9.0/256.0;
+ prolongation[1](28,26) = -15.0/256.0;
+ prolongation[1](28,27) = 5.0/256.0;
+ prolongation[1](28,28) = -15.0/256.0;
+ prolongation[1](28,29) = 5.0/256.0;
+ prolongation[1](28,44) = 135.0/256.0;
+ prolongation[1](28,45) = -45.0/256.0;
+ prolongation[1](28,46) = 135.0/256.0;
+ prolongation[1](28,47) = -45.0/256.0;
+ prolongation[1](29,26) = -1.0/16.0;
+ prolongation[1](29,28) = -1.0/16.0;
+ prolongation[1](29,44) = 9.0/16.0;
+ prolongation[1](29,46) = 9.0/16.0;
+ prolongation[1](30,0) = 5.0/4096.0;
+ prolongation[1](30,1) = 5.0/4096.0;
+ prolongation[1](30,2) = 5.0/4096.0;
+ prolongation[1](30,3) = 5.0/4096.0;
+ prolongation[1](30,4) = 1.0/4096.0;
+ prolongation[1](30,5) = 1.0/4096.0;
+ prolongation[1](30,6) = 1.0/4096.0;
+ prolongation[1](30,7) = 1.0/4096.0;
+ prolongation[1](30,8) = -45.0/4096.0;
+ prolongation[1](30,9) = -45.0/4096.0;
+ prolongation[1](30,10) = -45.0/4096.0;
+ prolongation[1](30,11) = -45.0/4096.0;
+ prolongation[1](30,12) = -45.0/4096.0;
+ prolongation[1](30,13) = -45.0/4096.0;
+ prolongation[1](30,14) = -45.0/4096.0;
+ prolongation[1](30,15) = -45.0/4096.0;
+ prolongation[1](30,16) = -9.0/4096.0;
+ prolongation[1](30,17) = -9.0/4096.0;
+ prolongation[1](30,18) = -9.0/4096.0;
+ prolongation[1](30,19) = -9.0/4096.0;
+ prolongation[1](30,20) = -9.0/4096.0;
+ prolongation[1](30,21) = -9.0/4096.0;
+ prolongation[1](30,22) = -9.0/4096.0;
+ prolongation[1](30,23) = -9.0/4096.0;
+ prolongation[1](30,24) = 15.0/4096.0;
+ prolongation[1](30,25) = -5.0/4096.0;
+ prolongation[1](30,26) = 15.0/4096.0;
+ prolongation[1](30,27) = -5.0/4096.0;
+ prolongation[1](30,28) = 15.0/4096.0;
+ prolongation[1](30,29) = -5.0/4096.0;
+ prolongation[1](30,30) = 15.0/4096.0;
+ prolongation[1](30,31) = -5.0/4096.0;
+ prolongation[1](30,32) = 405.0/4096.0;
+ prolongation[1](30,33) = 405.0/4096.0;
+ prolongation[1](30,34) = 405.0/4096.0;
+ prolongation[1](30,35) = 405.0/4096.0;
+ prolongation[1](30,36) = 81.0/4096.0;
+ prolongation[1](30,37) = 81.0/4096.0;
+ prolongation[1](30,38) = 81.0/4096.0;
+ prolongation[1](30,39) = 81.0/4096.0;
+ prolongation[1](30,40) = -135.0/4096.0;
+ prolongation[1](30,41) = -135.0/4096.0;
+ prolongation[1](30,42) = 45.0/4096.0;
+ prolongation[1](30,43) = 45.0/4096.0;
+ prolongation[1](30,44) = -135.0/4096.0;
+ prolongation[1](30,45) = 45.0/4096.0;
+ prolongation[1](30,46) = -135.0/4096.0;
+ prolongation[1](30,47) = 45.0/4096.0;
+ prolongation[1](30,48) = -135.0/4096.0;
+ prolongation[1](30,49) = -135.0/4096.0;
+ prolongation[1](30,50) = 45.0/4096.0;
+ prolongation[1](30,51) = 45.0/4096.0;
+ prolongation[1](30,52) = -135.0/4096.0;
+ prolongation[1](30,53) = 45.0/4096.0;
+ prolongation[1](30,54) = -135.0/4096.0;
+ prolongation[1](30,55) = 45.0/4096.0;
+ prolongation[1](30,56) = 1215.0/4096.0;
+ prolongation[1](30,57) = 1215.0/4096.0;
+ prolongation[1](30,58) = -405.0/4096.0;
+ prolongation[1](30,59) = -405.0/4096.0;
+ prolongation[1](30,60) = 1215.0/4096.0;
+ prolongation[1](30,61) = 1215.0/4096.0;
+ prolongation[1](30,62) = -405.0/4096.0;
+ prolongation[1](30,63) = -405.0/4096.0;
+ prolongation[1](31,24) = 1.0/256.0;
+ prolongation[1](31,26) = 1.0/256.0;
+ prolongation[1](31,28) = 1.0/256.0;
+ prolongation[1](31,30) = 1.0/256.0;
+ prolongation[1](31,40) = -9.0/256.0;
+ prolongation[1](31,41) = -9.0/256.0;
+ prolongation[1](31,44) = -9.0/256.0;
+ prolongation[1](31,46) = -9.0/256.0;
+ prolongation[1](31,48) = -9.0/256.0;
+ prolongation[1](31,49) = -9.0/256.0;
+ prolongation[1](31,52) = -9.0/256.0;
+ prolongation[1](31,54) = -9.0/256.0;
+ prolongation[1](31,56) = 81.0/256.0;
+ prolongation[1](31,57) = 81.0/256.0;
+ prolongation[1](31,60) = 81.0/256.0;
+ prolongation[1](31,61) = 81.0/256.0;
+ prolongation[1](32,9) = 5.0/16.0;
+ prolongation[1](32,13) = 1.0/16.0;
+ prolongation[1](32,33) = 15.0/16.0;
+ prolongation[1](32,35) = -5.0/16.0;
+ prolongation[1](33,0) = 5.0/256.0;
+ prolongation[1](33,1) = 25.0/256.0;
+ prolongation[1](33,2) = 5.0/256.0;
+ prolongation[1](33,3) = 1.0/256.0;
+ prolongation[1](33,8) = -25.0/256.0;
+ prolongation[1](33,9) = 75.0/256.0;
+ prolongation[1](33,10) = 75.0/256.0;
+ prolongation[1](33,11) = -25.0/256.0;
+ prolongation[1](33,12) = -5.0/256.0;
+ prolongation[1](33,13) = 15.0/256.0;
+ prolongation[1](33,14) = 15.0/256.0;
+ prolongation[1](33,15) = -5.0/256.0;
+ prolongation[1](33,32) = -75.0/256.0;
+ prolongation[1](33,33) = 225.0/256.0;
+ prolongation[1](33,34) = 25.0/256.0;
+ prolongation[1](33,35) = -75.0/256.0;
+ prolongation[1](34,33) = 1.0;
+ prolongation[1](35,10) = 5.0/16.0;
+ prolongation[1](35,14) = 1.0/16.0;
+ prolongation[1](35,32) = -5.0/16.0;
+ prolongation[1](35,33) = 15.0/16.0;
+ prolongation[1](36,9) = -5.0/256.0;
+ prolongation[1](36,13) = -1.0/256.0;
+ prolongation[1](36,17) = -5.0/256.0;
+ prolongation[1](36,21) = -1.0/256.0;
+ prolongation[1](36,33) = -15.0/256.0;
+ prolongation[1](36,35) = 5.0/256.0;
+ prolongation[1](36,37) = -15.0/256.0;
+ prolongation[1](36,39) = 5.0/256.0;
+ prolongation[1](36,41) = 45.0/256.0;
+ prolongation[1](36,43) = 45.0/256.0;
+ prolongation[1](36,49) = 9.0/256.0;
+ prolongation[1](36,51) = 9.0/256.0;
+ prolongation[1](36,57) = 135.0/256.0;
+ prolongation[1](36,59) = 135.0/256.0;
+ prolongation[1](36,61) = -45.0/256.0;
+ prolongation[1](36,63) = -45.0/256.0;
+ prolongation[1](37,0) = -5.0/4096.0;
+ prolongation[1](37,1) = -25.0/4096.0;
+ prolongation[1](37,2) = -5.0/4096.0;
+ prolongation[1](37,3) = -1.0/4096.0;
+ prolongation[1](37,4) = -5.0/4096.0;
+ prolongation[1](37,5) = -25.0/4096.0;
+ prolongation[1](37,6) = -5.0/4096.0;
+ prolongation[1](37,7) = -1.0/4096.0;
+ prolongation[1](37,8) = 25.0/4096.0;
+ prolongation[1](37,9) = -75.0/4096.0;
+ prolongation[1](37,10) = -75.0/4096.0;
+ prolongation[1](37,11) = 25.0/4096.0;
+ prolongation[1](37,12) = 5.0/4096.0;
+ prolongation[1](37,13) = -15.0/4096.0;
+ prolongation[1](37,14) = -15.0/4096.0;
+ prolongation[1](37,15) = 5.0/4096.0;
+ prolongation[1](37,16) = 25.0/4096.0;
+ prolongation[1](37,17) = -75.0/4096.0;
+ prolongation[1](37,18) = -75.0/4096.0;
+ prolongation[1](37,19) = 25.0/4096.0;
+ prolongation[1](37,20) = 5.0/4096.0;
+ prolongation[1](37,21) = -15.0/4096.0;
+ prolongation[1](37,22) = -15.0/4096.0;
+ prolongation[1](37,23) = 5.0/4096.0;
+ prolongation[1](37,24) = 45.0/4096.0;
+ prolongation[1](37,25) = 45.0/4096.0;
+ prolongation[1](37,26) = 225.0/4096.0;
+ prolongation[1](37,27) = 225.0/4096.0;
+ prolongation[1](37,28) = 45.0/4096.0;
+ prolongation[1](37,29) = 45.0/4096.0;
+ prolongation[1](37,30) = 9.0/4096.0;
+ prolongation[1](37,31) = 9.0/4096.0;
+ prolongation[1](37,32) = 75.0/4096.0;
+ prolongation[1](37,33) = -225.0/4096.0;
+ prolongation[1](37,34) = -25.0/4096.0;
+ prolongation[1](37,35) = 75.0/4096.0;
+ prolongation[1](37,36) = 75.0/4096.0;
+ prolongation[1](37,37) = -225.0/4096.0;
+ prolongation[1](37,38) = -25.0/4096.0;
+ prolongation[1](37,39) = 75.0/4096.0;
+ prolongation[1](37,40) = -225.0/4096.0;
+ prolongation[1](37,41) = 675.0/4096.0;
+ prolongation[1](37,42) = -225.0/4096.0;
+ prolongation[1](37,43) = 675.0/4096.0;
+ prolongation[1](37,44) = 675.0/4096.0;
+ prolongation[1](37,45) = 675.0/4096.0;
+ prolongation[1](37,46) = -225.0/4096.0;
+ prolongation[1](37,47) = -225.0/4096.0;
+ prolongation[1](37,48) = -45.0/4096.0;
+ prolongation[1](37,49) = 135.0/4096.0;
+ prolongation[1](37,50) = -45.0/4096.0;
+ prolongation[1](37,51) = 135.0/4096.0;
+ prolongation[1](37,52) = 135.0/4096.0;
+ prolongation[1](37,53) = 135.0/4096.0;
+ prolongation[1](37,54) = -45.0/4096.0;
+ prolongation[1](37,55) = -45.0/4096.0;
+ prolongation[1](37,56) = -675.0/4096.0;
+ prolongation[1](37,57) = 2025.0/4096.0;
+ prolongation[1](37,58) = -675.0/4096.0;
+ prolongation[1](37,59) = 2025.0/4096.0;
+ prolongation[1](37,60) = 225.0/4096.0;
+ prolongation[1](37,61) = -675.0/4096.0;
+ prolongation[1](37,62) = 225.0/4096.0;
+ prolongation[1](37,63) = -675.0/4096.0;
+ prolongation[1](38,33) = -1.0/16.0;
+ prolongation[1](38,37) = -1.0/16.0;
+ prolongation[1](38,57) = 9.0/16.0;
+ prolongation[1](38,59) = 9.0/16.0;
+ prolongation[1](39,10) = -5.0/256.0;
+ prolongation[1](39,14) = -1.0/256.0;
+ prolongation[1](39,18) = -5.0/256.0;
+ prolongation[1](39,22) = -1.0/256.0;
+ prolongation[1](39,32) = 5.0/256.0;
+ prolongation[1](39,33) = -15.0/256.0;
+ prolongation[1](39,36) = 5.0/256.0;
+ prolongation[1](39,37) = -15.0/256.0;
+ prolongation[1](39,44) = 45.0/256.0;
+ prolongation[1](39,45) = 45.0/256.0;
+ prolongation[1](39,52) = 9.0/256.0;
+ prolongation[1](39,53) = 9.0/256.0;
+ prolongation[1](39,56) = -45.0/256.0;
+ prolongation[1](39,57) = 135.0/256.0;
+ prolongation[1](39,58) = -45.0/256.0;
+ prolongation[1](39,59) = 135.0/256.0;
+ prolongation[1](40,9) = 5.0/16.0;
+ prolongation[1](40,17) = 1.0/16.0;
+ prolongation[1](40,41) = 15.0/16.0;
+ prolongation[1](40,43) = -5.0/16.0;
+ prolongation[1](41,0) = 5.0/256.0;
+ prolongation[1](41,1) = 25.0/256.0;
+ prolongation[1](41,4) = 1.0/256.0;
+ prolongation[1](41,5) = 5.0/256.0;
+ prolongation[1](41,8) = -25.0/256.0;
+ prolongation[1](41,9) = 75.0/256.0;
+ prolongation[1](41,16) = -5.0/256.0;
+ prolongation[1](41,17) = 15.0/256.0;
+ prolongation[1](41,24) = 15.0/256.0;
+ prolongation[1](41,25) = -5.0/256.0;
+ prolongation[1](41,26) = 75.0/256.0;
+ prolongation[1](41,27) = -25.0/256.0;
+ prolongation[1](41,40) = -75.0/256.0;
+ prolongation[1](41,41) = 225.0/256.0;
+ prolongation[1](41,42) = 25.0/256.0;
+ prolongation[1](41,43) = -75.0/256.0;
+ prolongation[1](42,41) = 1.0;
+ prolongation[1](43,24) = 1.0/16.0;
+ prolongation[1](43,26) = 5.0/16.0;
+ prolongation[1](43,40) = -5.0/16.0;
+ prolongation[1](43,41) = 15.0/16.0;
+ prolongation[1](44,1) = 25.0/256.0;
+ prolongation[1](44,2) = 5.0/256.0;
+ prolongation[1](44,5) = 5.0/256.0;
+ prolongation[1](44,6) = 1.0/256.0;
+ prolongation[1](44,10) = 75.0/256.0;
+ prolongation[1](44,11) = -25.0/256.0;
+ prolongation[1](44,18) = 15.0/256.0;
+ prolongation[1](44,19) = -5.0/256.0;
+ prolongation[1](44,26) = 75.0/256.0;
+ prolongation[1](44,27) = -25.0/256.0;
+ prolongation[1](44,28) = 15.0/256.0;
+ prolongation[1](44,29) = -5.0/256.0;
+ prolongation[1](44,44) = 225.0/256.0;
+ prolongation[1](44,45) = -75.0/256.0;
+ prolongation[1](44,46) = -75.0/256.0;
+ prolongation[1](44,47) = 25.0/256.0;
+ prolongation[1](45,26) = 5.0/16.0;
+ prolongation[1](45,28) = 1.0/16.0;
+ prolongation[1](45,44) = 15.0/16.0;
+ prolongation[1](45,46) = -5.0/16.0;
+ prolongation[1](46,10) = 5.0/16.0;
+ prolongation[1](46,18) = 1.0/16.0;
+ prolongation[1](46,44) = 15.0/16.0;
+ prolongation[1](46,45) = -5.0/16.0;
+ prolongation[1](47,44) = 1.0;
+ prolongation[1](48,9) = -5.0/256.0;
+ prolongation[1](48,13) = -5.0/256.0;
+ prolongation[1](48,17) = -1.0/256.0;
+ prolongation[1](48,21) = -1.0/256.0;
+ prolongation[1](48,33) = 45.0/256.0;
+ prolongation[1](48,35) = 45.0/256.0;
+ prolongation[1](48,37) = 9.0/256.0;
+ prolongation[1](48,39) = 9.0/256.0;
+ prolongation[1](48,41) = -15.0/256.0;
+ prolongation[1](48,43) = 5.0/256.0;
+ prolongation[1](48,49) = -15.0/256.0;
+ prolongation[1](48,51) = 5.0/256.0;
+ prolongation[1](48,57) = 135.0/256.0;
+ prolongation[1](48,59) = -45.0/256.0;
+ prolongation[1](48,61) = 135.0/256.0;
+ prolongation[1](48,63) = -45.0/256.0;
+ prolongation[1](49,0) = -5.0/4096.0;
+ prolongation[1](49,1) = -25.0/4096.0;
+ prolongation[1](49,2) = -25.0/4096.0;
+ prolongation[1](49,3) = -5.0/4096.0;
+ prolongation[1](49,4) = -1.0/4096.0;
+ prolongation[1](49,5) = -5.0/4096.0;
+ prolongation[1](49,6) = -5.0/4096.0;
+ prolongation[1](49,7) = -1.0/4096.0;
+ prolongation[1](49,8) = 25.0/4096.0;
+ prolongation[1](49,9) = -75.0/4096.0;
+ prolongation[1](49,10) = 225.0/4096.0;
+ prolongation[1](49,11) = 225.0/4096.0;
+ prolongation[1](49,12) = 25.0/4096.0;
+ prolongation[1](49,13) = -75.0/4096.0;
+ prolongation[1](49,14) = 45.0/4096.0;
+ prolongation[1](49,15) = 45.0/4096.0;
+ prolongation[1](49,16) = 5.0/4096.0;
+ prolongation[1](49,17) = -15.0/4096.0;
+ prolongation[1](49,18) = 45.0/4096.0;
+ prolongation[1](49,19) = 45.0/4096.0;
+ prolongation[1](49,20) = 5.0/4096.0;
+ prolongation[1](49,21) = -15.0/4096.0;
+ prolongation[1](49,22) = 9.0/4096.0;
+ prolongation[1](49,23) = 9.0/4096.0;
+ prolongation[1](49,24) = -15.0/4096.0;
+ prolongation[1](49,25) = 5.0/4096.0;
+ prolongation[1](49,26) = -75.0/4096.0;
+ prolongation[1](49,27) = 25.0/4096.0;
+ prolongation[1](49,28) = -75.0/4096.0;
+ prolongation[1](49,29) = 25.0/4096.0;
+ prolongation[1](49,30) = -15.0/4096.0;
+ prolongation[1](49,31) = 5.0/4096.0;
+ prolongation[1](49,32) = -225.0/4096.0;
+ prolongation[1](49,33) = 675.0/4096.0;
+ prolongation[1](49,34) = -225.0/4096.0;
+ prolongation[1](49,35) = 675.0/4096.0;
+ prolongation[1](49,36) = -45.0/4096.0;
+ prolongation[1](49,37) = 135.0/4096.0;
+ prolongation[1](49,38) = -45.0/4096.0;
+ prolongation[1](49,39) = 135.0/4096.0;
+ prolongation[1](49,40) = 75.0/4096.0;
+ prolongation[1](49,41) = -225.0/4096.0;
+ prolongation[1](49,42) = -25.0/4096.0;
+ prolongation[1](49,43) = 75.0/4096.0;
+ prolongation[1](49,44) = 675.0/4096.0;
+ prolongation[1](49,45) = -225.0/4096.0;
+ prolongation[1](49,46) = 675.0/4096.0;
+ prolongation[1](49,47) = -225.0/4096.0;
+ prolongation[1](49,48) = 75.0/4096.0;
+ prolongation[1](49,49) = -225.0/4096.0;
+ prolongation[1](49,50) = -25.0/4096.0;
+ prolongation[1](49,51) = 75.0/4096.0;
+ prolongation[1](49,52) = 135.0/4096.0;
+ prolongation[1](49,53) = -45.0/4096.0;
+ prolongation[1](49,54) = 135.0/4096.0;
+ prolongation[1](49,55) = -45.0/4096.0;
+ prolongation[1](49,56) = -675.0/4096.0;
+ prolongation[1](49,57) = 2025.0/4096.0;
+ prolongation[1](49,58) = 225.0/4096.0;
+ prolongation[1](49,59) = -675.0/4096.0;
+ prolongation[1](49,60) = -675.0/4096.0;
+ prolongation[1](49,61) = 2025.0/4096.0;
+ prolongation[1](49,62) = 225.0/4096.0;
+ prolongation[1](49,63) = -675.0/4096.0;
+ prolongation[1](50,41) = -1.0/16.0;
+ prolongation[1](50,49) = -1.0/16.0;
+ prolongation[1](50,57) = 9.0/16.0;
+ prolongation[1](50,61) = 9.0/16.0;
+ prolongation[1](51,24) = -1.0/256.0;
+ prolongation[1](51,26) = -5.0/256.0;
+ prolongation[1](51,28) = -5.0/256.0;
+ prolongation[1](51,30) = -1.0/256.0;
+ prolongation[1](51,40) = 5.0/256.0;
+ prolongation[1](51,41) = -15.0/256.0;
+ prolongation[1](51,44) = 45.0/256.0;
+ prolongation[1](51,46) = 45.0/256.0;
+ prolongation[1](51,48) = 5.0/256.0;
+ prolongation[1](51,49) = -15.0/256.0;
+ prolongation[1](51,52) = 9.0/256.0;
+ prolongation[1](51,54) = 9.0/256.0;
+ prolongation[1](51,56) = -45.0/256.0;
+ prolongation[1](51,57) = 135.0/256.0;
+ prolongation[1](51,60) = -45.0/256.0;
+ prolongation[1](51,61) = 135.0/256.0;
+ prolongation[1](52,0) = -25.0/4096.0;
+ prolongation[1](52,1) = -25.0/4096.0;
+ prolongation[1](52,2) = -5.0/4096.0;
+ prolongation[1](52,3) = -5.0/4096.0;
+ prolongation[1](52,4) = -5.0/4096.0;
+ prolongation[1](52,5) = -5.0/4096.0;
+ prolongation[1](52,6) = -1.0/4096.0;
+ prolongation[1](52,7) = -1.0/4096.0;
+ prolongation[1](52,8) = 225.0/4096.0;
+ prolongation[1](52,9) = 225.0/4096.0;
+ prolongation[1](52,10) = -75.0/4096.0;
+ prolongation[1](52,11) = 25.0/4096.0;
+ prolongation[1](52,12) = 45.0/4096.0;
+ prolongation[1](52,13) = 45.0/4096.0;
+ prolongation[1](52,14) = -75.0/4096.0;
+ prolongation[1](52,15) = 25.0/4096.0;
+ prolongation[1](52,16) = 45.0/4096.0;
+ prolongation[1](52,17) = 45.0/4096.0;
+ prolongation[1](52,18) = -15.0/4096.0;
+ prolongation[1](52,19) = 5.0/4096.0;
+ prolongation[1](52,20) = 9.0/4096.0;
+ prolongation[1](52,21) = 9.0/4096.0;
+ prolongation[1](52,22) = -15.0/4096.0;
+ prolongation[1](52,23) = 5.0/4096.0;
+ prolongation[1](52,24) = -75.0/4096.0;
+ prolongation[1](52,25) = 25.0/4096.0;
+ prolongation[1](52,26) = -75.0/4096.0;
+ prolongation[1](52,27) = 25.0/4096.0;
+ prolongation[1](52,28) = -15.0/4096.0;
+ prolongation[1](52,29) = 5.0/4096.0;
+ prolongation[1](52,30) = -15.0/4096.0;
+ prolongation[1](52,31) = 5.0/4096.0;
+ prolongation[1](52,32) = 675.0/4096.0;
+ prolongation[1](52,33) = 675.0/4096.0;
+ prolongation[1](52,34) = -225.0/4096.0;
+ prolongation[1](52,35) = -225.0/4096.0;
+ prolongation[1](52,36) = 135.0/4096.0;
+ prolongation[1](52,37) = 135.0/4096.0;
+ prolongation[1](52,38) = -45.0/4096.0;
+ prolongation[1](52,39) = -45.0/4096.0;
+ prolongation[1](52,40) = 675.0/4096.0;
+ prolongation[1](52,41) = 675.0/4096.0;
+ prolongation[1](52,42) = -225.0/4096.0;
+ prolongation[1](52,43) = -225.0/4096.0;
+ prolongation[1](52,44) = -225.0/4096.0;
+ prolongation[1](52,45) = 75.0/4096.0;
+ prolongation[1](52,46) = 75.0/4096.0;
+ prolongation[1](52,47) = -25.0/4096.0;
+ prolongation[1](52,48) = 135.0/4096.0;
+ prolongation[1](52,49) = 135.0/4096.0;
+ prolongation[1](52,50) = -45.0/4096.0;
+ prolongation[1](52,51) = -45.0/4096.0;
+ prolongation[1](52,52) = -225.0/4096.0;
+ prolongation[1](52,53) = 75.0/4096.0;
+ prolongation[1](52,54) = 75.0/4096.0;
+ prolongation[1](52,55) = -25.0/4096.0;
+ prolongation[1](52,56) = 2025.0/4096.0;
+ prolongation[1](52,57) = 2025.0/4096.0;
+ prolongation[1](52,58) = -675.0/4096.0;
+ prolongation[1](52,59) = -675.0/4096.0;
+ prolongation[1](52,60) = -675.0/4096.0;
+ prolongation[1](52,61) = -675.0/4096.0;
+ prolongation[1](52,62) = 225.0/4096.0;
+ prolongation[1](52,63) = 225.0/4096.0;
+ prolongation[1](53,24) = -5.0/256.0;
+ prolongation[1](53,26) = -5.0/256.0;
+ prolongation[1](53,28) = -1.0/256.0;
+ prolongation[1](53,30) = -1.0/256.0;
+ prolongation[1](53,40) = 45.0/256.0;
+ prolongation[1](53,41) = 45.0/256.0;
+ prolongation[1](53,44) = -15.0/256.0;
+ prolongation[1](53,46) = 5.0/256.0;
+ prolongation[1](53,48) = 9.0/256.0;
+ prolongation[1](53,49) = 9.0/256.0;
+ prolongation[1](53,52) = -15.0/256.0;
+ prolongation[1](53,54) = 5.0/256.0;
+ prolongation[1](53,56) = 135.0/256.0;
+ prolongation[1](53,57) = 135.0/256.0;
+ prolongation[1](53,60) = -45.0/256.0;
+ prolongation[1](53,61) = -45.0/256.0;
+ prolongation[1](54,10) = -5.0/256.0;
+ prolongation[1](54,14) = -5.0/256.0;
+ prolongation[1](54,18) = -1.0/256.0;
+ prolongation[1](54,22) = -1.0/256.0;
+ prolongation[1](54,32) = 45.0/256.0;
+ prolongation[1](54,33) = 45.0/256.0;
+ prolongation[1](54,36) = 9.0/256.0;
+ prolongation[1](54,37) = 9.0/256.0;
+ prolongation[1](54,44) = -15.0/256.0;
+ prolongation[1](54,45) = 5.0/256.0;
+ prolongation[1](54,52) = -15.0/256.0;
+ prolongation[1](54,53) = 5.0/256.0;
+ prolongation[1](54,56) = 135.0/256.0;
+ prolongation[1](54,57) = 135.0/256.0;
+ prolongation[1](54,58) = -45.0/256.0;
+ prolongation[1](54,59) = -45.0/256.0;
+ prolongation[1](55,44) = -1.0/16.0;
+ prolongation[1](55,52) = -1.0/16.0;
+ prolongation[1](55,56) = 9.0/16.0;
+ prolongation[1](55,57) = 9.0/16.0;
+ prolongation[1](56,9) = 25.0/256.0;
+ prolongation[1](56,13) = 5.0/256.0;
+ prolongation[1](56,17) = 5.0/256.0;
+ prolongation[1](56,21) = 1.0/256.0;
+ prolongation[1](56,33) = 75.0/256.0;
+ prolongation[1](56,35) = -25.0/256.0;
+ prolongation[1](56,37) = 15.0/256.0;
+ prolongation[1](56,39) = -5.0/256.0;
+ prolongation[1](56,41) = 75.0/256.0;
+ prolongation[1](56,43) = -25.0/256.0;
+ prolongation[1](56,49) = 15.0/256.0;
+ prolongation[1](56,51) = -5.0/256.0;
+ prolongation[1](56,57) = 225.0/256.0;
+ prolongation[1](56,59) = -75.0/256.0;
+ prolongation[1](56,61) = -75.0/256.0;
+ prolongation[1](56,63) = 25.0/256.0;
+ prolongation[1](57,0) = 25.0/4096.0;
+ prolongation[1](57,1) = 125.0/4096.0;
+ prolongation[1](57,2) = 25.0/4096.0;
+ prolongation[1](57,3) = 5.0/4096.0;
+ prolongation[1](57,4) = 5.0/4096.0;
+ prolongation[1](57,5) = 25.0/4096.0;
+ prolongation[1](57,6) = 5.0/4096.0;
+ prolongation[1](57,7) = 1.0/4096.0;
+ prolongation[1](57,8) = -125.0/4096.0;
+ prolongation[1](57,9) = 375.0/4096.0;
+ prolongation[1](57,10) = 375.0/4096.0;
+ prolongation[1](57,11) = -125.0/4096.0;
+ prolongation[1](57,12) = -25.0/4096.0;
+ prolongation[1](57,13) = 75.0/4096.0;
+ prolongation[1](57,14) = 75.0/4096.0;
+ prolongation[1](57,15) = -25.0/4096.0;
+ prolongation[1](57,16) = -25.0/4096.0;
+ prolongation[1](57,17) = 75.0/4096.0;
+ prolongation[1](57,18) = 75.0/4096.0;
+ prolongation[1](57,19) = -25.0/4096.0;
+ prolongation[1](57,20) = -5.0/4096.0;
+ prolongation[1](57,21) = 15.0/4096.0;
+ prolongation[1](57,22) = 15.0/4096.0;
+ prolongation[1](57,23) = -5.0/4096.0;
+ prolongation[1](57,24) = 75.0/4096.0;
+ prolongation[1](57,25) = -25.0/4096.0;
+ prolongation[1](57,26) = 375.0/4096.0;
+ prolongation[1](57,27) = -125.0/4096.0;
+ prolongation[1](57,28) = 75.0/4096.0;
+ prolongation[1](57,29) = -25.0/4096.0;
+ prolongation[1](57,30) = 15.0/4096.0;
+ prolongation[1](57,31) = -5.0/4096.0;
+ prolongation[1](57,32) = -375.0/4096.0;
+ prolongation[1](57,33) = 1125.0/4096.0;
+ prolongation[1](57,34) = 125.0/4096.0;
+ prolongation[1](57,35) = -375.0/4096.0;
+ prolongation[1](57,36) = -75.0/4096.0;
+ prolongation[1](57,37) = 225.0/4096.0;
+ prolongation[1](57,38) = 25.0/4096.0;
+ prolongation[1](57,39) = -75.0/4096.0;
+ prolongation[1](57,40) = -375.0/4096.0;
+ prolongation[1](57,41) = 1125.0/4096.0;
+ prolongation[1](57,42) = 125.0/4096.0;
+ prolongation[1](57,43) = -375.0/4096.0;
+ prolongation[1](57,44) = 1125.0/4096.0;
+ prolongation[1](57,45) = -375.0/4096.0;
+ prolongation[1](57,46) = -375.0/4096.0;
+ prolongation[1](57,47) = 125.0/4096.0;
+ prolongation[1](57,48) = -75.0/4096.0;
+ prolongation[1](57,49) = 225.0/4096.0;
+ prolongation[1](57,50) = 25.0/4096.0;
+ prolongation[1](57,51) = -75.0/4096.0;
+ prolongation[1](57,52) = 225.0/4096.0;
+ prolongation[1](57,53) = -75.0/4096.0;
+ prolongation[1](57,54) = -75.0/4096.0;
+ prolongation[1](57,55) = 25.0/4096.0;
+ prolongation[1](57,56) = -1125.0/4096.0;
+ prolongation[1](57,57) = 3375.0/4096.0;
+ prolongation[1](57,58) = 375.0/4096.0;
+ prolongation[1](57,59) = -1125.0/4096.0;
+ prolongation[1](57,60) = 375.0/4096.0;
+ prolongation[1](57,61) = -1125.0/4096.0;
+ prolongation[1](57,62) = -125.0/4096.0;
+ prolongation[1](57,63) = 375.0/4096.0;
+ prolongation[1](58,41) = 5.0/16.0;
+ prolongation[1](58,49) = 1.0/16.0;
+ prolongation[1](58,57) = 15.0/16.0;
+ prolongation[1](58,61) = -5.0/16.0;
+ prolongation[1](59,24) = 5.0/256.0;
+ prolongation[1](59,26) = 25.0/256.0;
+ prolongation[1](59,28) = 5.0/256.0;
+ prolongation[1](59,30) = 1.0/256.0;
+ prolongation[1](59,40) = -25.0/256.0;
+ prolongation[1](59,41) = 75.0/256.0;
+ prolongation[1](59,44) = 75.0/256.0;
+ prolongation[1](59,46) = -25.0/256.0;
+ prolongation[1](59,48) = -5.0/256.0;
+ prolongation[1](59,49) = 15.0/256.0;
+ prolongation[1](59,52) = 15.0/256.0;
+ prolongation[1](59,54) = -5.0/256.0;
+ prolongation[1](59,56) = -75.0/256.0;
+ prolongation[1](59,57) = 225.0/256.0;
+ prolongation[1](59,60) = 25.0/256.0;
+ prolongation[1](59,61) = -75.0/256.0;
+ prolongation[1](60,33) = 5.0/16.0;
+ prolongation[1](60,37) = 1.0/16.0;
+ prolongation[1](60,57) = 15.0/16.0;
+ prolongation[1](60,59) = -5.0/16.0;
+ prolongation[1](61,10) = 25.0/256.0;
+ prolongation[1](61,14) = 5.0/256.0;
+ prolongation[1](61,18) = 5.0/256.0;
+ prolongation[1](61,22) = 1.0/256.0;
+ prolongation[1](61,32) = -25.0/256.0;
+ prolongation[1](61,33) = 75.0/256.0;
+ prolongation[1](61,36) = -5.0/256.0;
+ prolongation[1](61,37) = 15.0/256.0;
+ prolongation[1](61,44) = 75.0/256.0;
+ prolongation[1](61,45) = -25.0/256.0;
+ prolongation[1](61,52) = 15.0/256.0;
+ prolongation[1](61,53) = -5.0/256.0;
+ prolongation[1](61,56) = -75.0/256.0;
+ prolongation[1](61,57) = 225.0/256.0;
+ prolongation[1](61,58) = 25.0/256.0;
+ prolongation[1](61,59) = -75.0/256.0;
+ prolongation[1](62,57) = 1.0;
+ prolongation[1](63,44) = 5.0/16.0;
+ prolongation[1](63,52) = 1.0/16.0;
+ prolongation[1](63,56) = -5.0/16.0;
+ prolongation[1](63,57) = 15.0/16.0;
+ prolongation[2](0,0) = 1.0/256.0;
+ prolongation[2](0,1) = 1.0/256.0;
+ prolongation[2](0,2) = 1.0/256.0;
+ prolongation[2](0,3) = 1.0/256.0;
+ prolongation[2](0,8) = -9.0/256.0;
+ prolongation[2](0,9) = -9.0/256.0;
+ prolongation[2](0,10) = -9.0/256.0;
+ prolongation[2](0,11) = -9.0/256.0;
+ prolongation[2](0,12) = -9.0/256.0;
+ prolongation[2](0,13) = -9.0/256.0;
+ prolongation[2](0,14) = -9.0/256.0;
+ prolongation[2](0,15) = -9.0/256.0;
+ prolongation[2](0,32) = 81.0/256.0;
+ prolongation[2](0,33) = 81.0/256.0;
+ prolongation[2](0,34) = 81.0/256.0;
+ prolongation[2](0,35) = 81.0/256.0;
+ prolongation[2](1,1) = -1.0/16.0;
+ prolongation[2](1,2) = -1.0/16.0;
+ prolongation[2](1,10) = 9.0/16.0;
+ prolongation[2](1,11) = 9.0/16.0;
+ prolongation[2](2,2) = 1.0;
+ prolongation[2](3,2) = -1.0/16.0;
+ prolongation[2](3,3) = -1.0/16.0;
+ prolongation[2](3,12) = 9.0/16.0;
+ prolongation[2](3,13) = 9.0/16.0;
+ prolongation[2](4,0) = -1.0/4096.0;
+ prolongation[2](4,1) = -1.0/4096.0;
+ prolongation[2](4,2) = -1.0/4096.0;
+ prolongation[2](4,3) = -1.0/4096.0;
+ prolongation[2](4,4) = -1.0/4096.0;
+ prolongation[2](4,5) = -1.0/4096.0;
+ prolongation[2](4,6) = -1.0/4096.0;
+ prolongation[2](4,7) = -1.0/4096.0;
+ prolongation[2](4,8) = 9.0/4096.0;
+ prolongation[2](4,9) = 9.0/4096.0;
+ prolongation[2](4,10) = 9.0/4096.0;
+ prolongation[2](4,11) = 9.0/4096.0;
+ prolongation[2](4,12) = 9.0/4096.0;
+ prolongation[2](4,13) = 9.0/4096.0;
+ prolongation[2](4,14) = 9.0/4096.0;
+ prolongation[2](4,15) = 9.0/4096.0;
+ prolongation[2](4,16) = 9.0/4096.0;
+ prolongation[2](4,17) = 9.0/4096.0;
+ prolongation[2](4,18) = 9.0/4096.0;
+ prolongation[2](4,19) = 9.0/4096.0;
+ prolongation[2](4,20) = 9.0/4096.0;
+ prolongation[2](4,21) = 9.0/4096.0;
+ prolongation[2](4,22) = 9.0/4096.0;
+ prolongation[2](4,23) = 9.0/4096.0;
+ prolongation[2](4,24) = 9.0/4096.0;
+ prolongation[2](4,25) = 9.0/4096.0;
+ prolongation[2](4,26) = 9.0/4096.0;
+ prolongation[2](4,27) = 9.0/4096.0;
+ prolongation[2](4,28) = 9.0/4096.0;
+ prolongation[2](4,29) = 9.0/4096.0;
+ prolongation[2](4,30) = 9.0/4096.0;
+ prolongation[2](4,31) = 9.0/4096.0;
+ prolongation[2](4,32) = -81.0/4096.0;
+ prolongation[2](4,33) = -81.0/4096.0;
+ prolongation[2](4,34) = -81.0/4096.0;
+ prolongation[2](4,35) = -81.0/4096.0;
+ prolongation[2](4,36) = -81.0/4096.0;
+ prolongation[2](4,37) = -81.0/4096.0;
+ prolongation[2](4,38) = -81.0/4096.0;
+ prolongation[2](4,39) = -81.0/4096.0;
+ prolongation[2](4,40) = -81.0/4096.0;
+ prolongation[2](4,41) = -81.0/4096.0;
+ prolongation[2](4,42) = -81.0/4096.0;
+ prolongation[2](4,43) = -81.0/4096.0;
+ prolongation[2](4,44) = -81.0/4096.0;
+ prolongation[2](4,45) = -81.0/4096.0;
+ prolongation[2](4,46) = -81.0/4096.0;
+ prolongation[2](4,47) = -81.0/4096.0;
+ prolongation[2](4,48) = -81.0/4096.0;
+ prolongation[2](4,49) = -81.0/4096.0;
+ prolongation[2](4,50) = -81.0/4096.0;
+ prolongation[2](4,51) = -81.0/4096.0;
+ prolongation[2](4,52) = -81.0/4096.0;
+ prolongation[2](4,53) = -81.0/4096.0;
+ prolongation[2](4,54) = -81.0/4096.0;
+ prolongation[2](4,55) = -81.0/4096.0;
+ prolongation[2](4,56) = 729.0/4096.0;
+ prolongation[2](4,57) = 729.0/4096.0;
+ prolongation[2](4,58) = 729.0/4096.0;
+ prolongation[2](4,59) = 729.0/4096.0;
+ prolongation[2](4,60) = 729.0/4096.0;
+ prolongation[2](4,61) = 729.0/4096.0;
+ prolongation[2](4,62) = 729.0/4096.0;
+ prolongation[2](4,63) = 729.0/4096.0;
+ prolongation[2](5,1) = 1.0/256.0;
+ prolongation[2](5,2) = 1.0/256.0;
+ prolongation[2](5,5) = 1.0/256.0;
+ prolongation[2](5,6) = 1.0/256.0;
+ prolongation[2](5,10) = -9.0/256.0;
+ prolongation[2](5,11) = -9.0/256.0;
+ prolongation[2](5,18) = -9.0/256.0;
+ prolongation[2](5,19) = -9.0/256.0;
+ prolongation[2](5,26) = -9.0/256.0;
+ prolongation[2](5,27) = -9.0/256.0;
+ prolongation[2](5,28) = -9.0/256.0;
+ prolongation[2](5,29) = -9.0/256.0;
+ prolongation[2](5,44) = 81.0/256.0;
+ prolongation[2](5,45) = 81.0/256.0;
+ prolongation[2](5,46) = 81.0/256.0;
+ prolongation[2](5,47) = 81.0/256.0;
+ prolongation[2](6,2) = -1.0/16.0;
+ prolongation[2](6,6) = -1.0/16.0;
+ prolongation[2](6,28) = 9.0/16.0;
+ prolongation[2](6,29) = 9.0/16.0;
+ prolongation[2](7,2) = 1.0/256.0;
+ prolongation[2](7,3) = 1.0/256.0;
+ prolongation[2](7,6) = 1.0/256.0;
+ prolongation[2](7,7) = 1.0/256.0;
+ prolongation[2](7,12) = -9.0/256.0;
+ prolongation[2](7,13) = -9.0/256.0;
+ prolongation[2](7,20) = -9.0/256.0;
+ prolongation[2](7,21) = -9.0/256.0;
+ prolongation[2](7,28) = -9.0/256.0;
+ prolongation[2](7,29) = -9.0/256.0;
+ prolongation[2](7,30) = -9.0/256.0;
+ prolongation[2](7,31) = -9.0/256.0;
+ prolongation[2](7,48) = 81.0/256.0;
+ prolongation[2](7,49) = 81.0/256.0;
+ prolongation[2](7,50) = 81.0/256.0;
+ prolongation[2](7,51) = 81.0/256.0;
+ prolongation[2](8,9) = -1.0/16.0;
+ prolongation[2](8,13) = -1.0/16.0;
+ prolongation[2](8,33) = 9.0/16.0;
+ prolongation[2](8,35) = 9.0/16.0;
+ prolongation[2](9,0) = -1.0/256.0;
+ prolongation[2](9,1) = -5.0/256.0;
+ prolongation[2](9,2) = -5.0/256.0;
+ prolongation[2](9,3) = -1.0/256.0;
+ prolongation[2](9,8) = 5.0/256.0;
+ prolongation[2](9,9) = -15.0/256.0;
+ prolongation[2](9,10) = 45.0/256.0;
+ prolongation[2](9,11) = 45.0/256.0;
+ prolongation[2](9,12) = 5.0/256.0;
+ prolongation[2](9,13) = -15.0/256.0;
+ prolongation[2](9,14) = 9.0/256.0;
+ prolongation[2](9,15) = 9.0/256.0;
+ prolongation[2](9,32) = -45.0/256.0;
+ prolongation[2](9,33) = 135.0/256.0;
+ prolongation[2](9,34) = -45.0/256.0;
+ prolongation[2](9,35) = 135.0/256.0;
+ prolongation[2](10,11) = 1.0;
+ prolongation[2](11,1) = 1.0/16.0;
+ prolongation[2](11,2) = 5.0/16.0;
+ prolongation[2](11,10) = -5.0/16.0;
+ prolongation[2](11,11) = 15.0/16.0;
+ prolongation[2](12,13) = 1.0;
+ prolongation[2](13,2) = 5.0/16.0;
+ prolongation[2](13,3) = 1.0/16.0;
+ prolongation[2](13,12) = -5.0/16.0;
+ prolongation[2](13,13) = 15.0/16.0;
+ prolongation[2](14,11) = -1.0/16.0;
+ prolongation[2](14,15) = -1.0/16.0;
+ prolongation[2](14,34) = 9.0/16.0;
+ prolongation[2](14,35) = 9.0/16.0;
+ prolongation[2](15,0) = -1.0/256.0;
+ prolongation[2](15,1) = -1.0/256.0;
+ prolongation[2](15,2) = -5.0/256.0;
+ prolongation[2](15,3) = -5.0/256.0;
+ prolongation[2](15,8) = 9.0/256.0;
+ prolongation[2](15,9) = 9.0/256.0;
+ prolongation[2](15,10) = 5.0/256.0;
+ prolongation[2](15,11) = -15.0/256.0;
+ prolongation[2](15,12) = 45.0/256.0;
+ prolongation[2](15,13) = 45.0/256.0;
+ prolongation[2](15,14) = 5.0/256.0;
+ prolongation[2](15,15) = -15.0/256.0;
+ prolongation[2](15,32) = -45.0/256.0;
+ prolongation[2](15,33) = -45.0/256.0;
+ prolongation[2](15,34) = 135.0/256.0;
+ prolongation[2](15,35) = 135.0/256.0;
+ prolongation[2](16,9) = 1.0/256.0;
+ prolongation[2](16,13) = 1.0/256.0;
+ prolongation[2](16,17) = 1.0/256.0;
+ prolongation[2](16,21) = 1.0/256.0;
+ prolongation[2](16,33) = -9.0/256.0;
+ prolongation[2](16,35) = -9.0/256.0;
+ prolongation[2](16,37) = -9.0/256.0;
+ prolongation[2](16,39) = -9.0/256.0;
+ prolongation[2](16,41) = -9.0/256.0;
+ prolongation[2](16,43) = -9.0/256.0;
+ prolongation[2](16,49) = -9.0/256.0;
+ prolongation[2](16,51) = -9.0/256.0;
+ prolongation[2](16,57) = 81.0/256.0;
+ prolongation[2](16,59) = 81.0/256.0;
+ prolongation[2](16,61) = 81.0/256.0;
+ prolongation[2](16,63) = 81.0/256.0;
+ prolongation[2](17,0) = 1.0/4096.0;
+ prolongation[2](17,1) = 5.0/4096.0;
+ prolongation[2](17,2) = 5.0/4096.0;
+ prolongation[2](17,3) = 1.0/4096.0;
+ prolongation[2](17,4) = 1.0/4096.0;
+ prolongation[2](17,5) = 5.0/4096.0;
+ prolongation[2](17,6) = 5.0/4096.0;
+ prolongation[2](17,7) = 1.0/4096.0;
+ prolongation[2](17,8) = -5.0/4096.0;
+ prolongation[2](17,9) = 15.0/4096.0;
+ prolongation[2](17,10) = -45.0/4096.0;
+ prolongation[2](17,11) = -45.0/4096.0;
+ prolongation[2](17,12) = -5.0/4096.0;
+ prolongation[2](17,13) = 15.0/4096.0;
+ prolongation[2](17,14) = -9.0/4096.0;
+ prolongation[2](17,15) = -9.0/4096.0;
+ prolongation[2](17,16) = -5.0/4096.0;
+ prolongation[2](17,17) = 15.0/4096.0;
+ prolongation[2](17,18) = -45.0/4096.0;
+ prolongation[2](17,19) = -45.0/4096.0;
+ prolongation[2](17,20) = -5.0/4096.0;
+ prolongation[2](17,21) = 15.0/4096.0;
+ prolongation[2](17,22) = -9.0/4096.0;
+ prolongation[2](17,23) = -9.0/4096.0;
+ prolongation[2](17,24) = -9.0/4096.0;
+ prolongation[2](17,25) = -9.0/4096.0;
+ prolongation[2](17,26) = -45.0/4096.0;
+ prolongation[2](17,27) = -45.0/4096.0;
+ prolongation[2](17,28) = -45.0/4096.0;
+ prolongation[2](17,29) = -45.0/4096.0;
+ prolongation[2](17,30) = -9.0/4096.0;
+ prolongation[2](17,31) = -9.0/4096.0;
+ prolongation[2](17,32) = 45.0/4096.0;
+ prolongation[2](17,33) = -135.0/4096.0;
+ prolongation[2](17,34) = 45.0/4096.0;
+ prolongation[2](17,35) = -135.0/4096.0;
+ prolongation[2](17,36) = 45.0/4096.0;
+ prolongation[2](17,37) = -135.0/4096.0;
+ prolongation[2](17,38) = 45.0/4096.0;
+ prolongation[2](17,39) = -135.0/4096.0;
+ prolongation[2](17,40) = 45.0/4096.0;
+ prolongation[2](17,41) = -135.0/4096.0;
+ prolongation[2](17,42) = 45.0/4096.0;
+ prolongation[2](17,43) = -135.0/4096.0;
+ prolongation[2](17,44) = 405.0/4096.0;
+ prolongation[2](17,45) = 405.0/4096.0;
+ prolongation[2](17,46) = 405.0/4096.0;
+ prolongation[2](17,47) = 405.0/4096.0;
+ prolongation[2](17,48) = 45.0/4096.0;
+ prolongation[2](17,49) = -135.0/4096.0;
+ prolongation[2](17,50) = 45.0/4096.0;
+ prolongation[2](17,51) = -135.0/4096.0;
+ prolongation[2](17,52) = 81.0/4096.0;
+ prolongation[2](17,53) = 81.0/4096.0;
+ prolongation[2](17,54) = 81.0/4096.0;
+ prolongation[2](17,55) = 81.0/4096.0;
+ prolongation[2](17,56) = -405.0/4096.0;
+ prolongation[2](17,57) = 1215.0/4096.0;
+ prolongation[2](17,58) = -405.0/4096.0;
+ prolongation[2](17,59) = 1215.0/4096.0;
+ prolongation[2](17,60) = -405.0/4096.0;
+ prolongation[2](17,61) = 1215.0/4096.0;
+ prolongation[2](17,62) = -405.0/4096.0;
+ prolongation[2](17,63) = 1215.0/4096.0;
+ prolongation[2](18,11) = -1.0/16.0;
+ prolongation[2](18,19) = -1.0/16.0;
+ prolongation[2](18,46) = 9.0/16.0;
+ prolongation[2](18,47) = 9.0/16.0;
+ prolongation[2](19,1) = -1.0/256.0;
+ prolongation[2](19,2) = -5.0/256.0;
+ prolongation[2](19,5) = -1.0/256.0;
+ prolongation[2](19,6) = -5.0/256.0;
+ prolongation[2](19,10) = 5.0/256.0;
+ prolongation[2](19,11) = -15.0/256.0;
+ prolongation[2](19,18) = 5.0/256.0;
+ prolongation[2](19,19) = -15.0/256.0;
+ prolongation[2](19,26) = 9.0/256.0;
+ prolongation[2](19,27) = 9.0/256.0;
+ prolongation[2](19,28) = 45.0/256.0;
+ prolongation[2](19,29) = 45.0/256.0;
+ prolongation[2](19,44) = -45.0/256.0;
+ prolongation[2](19,45) = -45.0/256.0;
+ prolongation[2](19,46) = 135.0/256.0;
+ prolongation[2](19,47) = 135.0/256.0;
+ prolongation[2](20,13) = -1.0/16.0;
+ prolongation[2](20,21) = -1.0/16.0;
+ prolongation[2](20,49) = 9.0/16.0;
+ prolongation[2](20,51) = 9.0/16.0;
+ prolongation[2](21,2) = -5.0/256.0;
+ prolongation[2](21,3) = -1.0/256.0;
+ prolongation[2](21,6) = -5.0/256.0;
+ prolongation[2](21,7) = -1.0/256.0;
+ prolongation[2](21,12) = 5.0/256.0;
+ prolongation[2](21,13) = -15.0/256.0;
+ prolongation[2](21,20) = 5.0/256.0;
+ prolongation[2](21,21) = -15.0/256.0;
+ prolongation[2](21,28) = 45.0/256.0;
+ prolongation[2](21,29) = 45.0/256.0;
+ prolongation[2](21,30) = 9.0/256.0;
+ prolongation[2](21,31) = 9.0/256.0;
+ prolongation[2](21,48) = -45.0/256.0;
+ prolongation[2](21,49) = 135.0/256.0;
+ prolongation[2](21,50) = -45.0/256.0;
+ prolongation[2](21,51) = 135.0/256.0;
+ prolongation[2](22,11) = 1.0/256.0;
+ prolongation[2](22,15) = 1.0/256.0;
+ prolongation[2](22,19) = 1.0/256.0;
+ prolongation[2](22,23) = 1.0/256.0;
+ prolongation[2](22,34) = -9.0/256.0;
+ prolongation[2](22,35) = -9.0/256.0;
+ prolongation[2](22,38) = -9.0/256.0;
+ prolongation[2](22,39) = -9.0/256.0;
+ prolongation[2](22,46) = -9.0/256.0;
+ prolongation[2](22,47) = -9.0/256.0;
+ prolongation[2](22,54) = -9.0/256.0;
+ prolongation[2](22,55) = -9.0/256.0;
+ prolongation[2](22,60) = 81.0/256.0;
+ prolongation[2](22,61) = 81.0/256.0;
+ prolongation[2](22,62) = 81.0/256.0;
+ prolongation[2](22,63) = 81.0/256.0;
+ prolongation[2](23,0) = 1.0/4096.0;
+ prolongation[2](23,1) = 1.0/4096.0;
+ prolongation[2](23,2) = 5.0/4096.0;
+ prolongation[2](23,3) = 5.0/4096.0;
+ prolongation[2](23,4) = 1.0/4096.0;
+ prolongation[2](23,5) = 1.0/4096.0;
+ prolongation[2](23,6) = 5.0/4096.0;
+ prolongation[2](23,7) = 5.0/4096.0;
+ prolongation[2](23,8) = -9.0/4096.0;
+ prolongation[2](23,9) = -9.0/4096.0;
+ prolongation[2](23,10) = -5.0/4096.0;
+ prolongation[2](23,11) = 15.0/4096.0;
+ prolongation[2](23,12) = -45.0/4096.0;
+ prolongation[2](23,13) = -45.0/4096.0;
+ prolongation[2](23,14) = -5.0/4096.0;
+ prolongation[2](23,15) = 15.0/4096.0;
+ prolongation[2](23,16) = -9.0/4096.0;
+ prolongation[2](23,17) = -9.0/4096.0;
+ prolongation[2](23,18) = -5.0/4096.0;
+ prolongation[2](23,19) = 15.0/4096.0;
+ prolongation[2](23,20) = -45.0/4096.0;
+ prolongation[2](23,21) = -45.0/4096.0;
+ prolongation[2](23,22) = -5.0/4096.0;
+ prolongation[2](23,23) = 15.0/4096.0;
+ prolongation[2](23,24) = -9.0/4096.0;
+ prolongation[2](23,25) = -9.0/4096.0;
+ prolongation[2](23,26) = -9.0/4096.0;
+ prolongation[2](23,27) = -9.0/4096.0;
+ prolongation[2](23,28) = -45.0/4096.0;
+ prolongation[2](23,29) = -45.0/4096.0;
+ prolongation[2](23,30) = -45.0/4096.0;
+ prolongation[2](23,31) = -45.0/4096.0;
+ prolongation[2](23,32) = 45.0/4096.0;
+ prolongation[2](23,33) = 45.0/4096.0;
+ prolongation[2](23,34) = -135.0/4096.0;
+ prolongation[2](23,35) = -135.0/4096.0;
+ prolongation[2](23,36) = 45.0/4096.0;
+ prolongation[2](23,37) = 45.0/4096.0;
+ prolongation[2](23,38) = -135.0/4096.0;
+ prolongation[2](23,39) = -135.0/4096.0;
+ prolongation[2](23,40) = 81.0/4096.0;
+ prolongation[2](23,41) = 81.0/4096.0;
+ prolongation[2](23,42) = 81.0/4096.0;
+ prolongation[2](23,43) = 81.0/4096.0;
+ prolongation[2](23,44) = 45.0/4096.0;
+ prolongation[2](23,45) = 45.0/4096.0;
+ prolongation[2](23,46) = -135.0/4096.0;
+ prolongation[2](23,47) = -135.0/4096.0;
+ prolongation[2](23,48) = 405.0/4096.0;
+ prolongation[2](23,49) = 405.0/4096.0;
+ prolongation[2](23,50) = 405.0/4096.0;
+ prolongation[2](23,51) = 405.0/4096.0;
+ prolongation[2](23,52) = 45.0/4096.0;
+ prolongation[2](23,53) = 45.0/4096.0;
+ prolongation[2](23,54) = -135.0/4096.0;
+ prolongation[2](23,55) = -135.0/4096.0;
+ prolongation[2](23,56) = -405.0/4096.0;
+ prolongation[2](23,57) = -405.0/4096.0;
+ prolongation[2](23,58) = -405.0/4096.0;
+ prolongation[2](23,59) = -405.0/4096.0;
+ prolongation[2](23,60) = 1215.0/4096.0;
+ prolongation[2](23,61) = 1215.0/4096.0;
+ prolongation[2](23,62) = 1215.0/4096.0;
+ prolongation[2](23,63) = 1215.0/4096.0;
+ prolongation[2](24,0) = 5.0/4096.0;
+ prolongation[2](24,1) = 5.0/4096.0;
+ prolongation[2](24,2) = 5.0/4096.0;
+ prolongation[2](24,3) = 5.0/4096.0;
+ prolongation[2](24,4) = 1.0/4096.0;
+ prolongation[2](24,5) = 1.0/4096.0;
+ prolongation[2](24,6) = 1.0/4096.0;
+ prolongation[2](24,7) = 1.0/4096.0;
+ prolongation[2](24,8) = -45.0/4096.0;
+ prolongation[2](24,9) = -45.0/4096.0;
+ prolongation[2](24,10) = -45.0/4096.0;
+ prolongation[2](24,11) = -45.0/4096.0;
+ prolongation[2](24,12) = -45.0/4096.0;
+ prolongation[2](24,13) = -45.0/4096.0;
+ prolongation[2](24,14) = -45.0/4096.0;
+ prolongation[2](24,15) = -45.0/4096.0;
+ prolongation[2](24,16) = -9.0/4096.0;
+ prolongation[2](24,17) = -9.0/4096.0;
+ prolongation[2](24,18) = -9.0/4096.0;
+ prolongation[2](24,19) = -9.0/4096.0;
+ prolongation[2](24,20) = -9.0/4096.0;
+ prolongation[2](24,21) = -9.0/4096.0;
+ prolongation[2](24,22) = -9.0/4096.0;
+ prolongation[2](24,23) = -9.0/4096.0;
+ prolongation[2](24,24) = 15.0/4096.0;
+ prolongation[2](24,25) = -5.0/4096.0;
+ prolongation[2](24,26) = 15.0/4096.0;
+ prolongation[2](24,27) = -5.0/4096.0;
+ prolongation[2](24,28) = 15.0/4096.0;
+ prolongation[2](24,29) = -5.0/4096.0;
+ prolongation[2](24,30) = 15.0/4096.0;
+ prolongation[2](24,31) = -5.0/4096.0;
+ prolongation[2](24,32) = 405.0/4096.0;
+ prolongation[2](24,33) = 405.0/4096.0;
+ prolongation[2](24,34) = 405.0/4096.0;
+ prolongation[2](24,35) = 405.0/4096.0;
+ prolongation[2](24,36) = 81.0/4096.0;
+ prolongation[2](24,37) = 81.0/4096.0;
+ prolongation[2](24,38) = 81.0/4096.0;
+ prolongation[2](24,39) = 81.0/4096.0;
+ prolongation[2](24,40) = -135.0/4096.0;
+ prolongation[2](24,41) = -135.0/4096.0;
+ prolongation[2](24,42) = 45.0/4096.0;
+ prolongation[2](24,43) = 45.0/4096.0;
+ prolongation[2](24,44) = -135.0/4096.0;
+ prolongation[2](24,45) = 45.0/4096.0;
+ prolongation[2](24,46) = -135.0/4096.0;
+ prolongation[2](24,47) = 45.0/4096.0;
+ prolongation[2](24,48) = -135.0/4096.0;
+ prolongation[2](24,49) = -135.0/4096.0;
+ prolongation[2](24,50) = 45.0/4096.0;
+ prolongation[2](24,51) = 45.0/4096.0;
+ prolongation[2](24,52) = -135.0/4096.0;
+ prolongation[2](24,53) = 45.0/4096.0;
+ prolongation[2](24,54) = -135.0/4096.0;
+ prolongation[2](24,55) = 45.0/4096.0;
+ prolongation[2](24,56) = 1215.0/4096.0;
+ prolongation[2](24,57) = 1215.0/4096.0;
+ prolongation[2](24,58) = -405.0/4096.0;
+ prolongation[2](24,59) = -405.0/4096.0;
+ prolongation[2](24,60) = 1215.0/4096.0;
+ prolongation[2](24,61) = 1215.0/4096.0;
+ prolongation[2](24,62) = -405.0/4096.0;
+ prolongation[2](24,63) = -405.0/4096.0;
+ prolongation[2](25,24) = 1.0/256.0;
+ prolongation[2](25,26) = 1.0/256.0;
+ prolongation[2](25,28) = 1.0/256.0;
+ prolongation[2](25,30) = 1.0/256.0;
+ prolongation[2](25,40) = -9.0/256.0;
+ prolongation[2](25,41) = -9.0/256.0;
+ prolongation[2](25,44) = -9.0/256.0;
+ prolongation[2](25,46) = -9.0/256.0;
+ prolongation[2](25,48) = -9.0/256.0;
+ prolongation[2](25,49) = -9.0/256.0;
+ prolongation[2](25,52) = -9.0/256.0;
+ prolongation[2](25,54) = -9.0/256.0;
+ prolongation[2](25,56) = 81.0/256.0;
+ prolongation[2](25,57) = 81.0/256.0;
+ prolongation[2](25,60) = 81.0/256.0;
+ prolongation[2](25,61) = 81.0/256.0;
+ prolongation[2](26,1) = -5.0/256.0;
+ prolongation[2](26,2) = -5.0/256.0;
+ prolongation[2](26,5) = -1.0/256.0;
+ prolongation[2](26,6) = -1.0/256.0;
+ prolongation[2](26,10) = 45.0/256.0;
+ prolongation[2](26,11) = 45.0/256.0;
+ prolongation[2](26,18) = 9.0/256.0;
+ prolongation[2](26,19) = 9.0/256.0;
+ prolongation[2](26,26) = -15.0/256.0;
+ prolongation[2](26,27) = 5.0/256.0;
+ prolongation[2](26,28) = -15.0/256.0;
+ prolongation[2](26,29) = 5.0/256.0;
+ prolongation[2](26,44) = 135.0/256.0;
+ prolongation[2](26,45) = -45.0/256.0;
+ prolongation[2](26,46) = 135.0/256.0;
+ prolongation[2](26,47) = -45.0/256.0;
+ prolongation[2](27,26) = -1.0/16.0;
+ prolongation[2](27,28) = -1.0/16.0;
+ prolongation[2](27,44) = 9.0/16.0;
+ prolongation[2](27,46) = 9.0/16.0;
+ prolongation[2](28,2) = 5.0/16.0;
+ prolongation[2](28,6) = 1.0/16.0;
+ prolongation[2](28,28) = 15.0/16.0;
+ prolongation[2](28,29) = -5.0/16.0;
+ prolongation[2](29,28) = 1.0;
+ prolongation[2](30,2) = -5.0/256.0;
+ prolongation[2](30,3) = -5.0/256.0;
+ prolongation[2](30,6) = -1.0/256.0;
+ prolongation[2](30,7) = -1.0/256.0;
+ prolongation[2](30,12) = 45.0/256.0;
+ prolongation[2](30,13) = 45.0/256.0;
+ prolongation[2](30,20) = 9.0/256.0;
+ prolongation[2](30,21) = 9.0/256.0;
+ prolongation[2](30,28) = -15.0/256.0;
+ prolongation[2](30,29) = 5.0/256.0;
+ prolongation[2](30,30) = -15.0/256.0;
+ prolongation[2](30,31) = 5.0/256.0;
+ prolongation[2](30,48) = 135.0/256.0;
+ prolongation[2](30,49) = 135.0/256.0;
+ prolongation[2](30,50) = -45.0/256.0;
+ prolongation[2](30,51) = -45.0/256.0;
+ prolongation[2](31,28) = -1.0/16.0;
+ prolongation[2](31,30) = -1.0/16.0;
+ prolongation[2](31,48) = 9.0/16.0;
+ prolongation[2](31,49) = 9.0/16.0;
+ prolongation[2](32,35) = 1.0;
+ prolongation[2](33,11) = 5.0/16.0;
+ prolongation[2](33,15) = 1.0/16.0;
+ prolongation[2](33,34) = -5.0/16.0;
+ prolongation[2](33,35) = 15.0/16.0;
+ prolongation[2](34,9) = 1.0/16.0;
+ prolongation[2](34,13) = 5.0/16.0;
+ prolongation[2](34,33) = -5.0/16.0;
+ prolongation[2](34,35) = 15.0/16.0;
+ prolongation[2](35,0) = 1.0/256.0;
+ prolongation[2](35,1) = 5.0/256.0;
+ prolongation[2](35,2) = 25.0/256.0;
+ prolongation[2](35,3) = 5.0/256.0;
+ prolongation[2](35,8) = -5.0/256.0;
+ prolongation[2](35,9) = 15.0/256.0;
+ prolongation[2](35,10) = -25.0/256.0;
+ prolongation[2](35,11) = 75.0/256.0;
+ prolongation[2](35,12) = -25.0/256.0;
+ prolongation[2](35,13) = 75.0/256.0;
+ prolongation[2](35,14) = -5.0/256.0;
+ prolongation[2](35,15) = 15.0/256.0;
+ prolongation[2](35,32) = 25.0/256.0;
+ prolongation[2](35,33) = -75.0/256.0;
+ prolongation[2](35,34) = -75.0/256.0;
+ prolongation[2](35,35) = 225.0/256.0;
+ prolongation[2](36,35) = -1.0/16.0;
+ prolongation[2](36,39) = -1.0/16.0;
+ prolongation[2](36,61) = 9.0/16.0;
+ prolongation[2](36,63) = 9.0/16.0;
+ prolongation[2](37,11) = -5.0/256.0;
+ prolongation[2](37,15) = -1.0/256.0;
+ prolongation[2](37,19) = -5.0/256.0;
+ prolongation[2](37,23) = -1.0/256.0;
+ prolongation[2](37,34) = 5.0/256.0;
+ prolongation[2](37,35) = -15.0/256.0;
+ prolongation[2](37,38) = 5.0/256.0;
+ prolongation[2](37,39) = -15.0/256.0;
+ prolongation[2](37,46) = 45.0/256.0;
+ prolongation[2](37,47) = 45.0/256.0;
+ prolongation[2](37,54) = 9.0/256.0;
+ prolongation[2](37,55) = 9.0/256.0;
+ prolongation[2](37,60) = -45.0/256.0;
+ prolongation[2](37,61) = 135.0/256.0;
+ prolongation[2](37,62) = -45.0/256.0;
+ prolongation[2](37,63) = 135.0/256.0;
+ prolongation[2](38,9) = -1.0/256.0;
+ prolongation[2](38,13) = -5.0/256.0;
+ prolongation[2](38,17) = -1.0/256.0;
+ prolongation[2](38,21) = -5.0/256.0;
+ prolongation[2](38,33) = 5.0/256.0;
+ prolongation[2](38,35) = -15.0/256.0;
+ prolongation[2](38,37) = 5.0/256.0;
+ prolongation[2](38,39) = -15.0/256.0;
+ prolongation[2](38,41) = 9.0/256.0;
+ prolongation[2](38,43) = 9.0/256.0;
+ prolongation[2](38,49) = 45.0/256.0;
+ prolongation[2](38,51) = 45.0/256.0;
+ prolongation[2](38,57) = -45.0/256.0;
+ prolongation[2](38,59) = -45.0/256.0;
+ prolongation[2](38,61) = 135.0/256.0;
+ prolongation[2](38,63) = 135.0/256.0;
+ prolongation[2](39,0) = -1.0/4096.0;
+ prolongation[2](39,1) = -5.0/4096.0;
+ prolongation[2](39,2) = -25.0/4096.0;
+ prolongation[2](39,3) = -5.0/4096.0;
+ prolongation[2](39,4) = -1.0/4096.0;
+ prolongation[2](39,5) = -5.0/4096.0;
+ prolongation[2](39,6) = -25.0/4096.0;
+ prolongation[2](39,7) = -5.0/4096.0;
+ prolongation[2](39,8) = 5.0/4096.0;
+ prolongation[2](39,9) = -15.0/4096.0;
+ prolongation[2](39,10) = 25.0/4096.0;
+ prolongation[2](39,11) = -75.0/4096.0;
+ prolongation[2](39,12) = 25.0/4096.0;
+ prolongation[2](39,13) = -75.0/4096.0;
+ prolongation[2](39,14) = 5.0/4096.0;
+ prolongation[2](39,15) = -15.0/4096.0;
+ prolongation[2](39,16) = 5.0/4096.0;
+ prolongation[2](39,17) = -15.0/4096.0;
+ prolongation[2](39,18) = 25.0/4096.0;
+ prolongation[2](39,19) = -75.0/4096.0;
+ prolongation[2](39,20) = 25.0/4096.0;
+ prolongation[2](39,21) = -75.0/4096.0;
+ prolongation[2](39,22) = 5.0/4096.0;
+ prolongation[2](39,23) = -15.0/4096.0;
+ prolongation[2](39,24) = 9.0/4096.0;
+ prolongation[2](39,25) = 9.0/4096.0;
+ prolongation[2](39,26) = 45.0/4096.0;
+ prolongation[2](39,27) = 45.0/4096.0;
+ prolongation[2](39,28) = 225.0/4096.0;
+ prolongation[2](39,29) = 225.0/4096.0;
+ prolongation[2](39,30) = 45.0/4096.0;
+ prolongation[2](39,31) = 45.0/4096.0;
+ prolongation[2](39,32) = -25.0/4096.0;
+ prolongation[2](39,33) = 75.0/4096.0;
+ prolongation[2](39,34) = 75.0/4096.0;
+ prolongation[2](39,35) = -225.0/4096.0;
+ prolongation[2](39,36) = -25.0/4096.0;
+ prolongation[2](39,37) = 75.0/4096.0;
+ prolongation[2](39,38) = 75.0/4096.0;
+ prolongation[2](39,39) = -225.0/4096.0;
+ prolongation[2](39,40) = -45.0/4096.0;
+ prolongation[2](39,41) = 135.0/4096.0;
+ prolongation[2](39,42) = -45.0/4096.0;
+ prolongation[2](39,43) = 135.0/4096.0;
+ prolongation[2](39,44) = -225.0/4096.0;
+ prolongation[2](39,45) = -225.0/4096.0;
+ prolongation[2](39,46) = 675.0/4096.0;
+ prolongation[2](39,47) = 675.0/4096.0;
+ prolongation[2](39,48) = -225.0/4096.0;
+ prolongation[2](39,49) = 675.0/4096.0;
+ prolongation[2](39,50) = -225.0/4096.0;
+ prolongation[2](39,51) = 675.0/4096.0;
+ prolongation[2](39,52) = -45.0/4096.0;
+ prolongation[2](39,53) = -45.0/4096.0;
+ prolongation[2](39,54) = 135.0/4096.0;
+ prolongation[2](39,55) = 135.0/4096.0;
+ prolongation[2](39,56) = 225.0/4096.0;
+ prolongation[2](39,57) = -675.0/4096.0;
+ prolongation[2](39,58) = 225.0/4096.0;
+ prolongation[2](39,59) = -675.0/4096.0;
+ prolongation[2](39,60) = -675.0/4096.0;
+ prolongation[2](39,61) = 2025.0/4096.0;
+ prolongation[2](39,62) = -675.0/4096.0;
+ prolongation[2](39,63) = 2025.0/4096.0;
+ prolongation[2](40,9) = -5.0/256.0;
+ prolongation[2](40,13) = -5.0/256.0;
+ prolongation[2](40,17) = -1.0/256.0;
+ prolongation[2](40,21) = -1.0/256.0;
+ prolongation[2](40,33) = 45.0/256.0;
+ prolongation[2](40,35) = 45.0/256.0;
+ prolongation[2](40,37) = 9.0/256.0;
+ prolongation[2](40,39) = 9.0/256.0;
+ prolongation[2](40,41) = -15.0/256.0;
+ prolongation[2](40,43) = 5.0/256.0;
+ prolongation[2](40,49) = -15.0/256.0;
+ prolongation[2](40,51) = 5.0/256.0;
+ prolongation[2](40,57) = 135.0/256.0;
+ prolongation[2](40,59) = -45.0/256.0;
+ prolongation[2](40,61) = 135.0/256.0;
+ prolongation[2](40,63) = -45.0/256.0;
+ prolongation[2](41,0) = -5.0/4096.0;
+ prolongation[2](41,1) = -25.0/4096.0;
+ prolongation[2](41,2) = -25.0/4096.0;
+ prolongation[2](41,3) = -5.0/4096.0;
+ prolongation[2](41,4) = -1.0/4096.0;
+ prolongation[2](41,5) = -5.0/4096.0;
+ prolongation[2](41,6) = -5.0/4096.0;
+ prolongation[2](41,7) = -1.0/4096.0;
+ prolongation[2](41,8) = 25.0/4096.0;
+ prolongation[2](41,9) = -75.0/4096.0;
+ prolongation[2](41,10) = 225.0/4096.0;
+ prolongation[2](41,11) = 225.0/4096.0;
+ prolongation[2](41,12) = 25.0/4096.0;
+ prolongation[2](41,13) = -75.0/4096.0;
+ prolongation[2](41,14) = 45.0/4096.0;
+ prolongation[2](41,15) = 45.0/4096.0;
+ prolongation[2](41,16) = 5.0/4096.0;
+ prolongation[2](41,17) = -15.0/4096.0;
+ prolongation[2](41,18) = 45.0/4096.0;
+ prolongation[2](41,19) = 45.0/4096.0;
+ prolongation[2](41,20) = 5.0/4096.0;
+ prolongation[2](41,21) = -15.0/4096.0;
+ prolongation[2](41,22) = 9.0/4096.0;
+ prolongation[2](41,23) = 9.0/4096.0;
+ prolongation[2](41,24) = -15.0/4096.0;
+ prolongation[2](41,25) = 5.0/4096.0;
+ prolongation[2](41,26) = -75.0/4096.0;
+ prolongation[2](41,27) = 25.0/4096.0;
+ prolongation[2](41,28) = -75.0/4096.0;
+ prolongation[2](41,29) = 25.0/4096.0;
+ prolongation[2](41,30) = -15.0/4096.0;
+ prolongation[2](41,31) = 5.0/4096.0;
+ prolongation[2](41,32) = -225.0/4096.0;
+ prolongation[2](41,33) = 675.0/4096.0;
+ prolongation[2](41,34) = -225.0/4096.0;
+ prolongation[2](41,35) = 675.0/4096.0;
+ prolongation[2](41,36) = -45.0/4096.0;
+ prolongation[2](41,37) = 135.0/4096.0;
+ prolongation[2](41,38) = -45.0/4096.0;
+ prolongation[2](41,39) = 135.0/4096.0;
+ prolongation[2](41,40) = 75.0/4096.0;
+ prolongation[2](41,41) = -225.0/4096.0;
+ prolongation[2](41,42) = -25.0/4096.0;
+ prolongation[2](41,43) = 75.0/4096.0;
+ prolongation[2](41,44) = 675.0/4096.0;
+ prolongation[2](41,45) = -225.0/4096.0;
+ prolongation[2](41,46) = 675.0/4096.0;
+ prolongation[2](41,47) = -225.0/4096.0;
+ prolongation[2](41,48) = 75.0/4096.0;
+ prolongation[2](41,49) = -225.0/4096.0;
+ prolongation[2](41,50) = -25.0/4096.0;
+ prolongation[2](41,51) = 75.0/4096.0;
+ prolongation[2](41,52) = 135.0/4096.0;
+ prolongation[2](41,53) = -45.0/4096.0;
+ prolongation[2](41,54) = 135.0/4096.0;
+ prolongation[2](41,55) = -45.0/4096.0;
+ prolongation[2](41,56) = -675.0/4096.0;
+ prolongation[2](41,57) = 2025.0/4096.0;
+ prolongation[2](41,58) = 225.0/4096.0;
+ prolongation[2](41,59) = -675.0/4096.0;
+ prolongation[2](41,60) = -675.0/4096.0;
+ prolongation[2](41,61) = 2025.0/4096.0;
+ prolongation[2](41,62) = 225.0/4096.0;
+ prolongation[2](41,63) = -675.0/4096.0;
+ prolongation[2](42,41) = -1.0/16.0;
+ prolongation[2](42,49) = -1.0/16.0;
+ prolongation[2](42,57) = 9.0/16.0;
+ prolongation[2](42,61) = 9.0/16.0;
+ prolongation[2](43,24) = -1.0/256.0;
+ prolongation[2](43,26) = -5.0/256.0;
+ prolongation[2](43,28) = -5.0/256.0;
+ prolongation[2](43,30) = -1.0/256.0;
+ prolongation[2](43,40) = 5.0/256.0;
+ prolongation[2](43,41) = -15.0/256.0;
+ prolongation[2](43,44) = 45.0/256.0;
+ prolongation[2](43,46) = 45.0/256.0;
+ prolongation[2](43,48) = 5.0/256.0;
+ prolongation[2](43,49) = -15.0/256.0;
+ prolongation[2](43,52) = 9.0/256.0;
+ prolongation[2](43,54) = 9.0/256.0;
+ prolongation[2](43,56) = -45.0/256.0;
+ prolongation[2](43,57) = 135.0/256.0;
+ prolongation[2](43,60) = -45.0/256.0;
+ prolongation[2](43,61) = 135.0/256.0;
+ prolongation[2](44,11) = 5.0/16.0;
+ prolongation[2](44,19) = 1.0/16.0;
+ prolongation[2](44,46) = 15.0/16.0;
+ prolongation[2](44,47) = -5.0/16.0;
+ prolongation[2](45,46) = 1.0;
+ prolongation[2](46,1) = 5.0/256.0;
+ prolongation[2](46,2) = 25.0/256.0;
+ prolongation[2](46,5) = 1.0/256.0;
+ prolongation[2](46,6) = 5.0/256.0;
+ prolongation[2](46,10) = -25.0/256.0;
+ prolongation[2](46,11) = 75.0/256.0;
+ prolongation[2](46,18) = -5.0/256.0;
+ prolongation[2](46,19) = 15.0/256.0;
+ prolongation[2](46,26) = 15.0/256.0;
+ prolongation[2](46,27) = -5.0/256.0;
+ prolongation[2](46,28) = 75.0/256.0;
+ prolongation[2](46,29) = -25.0/256.0;
+ prolongation[2](46,44) = -75.0/256.0;
+ prolongation[2](46,45) = 25.0/256.0;
+ prolongation[2](46,46) = 225.0/256.0;
+ prolongation[2](46,47) = -75.0/256.0;
+ prolongation[2](47,26) = 1.0/16.0;
+ prolongation[2](47,28) = 5.0/16.0;
+ prolongation[2](47,44) = -5.0/16.0;
+ prolongation[2](47,46) = 15.0/16.0;
+ prolongation[2](48,13) = 5.0/16.0;
+ prolongation[2](48,21) = 1.0/16.0;
+ prolongation[2](48,49) = 15.0/16.0;
+ prolongation[2](48,51) = -5.0/16.0;
+ prolongation[2](49,2) = 25.0/256.0;
+ prolongation[2](49,3) = 5.0/256.0;
+ prolongation[2](49,6) = 5.0/256.0;
+ prolongation[2](49,7) = 1.0/256.0;
+ prolongation[2](49,12) = -25.0/256.0;
+ prolongation[2](49,13) = 75.0/256.0;
+ prolongation[2](49,20) = -5.0/256.0;
+ prolongation[2](49,21) = 15.0/256.0;
+ prolongation[2](49,28) = 75.0/256.0;
+ prolongation[2](49,29) = -25.0/256.0;
+ prolongation[2](49,30) = 15.0/256.0;
+ prolongation[2](49,31) = -5.0/256.0;
+ prolongation[2](49,48) = -75.0/256.0;
+ prolongation[2](49,49) = 225.0/256.0;
+ prolongation[2](49,50) = 25.0/256.0;
+ prolongation[2](49,51) = -75.0/256.0;
+ prolongation[2](50,49) = 1.0;
+ prolongation[2](51,28) = 5.0/16.0;
+ prolongation[2](51,30) = 1.0/16.0;
+ prolongation[2](51,48) = -5.0/16.0;
+ prolongation[2](51,49) = 15.0/16.0;
+ prolongation[2](52,11) = -5.0/256.0;
+ prolongation[2](52,15) = -5.0/256.0;
+ prolongation[2](52,19) = -1.0/256.0;
+ prolongation[2](52,23) = -1.0/256.0;
+ prolongation[2](52,34) = 45.0/256.0;
+ prolongation[2](52,35) = 45.0/256.0;
+ prolongation[2](52,38) = 9.0/256.0;
+ prolongation[2](52,39) = 9.0/256.0;
+ prolongation[2](52,46) = -15.0/256.0;
+ prolongation[2](52,47) = 5.0/256.0;
+ prolongation[2](52,54) = -15.0/256.0;
+ prolongation[2](52,55) = 5.0/256.0;
+ prolongation[2](52,60) = 135.0/256.0;
+ prolongation[2](52,61) = 135.0/256.0;
+ prolongation[2](52,62) = -45.0/256.0;
+ prolongation[2](52,63) = -45.0/256.0;
+ prolongation[2](53,46) = -1.0/16.0;
+ prolongation[2](53,54) = -1.0/16.0;
+ prolongation[2](53,60) = 9.0/16.0;
+ prolongation[2](53,61) = 9.0/16.0;
+ prolongation[2](54,0) = -5.0/4096.0;
+ prolongation[2](54,1) = -5.0/4096.0;
+ prolongation[2](54,2) = -25.0/4096.0;
+ prolongation[2](54,3) = -25.0/4096.0;
+ prolongation[2](54,4) = -1.0/4096.0;
+ prolongation[2](54,5) = -1.0/4096.0;
+ prolongation[2](54,6) = -5.0/4096.0;
+ prolongation[2](54,7) = -5.0/4096.0;
+ prolongation[2](54,8) = 45.0/4096.0;
+ prolongation[2](54,9) = 45.0/4096.0;
+ prolongation[2](54,10) = 25.0/4096.0;
+ prolongation[2](54,11) = -75.0/4096.0;
+ prolongation[2](54,12) = 225.0/4096.0;
+ prolongation[2](54,13) = 225.0/4096.0;
+ prolongation[2](54,14) = 25.0/4096.0;
+ prolongation[2](54,15) = -75.0/4096.0;
+ prolongation[2](54,16) = 9.0/4096.0;
+ prolongation[2](54,17) = 9.0/4096.0;
+ prolongation[2](54,18) = 5.0/4096.0;
+ prolongation[2](54,19) = -15.0/4096.0;
+ prolongation[2](54,20) = 45.0/4096.0;
+ prolongation[2](54,21) = 45.0/4096.0;
+ prolongation[2](54,22) = 5.0/4096.0;
+ prolongation[2](54,23) = -15.0/4096.0;
+ prolongation[2](54,24) = -15.0/4096.0;
+ prolongation[2](54,25) = 5.0/4096.0;
+ prolongation[2](54,26) = -15.0/4096.0;
+ prolongation[2](54,27) = 5.0/4096.0;
+ prolongation[2](54,28) = -75.0/4096.0;
+ prolongation[2](54,29) = 25.0/4096.0;
+ prolongation[2](54,30) = -75.0/4096.0;
+ prolongation[2](54,31) = 25.0/4096.0;
+ prolongation[2](54,32) = -225.0/4096.0;
+ prolongation[2](54,33) = -225.0/4096.0;
+ prolongation[2](54,34) = 675.0/4096.0;
+ prolongation[2](54,35) = 675.0/4096.0;
+ prolongation[2](54,36) = -45.0/4096.0;
+ prolongation[2](54,37) = -45.0/4096.0;
+ prolongation[2](54,38) = 135.0/4096.0;
+ prolongation[2](54,39) = 135.0/4096.0;
+ prolongation[2](54,40) = 135.0/4096.0;
+ prolongation[2](54,41) = 135.0/4096.0;
+ prolongation[2](54,42) = -45.0/4096.0;
+ prolongation[2](54,43) = -45.0/4096.0;
+ prolongation[2](54,44) = 75.0/4096.0;
+ prolongation[2](54,45) = -25.0/4096.0;
+ prolongation[2](54,46) = -225.0/4096.0;
+ prolongation[2](54,47) = 75.0/4096.0;
+ prolongation[2](54,48) = 675.0/4096.0;
+ prolongation[2](54,49) = 675.0/4096.0;
+ prolongation[2](54,50) = -225.0/4096.0;
+ prolongation[2](54,51) = -225.0/4096.0;
+ prolongation[2](54,52) = 75.0/4096.0;
+ prolongation[2](54,53) = -25.0/4096.0;
+ prolongation[2](54,54) = -225.0/4096.0;
+ prolongation[2](54,55) = 75.0/4096.0;
+ prolongation[2](54,56) = -675.0/4096.0;
+ prolongation[2](54,57) = -675.0/4096.0;
+ prolongation[2](54,58) = 225.0/4096.0;
+ prolongation[2](54,59) = 225.0/4096.0;
+ prolongation[2](54,60) = 2025.0/4096.0;
+ prolongation[2](54,61) = 2025.0/4096.0;
+ prolongation[2](54,62) = -675.0/4096.0;
+ prolongation[2](54,63) = -675.0/4096.0;
+ prolongation[2](55,24) = -1.0/256.0;
+ prolongation[2](55,26) = -1.0/256.0;
+ prolongation[2](55,28) = -5.0/256.0;
+ prolongation[2](55,30) = -5.0/256.0;
+ prolongation[2](55,40) = 9.0/256.0;
+ prolongation[2](55,41) = 9.0/256.0;
+ prolongation[2](55,44) = 5.0/256.0;
+ prolongation[2](55,46) = -15.0/256.0;
+ prolongation[2](55,48) = 45.0/256.0;
+ prolongation[2](55,49) = 45.0/256.0;
+ prolongation[2](55,52) = 5.0/256.0;
+ prolongation[2](55,54) = -15.0/256.0;
+ prolongation[2](55,56) = -45.0/256.0;
+ prolongation[2](55,57) = -45.0/256.0;
+ prolongation[2](55,60) = 135.0/256.0;
+ prolongation[2](55,61) = 135.0/256.0;
+ prolongation[2](56,35) = 5.0/16.0;
+ prolongation[2](56,39) = 1.0/16.0;
+ prolongation[2](56,61) = 15.0/16.0;
+ prolongation[2](56,63) = -5.0/16.0;
+ prolongation[2](57,11) = 25.0/256.0;
+ prolongation[2](57,15) = 5.0/256.0;
+ prolongation[2](57,19) = 5.0/256.0;
+ prolongation[2](57,23) = 1.0/256.0;
+ prolongation[2](57,34) = -25.0/256.0;
+ prolongation[2](57,35) = 75.0/256.0;
+ prolongation[2](57,38) = -5.0/256.0;
+ prolongation[2](57,39) = 15.0/256.0;
+ prolongation[2](57,46) = 75.0/256.0;
+ prolongation[2](57,47) = -25.0/256.0;
+ prolongation[2](57,54) = 15.0/256.0;
+ prolongation[2](57,55) = -5.0/256.0;
+ prolongation[2](57,60) = -75.0/256.0;
+ prolongation[2](57,61) = 225.0/256.0;
+ prolongation[2](57,62) = 25.0/256.0;
+ prolongation[2](57,63) = -75.0/256.0;
+ prolongation[2](58,61) = 1.0;
+ prolongation[2](59,46) = 5.0/16.0;
+ prolongation[2](59,54) = 1.0/16.0;
+ prolongation[2](59,60) = -5.0/16.0;
+ prolongation[2](59,61) = 15.0/16.0;
+ prolongation[2](60,9) = 5.0/256.0;
+ prolongation[2](60,13) = 25.0/256.0;
+ prolongation[2](60,17) = 1.0/256.0;
+ prolongation[2](60,21) = 5.0/256.0;
+ prolongation[2](60,33) = -25.0/256.0;
+ prolongation[2](60,35) = 75.0/256.0;
+ prolongation[2](60,37) = -5.0/256.0;
+ prolongation[2](60,39) = 15.0/256.0;
+ prolongation[2](60,41) = 15.0/256.0;
+ prolongation[2](60,43) = -5.0/256.0;
+ prolongation[2](60,49) = 75.0/256.0;
+ prolongation[2](60,51) = -25.0/256.0;
+ prolongation[2](60,57) = -75.0/256.0;
+ prolongation[2](60,59) = 25.0/256.0;
+ prolongation[2](60,61) = 225.0/256.0;
+ prolongation[2](60,63) = -75.0/256.0;
+ prolongation[2](61,0) = 5.0/4096.0;
+ prolongation[2](61,1) = 25.0/4096.0;
+ prolongation[2](61,2) = 125.0/4096.0;
+ prolongation[2](61,3) = 25.0/4096.0;
+ prolongation[2](61,4) = 1.0/4096.0;
+ prolongation[2](61,5) = 5.0/4096.0;
+ prolongation[2](61,6) = 25.0/4096.0;
+ prolongation[2](61,7) = 5.0/4096.0;
+ prolongation[2](61,8) = -25.0/4096.0;
+ prolongation[2](61,9) = 75.0/4096.0;
+ prolongation[2](61,10) = -125.0/4096.0;
+ prolongation[2](61,11) = 375.0/4096.0;
+ prolongation[2](61,12) = -125.0/4096.0;
+ prolongation[2](61,13) = 375.0/4096.0;
+ prolongation[2](61,14) = -25.0/4096.0;
+ prolongation[2](61,15) = 75.0/4096.0;
+ prolongation[2](61,16) = -5.0/4096.0;
+ prolongation[2](61,17) = 15.0/4096.0;
+ prolongation[2](61,18) = -25.0/4096.0;
+ prolongation[2](61,19) = 75.0/4096.0;
+ prolongation[2](61,20) = -25.0/4096.0;
+ prolongation[2](61,21) = 75.0/4096.0;
+ prolongation[2](61,22) = -5.0/4096.0;
+ prolongation[2](61,23) = 15.0/4096.0;
+ prolongation[2](61,24) = 15.0/4096.0;
+ prolongation[2](61,25) = -5.0/4096.0;
+ prolongation[2](61,26) = 75.0/4096.0;
+ prolongation[2](61,27) = -25.0/4096.0;
+ prolongation[2](61,28) = 375.0/4096.0;
+ prolongation[2](61,29) = -125.0/4096.0;
+ prolongation[2](61,30) = 75.0/4096.0;
+ prolongation[2](61,31) = -25.0/4096.0;
+ prolongation[2](61,32) = 125.0/4096.0;
+ prolongation[2](61,33) = -375.0/4096.0;
+ prolongation[2](61,34) = -375.0/4096.0;
+ prolongation[2](61,35) = 1125.0/4096.0;
+ prolongation[2](61,36) = 25.0/4096.0;
+ prolongation[2](61,37) = -75.0/4096.0;
+ prolongation[2](61,38) = -75.0/4096.0;
+ prolongation[2](61,39) = 225.0/4096.0;
+ prolongation[2](61,40) = -75.0/4096.0;
+ prolongation[2](61,41) = 225.0/4096.0;
+ prolongation[2](61,42) = 25.0/4096.0;
+ prolongation[2](61,43) = -75.0/4096.0;
+ prolongation[2](61,44) = -375.0/4096.0;
+ prolongation[2](61,45) = 125.0/4096.0;
+ prolongation[2](61,46) = 1125.0/4096.0;
+ prolongation[2](61,47) = -375.0/4096.0;
+ prolongation[2](61,48) = -375.0/4096.0;
+ prolongation[2](61,49) = 1125.0/4096.0;
+ prolongation[2](61,50) = 125.0/4096.0;
+ prolongation[2](61,51) = -375.0/4096.0;
+ prolongation[2](61,52) = -75.0/4096.0;
+ prolongation[2](61,53) = 25.0/4096.0;
+ prolongation[2](61,54) = 225.0/4096.0;
+ prolongation[2](61,55) = -75.0/4096.0;
+ prolongation[2](61,56) = 375.0/4096.0;
+ prolongation[2](61,57) = -1125.0/4096.0;
+ prolongation[2](61,58) = -125.0/4096.0;
+ prolongation[2](61,59) = 375.0/4096.0;
+ prolongation[2](61,60) = -1125.0/4096.0;
+ prolongation[2](61,61) = 3375.0/4096.0;
+ prolongation[2](61,62) = 375.0/4096.0;
+ prolongation[2](61,63) = -1125.0/4096.0;
+ prolongation[2](62,41) = 1.0/16.0;
+ prolongation[2](62,49) = 5.0/16.0;
+ prolongation[2](62,57) = -5.0/16.0;
+ prolongation[2](62,61) = 15.0/16.0;
+ prolongation[2](63,24) = 1.0/256.0;
+ prolongation[2](63,26) = 5.0/256.0;
+ prolongation[2](63,28) = 25.0/256.0;
+ prolongation[2](63,30) = 5.0/256.0;
+ prolongation[2](63,40) = -5.0/256.0;
+ prolongation[2](63,41) = 15.0/256.0;
+ prolongation[2](63,44) = -25.0/256.0;
+ prolongation[2](63,46) = 75.0/256.0;
+ prolongation[2](63,48) = -25.0/256.0;
+ prolongation[2](63,49) = 75.0/256.0;
+ prolongation[2](63,52) = -5.0/256.0;
+ prolongation[2](63,54) = 15.0/256.0;
+ prolongation[2](63,56) = 25.0/256.0;
+ prolongation[2](63,57) = -75.0/256.0;
+ prolongation[2](63,60) = -75.0/256.0;
+ prolongation[2](63,61) = 225.0/256.0;
+ prolongation[3](0,0) = -1.0/16.0;
+ prolongation[3](0,3) = -1.0/16.0;
+ prolongation[3](0,14) = 9.0/16.0;
+ prolongation[3](0,15) = 9.0/16.0;
+ prolongation[3](1,0) = 1.0/256.0;
+ prolongation[3](1,1) = 1.0/256.0;
+ prolongation[3](1,2) = 1.0/256.0;
+ prolongation[3](1,3) = 1.0/256.0;
+ prolongation[3](1,8) = -9.0/256.0;
+ prolongation[3](1,9) = -9.0/256.0;
+ prolongation[3](1,10) = -9.0/256.0;
+ prolongation[3](1,11) = -9.0/256.0;
+ prolongation[3](1,12) = -9.0/256.0;
+ prolongation[3](1,13) = -9.0/256.0;
+ prolongation[3](1,14) = -9.0/256.0;
+ prolongation[3](1,15) = -9.0/256.0;
+ prolongation[3](1,32) = 81.0/256.0;
+ prolongation[3](1,33) = 81.0/256.0;
+ prolongation[3](1,34) = 81.0/256.0;
+ prolongation[3](1,35) = 81.0/256.0;
+ prolongation[3](2,2) = -1.0/16.0;
+ prolongation[3](2,3) = -1.0/16.0;
+ prolongation[3](2,12) = 9.0/16.0;
+ prolongation[3](2,13) = 9.0/16.0;
+ prolongation[3](3,3) = 1.0;
+ prolongation[3](4,0) = 1.0/256.0;
+ prolongation[3](4,3) = 1.0/256.0;
+ prolongation[3](4,4) = 1.0/256.0;
+ prolongation[3](4,7) = 1.0/256.0;
+ prolongation[3](4,14) = -9.0/256.0;
+ prolongation[3](4,15) = -9.0/256.0;
+ prolongation[3](4,22) = -9.0/256.0;
+ prolongation[3](4,23) = -9.0/256.0;
+ prolongation[3](4,24) = -9.0/256.0;
+ prolongation[3](4,25) = -9.0/256.0;
+ prolongation[3](4,30) = -9.0/256.0;
+ prolongation[3](4,31) = -9.0/256.0;
+ prolongation[3](4,52) = 81.0/256.0;
+ prolongation[3](4,53) = 81.0/256.0;
+ prolongation[3](4,54) = 81.0/256.0;
+ prolongation[3](4,55) = 81.0/256.0;
+ prolongation[3](5,0) = -1.0/4096.0;
+ prolongation[3](5,1) = -1.0/4096.0;
+ prolongation[3](5,2) = -1.0/4096.0;
+ prolongation[3](5,3) = -1.0/4096.0;
+ prolongation[3](5,4) = -1.0/4096.0;
+ prolongation[3](5,5) = -1.0/4096.0;
+ prolongation[3](5,6) = -1.0/4096.0;
+ prolongation[3](5,7) = -1.0/4096.0;
+ prolongation[3](5,8) = 9.0/4096.0;
+ prolongation[3](5,9) = 9.0/4096.0;
+ prolongation[3](5,10) = 9.0/4096.0;
+ prolongation[3](5,11) = 9.0/4096.0;
+ prolongation[3](5,12) = 9.0/4096.0;
+ prolongation[3](5,13) = 9.0/4096.0;
+ prolongation[3](5,14) = 9.0/4096.0;
+ prolongation[3](5,15) = 9.0/4096.0;
+ prolongation[3](5,16) = 9.0/4096.0;
+ prolongation[3](5,17) = 9.0/4096.0;
+ prolongation[3](5,18) = 9.0/4096.0;
+ prolongation[3](5,19) = 9.0/4096.0;
+ prolongation[3](5,20) = 9.0/4096.0;
+ prolongation[3](5,21) = 9.0/4096.0;
+ prolongation[3](5,22) = 9.0/4096.0;
+ prolongation[3](5,23) = 9.0/4096.0;
+ prolongation[3](5,24) = 9.0/4096.0;
+ prolongation[3](5,25) = 9.0/4096.0;
+ prolongation[3](5,26) = 9.0/4096.0;
+ prolongation[3](5,27) = 9.0/4096.0;
+ prolongation[3](5,28) = 9.0/4096.0;
+ prolongation[3](5,29) = 9.0/4096.0;
+ prolongation[3](5,30) = 9.0/4096.0;
+ prolongation[3](5,31) = 9.0/4096.0;
+ prolongation[3](5,32) = -81.0/4096.0;
+ prolongation[3](5,33) = -81.0/4096.0;
+ prolongation[3](5,34) = -81.0/4096.0;
+ prolongation[3](5,35) = -81.0/4096.0;
+ prolongation[3](5,36) = -81.0/4096.0;
+ prolongation[3](5,37) = -81.0/4096.0;
+ prolongation[3](5,38) = -81.0/4096.0;
+ prolongation[3](5,39) = -81.0/4096.0;
+ prolongation[3](5,40) = -81.0/4096.0;
+ prolongation[3](5,41) = -81.0/4096.0;
+ prolongation[3](5,42) = -81.0/4096.0;
+ prolongation[3](5,43) = -81.0/4096.0;
+ prolongation[3](5,44) = -81.0/4096.0;
+ prolongation[3](5,45) = -81.0/4096.0;
+ prolongation[3](5,46) = -81.0/4096.0;
+ prolongation[3](5,47) = -81.0/4096.0;
+ prolongation[3](5,48) = -81.0/4096.0;
+ prolongation[3](5,49) = -81.0/4096.0;
+ prolongation[3](5,50) = -81.0/4096.0;
+ prolongation[3](5,51) = -81.0/4096.0;
+ prolongation[3](5,52) = -81.0/4096.0;
+ prolongation[3](5,53) = -81.0/4096.0;
+ prolongation[3](5,54) = -81.0/4096.0;
+ prolongation[3](5,55) = -81.0/4096.0;
+ prolongation[3](5,56) = 729.0/4096.0;
+ prolongation[3](5,57) = 729.0/4096.0;
+ prolongation[3](5,58) = 729.0/4096.0;
+ prolongation[3](5,59) = 729.0/4096.0;
+ prolongation[3](5,60) = 729.0/4096.0;
+ prolongation[3](5,61) = 729.0/4096.0;
+ prolongation[3](5,62) = 729.0/4096.0;
+ prolongation[3](5,63) = 729.0/4096.0;
+ prolongation[3](6,2) = 1.0/256.0;
+ prolongation[3](6,3) = 1.0/256.0;
+ prolongation[3](6,6) = 1.0/256.0;
+ prolongation[3](6,7) = 1.0/256.0;
+ prolongation[3](6,12) = -9.0/256.0;
+ prolongation[3](6,13) = -9.0/256.0;
+ prolongation[3](6,20) = -9.0/256.0;
+ prolongation[3](6,21) = -9.0/256.0;
+ prolongation[3](6,28) = -9.0/256.0;
+ prolongation[3](6,29) = -9.0/256.0;
+ prolongation[3](6,30) = -9.0/256.0;
+ prolongation[3](6,31) = -9.0/256.0;
+ prolongation[3](6,48) = 81.0/256.0;
+ prolongation[3](6,49) = 81.0/256.0;
+ prolongation[3](6,50) = 81.0/256.0;
+ prolongation[3](6,51) = 81.0/256.0;
+ prolongation[3](7,3) = -1.0/16.0;
+ prolongation[3](7,7) = -1.0/16.0;
+ prolongation[3](7,30) = 9.0/16.0;
+ prolongation[3](7,31) = 9.0/16.0;
+ prolongation[3](8,0) = -5.0/256.0;
+ prolongation[3](8,1) = -1.0/256.0;
+ prolongation[3](8,2) = -1.0/256.0;
+ prolongation[3](8,3) = -5.0/256.0;
+ prolongation[3](8,8) = -15.0/256.0;
+ prolongation[3](8,9) = 5.0/256.0;
+ prolongation[3](8,10) = 9.0/256.0;
+ prolongation[3](8,11) = 9.0/256.0;
+ prolongation[3](8,12) = -15.0/256.0;
+ prolongation[3](8,13) = 5.0/256.0;
+ prolongation[3](8,14) = 45.0/256.0;
+ prolongation[3](8,15) = 45.0/256.0;
+ prolongation[3](8,32) = 135.0/256.0;
+ prolongation[3](8,33) = -45.0/256.0;
+ prolongation[3](8,34) = 135.0/256.0;
+ prolongation[3](8,35) = -45.0/256.0;
+ prolongation[3](9,8) = -1.0/16.0;
+ prolongation[3](9,12) = -1.0/16.0;
+ prolongation[3](9,32) = 9.0/16.0;
+ prolongation[3](9,34) = 9.0/16.0;
+ prolongation[3](10,11) = -1.0/16.0;
+ prolongation[3](10,15) = -1.0/16.0;
+ prolongation[3](10,34) = 9.0/16.0;
+ prolongation[3](10,35) = 9.0/16.0;
+ prolongation[3](11,0) = -1.0/256.0;
+ prolongation[3](11,1) = -1.0/256.0;
+ prolongation[3](11,2) = -5.0/256.0;
+ prolongation[3](11,3) = -5.0/256.0;
+ prolongation[3](11,8) = 9.0/256.0;
+ prolongation[3](11,9) = 9.0/256.0;
+ prolongation[3](11,10) = 5.0/256.0;
+ prolongation[3](11,11) = -15.0/256.0;
+ prolongation[3](11,12) = 45.0/256.0;
+ prolongation[3](11,13) = 45.0/256.0;
+ prolongation[3](11,14) = 5.0/256.0;
+ prolongation[3](11,15) = -15.0/256.0;
+ prolongation[3](11,32) = -45.0/256.0;
+ prolongation[3](11,33) = -45.0/256.0;
+ prolongation[3](11,34) = 135.0/256.0;
+ prolongation[3](11,35) = 135.0/256.0;
+ prolongation[3](12,2) = 1.0/16.0;
+ prolongation[3](12,3) = 5.0/16.0;
+ prolongation[3](12,12) = 15.0/16.0;
+ prolongation[3](12,13) = -5.0/16.0;
+ prolongation[3](13,12) = 1.0;
+ prolongation[3](14,15) = 1.0;
+ prolongation[3](15,0) = 1.0/16.0;
+ prolongation[3](15,3) = 5.0/16.0;
+ prolongation[3](15,14) = -5.0/16.0;
+ prolongation[3](15,15) = 15.0/16.0;
+ prolongation[3](16,0) = 5.0/4096.0;
+ prolongation[3](16,1) = 1.0/4096.0;
+ prolongation[3](16,2) = 1.0/4096.0;
+ prolongation[3](16,3) = 5.0/4096.0;
+ prolongation[3](16,4) = 5.0/4096.0;
+ prolongation[3](16,5) = 1.0/4096.0;
+ prolongation[3](16,6) = 1.0/4096.0;
+ prolongation[3](16,7) = 5.0/4096.0;
+ prolongation[3](16,8) = 15.0/4096.0;
+ prolongation[3](16,9) = -5.0/4096.0;
+ prolongation[3](16,10) = -9.0/4096.0;
+ prolongation[3](16,11) = -9.0/4096.0;
+ prolongation[3](16,12) = 15.0/4096.0;
+ prolongation[3](16,13) = -5.0/4096.0;
+ prolongation[3](16,14) = -45.0/4096.0;
+ prolongation[3](16,15) = -45.0/4096.0;
+ prolongation[3](16,16) = 15.0/4096.0;
+ prolongation[3](16,17) = -5.0/4096.0;
+ prolongation[3](16,18) = -9.0/4096.0;
+ prolongation[3](16,19) = -9.0/4096.0;
+ prolongation[3](16,20) = 15.0/4096.0;
+ prolongation[3](16,21) = -5.0/4096.0;
+ prolongation[3](16,22) = -45.0/4096.0;
+ prolongation[3](16,23) = -45.0/4096.0;
+ prolongation[3](16,24) = -45.0/4096.0;
+ prolongation[3](16,25) = -45.0/4096.0;
+ prolongation[3](16,26) = -9.0/4096.0;
+ prolongation[3](16,27) = -9.0/4096.0;
+ prolongation[3](16,28) = -9.0/4096.0;
+ prolongation[3](16,29) = -9.0/4096.0;
+ prolongation[3](16,30) = -45.0/4096.0;
+ prolongation[3](16,31) = -45.0/4096.0;
+ prolongation[3](16,32) = -135.0/4096.0;
+ prolongation[3](16,33) = 45.0/4096.0;
+ prolongation[3](16,34) = -135.0/4096.0;
+ prolongation[3](16,35) = 45.0/4096.0;
+ prolongation[3](16,36) = -135.0/4096.0;
+ prolongation[3](16,37) = 45.0/4096.0;
+ prolongation[3](16,38) = -135.0/4096.0;
+ prolongation[3](16,39) = 45.0/4096.0;
+ prolongation[3](16,40) = -135.0/4096.0;
+ prolongation[3](16,41) = 45.0/4096.0;
+ prolongation[3](16,42) = -135.0/4096.0;
+ prolongation[3](16,43) = 45.0/4096.0;
+ prolongation[3](16,44) = 81.0/4096.0;
+ prolongation[3](16,45) = 81.0/4096.0;
+ prolongation[3](16,46) = 81.0/4096.0;
+ prolongation[3](16,47) = 81.0/4096.0;
+ prolongation[3](16,48) = -135.0/4096.0;
+ prolongation[3](16,49) = 45.0/4096.0;
+ prolongation[3](16,50) = -135.0/4096.0;
+ prolongation[3](16,51) = 45.0/4096.0;
+ prolongation[3](16,52) = 405.0/4096.0;
+ prolongation[3](16,53) = 405.0/4096.0;
+ prolongation[3](16,54) = 405.0/4096.0;
+ prolongation[3](16,55) = 405.0/4096.0;
+ prolongation[3](16,56) = 1215.0/4096.0;
+ prolongation[3](16,57) = -405.0/4096.0;
+ prolongation[3](16,58) = 1215.0/4096.0;
+ prolongation[3](16,59) = -405.0/4096.0;
+ prolongation[3](16,60) = 1215.0/4096.0;
+ prolongation[3](16,61) = -405.0/4096.0;
+ prolongation[3](16,62) = 1215.0/4096.0;
+ prolongation[3](16,63) = -405.0/4096.0;
+ prolongation[3](17,8) = 1.0/256.0;
+ prolongation[3](17,12) = 1.0/256.0;
+ prolongation[3](17,16) = 1.0/256.0;
+ prolongation[3](17,20) = 1.0/256.0;
+ prolongation[3](17,32) = -9.0/256.0;
+ prolongation[3](17,34) = -9.0/256.0;
+ prolongation[3](17,36) = -9.0/256.0;
+ prolongation[3](17,38) = -9.0/256.0;
+ prolongation[3](17,40) = -9.0/256.0;
+ prolongation[3](17,42) = -9.0/256.0;
+ prolongation[3](17,48) = -9.0/256.0;
+ prolongation[3](17,50) = -9.0/256.0;
+ prolongation[3](17,56) = 81.0/256.0;
+ prolongation[3](17,58) = 81.0/256.0;
+ prolongation[3](17,60) = 81.0/256.0;
+ prolongation[3](17,62) = 81.0/256.0;
+ prolongation[3](18,11) = 1.0/256.0;
+ prolongation[3](18,15) = 1.0/256.0;
+ prolongation[3](18,19) = 1.0/256.0;
+ prolongation[3](18,23) = 1.0/256.0;
+ prolongation[3](18,34) = -9.0/256.0;
+ prolongation[3](18,35) = -9.0/256.0;
+ prolongation[3](18,38) = -9.0/256.0;
+ prolongation[3](18,39) = -9.0/256.0;
+ prolongation[3](18,46) = -9.0/256.0;
+ prolongation[3](18,47) = -9.0/256.0;
+ prolongation[3](18,54) = -9.0/256.0;
+ prolongation[3](18,55) = -9.0/256.0;
+ prolongation[3](18,60) = 81.0/256.0;
+ prolongation[3](18,61) = 81.0/256.0;
+ prolongation[3](18,62) = 81.0/256.0;
+ prolongation[3](18,63) = 81.0/256.0;
+ prolongation[3](19,0) = 1.0/4096.0;
+ prolongation[3](19,1) = 1.0/4096.0;
+ prolongation[3](19,2) = 5.0/4096.0;
+ prolongation[3](19,3) = 5.0/4096.0;
+ prolongation[3](19,4) = 1.0/4096.0;
+ prolongation[3](19,5) = 1.0/4096.0;
+ prolongation[3](19,6) = 5.0/4096.0;
+ prolongation[3](19,7) = 5.0/4096.0;
+ prolongation[3](19,8) = -9.0/4096.0;
+ prolongation[3](19,9) = -9.0/4096.0;
+ prolongation[3](19,10) = -5.0/4096.0;
+ prolongation[3](19,11) = 15.0/4096.0;
+ prolongation[3](19,12) = -45.0/4096.0;
+ prolongation[3](19,13) = -45.0/4096.0;
+ prolongation[3](19,14) = -5.0/4096.0;
+ prolongation[3](19,15) = 15.0/4096.0;
+ prolongation[3](19,16) = -9.0/4096.0;
+ prolongation[3](19,17) = -9.0/4096.0;
+ prolongation[3](19,18) = -5.0/4096.0;
+ prolongation[3](19,19) = 15.0/4096.0;
+ prolongation[3](19,20) = -45.0/4096.0;
+ prolongation[3](19,21) = -45.0/4096.0;
+ prolongation[3](19,22) = -5.0/4096.0;
+ prolongation[3](19,23) = 15.0/4096.0;
+ prolongation[3](19,24) = -9.0/4096.0;
+ prolongation[3](19,25) = -9.0/4096.0;
+ prolongation[3](19,26) = -9.0/4096.0;
+ prolongation[3](19,27) = -9.0/4096.0;
+ prolongation[3](19,28) = -45.0/4096.0;
+ prolongation[3](19,29) = -45.0/4096.0;
+ prolongation[3](19,30) = -45.0/4096.0;
+ prolongation[3](19,31) = -45.0/4096.0;
+ prolongation[3](19,32) = 45.0/4096.0;
+ prolongation[3](19,33) = 45.0/4096.0;
+ prolongation[3](19,34) = -135.0/4096.0;
+ prolongation[3](19,35) = -135.0/4096.0;
+ prolongation[3](19,36) = 45.0/4096.0;
+ prolongation[3](19,37) = 45.0/4096.0;
+ prolongation[3](19,38) = -135.0/4096.0;
+ prolongation[3](19,39) = -135.0/4096.0;
+ prolongation[3](19,40) = 81.0/4096.0;
+ prolongation[3](19,41) = 81.0/4096.0;
+ prolongation[3](19,42) = 81.0/4096.0;
+ prolongation[3](19,43) = 81.0/4096.0;
+ prolongation[3](19,44) = 45.0/4096.0;
+ prolongation[3](19,45) = 45.0/4096.0;
+ prolongation[3](19,46) = -135.0/4096.0;
+ prolongation[3](19,47) = -135.0/4096.0;
+ prolongation[3](19,48) = 405.0/4096.0;
+ prolongation[3](19,49) = 405.0/4096.0;
+ prolongation[3](19,50) = 405.0/4096.0;
+ prolongation[3](19,51) = 405.0/4096.0;
+ prolongation[3](19,52) = 45.0/4096.0;
+ prolongation[3](19,53) = 45.0/4096.0;
+ prolongation[3](19,54) = -135.0/4096.0;
+ prolongation[3](19,55) = -135.0/4096.0;
+ prolongation[3](19,56) = -405.0/4096.0;
+ prolongation[3](19,57) = -405.0/4096.0;
+ prolongation[3](19,58) = -405.0/4096.0;
+ prolongation[3](19,59) = -405.0/4096.0;
+ prolongation[3](19,60) = 1215.0/4096.0;
+ prolongation[3](19,61) = 1215.0/4096.0;
+ prolongation[3](19,62) = 1215.0/4096.0;
+ prolongation[3](19,63) = 1215.0/4096.0;
+ prolongation[3](20,2) = -1.0/256.0;
+ prolongation[3](20,3) = -5.0/256.0;
+ prolongation[3](20,6) = -1.0/256.0;
+ prolongation[3](20,7) = -5.0/256.0;
+ prolongation[3](20,12) = -15.0/256.0;
+ prolongation[3](20,13) = 5.0/256.0;
+ prolongation[3](20,20) = -15.0/256.0;
+ prolongation[3](20,21) = 5.0/256.0;
+ prolongation[3](20,28) = 9.0/256.0;
+ prolongation[3](20,29) = 9.0/256.0;
+ prolongation[3](20,30) = 45.0/256.0;
+ prolongation[3](20,31) = 45.0/256.0;
+ prolongation[3](20,48) = 135.0/256.0;
+ prolongation[3](20,49) = -45.0/256.0;
+ prolongation[3](20,50) = 135.0/256.0;
+ prolongation[3](20,51) = -45.0/256.0;
+ prolongation[3](21,12) = -1.0/16.0;
+ prolongation[3](21,20) = -1.0/16.0;
+ prolongation[3](21,48) = 9.0/16.0;
+ prolongation[3](21,50) = 9.0/16.0;
+ prolongation[3](22,15) = -1.0/16.0;
+ prolongation[3](22,23) = -1.0/16.0;
+ prolongation[3](22,54) = 9.0/16.0;
+ prolongation[3](22,55) = 9.0/16.0;
+ prolongation[3](23,0) = -1.0/256.0;
+ prolongation[3](23,3) = -5.0/256.0;
+ prolongation[3](23,4) = -1.0/256.0;
+ prolongation[3](23,7) = -5.0/256.0;
+ prolongation[3](23,14) = 5.0/256.0;
+ prolongation[3](23,15) = -15.0/256.0;
+ prolongation[3](23,22) = 5.0/256.0;
+ prolongation[3](23,23) = -15.0/256.0;
+ prolongation[3](23,24) = 9.0/256.0;
+ prolongation[3](23,25) = 9.0/256.0;
+ prolongation[3](23,30) = 45.0/256.0;
+ prolongation[3](23,31) = 45.0/256.0;
+ prolongation[3](23,52) = -45.0/256.0;
+ prolongation[3](23,53) = -45.0/256.0;
+ prolongation[3](23,54) = 135.0/256.0;
+ prolongation[3](23,55) = 135.0/256.0;
+ prolongation[3](24,0) = -5.0/256.0;
+ prolongation[3](24,3) = -5.0/256.0;
+ prolongation[3](24,4) = -1.0/256.0;
+ prolongation[3](24,7) = -1.0/256.0;
+ prolongation[3](24,14) = 45.0/256.0;
+ prolongation[3](24,15) = 45.0/256.0;
+ prolongation[3](24,22) = 9.0/256.0;
+ prolongation[3](24,23) = 9.0/256.0;
+ prolongation[3](24,24) = -15.0/256.0;
+ prolongation[3](24,25) = 5.0/256.0;
+ prolongation[3](24,30) = -15.0/256.0;
+ prolongation[3](24,31) = 5.0/256.0;
+ prolongation[3](24,52) = 135.0/256.0;
+ prolongation[3](24,53) = -45.0/256.0;
+ prolongation[3](24,54) = 135.0/256.0;
+ prolongation[3](24,55) = -45.0/256.0;
+ prolongation[3](25,24) = -1.0/16.0;
+ prolongation[3](25,30) = -1.0/16.0;
+ prolongation[3](25,52) = 9.0/16.0;
+ prolongation[3](25,54) = 9.0/16.0;
+ prolongation[3](26,0) = 5.0/4096.0;
+ prolongation[3](26,1) = 5.0/4096.0;
+ prolongation[3](26,2) = 5.0/4096.0;
+ prolongation[3](26,3) = 5.0/4096.0;
+ prolongation[3](26,4) = 1.0/4096.0;
+ prolongation[3](26,5) = 1.0/4096.0;
+ prolongation[3](26,6) = 1.0/4096.0;
+ prolongation[3](26,7) = 1.0/4096.0;
+ prolongation[3](26,8) = -45.0/4096.0;
+ prolongation[3](26,9) = -45.0/4096.0;
+ prolongation[3](26,10) = -45.0/4096.0;
+ prolongation[3](26,11) = -45.0/4096.0;
+ prolongation[3](26,12) = -45.0/4096.0;
+ prolongation[3](26,13) = -45.0/4096.0;
+ prolongation[3](26,14) = -45.0/4096.0;
+ prolongation[3](26,15) = -45.0/4096.0;
+ prolongation[3](26,16) = -9.0/4096.0;
+ prolongation[3](26,17) = -9.0/4096.0;
+ prolongation[3](26,18) = -9.0/4096.0;
+ prolongation[3](26,19) = -9.0/4096.0;
+ prolongation[3](26,20) = -9.0/4096.0;
+ prolongation[3](26,21) = -9.0/4096.0;
+ prolongation[3](26,22) = -9.0/4096.0;
+ prolongation[3](26,23) = -9.0/4096.0;
+ prolongation[3](26,24) = 15.0/4096.0;
+ prolongation[3](26,25) = -5.0/4096.0;
+ prolongation[3](26,26) = 15.0/4096.0;
+ prolongation[3](26,27) = -5.0/4096.0;
+ prolongation[3](26,28) = 15.0/4096.0;
+ prolongation[3](26,29) = -5.0/4096.0;
+ prolongation[3](26,30) = 15.0/4096.0;
+ prolongation[3](26,31) = -5.0/4096.0;
+ prolongation[3](26,32) = 405.0/4096.0;
+ prolongation[3](26,33) = 405.0/4096.0;
+ prolongation[3](26,34) = 405.0/4096.0;
+ prolongation[3](26,35) = 405.0/4096.0;
+ prolongation[3](26,36) = 81.0/4096.0;
+ prolongation[3](26,37) = 81.0/4096.0;
+ prolongation[3](26,38) = 81.0/4096.0;
+ prolongation[3](26,39) = 81.0/4096.0;
+ prolongation[3](26,40) = -135.0/4096.0;
+ prolongation[3](26,41) = -135.0/4096.0;
+ prolongation[3](26,42) = 45.0/4096.0;
+ prolongation[3](26,43) = 45.0/4096.0;
+ prolongation[3](26,44) = -135.0/4096.0;
+ prolongation[3](26,45) = 45.0/4096.0;
+ prolongation[3](26,46) = -135.0/4096.0;
+ prolongation[3](26,47) = 45.0/4096.0;
+ prolongation[3](26,48) = -135.0/4096.0;
+ prolongation[3](26,49) = -135.0/4096.0;
+ prolongation[3](26,50) = 45.0/4096.0;
+ prolongation[3](26,51) = 45.0/4096.0;
+ prolongation[3](26,52) = -135.0/4096.0;
+ prolongation[3](26,53) = 45.0/4096.0;
+ prolongation[3](26,54) = -135.0/4096.0;
+ prolongation[3](26,55) = 45.0/4096.0;
+ prolongation[3](26,56) = 1215.0/4096.0;
+ prolongation[3](26,57) = 1215.0/4096.0;
+ prolongation[3](26,58) = -405.0/4096.0;
+ prolongation[3](26,59) = -405.0/4096.0;
+ prolongation[3](26,60) = 1215.0/4096.0;
+ prolongation[3](26,61) = 1215.0/4096.0;
+ prolongation[3](26,62) = -405.0/4096.0;
+ prolongation[3](26,63) = -405.0/4096.0;
+ prolongation[3](27,24) = 1.0/256.0;
+ prolongation[3](27,26) = 1.0/256.0;
+ prolongation[3](27,28) = 1.0/256.0;
+ prolongation[3](27,30) = 1.0/256.0;
+ prolongation[3](27,40) = -9.0/256.0;
+ prolongation[3](27,41) = -9.0/256.0;
+ prolongation[3](27,44) = -9.0/256.0;
+ prolongation[3](27,46) = -9.0/256.0;
+ prolongation[3](27,48) = -9.0/256.0;
+ prolongation[3](27,49) = -9.0/256.0;
+ prolongation[3](27,52) = -9.0/256.0;
+ prolongation[3](27,54) = -9.0/256.0;
+ prolongation[3](27,56) = 81.0/256.0;
+ prolongation[3](27,57) = 81.0/256.0;
+ prolongation[3](27,60) = 81.0/256.0;
+ prolongation[3](27,61) = 81.0/256.0;
+ prolongation[3](28,2) = -5.0/256.0;
+ prolongation[3](28,3) = -5.0/256.0;
+ prolongation[3](28,6) = -1.0/256.0;
+ prolongation[3](28,7) = -1.0/256.0;
+ prolongation[3](28,12) = 45.0/256.0;
+ prolongation[3](28,13) = 45.0/256.0;
+ prolongation[3](28,20) = 9.0/256.0;
+ prolongation[3](28,21) = 9.0/256.0;
+ prolongation[3](28,28) = -15.0/256.0;
+ prolongation[3](28,29) = 5.0/256.0;
+ prolongation[3](28,30) = -15.0/256.0;
+ prolongation[3](28,31) = 5.0/256.0;
+ prolongation[3](28,48) = 135.0/256.0;
+ prolongation[3](28,49) = 135.0/256.0;
+ prolongation[3](28,50) = -45.0/256.0;
+ prolongation[3](28,51) = -45.0/256.0;
+ prolongation[3](29,28) = -1.0/16.0;
+ prolongation[3](29,30) = -1.0/16.0;
+ prolongation[3](29,48) = 9.0/16.0;
+ prolongation[3](29,49) = 9.0/16.0;
+ prolongation[3](30,3) = 5.0/16.0;
+ prolongation[3](30,7) = 1.0/16.0;
+ prolongation[3](30,30) = 15.0/16.0;
+ prolongation[3](30,31) = -5.0/16.0;
+ prolongation[3](31,30) = 1.0;
+ prolongation[3](32,11) = 1.0/16.0;
+ prolongation[3](32,15) = 5.0/16.0;
+ prolongation[3](32,34) = 15.0/16.0;
+ prolongation[3](32,35) = -5.0/16.0;
+ prolongation[3](33,34) = 1.0;
+ prolongation[3](34,0) = 5.0/256.0;
+ prolongation[3](34,1) = 1.0/256.0;
+ prolongation[3](34,2) = 5.0/256.0;
+ prolongation[3](34,3) = 25.0/256.0;
+ prolongation[3](34,8) = 15.0/256.0;
+ prolongation[3](34,9) = -5.0/256.0;
+ prolongation[3](34,10) = -5.0/256.0;
+ prolongation[3](34,11) = 15.0/256.0;
+ prolongation[3](34,12) = 75.0/256.0;
+ prolongation[3](34,13) = -25.0/256.0;
+ prolongation[3](34,14) = -25.0/256.0;
+ prolongation[3](34,15) = 75.0/256.0;
+ prolongation[3](34,32) = -75.0/256.0;
+ prolongation[3](34,33) = 25.0/256.0;
+ prolongation[3](34,34) = 225.0/256.0;
+ prolongation[3](34,35) = -75.0/256.0;
+ prolongation[3](35,8) = 1.0/16.0;
+ prolongation[3](35,12) = 5.0/16.0;
+ prolongation[3](35,32) = -5.0/16.0;
+ prolongation[3](35,34) = 15.0/16.0;
+ prolongation[3](36,11) = -1.0/256.0;
+ prolongation[3](36,15) = -5.0/256.0;
+ prolongation[3](36,19) = -1.0/256.0;
+ prolongation[3](36,23) = -5.0/256.0;
+ prolongation[3](36,34) = -15.0/256.0;
+ prolongation[3](36,35) = 5.0/256.0;
+ prolongation[3](36,38) = -15.0/256.0;
+ prolongation[3](36,39) = 5.0/256.0;
+ prolongation[3](36,46) = 9.0/256.0;
+ prolongation[3](36,47) = 9.0/256.0;
+ prolongation[3](36,54) = 45.0/256.0;
+ prolongation[3](36,55) = 45.0/256.0;
+ prolongation[3](36,60) = 135.0/256.0;
+ prolongation[3](36,61) = -45.0/256.0;
+ prolongation[3](36,62) = 135.0/256.0;
+ prolongation[3](36,63) = -45.0/256.0;
+ prolongation[3](37,34) = -1.0/16.0;
+ prolongation[3](37,38) = -1.0/16.0;
+ prolongation[3](37,60) = 9.0/16.0;
+ prolongation[3](37,62) = 9.0/16.0;
+ prolongation[3](38,0) = -5.0/4096.0;
+ prolongation[3](38,1) = -1.0/4096.0;
+ prolongation[3](38,2) = -5.0/4096.0;
+ prolongation[3](38,3) = -25.0/4096.0;
+ prolongation[3](38,4) = -5.0/4096.0;
+ prolongation[3](38,5) = -1.0/4096.0;
+ prolongation[3](38,6) = -5.0/4096.0;
+ prolongation[3](38,7) = -25.0/4096.0;
+ prolongation[3](38,8) = -15.0/4096.0;
+ prolongation[3](38,9) = 5.0/4096.0;
+ prolongation[3](38,10) = 5.0/4096.0;
+ prolongation[3](38,11) = -15.0/4096.0;
+ prolongation[3](38,12) = -75.0/4096.0;
+ prolongation[3](38,13) = 25.0/4096.0;
+ prolongation[3](38,14) = 25.0/4096.0;
+ prolongation[3](38,15) = -75.0/4096.0;
+ prolongation[3](38,16) = -15.0/4096.0;
+ prolongation[3](38,17) = 5.0/4096.0;
+ prolongation[3](38,18) = 5.0/4096.0;
+ prolongation[3](38,19) = -15.0/4096.0;
+ prolongation[3](38,20) = -75.0/4096.0;
+ prolongation[3](38,21) = 25.0/4096.0;
+ prolongation[3](38,22) = 25.0/4096.0;
+ prolongation[3](38,23) = -75.0/4096.0;
+ prolongation[3](38,24) = 45.0/4096.0;
+ prolongation[3](38,25) = 45.0/4096.0;
+ prolongation[3](38,26) = 9.0/4096.0;
+ prolongation[3](38,27) = 9.0/4096.0;
+ prolongation[3](38,28) = 45.0/4096.0;
+ prolongation[3](38,29) = 45.0/4096.0;
+ prolongation[3](38,30) = 225.0/4096.0;
+ prolongation[3](38,31) = 225.0/4096.0;
+ prolongation[3](38,32) = 75.0/4096.0;
+ prolongation[3](38,33) = -25.0/4096.0;
+ prolongation[3](38,34) = -225.0/4096.0;
+ prolongation[3](38,35) = 75.0/4096.0;
+ prolongation[3](38,36) = 75.0/4096.0;
+ prolongation[3](38,37) = -25.0/4096.0;
+ prolongation[3](38,38) = -225.0/4096.0;
+ prolongation[3](38,39) = 75.0/4096.0;
+ prolongation[3](38,40) = 135.0/4096.0;
+ prolongation[3](38,41) = -45.0/4096.0;
+ prolongation[3](38,42) = 135.0/4096.0;
+ prolongation[3](38,43) = -45.0/4096.0;
+ prolongation[3](38,44) = -45.0/4096.0;
+ prolongation[3](38,45) = -45.0/4096.0;
+ prolongation[3](38,46) = 135.0/4096.0;
+ prolongation[3](38,47) = 135.0/4096.0;
+ prolongation[3](38,48) = 675.0/4096.0;
+ prolongation[3](38,49) = -225.0/4096.0;
+ prolongation[3](38,50) = 675.0/4096.0;
+ prolongation[3](38,51) = -225.0/4096.0;
+ prolongation[3](38,52) = -225.0/4096.0;
+ prolongation[3](38,53) = -225.0/4096.0;
+ prolongation[3](38,54) = 675.0/4096.0;
+ prolongation[3](38,55) = 675.0/4096.0;
+ prolongation[3](38,56) = -675.0/4096.0;
+ prolongation[3](38,57) = 225.0/4096.0;
+ prolongation[3](38,58) = -675.0/4096.0;
+ prolongation[3](38,59) = 225.0/4096.0;
+ prolongation[3](38,60) = 2025.0/4096.0;
+ prolongation[3](38,61) = -675.0/4096.0;
+ prolongation[3](38,62) = 2025.0/4096.0;
+ prolongation[3](38,63) = -675.0/4096.0;
+ prolongation[3](39,8) = -1.0/256.0;
+ prolongation[3](39,12) = -5.0/256.0;
+ prolongation[3](39,16) = -1.0/256.0;
+ prolongation[3](39,20) = -5.0/256.0;
+ prolongation[3](39,32) = 5.0/256.0;
+ prolongation[3](39,34) = -15.0/256.0;
+ prolongation[3](39,36) = 5.0/256.0;
+ prolongation[3](39,38) = -15.0/256.0;
+ prolongation[3](39,40) = 9.0/256.0;
+ prolongation[3](39,42) = 9.0/256.0;
+ prolongation[3](39,48) = 45.0/256.0;
+ prolongation[3](39,50) = 45.0/256.0;
+ prolongation[3](39,56) = -45.0/256.0;
+ prolongation[3](39,58) = -45.0/256.0;
+ prolongation[3](39,60) = 135.0/256.0;
+ prolongation[3](39,62) = 135.0/256.0;
+ prolongation[3](40,0) = -25.0/4096.0;
+ prolongation[3](40,1) = -5.0/4096.0;
+ prolongation[3](40,2) = -5.0/4096.0;
+ prolongation[3](40,3) = -25.0/4096.0;
+ prolongation[3](40,4) = -5.0/4096.0;
+ prolongation[3](40,5) = -1.0/4096.0;
+ prolongation[3](40,6) = -1.0/4096.0;
+ prolongation[3](40,7) = -5.0/4096.0;
+ prolongation[3](40,8) = -75.0/4096.0;
+ prolongation[3](40,9) = 25.0/4096.0;
+ prolongation[3](40,10) = 45.0/4096.0;
+ prolongation[3](40,11) = 45.0/4096.0;
+ prolongation[3](40,12) = -75.0/4096.0;
+ prolongation[3](40,13) = 25.0/4096.0;
+ prolongation[3](40,14) = 225.0/4096.0;
+ prolongation[3](40,15) = 225.0/4096.0;
+ prolongation[3](40,16) = -15.0/4096.0;
+ prolongation[3](40,17) = 5.0/4096.0;
+ prolongation[3](40,18) = 9.0/4096.0;
+ prolongation[3](40,19) = 9.0/4096.0;
+ prolongation[3](40,20) = -15.0/4096.0;
+ prolongation[3](40,21) = 5.0/4096.0;
+ prolongation[3](40,22) = 45.0/4096.0;
+ prolongation[3](40,23) = 45.0/4096.0;
+ prolongation[3](40,24) = -75.0/4096.0;
+ prolongation[3](40,25) = 25.0/4096.0;
+ prolongation[3](40,26) = -15.0/4096.0;
+ prolongation[3](40,27) = 5.0/4096.0;
+ prolongation[3](40,28) = -15.0/4096.0;
+ prolongation[3](40,29) = 5.0/4096.0;
+ prolongation[3](40,30) = -75.0/4096.0;
+ prolongation[3](40,31) = 25.0/4096.0;
+ prolongation[3](40,32) = 675.0/4096.0;
+ prolongation[3](40,33) = -225.0/4096.0;
+ prolongation[3](40,34) = 675.0/4096.0;
+ prolongation[3](40,35) = -225.0/4096.0;
+ prolongation[3](40,36) = 135.0/4096.0;
+ prolongation[3](40,37) = -45.0/4096.0;
+ prolongation[3](40,38) = 135.0/4096.0;
+ prolongation[3](40,39) = -45.0/4096.0;
+ prolongation[3](40,40) = -225.0/4096.0;
+ prolongation[3](40,41) = 75.0/4096.0;
+ prolongation[3](40,42) = 75.0/4096.0;
+ prolongation[3](40,43) = -25.0/4096.0;
+ prolongation[3](40,44) = 135.0/4096.0;
+ prolongation[3](40,45) = -45.0/4096.0;
+ prolongation[3](40,46) = 135.0/4096.0;
+ prolongation[3](40,47) = -45.0/4096.0;
+ prolongation[3](40,48) = -225.0/4096.0;
+ prolongation[3](40,49) = 75.0/4096.0;
+ prolongation[3](40,50) = 75.0/4096.0;
+ prolongation[3](40,51) = -25.0/4096.0;
+ prolongation[3](40,52) = 675.0/4096.0;
+ prolongation[3](40,53) = -225.0/4096.0;
+ prolongation[3](40,54) = 675.0/4096.0;
+ prolongation[3](40,55) = -225.0/4096.0;
+ prolongation[3](40,56) = 2025.0/4096.0;
+ prolongation[3](40,57) = -675.0/4096.0;
+ prolongation[3](40,58) = -675.0/4096.0;
+ prolongation[3](40,59) = 225.0/4096.0;
+ prolongation[3](40,60) = 2025.0/4096.0;
+ prolongation[3](40,61) = -675.0/4096.0;
+ prolongation[3](40,62) = -675.0/4096.0;
+ prolongation[3](40,63) = 225.0/4096.0;
+ prolongation[3](41,8) = -5.0/256.0;
+ prolongation[3](41,12) = -5.0/256.0;
+ prolongation[3](41,16) = -1.0/256.0;
+ prolongation[3](41,20) = -1.0/256.0;
+ prolongation[3](41,32) = 45.0/256.0;
+ prolongation[3](41,34) = 45.0/256.0;
+ prolongation[3](41,36) = 9.0/256.0;
+ prolongation[3](41,38) = 9.0/256.0;
+ prolongation[3](41,40) = -15.0/256.0;
+ prolongation[3](41,42) = 5.0/256.0;
+ prolongation[3](41,48) = -15.0/256.0;
+ prolongation[3](41,50) = 5.0/256.0;
+ prolongation[3](41,56) = 135.0/256.0;
+ prolongation[3](41,58) = -45.0/256.0;
+ prolongation[3](41,60) = 135.0/256.0;
+ prolongation[3](41,62) = -45.0/256.0;
+ prolongation[3](42,24) = -5.0/256.0;
+ prolongation[3](42,26) = -1.0/256.0;
+ prolongation[3](42,28) = -1.0/256.0;
+ prolongation[3](42,30) = -5.0/256.0;
+ prolongation[3](42,40) = -15.0/256.0;
+ prolongation[3](42,41) = 5.0/256.0;
+ prolongation[3](42,44) = 9.0/256.0;
+ prolongation[3](42,46) = 9.0/256.0;
+ prolongation[3](42,48) = -15.0/256.0;
+ prolongation[3](42,49) = 5.0/256.0;
+ prolongation[3](42,52) = 45.0/256.0;
+ prolongation[3](42,54) = 45.0/256.0;
+ prolongation[3](42,56) = 135.0/256.0;
+ prolongation[3](42,57) = -45.0/256.0;
+ prolongation[3](42,60) = 135.0/256.0;
+ prolongation[3](42,61) = -45.0/256.0;
+ prolongation[3](43,40) = -1.0/16.0;
+ prolongation[3](43,48) = -1.0/16.0;
+ prolongation[3](43,56) = 9.0/16.0;
+ prolongation[3](43,60) = 9.0/16.0;
+ prolongation[3](44,11) = -5.0/256.0;
+ prolongation[3](44,15) = -5.0/256.0;
+ prolongation[3](44,19) = -1.0/256.0;
+ prolongation[3](44,23) = -1.0/256.0;
+ prolongation[3](44,34) = 45.0/256.0;
+ prolongation[3](44,35) = 45.0/256.0;
+ prolongation[3](44,38) = 9.0/256.0;
+ prolongation[3](44,39) = 9.0/256.0;
+ prolongation[3](44,46) = -15.0/256.0;
+ prolongation[3](44,47) = 5.0/256.0;
+ prolongation[3](44,54) = -15.0/256.0;
+ prolongation[3](44,55) = 5.0/256.0;
+ prolongation[3](44,60) = 135.0/256.0;
+ prolongation[3](44,61) = 135.0/256.0;
+ prolongation[3](44,62) = -45.0/256.0;
+ prolongation[3](44,63) = -45.0/256.0;
+ prolongation[3](45,46) = -1.0/16.0;
+ prolongation[3](45,54) = -1.0/16.0;
+ prolongation[3](45,60) = 9.0/16.0;
+ prolongation[3](45,61) = 9.0/16.0;
+ prolongation[3](46,0) = -5.0/4096.0;
+ prolongation[3](46,1) = -5.0/4096.0;
+ prolongation[3](46,2) = -25.0/4096.0;
+ prolongation[3](46,3) = -25.0/4096.0;
+ prolongation[3](46,4) = -1.0/4096.0;
+ prolongation[3](46,5) = -1.0/4096.0;
+ prolongation[3](46,6) = -5.0/4096.0;
+ prolongation[3](46,7) = -5.0/4096.0;
+ prolongation[3](46,8) = 45.0/4096.0;
+ prolongation[3](46,9) = 45.0/4096.0;
+ prolongation[3](46,10) = 25.0/4096.0;
+ prolongation[3](46,11) = -75.0/4096.0;
+ prolongation[3](46,12) = 225.0/4096.0;
+ prolongation[3](46,13) = 225.0/4096.0;
+ prolongation[3](46,14) = 25.0/4096.0;
+ prolongation[3](46,15) = -75.0/4096.0;
+ prolongation[3](46,16) = 9.0/4096.0;
+ prolongation[3](46,17) = 9.0/4096.0;
+ prolongation[3](46,18) = 5.0/4096.0;
+ prolongation[3](46,19) = -15.0/4096.0;
+ prolongation[3](46,20) = 45.0/4096.0;
+ prolongation[3](46,21) = 45.0/4096.0;
+ prolongation[3](46,22) = 5.0/4096.0;
+ prolongation[3](46,23) = -15.0/4096.0;
+ prolongation[3](46,24) = -15.0/4096.0;
+ prolongation[3](46,25) = 5.0/4096.0;
+ prolongation[3](46,26) = -15.0/4096.0;
+ prolongation[3](46,27) = 5.0/4096.0;
+ prolongation[3](46,28) = -75.0/4096.0;
+ prolongation[3](46,29) = 25.0/4096.0;
+ prolongation[3](46,30) = -75.0/4096.0;
+ prolongation[3](46,31) = 25.0/4096.0;
+ prolongation[3](46,32) = -225.0/4096.0;
+ prolongation[3](46,33) = -225.0/4096.0;
+ prolongation[3](46,34) = 675.0/4096.0;
+ prolongation[3](46,35) = 675.0/4096.0;
+ prolongation[3](46,36) = -45.0/4096.0;
+ prolongation[3](46,37) = -45.0/4096.0;
+ prolongation[3](46,38) = 135.0/4096.0;
+ prolongation[3](46,39) = 135.0/4096.0;
+ prolongation[3](46,40) = 135.0/4096.0;
+ prolongation[3](46,41) = 135.0/4096.0;
+ prolongation[3](46,42) = -45.0/4096.0;
+ prolongation[3](46,43) = -45.0/4096.0;
+ prolongation[3](46,44) = 75.0/4096.0;
+ prolongation[3](46,45) = -25.0/4096.0;
+ prolongation[3](46,46) = -225.0/4096.0;
+ prolongation[3](46,47) = 75.0/4096.0;
+ prolongation[3](46,48) = 675.0/4096.0;
+ prolongation[3](46,49) = 675.0/4096.0;
+ prolongation[3](46,50) = -225.0/4096.0;
+ prolongation[3](46,51) = -225.0/4096.0;
+ prolongation[3](46,52) = 75.0/4096.0;
+ prolongation[3](46,53) = -25.0/4096.0;
+ prolongation[3](46,54) = -225.0/4096.0;
+ prolongation[3](46,55) = 75.0/4096.0;
+ prolongation[3](46,56) = -675.0/4096.0;
+ prolongation[3](46,57) = -675.0/4096.0;
+ prolongation[3](46,58) = 225.0/4096.0;
+ prolongation[3](46,59) = 225.0/4096.0;
+ prolongation[3](46,60) = 2025.0/4096.0;
+ prolongation[3](46,61) = 2025.0/4096.0;
+ prolongation[3](46,62) = -675.0/4096.0;
+ prolongation[3](46,63) = -675.0/4096.0;
+ prolongation[3](47,24) = -1.0/256.0;
+ prolongation[3](47,26) = -1.0/256.0;
+ prolongation[3](47,28) = -5.0/256.0;
+ prolongation[3](47,30) = -5.0/256.0;
+ prolongation[3](47,40) = 9.0/256.0;
+ prolongation[3](47,41) = 9.0/256.0;
+ prolongation[3](47,44) = 5.0/256.0;
+ prolongation[3](47,46) = -15.0/256.0;
+ prolongation[3](47,48) = 45.0/256.0;
+ prolongation[3](47,49) = 45.0/256.0;
+ prolongation[3](47,52) = 5.0/256.0;
+ prolongation[3](47,54) = -15.0/256.0;
+ prolongation[3](47,56) = -45.0/256.0;
+ prolongation[3](47,57) = -45.0/256.0;
+ prolongation[3](47,60) = 135.0/256.0;
+ prolongation[3](47,61) = 135.0/256.0;
+ prolongation[3](48,2) = 5.0/256.0;
+ prolongation[3](48,3) = 25.0/256.0;
+ prolongation[3](48,6) = 1.0/256.0;
+ prolongation[3](48,7) = 5.0/256.0;
+ prolongation[3](48,12) = 75.0/256.0;
+ prolongation[3](48,13) = -25.0/256.0;
+ prolongation[3](48,20) = 15.0/256.0;
+ prolongation[3](48,21) = -5.0/256.0;
+ prolongation[3](48,28) = 15.0/256.0;
+ prolongation[3](48,29) = -5.0/256.0;
+ prolongation[3](48,30) = 75.0/256.0;
+ prolongation[3](48,31) = -25.0/256.0;
+ prolongation[3](48,48) = 225.0/256.0;
+ prolongation[3](48,49) = -75.0/256.0;
+ prolongation[3](48,50) = -75.0/256.0;
+ prolongation[3](48,51) = 25.0/256.0;
+ prolongation[3](49,12) = 5.0/16.0;
+ prolongation[3](49,20) = 1.0/16.0;
+ prolongation[3](49,48) = 15.0/16.0;
+ prolongation[3](49,50) = -5.0/16.0;
+ prolongation[3](50,28) = 1.0/16.0;
+ prolongation[3](50,30) = 5.0/16.0;
+ prolongation[3](50,48) = 15.0/16.0;
+ prolongation[3](50,49) = -5.0/16.0;
+ prolongation[3](51,48) = 1.0;
+ prolongation[3](52,15) = 5.0/16.0;
+ prolongation[3](52,23) = 1.0/16.0;
+ prolongation[3](52,54) = 15.0/16.0;
+ prolongation[3](52,55) = -5.0/16.0;
+ prolongation[3](53,54) = 1.0;
+ prolongation[3](54,0) = 5.0/256.0;
+ prolongation[3](54,3) = 25.0/256.0;
+ prolongation[3](54,4) = 1.0/256.0;
+ prolongation[3](54,7) = 5.0/256.0;
+ prolongation[3](54,14) = -25.0/256.0;
+ prolongation[3](54,15) = 75.0/256.0;
+ prolongation[3](54,22) = -5.0/256.0;
+ prolongation[3](54,23) = 15.0/256.0;
+ prolongation[3](54,24) = 15.0/256.0;
+ prolongation[3](54,25) = -5.0/256.0;
+ prolongation[3](54,30) = 75.0/256.0;
+ prolongation[3](54,31) = -25.0/256.0;
+ prolongation[3](54,52) = -75.0/256.0;
+ prolongation[3](54,53) = 25.0/256.0;
+ prolongation[3](54,54) = 225.0/256.0;
+ prolongation[3](54,55) = -75.0/256.0;
+ prolongation[3](55,24) = 1.0/16.0;
+ prolongation[3](55,30) = 5.0/16.0;
+ prolongation[3](55,52) = -5.0/16.0;
+ prolongation[3](55,54) = 15.0/16.0;
+ prolongation[3](56,11) = 5.0/256.0;
+ prolongation[3](56,15) = 25.0/256.0;
+ prolongation[3](56,19) = 1.0/256.0;
+ prolongation[3](56,23) = 5.0/256.0;
+ prolongation[3](56,34) = 75.0/256.0;
+ prolongation[3](56,35) = -25.0/256.0;
+ prolongation[3](56,38) = 15.0/256.0;
+ prolongation[3](56,39) = -5.0/256.0;
+ prolongation[3](56,46) = 15.0/256.0;
+ prolongation[3](56,47) = -5.0/256.0;
+ prolongation[3](56,54) = 75.0/256.0;
+ prolongation[3](56,55) = -25.0/256.0;
+ prolongation[3](56,60) = 225.0/256.0;
+ prolongation[3](56,61) = -75.0/256.0;
+ prolongation[3](56,62) = -75.0/256.0;
+ prolongation[3](56,63) = 25.0/256.0;
+ prolongation[3](57,34) = 5.0/16.0;
+ prolongation[3](57,38) = 1.0/16.0;
+ prolongation[3](57,60) = 15.0/16.0;
+ prolongation[3](57,62) = -5.0/16.0;
+ prolongation[3](58,46) = 1.0/16.0;
+ prolongation[3](58,54) = 5.0/16.0;
+ prolongation[3](58,60) = 15.0/16.0;
+ prolongation[3](58,61) = -5.0/16.0;
+ prolongation[3](59,60) = 1.0;
+ prolongation[3](60,0) = 25.0/4096.0;
+ prolongation[3](60,1) = 5.0/4096.0;
+ prolongation[3](60,2) = 25.0/4096.0;
+ prolongation[3](60,3) = 125.0/4096.0;
+ prolongation[3](60,4) = 5.0/4096.0;
+ prolongation[3](60,5) = 1.0/4096.0;
+ prolongation[3](60,6) = 5.0/4096.0;
+ prolongation[3](60,7) = 25.0/4096.0;
+ prolongation[3](60,8) = 75.0/4096.0;
+ prolongation[3](60,9) = -25.0/4096.0;
+ prolongation[3](60,10) = -25.0/4096.0;
+ prolongation[3](60,11) = 75.0/4096.0;
+ prolongation[3](60,12) = 375.0/4096.0;
+ prolongation[3](60,13) = -125.0/4096.0;
+ prolongation[3](60,14) = -125.0/4096.0;
+ prolongation[3](60,15) = 375.0/4096.0;
+ prolongation[3](60,16) = 15.0/4096.0;
+ prolongation[3](60,17) = -5.0/4096.0;
+ prolongation[3](60,18) = -5.0/4096.0;
+ prolongation[3](60,19) = 15.0/4096.0;
+ prolongation[3](60,20) = 75.0/4096.0;
+ prolongation[3](60,21) = -25.0/4096.0;
+ prolongation[3](60,22) = -25.0/4096.0;
+ prolongation[3](60,23) = 75.0/4096.0;
+ prolongation[3](60,24) = 75.0/4096.0;
+ prolongation[3](60,25) = -25.0/4096.0;
+ prolongation[3](60,26) = 15.0/4096.0;
+ prolongation[3](60,27) = -5.0/4096.0;
+ prolongation[3](60,28) = 75.0/4096.0;
+ prolongation[3](60,29) = -25.0/4096.0;
+ prolongation[3](60,30) = 375.0/4096.0;
+ prolongation[3](60,31) = -125.0/4096.0;
+ prolongation[3](60,32) = -375.0/4096.0;
+ prolongation[3](60,33) = 125.0/4096.0;
+ prolongation[3](60,34) = 1125.0/4096.0;
+ prolongation[3](60,35) = -375.0/4096.0;
+ prolongation[3](60,36) = -75.0/4096.0;
+ prolongation[3](60,37) = 25.0/4096.0;
+ prolongation[3](60,38) = 225.0/4096.0;
+ prolongation[3](60,39) = -75.0/4096.0;
+ prolongation[3](60,40) = 225.0/4096.0;
+ prolongation[3](60,41) = -75.0/4096.0;
+ prolongation[3](60,42) = -75.0/4096.0;
+ prolongation[3](60,43) = 25.0/4096.0;
+ prolongation[3](60,44) = -75.0/4096.0;
+ prolongation[3](60,45) = 25.0/4096.0;
+ prolongation[3](60,46) = 225.0/4096.0;
+ prolongation[3](60,47) = -75.0/4096.0;
+ prolongation[3](60,48) = 1125.0/4096.0;
+ prolongation[3](60,49) = -375.0/4096.0;
+ prolongation[3](60,50) = -375.0/4096.0;
+ prolongation[3](60,51) = 125.0/4096.0;
+ prolongation[3](60,52) = -375.0/4096.0;
+ prolongation[3](60,53) = 125.0/4096.0;
+ prolongation[3](60,54) = 1125.0/4096.0;
+ prolongation[3](60,55) = -375.0/4096.0;
+ prolongation[3](60,56) = -1125.0/4096.0;
+ prolongation[3](60,57) = 375.0/4096.0;
+ prolongation[3](60,58) = 375.0/4096.0;
+ prolongation[3](60,59) = -125.0/4096.0;
+ prolongation[3](60,60) = 3375.0/4096.0;
+ prolongation[3](60,61) = -1125.0/4096.0;
+ prolongation[3](60,62) = -1125.0/4096.0;
+ prolongation[3](60,63) = 375.0/4096.0;
+ prolongation[3](61,8) = 5.0/256.0;
+ prolongation[3](61,12) = 25.0/256.0;
+ prolongation[3](61,16) = 1.0/256.0;
+ prolongation[3](61,20) = 5.0/256.0;
+ prolongation[3](61,32) = -25.0/256.0;
+ prolongation[3](61,34) = 75.0/256.0;
+ prolongation[3](61,36) = -5.0/256.0;
+ prolongation[3](61,38) = 15.0/256.0;
+ prolongation[3](61,40) = 15.0/256.0;
+ prolongation[3](61,42) = -5.0/256.0;
+ prolongation[3](61,48) = 75.0/256.0;
+ prolongation[3](61,50) = -25.0/256.0;
+ prolongation[3](61,56) = -75.0/256.0;
+ prolongation[3](61,58) = 25.0/256.0;
+ prolongation[3](61,60) = 225.0/256.0;
+ prolongation[3](61,62) = -75.0/256.0;
+ prolongation[3](62,24) = 5.0/256.0;
+ prolongation[3](62,26) = 1.0/256.0;
+ prolongation[3](62,28) = 5.0/256.0;
+ prolongation[3](62,30) = 25.0/256.0;
+ prolongation[3](62,40) = 15.0/256.0;
+ prolongation[3](62,41) = -5.0/256.0;
+ prolongation[3](62,44) = -5.0/256.0;
+ prolongation[3](62,46) = 15.0/256.0;
+ prolongation[3](62,48) = 75.0/256.0;
+ prolongation[3](62,49) = -25.0/256.0;
+ prolongation[3](62,52) = -25.0/256.0;
+ prolongation[3](62,54) = 75.0/256.0;
+ prolongation[3](62,56) = -75.0/256.0;
+ prolongation[3](62,57) = 25.0/256.0;
+ prolongation[3](62,60) = 225.0/256.0;
+ prolongation[3](62,61) = -75.0/256.0;
+ prolongation[3](63,40) = 1.0/16.0;
+ prolongation[3](63,48) = 5.0/16.0;
+ prolongation[3](63,56) = -5.0/16.0;
+ prolongation[3](63,60) = 15.0/16.0;
+ prolongation[4](0,0) = -1.0/16.0;
+ prolongation[4](0,4) = -1.0/16.0;
+ prolongation[4](0,24) = 9.0/16.0;
+ prolongation[4](0,25) = 9.0/16.0;
+ prolongation[4](1,0) = 1.0/256.0;
+ prolongation[4](1,1) = 1.0/256.0;
+ prolongation[4](1,4) = 1.0/256.0;
+ prolongation[4](1,5) = 1.0/256.0;
+ prolongation[4](1,8) = -9.0/256.0;
+ prolongation[4](1,9) = -9.0/256.0;
+ prolongation[4](1,16) = -9.0/256.0;
+ prolongation[4](1,17) = -9.0/256.0;
+ prolongation[4](1,24) = -9.0/256.0;
+ prolongation[4](1,25) = -9.0/256.0;
+ prolongation[4](1,26) = -9.0/256.0;
+ prolongation[4](1,27) = -9.0/256.0;
+ prolongation[4](1,40) = 81.0/256.0;
+ prolongation[4](1,41) = 81.0/256.0;
+ prolongation[4](1,42) = 81.0/256.0;
+ prolongation[4](1,43) = 81.0/256.0;
+ prolongation[4](2,0) = -1.0/4096.0;
+ prolongation[4](2,1) = -1.0/4096.0;
+ prolongation[4](2,2) = -1.0/4096.0;
+ prolongation[4](2,3) = -1.0/4096.0;
+ prolongation[4](2,4) = -1.0/4096.0;
+ prolongation[4](2,5) = -1.0/4096.0;
+ prolongation[4](2,6) = -1.0/4096.0;
+ prolongation[4](2,7) = -1.0/4096.0;
+ prolongation[4](2,8) = 9.0/4096.0;
+ prolongation[4](2,9) = 9.0/4096.0;
+ prolongation[4](2,10) = 9.0/4096.0;
+ prolongation[4](2,11) = 9.0/4096.0;
+ prolongation[4](2,12) = 9.0/4096.0;
+ prolongation[4](2,13) = 9.0/4096.0;
+ prolongation[4](2,14) = 9.0/4096.0;
+ prolongation[4](2,15) = 9.0/4096.0;
+ prolongation[4](2,16) = 9.0/4096.0;
+ prolongation[4](2,17) = 9.0/4096.0;
+ prolongation[4](2,18) = 9.0/4096.0;
+ prolongation[4](2,19) = 9.0/4096.0;
+ prolongation[4](2,20) = 9.0/4096.0;
+ prolongation[4](2,21) = 9.0/4096.0;
+ prolongation[4](2,22) = 9.0/4096.0;
+ prolongation[4](2,23) = 9.0/4096.0;
+ prolongation[4](2,24) = 9.0/4096.0;
+ prolongation[4](2,25) = 9.0/4096.0;
+ prolongation[4](2,26) = 9.0/4096.0;
+ prolongation[4](2,27) = 9.0/4096.0;
+ prolongation[4](2,28) = 9.0/4096.0;
+ prolongation[4](2,29) = 9.0/4096.0;
+ prolongation[4](2,30) = 9.0/4096.0;
+ prolongation[4](2,31) = 9.0/4096.0;
+ prolongation[4](2,32) = -81.0/4096.0;
+ prolongation[4](2,33) = -81.0/4096.0;
+ prolongation[4](2,34) = -81.0/4096.0;
+ prolongation[4](2,35) = -81.0/4096.0;
+ prolongation[4](2,36) = -81.0/4096.0;
+ prolongation[4](2,37) = -81.0/4096.0;
+ prolongation[4](2,38) = -81.0/4096.0;
+ prolongation[4](2,39) = -81.0/4096.0;
+ prolongation[4](2,40) = -81.0/4096.0;
+ prolongation[4](2,41) = -81.0/4096.0;
+ prolongation[4](2,42) = -81.0/4096.0;
+ prolongation[4](2,43) = -81.0/4096.0;
+ prolongation[4](2,44) = -81.0/4096.0;
+ prolongation[4](2,45) = -81.0/4096.0;
+ prolongation[4](2,46) = -81.0/4096.0;
+ prolongation[4](2,47) = -81.0/4096.0;
+ prolongation[4](2,48) = -81.0/4096.0;
+ prolongation[4](2,49) = -81.0/4096.0;
+ prolongation[4](2,50) = -81.0/4096.0;
+ prolongation[4](2,51) = -81.0/4096.0;
+ prolongation[4](2,52) = -81.0/4096.0;
+ prolongation[4](2,53) = -81.0/4096.0;
+ prolongation[4](2,54) = -81.0/4096.0;
+ prolongation[4](2,55) = -81.0/4096.0;
+ prolongation[4](2,56) = 729.0/4096.0;
+ prolongation[4](2,57) = 729.0/4096.0;
+ prolongation[4](2,58) = 729.0/4096.0;
+ prolongation[4](2,59) = 729.0/4096.0;
+ prolongation[4](2,60) = 729.0/4096.0;
+ prolongation[4](2,61) = 729.0/4096.0;
+ prolongation[4](2,62) = 729.0/4096.0;
+ prolongation[4](2,63) = 729.0/4096.0;
+ prolongation[4](3,0) = 1.0/256.0;
+ prolongation[4](3,3) = 1.0/256.0;
+ prolongation[4](3,4) = 1.0/256.0;
+ prolongation[4](3,7) = 1.0/256.0;
+ prolongation[4](3,14) = -9.0/256.0;
+ prolongation[4](3,15) = -9.0/256.0;
+ prolongation[4](3,22) = -9.0/256.0;
+ prolongation[4](3,23) = -9.0/256.0;
+ prolongation[4](3,24) = -9.0/256.0;
+ prolongation[4](3,25) = -9.0/256.0;
+ prolongation[4](3,30) = -9.0/256.0;
+ prolongation[4](3,31) = -9.0/256.0;
+ prolongation[4](3,52) = 81.0/256.0;
+ prolongation[4](3,53) = 81.0/256.0;
+ prolongation[4](3,54) = 81.0/256.0;
+ prolongation[4](3,55) = 81.0/256.0;
+ prolongation[4](4,4) = 1.0;
+ prolongation[4](5,4) = -1.0/16.0;
+ prolongation[4](5,5) = -1.0/16.0;
+ prolongation[4](5,16) = 9.0/16.0;
+ prolongation[4](5,17) = 9.0/16.0;
+ prolongation[4](6,4) = 1.0/256.0;
+ prolongation[4](6,5) = 1.0/256.0;
+ prolongation[4](6,6) = 1.0/256.0;
+ prolongation[4](6,7) = 1.0/256.0;
+ prolongation[4](6,16) = -9.0/256.0;
+ prolongation[4](6,17) = -9.0/256.0;
+ prolongation[4](6,18) = -9.0/256.0;
+ prolongation[4](6,19) = -9.0/256.0;
+ prolongation[4](6,20) = -9.0/256.0;
+ prolongation[4](6,21) = -9.0/256.0;
+ prolongation[4](6,22) = -9.0/256.0;
+ prolongation[4](6,23) = -9.0/256.0;
+ prolongation[4](6,36) = 81.0/256.0;
+ prolongation[4](6,37) = 81.0/256.0;
+ prolongation[4](6,38) = 81.0/256.0;
+ prolongation[4](6,39) = 81.0/256.0;
+ prolongation[4](7,4) = -1.0/16.0;
+ prolongation[4](7,7) = -1.0/16.0;
+ prolongation[4](7,22) = 9.0/16.0;
+ prolongation[4](7,23) = 9.0/16.0;
+ prolongation[4](8,0) = -5.0/256.0;
+ prolongation[4](8,1) = -1.0/256.0;
+ prolongation[4](8,4) = -5.0/256.0;
+ prolongation[4](8,5) = -1.0/256.0;
+ prolongation[4](8,8) = -15.0/256.0;
+ prolongation[4](8,9) = 5.0/256.0;
+ prolongation[4](8,16) = -15.0/256.0;
+ prolongation[4](8,17) = 5.0/256.0;
+ prolongation[4](8,24) = 45.0/256.0;
+ prolongation[4](8,25) = 45.0/256.0;
+ prolongation[4](8,26) = 9.0/256.0;
+ prolongation[4](8,27) = 9.0/256.0;
+ prolongation[4](8,40) = 135.0/256.0;
+ prolongation[4](8,41) = -45.0/256.0;
+ prolongation[4](8,42) = 135.0/256.0;
+ prolongation[4](8,43) = -45.0/256.0;
+ prolongation[4](9,8) = -1.0/16.0;
+ prolongation[4](9,16) = -1.0/16.0;
+ prolongation[4](9,40) = 9.0/16.0;
+ prolongation[4](9,42) = 9.0/16.0;
+ prolongation[4](10,0) = 5.0/4096.0;
+ prolongation[4](10,1) = 5.0/4096.0;
+ prolongation[4](10,2) = 1.0/4096.0;
+ prolongation[4](10,3) = 1.0/4096.0;
+ prolongation[4](10,4) = 5.0/4096.0;
+ prolongation[4](10,5) = 5.0/4096.0;
+ prolongation[4](10,6) = 1.0/4096.0;
+ prolongation[4](10,7) = 1.0/4096.0;
+ prolongation[4](10,8) = -45.0/4096.0;
+ prolongation[4](10,9) = -45.0/4096.0;
+ prolongation[4](10,10) = 15.0/4096.0;
+ prolongation[4](10,11) = -5.0/4096.0;
+ prolongation[4](10,12) = -9.0/4096.0;
+ prolongation[4](10,13) = -9.0/4096.0;
+ prolongation[4](10,14) = 15.0/4096.0;
+ prolongation[4](10,15) = -5.0/4096.0;
+ prolongation[4](10,16) = -45.0/4096.0;
+ prolongation[4](10,17) = -45.0/4096.0;
+ prolongation[4](10,18) = 15.0/4096.0;
+ prolongation[4](10,19) = -5.0/4096.0;
+ prolongation[4](10,20) = -9.0/4096.0;
+ prolongation[4](10,21) = -9.0/4096.0;
+ prolongation[4](10,22) = 15.0/4096.0;
+ prolongation[4](10,23) = -5.0/4096.0;
+ prolongation[4](10,24) = -45.0/4096.0;
+ prolongation[4](10,25) = -45.0/4096.0;
+ prolongation[4](10,26) = -45.0/4096.0;
+ prolongation[4](10,27) = -45.0/4096.0;
+ prolongation[4](10,28) = -9.0/4096.0;
+ prolongation[4](10,29) = -9.0/4096.0;
+ prolongation[4](10,30) = -9.0/4096.0;
+ prolongation[4](10,31) = -9.0/4096.0;
+ prolongation[4](10,32) = -135.0/4096.0;
+ prolongation[4](10,33) = -135.0/4096.0;
+ prolongation[4](10,34) = 45.0/4096.0;
+ prolongation[4](10,35) = 45.0/4096.0;
+ prolongation[4](10,36) = -135.0/4096.0;
+ prolongation[4](10,37) = -135.0/4096.0;
+ prolongation[4](10,38) = 45.0/4096.0;
+ prolongation[4](10,39) = 45.0/4096.0;
+ prolongation[4](10,40) = 405.0/4096.0;
+ prolongation[4](10,41) = 405.0/4096.0;
+ prolongation[4](10,42) = 405.0/4096.0;
+ prolongation[4](10,43) = 405.0/4096.0;
+ prolongation[4](10,44) = -135.0/4096.0;
+ prolongation[4](10,45) = -135.0/4096.0;
+ prolongation[4](10,46) = 45.0/4096.0;
+ prolongation[4](10,47) = 45.0/4096.0;
+ prolongation[4](10,48) = 81.0/4096.0;
+ prolongation[4](10,49) = 81.0/4096.0;
+ prolongation[4](10,50) = 81.0/4096.0;
+ prolongation[4](10,51) = 81.0/4096.0;
+ prolongation[4](10,52) = -135.0/4096.0;
+ prolongation[4](10,53) = -135.0/4096.0;
+ prolongation[4](10,54) = 45.0/4096.0;
+ prolongation[4](10,55) = 45.0/4096.0;
+ prolongation[4](10,56) = 1215.0/4096.0;
+ prolongation[4](10,57) = 1215.0/4096.0;
+ prolongation[4](10,58) = 1215.0/4096.0;
+ prolongation[4](10,59) = 1215.0/4096.0;
+ prolongation[4](10,60) = -405.0/4096.0;
+ prolongation[4](10,61) = -405.0/4096.0;
+ prolongation[4](10,62) = -405.0/4096.0;
+ prolongation[4](10,63) = -405.0/4096.0;
+ prolongation[4](11,10) = 1.0/256.0;
+ prolongation[4](11,14) = 1.0/256.0;
+ prolongation[4](11,18) = 1.0/256.0;
+ prolongation[4](11,22) = 1.0/256.0;
+ prolongation[4](11,32) = -9.0/256.0;
+ prolongation[4](11,33) = -9.0/256.0;
+ prolongation[4](11,36) = -9.0/256.0;
+ prolongation[4](11,37) = -9.0/256.0;
+ prolongation[4](11,44) = -9.0/256.0;
+ prolongation[4](11,45) = -9.0/256.0;
+ prolongation[4](11,52) = -9.0/256.0;
+ prolongation[4](11,53) = -9.0/256.0;
+ prolongation[4](11,56) = 81.0/256.0;
+ prolongation[4](11,57) = 81.0/256.0;
+ prolongation[4](11,58) = 81.0/256.0;
+ prolongation[4](11,59) = 81.0/256.0;
+ prolongation[4](12,0) = 5.0/4096.0;
+ prolongation[4](12,1) = 1.0/4096.0;
+ prolongation[4](12,2) = 1.0/4096.0;
+ prolongation[4](12,3) = 5.0/4096.0;
+ prolongation[4](12,4) = 5.0/4096.0;
+ prolongation[4](12,5) = 1.0/4096.0;
+ prolongation[4](12,6) = 1.0/4096.0;
+ prolongation[4](12,7) = 5.0/4096.0;
+ prolongation[4](12,8) = 15.0/4096.0;
+ prolongation[4](12,9) = -5.0/4096.0;
+ prolongation[4](12,10) = -9.0/4096.0;
+ prolongation[4](12,11) = -9.0/4096.0;
+ prolongation[4](12,12) = 15.0/4096.0;
+ prolongation[4](12,13) = -5.0/4096.0;
+ prolongation[4](12,14) = -45.0/4096.0;
+ prolongation[4](12,15) = -45.0/4096.0;
+ prolongation[4](12,16) = 15.0/4096.0;
+ prolongation[4](12,17) = -5.0/4096.0;
+ prolongation[4](12,18) = -9.0/4096.0;
+ prolongation[4](12,19) = -9.0/4096.0;
+ prolongation[4](12,20) = 15.0/4096.0;
+ prolongation[4](12,21) = -5.0/4096.0;
+ prolongation[4](12,22) = -45.0/4096.0;
+ prolongation[4](12,23) = -45.0/4096.0;
+ prolongation[4](12,24) = -45.0/4096.0;
+ prolongation[4](12,25) = -45.0/4096.0;
+ prolongation[4](12,26) = -9.0/4096.0;
+ prolongation[4](12,27) = -9.0/4096.0;
+ prolongation[4](12,28) = -9.0/4096.0;
+ prolongation[4](12,29) = -9.0/4096.0;
+ prolongation[4](12,30) = -45.0/4096.0;
+ prolongation[4](12,31) = -45.0/4096.0;
+ prolongation[4](12,32) = -135.0/4096.0;
+ prolongation[4](12,33) = 45.0/4096.0;
+ prolongation[4](12,34) = -135.0/4096.0;
+ prolongation[4](12,35) = 45.0/4096.0;
+ prolongation[4](12,36) = -135.0/4096.0;
+ prolongation[4](12,37) = 45.0/4096.0;
+ prolongation[4](12,38) = -135.0/4096.0;
+ prolongation[4](12,39) = 45.0/4096.0;
+ prolongation[4](12,40) = -135.0/4096.0;
+ prolongation[4](12,41) = 45.0/4096.0;
+ prolongation[4](12,42) = -135.0/4096.0;
+ prolongation[4](12,43) = 45.0/4096.0;
+ prolongation[4](12,44) = 81.0/4096.0;
+ prolongation[4](12,45) = 81.0/4096.0;
+ prolongation[4](12,46) = 81.0/4096.0;
+ prolongation[4](12,47) = 81.0/4096.0;
+ prolongation[4](12,48) = -135.0/4096.0;
+ prolongation[4](12,49) = 45.0/4096.0;
+ prolongation[4](12,50) = -135.0/4096.0;
+ prolongation[4](12,51) = 45.0/4096.0;
+ prolongation[4](12,52) = 405.0/4096.0;
+ prolongation[4](12,53) = 405.0/4096.0;
+ prolongation[4](12,54) = 405.0/4096.0;
+ prolongation[4](12,55) = 405.0/4096.0;
+ prolongation[4](12,56) = 1215.0/4096.0;
+ prolongation[4](12,57) = -405.0/4096.0;
+ prolongation[4](12,58) = 1215.0/4096.0;
+ prolongation[4](12,59) = -405.0/4096.0;
+ prolongation[4](12,60) = 1215.0/4096.0;
+ prolongation[4](12,61) = -405.0/4096.0;
+ prolongation[4](12,62) = 1215.0/4096.0;
+ prolongation[4](12,63) = -405.0/4096.0;
+ prolongation[4](13,8) = 1.0/256.0;
+ prolongation[4](13,12) = 1.0/256.0;
+ prolongation[4](13,16) = 1.0/256.0;
+ prolongation[4](13,20) = 1.0/256.0;
+ prolongation[4](13,32) = -9.0/256.0;
+ prolongation[4](13,34) = -9.0/256.0;
+ prolongation[4](13,36) = -9.0/256.0;
+ prolongation[4](13,38) = -9.0/256.0;
+ prolongation[4](13,40) = -9.0/256.0;
+ prolongation[4](13,42) = -9.0/256.0;
+ prolongation[4](13,48) = -9.0/256.0;
+ prolongation[4](13,50) = -9.0/256.0;
+ prolongation[4](13,56) = 81.0/256.0;
+ prolongation[4](13,58) = 81.0/256.0;
+ prolongation[4](13,60) = 81.0/256.0;
+ prolongation[4](13,62) = 81.0/256.0;
+ prolongation[4](14,0) = -5.0/256.0;
+ prolongation[4](14,3) = -1.0/256.0;
+ prolongation[4](14,4) = -5.0/256.0;
+ prolongation[4](14,7) = -1.0/256.0;
+ prolongation[4](14,14) = -15.0/256.0;
+ prolongation[4](14,15) = 5.0/256.0;
+ prolongation[4](14,22) = -15.0/256.0;
+ prolongation[4](14,23) = 5.0/256.0;
+ prolongation[4](14,24) = 45.0/256.0;
+ prolongation[4](14,25) = 45.0/256.0;
+ prolongation[4](14,30) = 9.0/256.0;
+ prolongation[4](14,31) = 9.0/256.0;
+ prolongation[4](14,52) = 135.0/256.0;
+ prolongation[4](14,53) = 135.0/256.0;
+ prolongation[4](14,54) = -45.0/256.0;
+ prolongation[4](14,55) = -45.0/256.0;
+ prolongation[4](15,14) = -1.0/16.0;
+ prolongation[4](15,22) = -1.0/16.0;
+ prolongation[4](15,52) = 9.0/16.0;
+ prolongation[4](15,53) = 9.0/16.0;
+ prolongation[4](16,4) = 5.0/16.0;
+ prolongation[4](16,5) = 1.0/16.0;
+ prolongation[4](16,16) = 15.0/16.0;
+ prolongation[4](16,17) = -5.0/16.0;
+ prolongation[4](17,16) = 1.0;
+ prolongation[4](18,4) = -5.0/256.0;
+ prolongation[4](18,5) = -5.0/256.0;
+ prolongation[4](18,6) = -1.0/256.0;
+ prolongation[4](18,7) = -1.0/256.0;
+ prolongation[4](18,16) = 45.0/256.0;
+ prolongation[4](18,17) = 45.0/256.0;
+ prolongation[4](18,18) = -15.0/256.0;
+ prolongation[4](18,19) = 5.0/256.0;
+ prolongation[4](18,20) = 9.0/256.0;
+ prolongation[4](18,21) = 9.0/256.0;
+ prolongation[4](18,22) = -15.0/256.0;
+ prolongation[4](18,23) = 5.0/256.0;
+ prolongation[4](18,36) = 135.0/256.0;
+ prolongation[4](18,37) = 135.0/256.0;
+ prolongation[4](18,38) = -45.0/256.0;
+ prolongation[4](18,39) = -45.0/256.0;
+ prolongation[4](19,18) = -1.0/16.0;
+ prolongation[4](19,22) = -1.0/16.0;
+ prolongation[4](19,36) = 9.0/16.0;
+ prolongation[4](19,37) = 9.0/16.0;
+ prolongation[4](20,4) = -5.0/256.0;
+ prolongation[4](20,5) = -1.0/256.0;
+ prolongation[4](20,6) = -1.0/256.0;
+ prolongation[4](20,7) = -5.0/256.0;
+ prolongation[4](20,16) = -15.0/256.0;
+ prolongation[4](20,17) = 5.0/256.0;
+ prolongation[4](20,18) = 9.0/256.0;
+ prolongation[4](20,19) = 9.0/256.0;
+ prolongation[4](20,20) = -15.0/256.0;
+ prolongation[4](20,21) = 5.0/256.0;
+ prolongation[4](20,22) = 45.0/256.0;
+ prolongation[4](20,23) = 45.0/256.0;
+ prolongation[4](20,36) = 135.0/256.0;
+ prolongation[4](20,37) = -45.0/256.0;
+ prolongation[4](20,38) = 135.0/256.0;
+ prolongation[4](20,39) = -45.0/256.0;
+ prolongation[4](21,16) = -1.0/16.0;
+ prolongation[4](21,20) = -1.0/16.0;
+ prolongation[4](21,36) = 9.0/16.0;
+ prolongation[4](21,38) = 9.0/16.0;
+ prolongation[4](22,4) = 5.0/16.0;
+ prolongation[4](22,7) = 1.0/16.0;
+ prolongation[4](22,22) = 15.0/16.0;
+ prolongation[4](22,23) = -5.0/16.0;
+ prolongation[4](23,22) = 1.0;
+ prolongation[4](24,25) = 1.0;
+ prolongation[4](25,0) = 1.0/16.0;
+ prolongation[4](25,4) = 5.0/16.0;
+ prolongation[4](25,24) = -5.0/16.0;
+ prolongation[4](25,25) = 15.0/16.0;
+ prolongation[4](26,25) = -1.0/16.0;
+ prolongation[4](26,27) = -1.0/16.0;
+ prolongation[4](26,42) = 9.0/16.0;
+ prolongation[4](26,43) = 9.0/16.0;
+ prolongation[4](27,0) = -1.0/256.0;
+ prolongation[4](27,1) = -1.0/256.0;
+ prolongation[4](27,4) = -5.0/256.0;
+ prolongation[4](27,5) = -5.0/256.0;
+ prolongation[4](27,8) = 9.0/256.0;
+ prolongation[4](27,9) = 9.0/256.0;
+ prolongation[4](27,16) = 45.0/256.0;
+ prolongation[4](27,17) = 45.0/256.0;
+ prolongation[4](27,24) = 5.0/256.0;
+ prolongation[4](27,25) = -15.0/256.0;
+ prolongation[4](27,26) = 5.0/256.0;
+ prolongation[4](27,27) = -15.0/256.0;
+ prolongation[4](27,40) = -45.0/256.0;
+ prolongation[4](27,41) = -45.0/256.0;
+ prolongation[4](27,42) = 135.0/256.0;
+ prolongation[4](27,43) = 135.0/256.0;
+ prolongation[4](28,25) = 1.0/256.0;
+ prolongation[4](28,27) = 1.0/256.0;
+ prolongation[4](28,29) = 1.0/256.0;
+ prolongation[4](28,31) = 1.0/256.0;
+ prolongation[4](28,42) = -9.0/256.0;
+ prolongation[4](28,43) = -9.0/256.0;
+ prolongation[4](28,45) = -9.0/256.0;
+ prolongation[4](28,47) = -9.0/256.0;
+ prolongation[4](28,50) = -9.0/256.0;
+ prolongation[4](28,51) = -9.0/256.0;
+ prolongation[4](28,53) = -9.0/256.0;
+ prolongation[4](28,55) = -9.0/256.0;
+ prolongation[4](28,58) = 81.0/256.0;
+ prolongation[4](28,59) = 81.0/256.0;
+ prolongation[4](28,62) = 81.0/256.0;
+ prolongation[4](28,63) = 81.0/256.0;
+ prolongation[4](29,0) = 1.0/4096.0;
+ prolongation[4](29,1) = 1.0/4096.0;
+ prolongation[4](29,2) = 1.0/4096.0;
+ prolongation[4](29,3) = 1.0/4096.0;
+ prolongation[4](29,4) = 5.0/4096.0;
+ prolongation[4](29,5) = 5.0/4096.0;
+ prolongation[4](29,6) = 5.0/4096.0;
+ prolongation[4](29,7) = 5.0/4096.0;
+ prolongation[4](29,8) = -9.0/4096.0;
+ prolongation[4](29,9) = -9.0/4096.0;
+ prolongation[4](29,10) = -9.0/4096.0;
+ prolongation[4](29,11) = -9.0/4096.0;
+ prolongation[4](29,12) = -9.0/4096.0;
+ prolongation[4](29,13) = -9.0/4096.0;
+ prolongation[4](29,14) = -9.0/4096.0;
+ prolongation[4](29,15) = -9.0/4096.0;
+ prolongation[4](29,16) = -45.0/4096.0;
+ prolongation[4](29,17) = -45.0/4096.0;
+ prolongation[4](29,18) = -45.0/4096.0;
+ prolongation[4](29,19) = -45.0/4096.0;
+ prolongation[4](29,20) = -45.0/4096.0;
+ prolongation[4](29,21) = -45.0/4096.0;
+ prolongation[4](29,22) = -45.0/4096.0;
+ prolongation[4](29,23) = -45.0/4096.0;
+ prolongation[4](29,24) = -5.0/4096.0;
+ prolongation[4](29,25) = 15.0/4096.0;
+ prolongation[4](29,26) = -5.0/4096.0;
+ prolongation[4](29,27) = 15.0/4096.0;
+ prolongation[4](29,28) = -5.0/4096.0;
+ prolongation[4](29,29) = 15.0/4096.0;
+ prolongation[4](29,30) = -5.0/4096.0;
+ prolongation[4](29,31) = 15.0/4096.0;
+ prolongation[4](29,32) = 81.0/4096.0;
+ prolongation[4](29,33) = 81.0/4096.0;
+ prolongation[4](29,34) = 81.0/4096.0;
+ prolongation[4](29,35) = 81.0/4096.0;
+ prolongation[4](29,36) = 405.0/4096.0;
+ prolongation[4](29,37) = 405.0/4096.0;
+ prolongation[4](29,38) = 405.0/4096.0;
+ prolongation[4](29,39) = 405.0/4096.0;
+ prolongation[4](29,40) = 45.0/4096.0;
+ prolongation[4](29,41) = 45.0/4096.0;
+ prolongation[4](29,42) = -135.0/4096.0;
+ prolongation[4](29,43) = -135.0/4096.0;
+ prolongation[4](29,44) = 45.0/4096.0;
+ prolongation[4](29,45) = -135.0/4096.0;
+ prolongation[4](29,46) = 45.0/4096.0;
+ prolongation[4](29,47) = -135.0/4096.0;
+ prolongation[4](29,48) = 45.0/4096.0;
+ prolongation[4](29,49) = 45.0/4096.0;
+ prolongation[4](29,50) = -135.0/4096.0;
+ prolongation[4](29,51) = -135.0/4096.0;
+ prolongation[4](29,52) = 45.0/4096.0;
+ prolongation[4](29,53) = -135.0/4096.0;
+ prolongation[4](29,54) = 45.0/4096.0;
+ prolongation[4](29,55) = -135.0/4096.0;
+ prolongation[4](29,56) = -405.0/4096.0;
+ prolongation[4](29,57) = -405.0/4096.0;
+ prolongation[4](29,58) = 1215.0/4096.0;
+ prolongation[4](29,59) = 1215.0/4096.0;
+ prolongation[4](29,60) = -405.0/4096.0;
+ prolongation[4](29,61) = -405.0/4096.0;
+ prolongation[4](29,62) = 1215.0/4096.0;
+ prolongation[4](29,63) = 1215.0/4096.0;
+ prolongation[4](30,25) = -1.0/16.0;
+ prolongation[4](30,31) = -1.0/16.0;
+ prolongation[4](30,53) = 9.0/16.0;
+ prolongation[4](30,55) = 9.0/16.0;
+ prolongation[4](31,0) = -1.0/256.0;
+ prolongation[4](31,3) = -1.0/256.0;
+ prolongation[4](31,4) = -5.0/256.0;
+ prolongation[4](31,7) = -5.0/256.0;
+ prolongation[4](31,14) = 9.0/256.0;
+ prolongation[4](31,15) = 9.0/256.0;
+ prolongation[4](31,22) = 45.0/256.0;
+ prolongation[4](31,23) = 45.0/256.0;
+ prolongation[4](31,24) = 5.0/256.0;
+ prolongation[4](31,25) = -15.0/256.0;
+ prolongation[4](31,30) = 5.0/256.0;
+ prolongation[4](31,31) = -15.0/256.0;
+ prolongation[4](31,52) = -45.0/256.0;
+ prolongation[4](31,53) = 135.0/256.0;
+ prolongation[4](31,54) = -45.0/256.0;
+ prolongation[4](31,55) = 135.0/256.0;
+ prolongation[4](32,0) = -25.0/4096.0;
+ prolongation[4](32,1) = -5.0/4096.0;
+ prolongation[4](32,2) = -1.0/4096.0;
+ prolongation[4](32,3) = -5.0/4096.0;
+ prolongation[4](32,4) = -25.0/4096.0;
+ prolongation[4](32,5) = -5.0/4096.0;
+ prolongation[4](32,6) = -1.0/4096.0;
+ prolongation[4](32,7) = -5.0/4096.0;
+ prolongation[4](32,8) = -75.0/4096.0;
+ prolongation[4](32,9) = 25.0/4096.0;
+ prolongation[4](32,10) = -15.0/4096.0;
+ prolongation[4](32,11) = 5.0/4096.0;
+ prolongation[4](32,12) = -15.0/4096.0;
+ prolongation[4](32,13) = 5.0/4096.0;
+ prolongation[4](32,14) = -75.0/4096.0;
+ prolongation[4](32,15) = 25.0/4096.0;
+ prolongation[4](32,16) = -75.0/4096.0;
+ prolongation[4](32,17) = 25.0/4096.0;
+ prolongation[4](32,18) = -15.0/4096.0;
+ prolongation[4](32,19) = 5.0/4096.0;
+ prolongation[4](32,20) = -15.0/4096.0;
+ prolongation[4](32,21) = 5.0/4096.0;
+ prolongation[4](32,22) = -75.0/4096.0;
+ prolongation[4](32,23) = 25.0/4096.0;
+ prolongation[4](32,24) = 225.0/4096.0;
+ prolongation[4](32,25) = 225.0/4096.0;
+ prolongation[4](32,26) = 45.0/4096.0;
+ prolongation[4](32,27) = 45.0/4096.0;
+ prolongation[4](32,28) = 9.0/4096.0;
+ prolongation[4](32,29) = 9.0/4096.0;
+ prolongation[4](32,30) = 45.0/4096.0;
+ prolongation[4](32,31) = 45.0/4096.0;
+ prolongation[4](32,32) = -225.0/4096.0;
+ prolongation[4](32,33) = 75.0/4096.0;
+ prolongation[4](32,34) = 75.0/4096.0;
+ prolongation[4](32,35) = -25.0/4096.0;
+ prolongation[4](32,36) = -225.0/4096.0;
+ prolongation[4](32,37) = 75.0/4096.0;
+ prolongation[4](32,38) = 75.0/4096.0;
+ prolongation[4](32,39) = -25.0/4096.0;
+ prolongation[4](32,40) = 675.0/4096.0;
+ prolongation[4](32,41) = -225.0/4096.0;
+ prolongation[4](32,42) = 675.0/4096.0;
+ prolongation[4](32,43) = -225.0/4096.0;
+ prolongation[4](32,44) = 135.0/4096.0;
+ prolongation[4](32,45) = 135.0/4096.0;
+ prolongation[4](32,46) = -45.0/4096.0;
+ prolongation[4](32,47) = -45.0/4096.0;
+ prolongation[4](32,48) = 135.0/4096.0;
+ prolongation[4](32,49) = -45.0/4096.0;
+ prolongation[4](32,50) = 135.0/4096.0;
+ prolongation[4](32,51) = -45.0/4096.0;
+ prolongation[4](32,52) = 675.0/4096.0;
+ prolongation[4](32,53) = 675.0/4096.0;
+ prolongation[4](32,54) = -225.0/4096.0;
+ prolongation[4](32,55) = -225.0/4096.0;
+ prolongation[4](32,56) = 2025.0/4096.0;
+ prolongation[4](32,57) = -675.0/4096.0;
+ prolongation[4](32,58) = 2025.0/4096.0;
+ prolongation[4](32,59) = -675.0/4096.0;
+ prolongation[4](32,60) = -675.0/4096.0;
+ prolongation[4](32,61) = 225.0/4096.0;
+ prolongation[4](32,62) = -675.0/4096.0;
+ prolongation[4](32,63) = 225.0/4096.0;
+ prolongation[4](33,8) = -5.0/256.0;
+ prolongation[4](33,12) = -1.0/256.0;
+ prolongation[4](33,16) = -5.0/256.0;
+ prolongation[4](33,20) = -1.0/256.0;
+ prolongation[4](33,32) = -15.0/256.0;
+ prolongation[4](33,34) = 5.0/256.0;
+ prolongation[4](33,36) = -15.0/256.0;
+ prolongation[4](33,38) = 5.0/256.0;
+ prolongation[4](33,40) = 45.0/256.0;
+ prolongation[4](33,42) = 45.0/256.0;
+ prolongation[4](33,48) = 9.0/256.0;
+ prolongation[4](33,50) = 9.0/256.0;
+ prolongation[4](33,56) = 135.0/256.0;
+ prolongation[4](33,58) = 135.0/256.0;
+ prolongation[4](33,60) = -45.0/256.0;
+ prolongation[4](33,62) = -45.0/256.0;
+ prolongation[4](34,10) = -1.0/256.0;
+ prolongation[4](34,14) = -5.0/256.0;
+ prolongation[4](34,18) = -1.0/256.0;
+ prolongation[4](34,22) = -5.0/256.0;
+ prolongation[4](34,32) = -15.0/256.0;
+ prolongation[4](34,33) = 5.0/256.0;
+ prolongation[4](34,36) = -15.0/256.0;
+ prolongation[4](34,37) = 5.0/256.0;
+ prolongation[4](34,44) = 9.0/256.0;
+ prolongation[4](34,45) = 9.0/256.0;
+ prolongation[4](34,52) = 45.0/256.0;
+ prolongation[4](34,53) = 45.0/256.0;
+ prolongation[4](34,56) = 135.0/256.0;
+ prolongation[4](34,57) = -45.0/256.0;
+ prolongation[4](34,58) = 135.0/256.0;
+ prolongation[4](34,59) = -45.0/256.0;
+ prolongation[4](35,32) = -1.0/16.0;
+ prolongation[4](35,36) = -1.0/16.0;
+ prolongation[4](35,56) = 9.0/16.0;
+ prolongation[4](35,58) = 9.0/16.0;
+ prolongation[4](36,4) = 25.0/256.0;
+ prolongation[4](36,5) = 5.0/256.0;
+ prolongation[4](36,6) = 1.0/256.0;
+ prolongation[4](36,7) = 5.0/256.0;
+ prolongation[4](36,16) = 75.0/256.0;
+ prolongation[4](36,17) = -25.0/256.0;
+ prolongation[4](36,18) = 15.0/256.0;
+ prolongation[4](36,19) = -5.0/256.0;
+ prolongation[4](36,20) = 15.0/256.0;
+ prolongation[4](36,21) = -5.0/256.0;
+ prolongation[4](36,22) = 75.0/256.0;
+ prolongation[4](36,23) = -25.0/256.0;
+ prolongation[4](36,36) = 225.0/256.0;
+ prolongation[4](36,37) = -75.0/256.0;
+ prolongation[4](36,38) = -75.0/256.0;
+ prolongation[4](36,39) = 25.0/256.0;
+ prolongation[4](37,16) = 5.0/16.0;
+ prolongation[4](37,20) = 1.0/16.0;
+ prolongation[4](37,36) = 15.0/16.0;
+ prolongation[4](37,38) = -5.0/16.0;
+ prolongation[4](38,18) = 1.0/16.0;
+ prolongation[4](38,22) = 5.0/16.0;
+ prolongation[4](38,36) = 15.0/16.0;
+ prolongation[4](38,37) = -5.0/16.0;
+ prolongation[4](39,36) = 1.0;
+ prolongation[4](40,25) = 5.0/16.0;
+ prolongation[4](40,27) = 1.0/16.0;
+ prolongation[4](40,42) = 15.0/16.0;
+ prolongation[4](40,43) = -5.0/16.0;
+ prolongation[4](41,42) = 1.0;
+ prolongation[4](42,0) = 5.0/256.0;
+ prolongation[4](42,1) = 1.0/256.0;
+ prolongation[4](42,4) = 25.0/256.0;
+ prolongation[4](42,5) = 5.0/256.0;
+ prolongation[4](42,8) = 15.0/256.0;
+ prolongation[4](42,9) = -5.0/256.0;
+ prolongation[4](42,16) = 75.0/256.0;
+ prolongation[4](42,17) = -25.0/256.0;
+ prolongation[4](42,24) = -25.0/256.0;
+ prolongation[4](42,25) = 75.0/256.0;
+ prolongation[4](42,26) = -5.0/256.0;
+ prolongation[4](42,27) = 15.0/256.0;
+ prolongation[4](42,40) = -75.0/256.0;
+ prolongation[4](42,41) = 25.0/256.0;
+ prolongation[4](42,42) = 225.0/256.0;
+ prolongation[4](42,43) = -75.0/256.0;
+ prolongation[4](43,8) = 1.0/16.0;
+ prolongation[4](43,16) = 5.0/16.0;
+ prolongation[4](43,40) = -5.0/16.0;
+ prolongation[4](43,42) = 15.0/16.0;
+ prolongation[4](44,25) = -5.0/256.0;
+ prolongation[4](44,27) = -5.0/256.0;
+ prolongation[4](44,29) = -1.0/256.0;
+ prolongation[4](44,31) = -1.0/256.0;
+ prolongation[4](44,42) = 45.0/256.0;
+ prolongation[4](44,43) = 45.0/256.0;
+ prolongation[4](44,45) = -15.0/256.0;
+ prolongation[4](44,47) = 5.0/256.0;
+ prolongation[4](44,50) = 9.0/256.0;
+ prolongation[4](44,51) = 9.0/256.0;
+ prolongation[4](44,53) = -15.0/256.0;
+ prolongation[4](44,55) = 5.0/256.0;
+ prolongation[4](44,58) = 135.0/256.0;
+ prolongation[4](44,59) = 135.0/256.0;
+ prolongation[4](44,62) = -45.0/256.0;
+ prolongation[4](44,63) = -45.0/256.0;
+ prolongation[4](45,0) = -5.0/4096.0;
+ prolongation[4](45,1) = -5.0/4096.0;
+ prolongation[4](45,2) = -1.0/4096.0;
+ prolongation[4](45,3) = -1.0/4096.0;
+ prolongation[4](45,4) = -25.0/4096.0;
+ prolongation[4](45,5) = -25.0/4096.0;
+ prolongation[4](45,6) = -5.0/4096.0;
+ prolongation[4](45,7) = -5.0/4096.0;
+ prolongation[4](45,8) = 45.0/4096.0;
+ prolongation[4](45,9) = 45.0/4096.0;
+ prolongation[4](45,10) = -15.0/4096.0;
+ prolongation[4](45,11) = 5.0/4096.0;
+ prolongation[4](45,12) = 9.0/4096.0;
+ prolongation[4](45,13) = 9.0/4096.0;
+ prolongation[4](45,14) = -15.0/4096.0;
+ prolongation[4](45,15) = 5.0/4096.0;
+ prolongation[4](45,16) = 225.0/4096.0;
+ prolongation[4](45,17) = 225.0/4096.0;
+ prolongation[4](45,18) = -75.0/4096.0;
+ prolongation[4](45,19) = 25.0/4096.0;
+ prolongation[4](45,20) = 45.0/4096.0;
+ prolongation[4](45,21) = 45.0/4096.0;
+ prolongation[4](45,22) = -75.0/4096.0;
+ prolongation[4](45,23) = 25.0/4096.0;
+ prolongation[4](45,24) = 25.0/4096.0;
+ prolongation[4](45,25) = -75.0/4096.0;
+ prolongation[4](45,26) = 25.0/4096.0;
+ prolongation[4](45,27) = -75.0/4096.0;
+ prolongation[4](45,28) = 5.0/4096.0;
+ prolongation[4](45,29) = -15.0/4096.0;
+ prolongation[4](45,30) = 5.0/4096.0;
+ prolongation[4](45,31) = -15.0/4096.0;
+ prolongation[4](45,32) = 135.0/4096.0;
+ prolongation[4](45,33) = 135.0/4096.0;
+ prolongation[4](45,34) = -45.0/4096.0;
+ prolongation[4](45,35) = -45.0/4096.0;
+ prolongation[4](45,36) = 675.0/4096.0;
+ prolongation[4](45,37) = 675.0/4096.0;
+ prolongation[4](45,38) = -225.0/4096.0;
+ prolongation[4](45,39) = -225.0/4096.0;
+ prolongation[4](45,40) = -225.0/4096.0;
+ prolongation[4](45,41) = -225.0/4096.0;
+ prolongation[4](45,42) = 675.0/4096.0;
+ prolongation[4](45,43) = 675.0/4096.0;
+ prolongation[4](45,44) = 75.0/4096.0;
+ prolongation[4](45,45) = -225.0/4096.0;
+ prolongation[4](45,46) = -25.0/4096.0;
+ prolongation[4](45,47) = 75.0/4096.0;
+ prolongation[4](45,48) = -45.0/4096.0;
+ prolongation[4](45,49) = -45.0/4096.0;
+ prolongation[4](45,50) = 135.0/4096.0;
+ prolongation[4](45,51) = 135.0/4096.0;
+ prolongation[4](45,52) = 75.0/4096.0;
+ prolongation[4](45,53) = -225.0/4096.0;
+ prolongation[4](45,54) = -25.0/4096.0;
+ prolongation[4](45,55) = 75.0/4096.0;
+ prolongation[4](45,56) = -675.0/4096.0;
+ prolongation[4](45,57) = -675.0/4096.0;
+ prolongation[4](45,58) = 2025.0/4096.0;
+ prolongation[4](45,59) = 2025.0/4096.0;
+ prolongation[4](45,60) = 225.0/4096.0;
+ prolongation[4](45,61) = 225.0/4096.0;
+ prolongation[4](45,62) = -675.0/4096.0;
+ prolongation[4](45,63) = -675.0/4096.0;
+ prolongation[4](46,45) = -1.0/16.0;
+ prolongation[4](46,53) = -1.0/16.0;
+ prolongation[4](46,58) = 9.0/16.0;
+ prolongation[4](46,59) = 9.0/16.0;
+ prolongation[4](47,10) = -1.0/256.0;
+ prolongation[4](47,14) = -1.0/256.0;
+ prolongation[4](47,18) = -5.0/256.0;
+ prolongation[4](47,22) = -5.0/256.0;
+ prolongation[4](47,32) = 9.0/256.0;
+ prolongation[4](47,33) = 9.0/256.0;
+ prolongation[4](47,36) = 45.0/256.0;
+ prolongation[4](47,37) = 45.0/256.0;
+ prolongation[4](47,44) = 5.0/256.0;
+ prolongation[4](47,45) = -15.0/256.0;
+ prolongation[4](47,52) = 5.0/256.0;
+ prolongation[4](47,53) = -15.0/256.0;
+ prolongation[4](47,56) = -45.0/256.0;
+ prolongation[4](47,57) = -45.0/256.0;
+ prolongation[4](47,58) = 135.0/256.0;
+ prolongation[4](47,59) = 135.0/256.0;
+ prolongation[4](48,25) = -5.0/256.0;
+ prolongation[4](48,27) = -1.0/256.0;
+ prolongation[4](48,29) = -1.0/256.0;
+ prolongation[4](48,31) = -5.0/256.0;
+ prolongation[4](48,42) = -15.0/256.0;
+ prolongation[4](48,43) = 5.0/256.0;
+ prolongation[4](48,45) = 9.0/256.0;
+ prolongation[4](48,47) = 9.0/256.0;
+ prolongation[4](48,50) = -15.0/256.0;
+ prolongation[4](48,51) = 5.0/256.0;
+ prolongation[4](48,53) = 45.0/256.0;
+ prolongation[4](48,55) = 45.0/256.0;
+ prolongation[4](48,58) = 135.0/256.0;
+ prolongation[4](48,59) = -45.0/256.0;
+ prolongation[4](48,62) = 135.0/256.0;
+ prolongation[4](48,63) = -45.0/256.0;
+ prolongation[4](49,42) = -1.0/16.0;
+ prolongation[4](49,50) = -1.0/16.0;
+ prolongation[4](49,58) = 9.0/16.0;
+ prolongation[4](49,62) = 9.0/16.0;
+ prolongation[4](50,0) = -5.0/4096.0;
+ prolongation[4](50,1) = -1.0/4096.0;
+ prolongation[4](50,2) = -1.0/4096.0;
+ prolongation[4](50,3) = -5.0/4096.0;
+ prolongation[4](50,4) = -25.0/4096.0;
+ prolongation[4](50,5) = -5.0/4096.0;
+ prolongation[4](50,6) = -5.0/4096.0;
+ prolongation[4](50,7) = -25.0/4096.0;
+ prolongation[4](50,8) = -15.0/4096.0;
+ prolongation[4](50,9) = 5.0/4096.0;
+ prolongation[4](50,10) = 9.0/4096.0;
+ prolongation[4](50,11) = 9.0/4096.0;
+ prolongation[4](50,12) = -15.0/4096.0;
+ prolongation[4](50,13) = 5.0/4096.0;
+ prolongation[4](50,14) = 45.0/4096.0;
+ prolongation[4](50,15) = 45.0/4096.0;
+ prolongation[4](50,16) = -75.0/4096.0;
+ prolongation[4](50,17) = 25.0/4096.0;
+ prolongation[4](50,18) = 45.0/4096.0;
+ prolongation[4](50,19) = 45.0/4096.0;
+ prolongation[4](50,20) = -75.0/4096.0;
+ prolongation[4](50,21) = 25.0/4096.0;
+ prolongation[4](50,22) = 225.0/4096.0;
+ prolongation[4](50,23) = 225.0/4096.0;
+ prolongation[4](50,24) = 25.0/4096.0;
+ prolongation[4](50,25) = -75.0/4096.0;
+ prolongation[4](50,26) = 5.0/4096.0;
+ prolongation[4](50,27) = -15.0/4096.0;
+ prolongation[4](50,28) = 5.0/4096.0;
+ prolongation[4](50,29) = -15.0/4096.0;
+ prolongation[4](50,30) = 25.0/4096.0;
+ prolongation[4](50,31) = -75.0/4096.0;
+ prolongation[4](50,32) = 135.0/4096.0;
+ prolongation[4](50,33) = -45.0/4096.0;
+ prolongation[4](50,34) = 135.0/4096.0;
+ prolongation[4](50,35) = -45.0/4096.0;
+ prolongation[4](50,36) = 675.0/4096.0;
+ prolongation[4](50,37) = -225.0/4096.0;
+ prolongation[4](50,38) = 675.0/4096.0;
+ prolongation[4](50,39) = -225.0/4096.0;
+ prolongation[4](50,40) = 75.0/4096.0;
+ prolongation[4](50,41) = -25.0/4096.0;
+ prolongation[4](50,42) = -225.0/4096.0;
+ prolongation[4](50,43) = 75.0/4096.0;
+ prolongation[4](50,44) = -45.0/4096.0;
+ prolongation[4](50,45) = 135.0/4096.0;
+ prolongation[4](50,46) = -45.0/4096.0;
+ prolongation[4](50,47) = 135.0/4096.0;
+ prolongation[4](50,48) = 75.0/4096.0;
+ prolongation[4](50,49) = -25.0/4096.0;
+ prolongation[4](50,50) = -225.0/4096.0;
+ prolongation[4](50,51) = 75.0/4096.0;
+ prolongation[4](50,52) = -225.0/4096.0;
+ prolongation[4](50,53) = 675.0/4096.0;
+ prolongation[4](50,54) = -225.0/4096.0;
+ prolongation[4](50,55) = 675.0/4096.0;
+ prolongation[4](50,56) = -675.0/4096.0;
+ prolongation[4](50,57) = 225.0/4096.0;
+ prolongation[4](50,58) = 2025.0/4096.0;
+ prolongation[4](50,59) = -675.0/4096.0;
+ prolongation[4](50,60) = -675.0/4096.0;
+ prolongation[4](50,61) = 225.0/4096.0;
+ prolongation[4](50,62) = 2025.0/4096.0;
+ prolongation[4](50,63) = -675.0/4096.0;
+ prolongation[4](51,8) = -1.0/256.0;
+ prolongation[4](51,12) = -1.0/256.0;
+ prolongation[4](51,16) = -5.0/256.0;
+ prolongation[4](51,20) = -5.0/256.0;
+ prolongation[4](51,32) = 9.0/256.0;
+ prolongation[4](51,34) = 9.0/256.0;
+ prolongation[4](51,36) = 45.0/256.0;
+ prolongation[4](51,38) = 45.0/256.0;
+ prolongation[4](51,40) = 5.0/256.0;
+ prolongation[4](51,42) = -15.0/256.0;
+ prolongation[4](51,48) = 5.0/256.0;
+ prolongation[4](51,50) = -15.0/256.0;
+ prolongation[4](51,56) = -45.0/256.0;
+ prolongation[4](51,58) = 135.0/256.0;
+ prolongation[4](51,60) = -45.0/256.0;
+ prolongation[4](51,62) = 135.0/256.0;
+ prolongation[4](52,25) = 5.0/16.0;
+ prolongation[4](52,31) = 1.0/16.0;
+ prolongation[4](52,53) = 15.0/16.0;
+ prolongation[4](52,55) = -5.0/16.0;
+ prolongation[4](53,0) = 5.0/256.0;
+ prolongation[4](53,3) = 1.0/256.0;
+ prolongation[4](53,4) = 25.0/256.0;
+ prolongation[4](53,7) = 5.0/256.0;
+ prolongation[4](53,14) = 15.0/256.0;
+ prolongation[4](53,15) = -5.0/256.0;
+ prolongation[4](53,22) = 75.0/256.0;
+ prolongation[4](53,23) = -25.0/256.0;
+ prolongation[4](53,24) = -25.0/256.0;
+ prolongation[4](53,25) = 75.0/256.0;
+ prolongation[4](53,30) = -5.0/256.0;
+ prolongation[4](53,31) = 15.0/256.0;
+ prolongation[4](53,52) = -75.0/256.0;
+ prolongation[4](53,53) = 225.0/256.0;
+ prolongation[4](53,54) = 25.0/256.0;
+ prolongation[4](53,55) = -75.0/256.0;
+ prolongation[4](54,53) = 1.0;
+ prolongation[4](55,14) = 1.0/16.0;
+ prolongation[4](55,22) = 5.0/16.0;
+ prolongation[4](55,52) = -5.0/16.0;
+ prolongation[4](55,53) = 15.0/16.0;
+ prolongation[4](56,25) = 25.0/256.0;
+ prolongation[4](56,27) = 5.0/256.0;
+ prolongation[4](56,29) = 1.0/256.0;
+ prolongation[4](56,31) = 5.0/256.0;
+ prolongation[4](56,42) = 75.0/256.0;
+ prolongation[4](56,43) = -25.0/256.0;
+ prolongation[4](56,45) = 15.0/256.0;
+ prolongation[4](56,47) = -5.0/256.0;
+ prolongation[4](56,50) = 15.0/256.0;
+ prolongation[4](56,51) = -5.0/256.0;
+ prolongation[4](56,53) = 75.0/256.0;
+ prolongation[4](56,55) = -25.0/256.0;
+ prolongation[4](56,58) = 225.0/256.0;
+ prolongation[4](56,59) = -75.0/256.0;
+ prolongation[4](56,62) = -75.0/256.0;
+ prolongation[4](56,63) = 25.0/256.0;
+ prolongation[4](57,42) = 5.0/16.0;
+ prolongation[4](57,50) = 1.0/16.0;
+ prolongation[4](57,58) = 15.0/16.0;
+ prolongation[4](57,62) = -5.0/16.0;
+ prolongation[4](58,0) = 25.0/4096.0;
+ prolongation[4](58,1) = 5.0/4096.0;
+ prolongation[4](58,2) = 1.0/4096.0;
+ prolongation[4](58,3) = 5.0/4096.0;
+ prolongation[4](58,4) = 125.0/4096.0;
+ prolongation[4](58,5) = 25.0/4096.0;
+ prolongation[4](58,6) = 5.0/4096.0;
+ prolongation[4](58,7) = 25.0/4096.0;
+ prolongation[4](58,8) = 75.0/4096.0;
+ prolongation[4](58,9) = -25.0/4096.0;
+ prolongation[4](58,10) = 15.0/4096.0;
+ prolongation[4](58,11) = -5.0/4096.0;
+ prolongation[4](58,12) = 15.0/4096.0;
+ prolongation[4](58,13) = -5.0/4096.0;
+ prolongation[4](58,14) = 75.0/4096.0;
+ prolongation[4](58,15) = -25.0/4096.0;
+ prolongation[4](58,16) = 375.0/4096.0;
+ prolongation[4](58,17) = -125.0/4096.0;
+ prolongation[4](58,18) = 75.0/4096.0;
+ prolongation[4](58,19) = -25.0/4096.0;
+ prolongation[4](58,20) = 75.0/4096.0;
+ prolongation[4](58,21) = -25.0/4096.0;
+ prolongation[4](58,22) = 375.0/4096.0;
+ prolongation[4](58,23) = -125.0/4096.0;
+ prolongation[4](58,24) = -125.0/4096.0;
+ prolongation[4](58,25) = 375.0/4096.0;
+ prolongation[4](58,26) = -25.0/4096.0;
+ prolongation[4](58,27) = 75.0/4096.0;
+ prolongation[4](58,28) = -5.0/4096.0;
+ prolongation[4](58,29) = 15.0/4096.0;
+ prolongation[4](58,30) = -25.0/4096.0;
+ prolongation[4](58,31) = 75.0/4096.0;
+ prolongation[4](58,32) = 225.0/4096.0;
+ prolongation[4](58,33) = -75.0/4096.0;
+ prolongation[4](58,34) = -75.0/4096.0;
+ prolongation[4](58,35) = 25.0/4096.0;
+ prolongation[4](58,36) = 1125.0/4096.0;
+ prolongation[4](58,37) = -375.0/4096.0;
+ prolongation[4](58,38) = -375.0/4096.0;
+ prolongation[4](58,39) = 125.0/4096.0;
+ prolongation[4](58,40) = -375.0/4096.0;
+ prolongation[4](58,41) = 125.0/4096.0;
+ prolongation[4](58,42) = 1125.0/4096.0;
+ prolongation[4](58,43) = -375.0/4096.0;
+ prolongation[4](58,44) = -75.0/4096.0;
+ prolongation[4](58,45) = 225.0/4096.0;
+ prolongation[4](58,46) = 25.0/4096.0;
+ prolongation[4](58,47) = -75.0/4096.0;
+ prolongation[4](58,48) = -75.0/4096.0;
+ prolongation[4](58,49) = 25.0/4096.0;
+ prolongation[4](58,50) = 225.0/4096.0;
+ prolongation[4](58,51) = -75.0/4096.0;
+ prolongation[4](58,52) = -375.0/4096.0;
+ prolongation[4](58,53) = 1125.0/4096.0;
+ prolongation[4](58,54) = 125.0/4096.0;
+ prolongation[4](58,55) = -375.0/4096.0;
+ prolongation[4](58,56) = -1125.0/4096.0;
+ prolongation[4](58,57) = 375.0/4096.0;
+ prolongation[4](58,58) = 3375.0/4096.0;
+ prolongation[4](58,59) = -1125.0/4096.0;
+ prolongation[4](58,60) = 375.0/4096.0;
+ prolongation[4](58,61) = -125.0/4096.0;
+ prolongation[4](58,62) = -1125.0/4096.0;
+ prolongation[4](58,63) = 375.0/4096.0;
+ prolongation[4](59,8) = 5.0/256.0;
+ prolongation[4](59,12) = 1.0/256.0;
+ prolongation[4](59,16) = 25.0/256.0;
+ prolongation[4](59,20) = 5.0/256.0;
+ prolongation[4](59,32) = 15.0/256.0;
+ prolongation[4](59,34) = -5.0/256.0;
+ prolongation[4](59,36) = 75.0/256.0;
+ prolongation[4](59,38) = -25.0/256.0;
+ prolongation[4](59,40) = -25.0/256.0;
+ prolongation[4](59,42) = 75.0/256.0;
+ prolongation[4](59,48) = -5.0/256.0;
+ prolongation[4](59,50) = 15.0/256.0;
+ prolongation[4](59,56) = -75.0/256.0;
+ prolongation[4](59,58) = 225.0/256.0;
+ prolongation[4](59,60) = 25.0/256.0;
+ prolongation[4](59,62) = -75.0/256.0;
+ prolongation[4](60,45) = 1.0/16.0;
+ prolongation[4](60,53) = 5.0/16.0;
+ prolongation[4](60,58) = 15.0/16.0;
+ prolongation[4](60,59) = -5.0/16.0;
+ prolongation[4](61,58) = 1.0;
+ prolongation[4](62,10) = 1.0/256.0;
+ prolongation[4](62,14) = 5.0/256.0;
+ prolongation[4](62,18) = 5.0/256.0;
+ prolongation[4](62,22) = 25.0/256.0;
+ prolongation[4](62,32) = 15.0/256.0;
+ prolongation[4](62,33) = -5.0/256.0;
+ prolongation[4](62,36) = 75.0/256.0;
+ prolongation[4](62,37) = -25.0/256.0;
+ prolongation[4](62,44) = -5.0/256.0;
+ prolongation[4](62,45) = 15.0/256.0;
+ prolongation[4](62,52) = -25.0/256.0;
+ prolongation[4](62,53) = 75.0/256.0;
+ prolongation[4](62,56) = -75.0/256.0;
+ prolongation[4](62,57) = 25.0/256.0;
+ prolongation[4](62,58) = 225.0/256.0;
+ prolongation[4](62,59) = -75.0/256.0;
+ prolongation[4](63,32) = 1.0/16.0;
+ prolongation[4](63,36) = 5.0/16.0;
+ prolongation[4](63,56) = -5.0/16.0;
+ prolongation[4](63,58) = 15.0/16.0;
+ prolongation[5](0,0) = 1.0/256.0;
+ prolongation[5](0,1) = 1.0/256.0;
+ prolongation[5](0,4) = 1.0/256.0;
+ prolongation[5](0,5) = 1.0/256.0;
+ prolongation[5](0,8) = -9.0/256.0;
+ prolongation[5](0,9) = -9.0/256.0;
+ prolongation[5](0,16) = -9.0/256.0;
+ prolongation[5](0,17) = -9.0/256.0;
+ prolongation[5](0,24) = -9.0/256.0;
+ prolongation[5](0,25) = -9.0/256.0;
+ prolongation[5](0,26) = -9.0/256.0;
+ prolongation[5](0,27) = -9.0/256.0;
+ prolongation[5](0,40) = 81.0/256.0;
+ prolongation[5](0,41) = 81.0/256.0;
+ prolongation[5](0,42) = 81.0/256.0;
+ prolongation[5](0,43) = 81.0/256.0;
+ prolongation[5](1,1) = -1.0/16.0;
+ prolongation[5](1,5) = -1.0/16.0;
+ prolongation[5](1,26) = 9.0/16.0;
+ prolongation[5](1,27) = 9.0/16.0;
+ prolongation[5](2,1) = 1.0/256.0;
+ prolongation[5](2,2) = 1.0/256.0;
+ prolongation[5](2,5) = 1.0/256.0;
+ prolongation[5](2,6) = 1.0/256.0;
+ prolongation[5](2,10) = -9.0/256.0;
+ prolongation[5](2,11) = -9.0/256.0;
+ prolongation[5](2,18) = -9.0/256.0;
+ prolongation[5](2,19) = -9.0/256.0;
+ prolongation[5](2,26) = -9.0/256.0;
+ prolongation[5](2,27) = -9.0/256.0;
+ prolongation[5](2,28) = -9.0/256.0;
+ prolongation[5](2,29) = -9.0/256.0;
+ prolongation[5](2,44) = 81.0/256.0;
+ prolongation[5](2,45) = 81.0/256.0;
+ prolongation[5](2,46) = 81.0/256.0;
+ prolongation[5](2,47) = 81.0/256.0;
+ prolongation[5](3,0) = -1.0/4096.0;
+ prolongation[5](3,1) = -1.0/4096.0;
+ prolongation[5](3,2) = -1.0/4096.0;
+ prolongation[5](3,3) = -1.0/4096.0;
+ prolongation[5](3,4) = -1.0/4096.0;
+ prolongation[5](3,5) = -1.0/4096.0;
+ prolongation[5](3,6) = -1.0/4096.0;
+ prolongation[5](3,7) = -1.0/4096.0;
+ prolongation[5](3,8) = 9.0/4096.0;
+ prolongation[5](3,9) = 9.0/4096.0;
+ prolongation[5](3,10) = 9.0/4096.0;
+ prolongation[5](3,11) = 9.0/4096.0;
+ prolongation[5](3,12) = 9.0/4096.0;
+ prolongation[5](3,13) = 9.0/4096.0;
+ prolongation[5](3,14) = 9.0/4096.0;
+ prolongation[5](3,15) = 9.0/4096.0;
+ prolongation[5](3,16) = 9.0/4096.0;
+ prolongation[5](3,17) = 9.0/4096.0;
+ prolongation[5](3,18) = 9.0/4096.0;
+ prolongation[5](3,19) = 9.0/4096.0;
+ prolongation[5](3,20) = 9.0/4096.0;
+ prolongation[5](3,21) = 9.0/4096.0;
+ prolongation[5](3,22) = 9.0/4096.0;
+ prolongation[5](3,23) = 9.0/4096.0;
+ prolongation[5](3,24) = 9.0/4096.0;
+ prolongation[5](3,25) = 9.0/4096.0;
+ prolongation[5](3,26) = 9.0/4096.0;
+ prolongation[5](3,27) = 9.0/4096.0;
+ prolongation[5](3,28) = 9.0/4096.0;
+ prolongation[5](3,29) = 9.0/4096.0;
+ prolongation[5](3,30) = 9.0/4096.0;
+ prolongation[5](3,31) = 9.0/4096.0;
+ prolongation[5](3,32) = -81.0/4096.0;
+ prolongation[5](3,33) = -81.0/4096.0;
+ prolongation[5](3,34) = -81.0/4096.0;
+ prolongation[5](3,35) = -81.0/4096.0;
+ prolongation[5](3,36) = -81.0/4096.0;
+ prolongation[5](3,37) = -81.0/4096.0;
+ prolongation[5](3,38) = -81.0/4096.0;
+ prolongation[5](3,39) = -81.0/4096.0;
+ prolongation[5](3,40) = -81.0/4096.0;
+ prolongation[5](3,41) = -81.0/4096.0;
+ prolongation[5](3,42) = -81.0/4096.0;
+ prolongation[5](3,43) = -81.0/4096.0;
+ prolongation[5](3,44) = -81.0/4096.0;
+ prolongation[5](3,45) = -81.0/4096.0;
+ prolongation[5](3,46) = -81.0/4096.0;
+ prolongation[5](3,47) = -81.0/4096.0;
+ prolongation[5](3,48) = -81.0/4096.0;
+ prolongation[5](3,49) = -81.0/4096.0;
+ prolongation[5](3,50) = -81.0/4096.0;
+ prolongation[5](3,51) = -81.0/4096.0;
+ prolongation[5](3,52) = -81.0/4096.0;
+ prolongation[5](3,53) = -81.0/4096.0;
+ prolongation[5](3,54) = -81.0/4096.0;
+ prolongation[5](3,55) = -81.0/4096.0;
+ prolongation[5](3,56) = 729.0/4096.0;
+ prolongation[5](3,57) = 729.0/4096.0;
+ prolongation[5](3,58) = 729.0/4096.0;
+ prolongation[5](3,59) = 729.0/4096.0;
+ prolongation[5](3,60) = 729.0/4096.0;
+ prolongation[5](3,61) = 729.0/4096.0;
+ prolongation[5](3,62) = 729.0/4096.0;
+ prolongation[5](3,63) = 729.0/4096.0;
+ prolongation[5](4,4) = -1.0/16.0;
+ prolongation[5](4,5) = -1.0/16.0;
+ prolongation[5](4,16) = 9.0/16.0;
+ prolongation[5](4,17) = 9.0/16.0;
+ prolongation[5](5,5) = 1.0;
+ prolongation[5](6,5) = -1.0/16.0;
+ prolongation[5](6,6) = -1.0/16.0;
+ prolongation[5](6,18) = 9.0/16.0;
+ prolongation[5](6,19) = 9.0/16.0;
+ prolongation[5](7,4) = 1.0/256.0;
+ prolongation[5](7,5) = 1.0/256.0;
+ prolongation[5](7,6) = 1.0/256.0;
+ prolongation[5](7,7) = 1.0/256.0;
+ prolongation[5](7,16) = -9.0/256.0;
+ prolongation[5](7,17) = -9.0/256.0;
+ prolongation[5](7,18) = -9.0/256.0;
+ prolongation[5](7,19) = -9.0/256.0;
+ prolongation[5](7,20) = -9.0/256.0;
+ prolongation[5](7,21) = -9.0/256.0;
+ prolongation[5](7,22) = -9.0/256.0;
+ prolongation[5](7,23) = -9.0/256.0;
+ prolongation[5](7,36) = 81.0/256.0;
+ prolongation[5](7,37) = 81.0/256.0;
+ prolongation[5](7,38) = 81.0/256.0;
+ prolongation[5](7,39) = 81.0/256.0;
+ prolongation[5](8,9) = -1.0/16.0;
+ prolongation[5](8,17) = -1.0/16.0;
+ prolongation[5](8,41) = 9.0/16.0;
+ prolongation[5](8,43) = 9.0/16.0;
+ prolongation[5](9,0) = -1.0/256.0;
+ prolongation[5](9,1) = -5.0/256.0;
+ prolongation[5](9,4) = -1.0/256.0;
+ prolongation[5](9,5) = -5.0/256.0;
+ prolongation[5](9,8) = 5.0/256.0;
+ prolongation[5](9,9) = -15.0/256.0;
+ prolongation[5](9,16) = 5.0/256.0;
+ prolongation[5](9,17) = -15.0/256.0;
+ prolongation[5](9,24) = 9.0/256.0;
+ prolongation[5](9,25) = 9.0/256.0;
+ prolongation[5](9,26) = 45.0/256.0;
+ prolongation[5](9,27) = 45.0/256.0;
+ prolongation[5](9,40) = -45.0/256.0;
+ prolongation[5](9,41) = 135.0/256.0;
+ prolongation[5](9,42) = -45.0/256.0;
+ prolongation[5](9,43) = 135.0/256.0;
+ prolongation[5](10,1) = -5.0/256.0;
+ prolongation[5](10,2) = -1.0/256.0;
+ prolongation[5](10,5) = -5.0/256.0;
+ prolongation[5](10,6) = -1.0/256.0;
+ prolongation[5](10,10) = -15.0/256.0;
+ prolongation[5](10,11) = 5.0/256.0;
+ prolongation[5](10,18) = -15.0/256.0;
+ prolongation[5](10,19) = 5.0/256.0;
+ prolongation[5](10,26) = 45.0/256.0;
+ prolongation[5](10,27) = 45.0/256.0;
+ prolongation[5](10,28) = 9.0/256.0;
+ prolongation[5](10,29) = 9.0/256.0;
+ prolongation[5](10,44) = 135.0/256.0;
+ prolongation[5](10,45) = 135.0/256.0;
+ prolongation[5](10,46) = -45.0/256.0;
+ prolongation[5](10,47) = -45.0/256.0;
+ prolongation[5](11,10) = -1.0/16.0;
+ prolongation[5](11,18) = -1.0/16.0;
+ prolongation[5](11,44) = 9.0/16.0;
+ prolongation[5](11,45) = 9.0/16.0;
+ prolongation[5](12,9) = 1.0/256.0;
+ prolongation[5](12,13) = 1.0/256.0;
+ prolongation[5](12,17) = 1.0/256.0;
+ prolongation[5](12,21) = 1.0/256.0;
+ prolongation[5](12,33) = -9.0/256.0;
+ prolongation[5](12,35) = -9.0/256.0;
+ prolongation[5](12,37) = -9.0/256.0;
+ prolongation[5](12,39) = -9.0/256.0;
+ prolongation[5](12,41) = -9.0/256.0;
+ prolongation[5](12,43) = -9.0/256.0;
+ prolongation[5](12,49) = -9.0/256.0;
+ prolongation[5](12,51) = -9.0/256.0;
+ prolongation[5](12,57) = 81.0/256.0;
+ prolongation[5](12,59) = 81.0/256.0;
+ prolongation[5](12,61) = 81.0/256.0;
+ prolongation[5](12,63) = 81.0/256.0;
+ prolongation[5](13,0) = 1.0/4096.0;
+ prolongation[5](13,1) = 5.0/4096.0;
+ prolongation[5](13,2) = 5.0/4096.0;
+ prolongation[5](13,3) = 1.0/4096.0;
+ prolongation[5](13,4) = 1.0/4096.0;
+ prolongation[5](13,5) = 5.0/4096.0;
+ prolongation[5](13,6) = 5.0/4096.0;
+ prolongation[5](13,7) = 1.0/4096.0;
+ prolongation[5](13,8) = -5.0/4096.0;
+ prolongation[5](13,9) = 15.0/4096.0;
+ prolongation[5](13,10) = -45.0/4096.0;
+ prolongation[5](13,11) = -45.0/4096.0;
+ prolongation[5](13,12) = -5.0/4096.0;
+ prolongation[5](13,13) = 15.0/4096.0;
+ prolongation[5](13,14) = -9.0/4096.0;
+ prolongation[5](13,15) = -9.0/4096.0;
+ prolongation[5](13,16) = -5.0/4096.0;
+ prolongation[5](13,17) = 15.0/4096.0;
+ prolongation[5](13,18) = -45.0/4096.0;
+ prolongation[5](13,19) = -45.0/4096.0;
+ prolongation[5](13,20) = -5.0/4096.0;
+ prolongation[5](13,21) = 15.0/4096.0;
+ prolongation[5](13,22) = -9.0/4096.0;
+ prolongation[5](13,23) = -9.0/4096.0;
+ prolongation[5](13,24) = -9.0/4096.0;
+ prolongation[5](13,25) = -9.0/4096.0;
+ prolongation[5](13,26) = -45.0/4096.0;
+ prolongation[5](13,27) = -45.0/4096.0;
+ prolongation[5](13,28) = -45.0/4096.0;
+ prolongation[5](13,29) = -45.0/4096.0;
+ prolongation[5](13,30) = -9.0/4096.0;
+ prolongation[5](13,31) = -9.0/4096.0;
+ prolongation[5](13,32) = 45.0/4096.0;
+ prolongation[5](13,33) = -135.0/4096.0;
+ prolongation[5](13,34) = 45.0/4096.0;
+ prolongation[5](13,35) = -135.0/4096.0;
+ prolongation[5](13,36) = 45.0/4096.0;
+ prolongation[5](13,37) = -135.0/4096.0;
+ prolongation[5](13,38) = 45.0/4096.0;
+ prolongation[5](13,39) = -135.0/4096.0;
+ prolongation[5](13,40) = 45.0/4096.0;
+ prolongation[5](13,41) = -135.0/4096.0;
+ prolongation[5](13,42) = 45.0/4096.0;
+ prolongation[5](13,43) = -135.0/4096.0;
+ prolongation[5](13,44) = 405.0/4096.0;
+ prolongation[5](13,45) = 405.0/4096.0;
+ prolongation[5](13,46) = 405.0/4096.0;
+ prolongation[5](13,47) = 405.0/4096.0;
+ prolongation[5](13,48) = 45.0/4096.0;
+ prolongation[5](13,49) = -135.0/4096.0;
+ prolongation[5](13,50) = 45.0/4096.0;
+ prolongation[5](13,51) = -135.0/4096.0;
+ prolongation[5](13,52) = 81.0/4096.0;
+ prolongation[5](13,53) = 81.0/4096.0;
+ prolongation[5](13,54) = 81.0/4096.0;
+ prolongation[5](13,55) = 81.0/4096.0;
+ prolongation[5](13,56) = -405.0/4096.0;
+ prolongation[5](13,57) = 1215.0/4096.0;
+ prolongation[5](13,58) = -405.0/4096.0;
+ prolongation[5](13,59) = 1215.0/4096.0;
+ prolongation[5](13,60) = -405.0/4096.0;
+ prolongation[5](13,61) = 1215.0/4096.0;
+ prolongation[5](13,62) = -405.0/4096.0;
+ prolongation[5](13,63) = 1215.0/4096.0;
+ prolongation[5](14,0) = 5.0/4096.0;
+ prolongation[5](14,1) = 5.0/4096.0;
+ prolongation[5](14,2) = 1.0/4096.0;
+ prolongation[5](14,3) = 1.0/4096.0;
+ prolongation[5](14,4) = 5.0/4096.0;
+ prolongation[5](14,5) = 5.0/4096.0;
+ prolongation[5](14,6) = 1.0/4096.0;
+ prolongation[5](14,7) = 1.0/4096.0;
+ prolongation[5](14,8) = -45.0/4096.0;
+ prolongation[5](14,9) = -45.0/4096.0;
+ prolongation[5](14,10) = 15.0/4096.0;
+ prolongation[5](14,11) = -5.0/4096.0;
+ prolongation[5](14,12) = -9.0/4096.0;
+ prolongation[5](14,13) = -9.0/4096.0;
+ prolongation[5](14,14) = 15.0/4096.0;
+ prolongation[5](14,15) = -5.0/4096.0;
+ prolongation[5](14,16) = -45.0/4096.0;
+ prolongation[5](14,17) = -45.0/4096.0;
+ prolongation[5](14,18) = 15.0/4096.0;
+ prolongation[5](14,19) = -5.0/4096.0;
+ prolongation[5](14,20) = -9.0/4096.0;
+ prolongation[5](14,21) = -9.0/4096.0;
+ prolongation[5](14,22) = 15.0/4096.0;
+ prolongation[5](14,23) = -5.0/4096.0;
+ prolongation[5](14,24) = -45.0/4096.0;
+ prolongation[5](14,25) = -45.0/4096.0;
+ prolongation[5](14,26) = -45.0/4096.0;
+ prolongation[5](14,27) = -45.0/4096.0;
+ prolongation[5](14,28) = -9.0/4096.0;
+ prolongation[5](14,29) = -9.0/4096.0;
+ prolongation[5](14,30) = -9.0/4096.0;
+ prolongation[5](14,31) = -9.0/4096.0;
+ prolongation[5](14,32) = -135.0/4096.0;
+ prolongation[5](14,33) = -135.0/4096.0;
+ prolongation[5](14,34) = 45.0/4096.0;
+ prolongation[5](14,35) = 45.0/4096.0;
+ prolongation[5](14,36) = -135.0/4096.0;
+ prolongation[5](14,37) = -135.0/4096.0;
+ prolongation[5](14,38) = 45.0/4096.0;
+ prolongation[5](14,39) = 45.0/4096.0;
+ prolongation[5](14,40) = 405.0/4096.0;
+ prolongation[5](14,41) = 405.0/4096.0;
+ prolongation[5](14,42) = 405.0/4096.0;
+ prolongation[5](14,43) = 405.0/4096.0;
+ prolongation[5](14,44) = -135.0/4096.0;
+ prolongation[5](14,45) = -135.0/4096.0;
+ prolongation[5](14,46) = 45.0/4096.0;
+ prolongation[5](14,47) = 45.0/4096.0;
+ prolongation[5](14,48) = 81.0/4096.0;
+ prolongation[5](14,49) = 81.0/4096.0;
+ prolongation[5](14,50) = 81.0/4096.0;
+ prolongation[5](14,51) = 81.0/4096.0;
+ prolongation[5](14,52) = -135.0/4096.0;
+ prolongation[5](14,53) = -135.0/4096.0;
+ prolongation[5](14,54) = 45.0/4096.0;
+ prolongation[5](14,55) = 45.0/4096.0;
+ prolongation[5](14,56) = 1215.0/4096.0;
+ prolongation[5](14,57) = 1215.0/4096.0;
+ prolongation[5](14,58) = 1215.0/4096.0;
+ prolongation[5](14,59) = 1215.0/4096.0;
+ prolongation[5](14,60) = -405.0/4096.0;
+ prolongation[5](14,61) = -405.0/4096.0;
+ prolongation[5](14,62) = -405.0/4096.0;
+ prolongation[5](14,63) = -405.0/4096.0;
+ prolongation[5](15,10) = 1.0/256.0;
+ prolongation[5](15,14) = 1.0/256.0;
+ prolongation[5](15,18) = 1.0/256.0;
+ prolongation[5](15,22) = 1.0/256.0;
+ prolongation[5](15,32) = -9.0/256.0;
+ prolongation[5](15,33) = -9.0/256.0;
+ prolongation[5](15,36) = -9.0/256.0;
+ prolongation[5](15,37) = -9.0/256.0;
+ prolongation[5](15,44) = -9.0/256.0;
+ prolongation[5](15,45) = -9.0/256.0;
+ prolongation[5](15,52) = -9.0/256.0;
+ prolongation[5](15,53) = -9.0/256.0;
+ prolongation[5](15,56) = 81.0/256.0;
+ prolongation[5](15,57) = 81.0/256.0;
+ prolongation[5](15,58) = 81.0/256.0;
+ prolongation[5](15,59) = 81.0/256.0;
+ prolongation[5](16,17) = 1.0;
+ prolongation[5](17,4) = 1.0/16.0;
+ prolongation[5](17,5) = 5.0/16.0;
+ prolongation[5](17,16) = -5.0/16.0;
+ prolongation[5](17,17) = 15.0/16.0;
+ prolongation[5](18,5) = 5.0/16.0;
+ prolongation[5](18,6) = 1.0/16.0;
+ prolongation[5](18,18) = 15.0/16.0;
+ prolongation[5](18,19) = -5.0/16.0;
+ prolongation[5](19,18) = 1.0;
+ prolongation[5](20,17) = -1.0/16.0;
+ prolongation[5](20,21) = -1.0/16.0;
+ prolongation[5](20,37) = 9.0/16.0;
+ prolongation[5](20,39) = 9.0/16.0;
+ prolongation[5](21,4) = -1.0/256.0;
+ prolongation[5](21,5) = -5.0/256.0;
+ prolongation[5](21,6) = -5.0/256.0;
+ prolongation[5](21,7) = -1.0/256.0;
+ prolongation[5](21,16) = 5.0/256.0;
+ prolongation[5](21,17) = -15.0/256.0;
+ prolongation[5](21,18) = 45.0/256.0;
+ prolongation[5](21,19) = 45.0/256.0;
+ prolongation[5](21,20) = 5.0/256.0;
+ prolongation[5](21,21) = -15.0/256.0;
+ prolongation[5](21,22) = 9.0/256.0;
+ prolongation[5](21,23) = 9.0/256.0;
+ prolongation[5](21,36) = -45.0/256.0;
+ prolongation[5](21,37) = 135.0/256.0;
+ prolongation[5](21,38) = -45.0/256.0;
+ prolongation[5](21,39) = 135.0/256.0;
+ prolongation[5](22,4) = -5.0/256.0;
+ prolongation[5](22,5) = -5.0/256.0;
+ prolongation[5](22,6) = -1.0/256.0;
+ prolongation[5](22,7) = -1.0/256.0;
+ prolongation[5](22,16) = 45.0/256.0;
+ prolongation[5](22,17) = 45.0/256.0;
+ prolongation[5](22,18) = -15.0/256.0;
+ prolongation[5](22,19) = 5.0/256.0;
+ prolongation[5](22,20) = 9.0/256.0;
+ prolongation[5](22,21) = 9.0/256.0;
+ prolongation[5](22,22) = -15.0/256.0;
+ prolongation[5](22,23) = 5.0/256.0;
+ prolongation[5](22,36) = 135.0/256.0;
+ prolongation[5](22,37) = 135.0/256.0;
+ prolongation[5](22,38) = -45.0/256.0;
+ prolongation[5](22,39) = -45.0/256.0;
+ prolongation[5](23,18) = -1.0/16.0;
+ prolongation[5](23,22) = -1.0/16.0;
+ prolongation[5](23,36) = 9.0/16.0;
+ prolongation[5](23,37) = 9.0/16.0;
+ prolongation[5](24,25) = -1.0/16.0;
+ prolongation[5](24,27) = -1.0/16.0;
+ prolongation[5](24,42) = 9.0/16.0;
+ prolongation[5](24,43) = 9.0/16.0;
+ prolongation[5](25,0) = -1.0/256.0;
+ prolongation[5](25,1) = -1.0/256.0;
+ prolongation[5](25,4) = -5.0/256.0;
+ prolongation[5](25,5) = -5.0/256.0;
+ prolongation[5](25,8) = 9.0/256.0;
+ prolongation[5](25,9) = 9.0/256.0;
+ prolongation[5](25,16) = 45.0/256.0;
+ prolongation[5](25,17) = 45.0/256.0;
+ prolongation[5](25,24) = 5.0/256.0;
+ prolongation[5](25,25) = -15.0/256.0;
+ prolongation[5](25,26) = 5.0/256.0;
+ prolongation[5](25,27) = -15.0/256.0;
+ prolongation[5](25,40) = -45.0/256.0;
+ prolongation[5](25,41) = -45.0/256.0;
+ prolongation[5](25,42) = 135.0/256.0;
+ prolongation[5](25,43) = 135.0/256.0;
+ prolongation[5](26,27) = 1.0;
+ prolongation[5](27,1) = 1.0/16.0;
+ prolongation[5](27,5) = 5.0/16.0;
+ prolongation[5](27,26) = -5.0/16.0;
+ prolongation[5](27,27) = 15.0/16.0;
+ prolongation[5](28,27) = -1.0/16.0;
+ prolongation[5](28,29) = -1.0/16.0;
+ prolongation[5](28,45) = 9.0/16.0;
+ prolongation[5](28,47) = 9.0/16.0;
+ prolongation[5](29,1) = -1.0/256.0;
+ prolongation[5](29,2) = -1.0/256.0;
+ prolongation[5](29,5) = -5.0/256.0;
+ prolongation[5](29,6) = -5.0/256.0;
+ prolongation[5](29,10) = 9.0/256.0;
+ prolongation[5](29,11) = 9.0/256.0;
+ prolongation[5](29,18) = 45.0/256.0;
+ prolongation[5](29,19) = 45.0/256.0;
+ prolongation[5](29,26) = 5.0/256.0;
+ prolongation[5](29,27) = -15.0/256.0;
+ prolongation[5](29,28) = 5.0/256.0;
+ prolongation[5](29,29) = -15.0/256.0;
+ prolongation[5](29,44) = -45.0/256.0;
+ prolongation[5](29,45) = 135.0/256.0;
+ prolongation[5](29,46) = -45.0/256.0;
+ prolongation[5](29,47) = 135.0/256.0;
+ prolongation[5](30,25) = 1.0/256.0;
+ prolongation[5](30,27) = 1.0/256.0;
+ prolongation[5](30,29) = 1.0/256.0;
+ prolongation[5](30,31) = 1.0/256.0;
+ prolongation[5](30,42) = -9.0/256.0;
+ prolongation[5](30,43) = -9.0/256.0;
+ prolongation[5](30,45) = -9.0/256.0;
+ prolongation[5](30,47) = -9.0/256.0;
+ prolongation[5](30,50) = -9.0/256.0;
+ prolongation[5](30,51) = -9.0/256.0;
+ prolongation[5](30,53) = -9.0/256.0;
+ prolongation[5](30,55) = -9.0/256.0;
+ prolongation[5](30,58) = 81.0/256.0;
+ prolongation[5](30,59) = 81.0/256.0;
+ prolongation[5](30,62) = 81.0/256.0;
+ prolongation[5](30,63) = 81.0/256.0;
+ prolongation[5](31,0) = 1.0/4096.0;
+ prolongation[5](31,1) = 1.0/4096.0;
+ prolongation[5](31,2) = 1.0/4096.0;
+ prolongation[5](31,3) = 1.0/4096.0;
+ prolongation[5](31,4) = 5.0/4096.0;
+ prolongation[5](31,5) = 5.0/4096.0;
+ prolongation[5](31,6) = 5.0/4096.0;
+ prolongation[5](31,7) = 5.0/4096.0;
+ prolongation[5](31,8) = -9.0/4096.0;
+ prolongation[5](31,9) = -9.0/4096.0;
+ prolongation[5](31,10) = -9.0/4096.0;
+ prolongation[5](31,11) = -9.0/4096.0;
+ prolongation[5](31,12) = -9.0/4096.0;
+ prolongation[5](31,13) = -9.0/4096.0;
+ prolongation[5](31,14) = -9.0/4096.0;
+ prolongation[5](31,15) = -9.0/4096.0;
+ prolongation[5](31,16) = -45.0/4096.0;
+ prolongation[5](31,17) = -45.0/4096.0;
+ prolongation[5](31,18) = -45.0/4096.0;
+ prolongation[5](31,19) = -45.0/4096.0;
+ prolongation[5](31,20) = -45.0/4096.0;
+ prolongation[5](31,21) = -45.0/4096.0;
+ prolongation[5](31,22) = -45.0/4096.0;
+ prolongation[5](31,23) = -45.0/4096.0;
+ prolongation[5](31,24) = -5.0/4096.0;
+ prolongation[5](31,25) = 15.0/4096.0;
+ prolongation[5](31,26) = -5.0/4096.0;
+ prolongation[5](31,27) = 15.0/4096.0;
+ prolongation[5](31,28) = -5.0/4096.0;
+ prolongation[5](31,29) = 15.0/4096.0;
+ prolongation[5](31,30) = -5.0/4096.0;
+ prolongation[5](31,31) = 15.0/4096.0;
+ prolongation[5](31,32) = 81.0/4096.0;
+ prolongation[5](31,33) = 81.0/4096.0;
+ prolongation[5](31,34) = 81.0/4096.0;
+ prolongation[5](31,35) = 81.0/4096.0;
+ prolongation[5](31,36) = 405.0/4096.0;
+ prolongation[5](31,37) = 405.0/4096.0;
+ prolongation[5](31,38) = 405.0/4096.0;
+ prolongation[5](31,39) = 405.0/4096.0;
+ prolongation[5](31,40) = 45.0/4096.0;
+ prolongation[5](31,41) = 45.0/4096.0;
+ prolongation[5](31,42) = -135.0/4096.0;
+ prolongation[5](31,43) = -135.0/4096.0;
+ prolongation[5](31,44) = 45.0/4096.0;
+ prolongation[5](31,45) = -135.0/4096.0;
+ prolongation[5](31,46) = 45.0/4096.0;
+ prolongation[5](31,47) = -135.0/4096.0;
+ prolongation[5](31,48) = 45.0/4096.0;
+ prolongation[5](31,49) = 45.0/4096.0;
+ prolongation[5](31,50) = -135.0/4096.0;
+ prolongation[5](31,51) = -135.0/4096.0;
+ prolongation[5](31,52) = 45.0/4096.0;
+ prolongation[5](31,53) = -135.0/4096.0;
+ prolongation[5](31,54) = 45.0/4096.0;
+ prolongation[5](31,55) = -135.0/4096.0;
+ prolongation[5](31,56) = -405.0/4096.0;
+ prolongation[5](31,57) = -405.0/4096.0;
+ prolongation[5](31,58) = 1215.0/4096.0;
+ prolongation[5](31,59) = 1215.0/4096.0;
+ prolongation[5](31,60) = -405.0/4096.0;
+ prolongation[5](31,61) = -405.0/4096.0;
+ prolongation[5](31,62) = 1215.0/4096.0;
+ prolongation[5](31,63) = 1215.0/4096.0;
+ prolongation[5](32,9) = -5.0/256.0;
+ prolongation[5](32,13) = -1.0/256.0;
+ prolongation[5](32,17) = -5.0/256.0;
+ prolongation[5](32,21) = -1.0/256.0;
+ prolongation[5](32,33) = -15.0/256.0;
+ prolongation[5](32,35) = 5.0/256.0;
+ prolongation[5](32,37) = -15.0/256.0;
+ prolongation[5](32,39) = 5.0/256.0;
+ prolongation[5](32,41) = 45.0/256.0;
+ prolongation[5](32,43) = 45.0/256.0;
+ prolongation[5](32,49) = 9.0/256.0;
+ prolongation[5](32,51) = 9.0/256.0;
+ prolongation[5](32,57) = 135.0/256.0;
+ prolongation[5](32,59) = 135.0/256.0;
+ prolongation[5](32,61) = -45.0/256.0;
+ prolongation[5](32,63) = -45.0/256.0;
+ prolongation[5](33,0) = -5.0/4096.0;
+ prolongation[5](33,1) = -25.0/4096.0;
+ prolongation[5](33,2) = -5.0/4096.0;
+ prolongation[5](33,3) = -1.0/4096.0;
+ prolongation[5](33,4) = -5.0/4096.0;
+ prolongation[5](33,5) = -25.0/4096.0;
+ prolongation[5](33,6) = -5.0/4096.0;
+ prolongation[5](33,7) = -1.0/4096.0;
+ prolongation[5](33,8) = 25.0/4096.0;
+ prolongation[5](33,9) = -75.0/4096.0;
+ prolongation[5](33,10) = -75.0/4096.0;
+ prolongation[5](33,11) = 25.0/4096.0;
+ prolongation[5](33,12) = 5.0/4096.0;
+ prolongation[5](33,13) = -15.0/4096.0;
+ prolongation[5](33,14) = -15.0/4096.0;
+ prolongation[5](33,15) = 5.0/4096.0;
+ prolongation[5](33,16) = 25.0/4096.0;
+ prolongation[5](33,17) = -75.0/4096.0;
+ prolongation[5](33,18) = -75.0/4096.0;
+ prolongation[5](33,19) = 25.0/4096.0;
+ prolongation[5](33,20) = 5.0/4096.0;
+ prolongation[5](33,21) = -15.0/4096.0;
+ prolongation[5](33,22) = -15.0/4096.0;
+ prolongation[5](33,23) = 5.0/4096.0;
+ prolongation[5](33,24) = 45.0/4096.0;
+ prolongation[5](33,25) = 45.0/4096.0;
+ prolongation[5](33,26) = 225.0/4096.0;
+ prolongation[5](33,27) = 225.0/4096.0;
+ prolongation[5](33,28) = 45.0/4096.0;
+ prolongation[5](33,29) = 45.0/4096.0;
+ prolongation[5](33,30) = 9.0/4096.0;
+ prolongation[5](33,31) = 9.0/4096.0;
+ prolongation[5](33,32) = 75.0/4096.0;
+ prolongation[5](33,33) = -225.0/4096.0;
+ prolongation[5](33,34) = -25.0/4096.0;
+ prolongation[5](33,35) = 75.0/4096.0;
+ prolongation[5](33,36) = 75.0/4096.0;
+ prolongation[5](33,37) = -225.0/4096.0;
+ prolongation[5](33,38) = -25.0/4096.0;
+ prolongation[5](33,39) = 75.0/4096.0;
+ prolongation[5](33,40) = -225.0/4096.0;
+ prolongation[5](33,41) = 675.0/4096.0;
+ prolongation[5](33,42) = -225.0/4096.0;
+ prolongation[5](33,43) = 675.0/4096.0;
+ prolongation[5](33,44) = 675.0/4096.0;
+ prolongation[5](33,45) = 675.0/4096.0;
+ prolongation[5](33,46) = -225.0/4096.0;
+ prolongation[5](33,47) = -225.0/4096.0;
+ prolongation[5](33,48) = -45.0/4096.0;
+ prolongation[5](33,49) = 135.0/4096.0;
+ prolongation[5](33,50) = -45.0/4096.0;
+ prolongation[5](33,51) = 135.0/4096.0;
+ prolongation[5](33,52) = 135.0/4096.0;
+ prolongation[5](33,53) = 135.0/4096.0;
+ prolongation[5](33,54) = -45.0/4096.0;
+ prolongation[5](33,55) = -45.0/4096.0;
+ prolongation[5](33,56) = -675.0/4096.0;
+ prolongation[5](33,57) = 2025.0/4096.0;
+ prolongation[5](33,58) = -675.0/4096.0;
prolongation[5](33,59) = 2025.0/4096.0;
prolongation[5](33,60) = 225.0/4096.0;
prolongation[5](33,61) = -675.0/4096.0;
template <>
-void FEQ3<3>::get_unit_support_points (vector<Point<3> > &unit_points) const
+void FEQ3<3>::get_unit_support_points (
std::vector<Point<3> > &unit_points) const
{
Assert (unit_points.size() == dofs_per_cell,
ExcWrongFieldDimension (unit_points.size(), dofs_per_cell));
template <>
void FEQ3<3>::get_support_points (const typename DoFHandler<3>::cell_iterator &cell,
- vector<Point<3> > &support_points) const
+
std::vector<Point<3> > &support_points) const
{
Assert (support_points.size() == dofs_per_cell,
ExcWrongFieldDimension (support_points.size(), dofs_per_cell));
template <>
void FEQ3<3>::get_face_support_points (const typename DoFHandler<3>::face_iterator &face,
- vector<Point<3> > &support_points) const
+
std::vector<Point<3> > &support_points) const
{
Assert (support_points.size() == dofs_per_face,
ExcWrongFieldDimension (support_points.size(), dofs_per_face));
template <>
FEQ3<3>::FEQ3 () :
FEQ1Mapping<3> (1, 2, 4, 8, 1,
- vector<bool> (1, false))
+ std::vector<bool> (1, false))
{
Assert (false, ExcNotImplemented());
};
template <>
FEQ3<3>::FEQ3 (const int) :
FEQ1Mapping<3> (0, 0, 0, 64, 1,
- vector<bool> (1, true))
+ std::vector<bool> (1, true))
{
Assert (false, ExcNotImplemented());
};
template <>
-void FEQ3<3>::get_unit_support_points (vector<Point<3> > &) const
+void FEQ3<3>::get_unit_support_points (
std::vector<Point<3> > &) const
{
Assert (false, ExcNotImplemented());
};
template <>
void FEQ3<3>::get_support_points (const DoFHandler<3>::cell_iterator &,
- vector<Point<3> > &) const
+
std::vector<Point<3> > &) const
{
Assert (false, ExcNotImplemented());
};
template <>
void FEQ3<3>::get_face_support_points (const DoFHandler<3>::face_iterator &,
- vector<Point<3> > &) const
+
std::vector<Point<3> > &) const
{
Assert (false, ExcNotImplemented());
};
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
template <int dim>
void
FEDG_Q1<dim>::get_face_support_points (const typename DoFHandler<dim>::face_iterator &,
- vector<Point<dim> > &support_points) const
+
std::vector<Point<dim> > &support_points) const
{
Assert ((support_points.size() == 0),
FiniteElementBase<dim>::ExcWrongFieldDimension (support_points.size(),0));
template <int dim>
void
FEDG_Q2<dim>::get_face_support_points (const typename DoFHandler<dim>::face_iterator &,
-
vector<Point<dim> > &support_points) const
+
std::vector<Point<dim> > &support_points) const
{
Assert ((support_points.size() == 0),
FiniteElementBase<dim>::ExcWrongFieldDimension (support_points.size(),0));
template <int dim>
void
FEDG_Q3<dim>::get_face_support_points (const typename DoFHandler<dim>::face_iterator &,
- vector<Point<dim> > &support_points) const
+
std::vector<Point<dim> > &support_points) const
{
Assert ((support_points.size() == 0),
FiniteElementBase<dim>::ExcWrongFieldDimension (support_points.size(),0));
template <int dim>
void
FEDG_Q4<dim>::get_face_support_points (const typename DoFHandler<dim>::face_iterator &,
- vector<Point<dim> > &support_points) const
+
std::vector<Point<dim> > &support_points) const
{
Assert ((support_points.size() == 0),
FiniteElementBase<dim>::ExcWrongFieldDimension (support_points.size(),0));
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
(dim==2 ? 1 : 0),
(dim==3 ? 1 : 0),
1,
- vector<bool> (1, true))
+ std::vector<bool> (1, true))
{
for (unsigned int i=0; i<GeometryInfo<dim>::children_per_cell; ++i)
{
template <>
void
FEDG_Q0<1>::get_face_support_points (const DoFHandler<1>::face_iterator &,
- vector<Point<1> > &) const
+
std::vector<Point<1> > &) const
{
Assert (false, ExcInternalError());
};
inline
double
FEDG_Q0<dim>::shape_value (const unsigned int i,
- const Point<dim>&) const
+ const Point<dim>&) const
{
Assert((i<dofs_per_cell), ExcIndexRange(i, 0, dofs_per_cell));
return 1.;
template <int dim>
void
-FEDG_Q0<dim>::get_unit_support_points (vector<Point<dim> > &unit_points) const
+FEDG_Q0<dim>::get_unit_support_points (
std::vector<Point<dim> > &unit_points) const
{
Assert (unit_points.size() == dofs_per_cell,
FiniteElementBase<dim>::ExcWrongFieldDimension (unit_points.size(), dofs_per_cell));
template <int dim>
void
FEDG_Q0<dim>::get_support_points (const typename DoFHandler<dim>::cell_iterator &cell,
- vector<Point<dim> > &support_points) const
+
std::vector<Point<dim> > &support_points) const
{
Assert (support_points.size() == dofs_per_cell,
FiniteElementBase<dim>::ExcWrongFieldDimension (support_points.size(), dofs_per_cell));
template <int dim>
void
FEDG_Q0<dim>::get_face_support_points (const typename DoFHandler<dim>::face_iterator &,
- vector<Point<dim> > &support_points) const
+
std::vector<Point<dim> > &support_points) const
{
Assert ((support_points.size() == 0),
FiniteElementBase<dim>::ExcWrongFieldDimension (support_points.size(),0));
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
template <>
FEDG_P1<1>::FEDG_P1 () :
FEQ1Mapping<1> (0, 2, 0, 0, 1,
- vector<bool> (1, true))
+ std::vector<bool> (1, true))
{
// initialize_matrices ();
};
template <>
double
FEDG_P1<1>::shape_value(const unsigned int i,
- const Point<1> &p) const
+ const Point<1> &p) const
{
Assert((i<dofs_per_cell), ExcIndexRange(i, 0, dofs_per_cell));
switch (i)
{
- case 0: return 1.-p(0);
- case 1: return p(0);
+ case 0: return 1.-p(0);
+ case 1: return p(0);
}
return 0.;
}
inline
Tensor<1,1>
FEDG_P1<1>::shape_grad(const unsigned int i,
- const Point<1>&) const
+ const Point<1>&) const
{
Assert((i<dofs_per_cell), ExcIndexRange(i, 0, dofs_per_cell));
// originally, the return type of the
// however
switch (i)
{
- case 0: return Point<1>(-1.);
- case 1: return Point<1>(1.);
+ case 0: return Point<1>(-1.);
+ case 1: return Point<1>(1.);
}
return Point<1>();
};
template <>
-void FEDG_P1<1>::get_unit_support_points (vector<Point<1> > &support_points) const
+void FEDG_P1<1>::get_unit_support_points (
std::vector<Point<1> > &support_points) const
{
FiniteElement<1>::get_unit_support_points (support_points);
};
template <>
void FEDG_P1<1>::get_support_points (const DoFHandler<1>::cell_iterator &cell,
- vector<Point<1> > &support_points) const
+
std::vector<Point<1> > &support_points) const
{
FiniteElement<1>::get_support_points (cell, support_points);
};
template <>
void FEDG_P1<1>::get_face_support_points (const DoFHandler<1>::face_iterator &,
- vector<Point<1> > &) const
+
std::vector<Point<1> > &) const
{
Assert (false, ExcInternalError());
};
template <>
void FEDG_P1<1>::get_local_mass_matrix (const DoFHandler<1>::cell_iterator &cell,
- FullMatrix<double> &local_mass_matrix) const
+ FullMatrix<double> &local_mass_matrix) const
{
Assert (local_mass_matrix.n() == dofs_per_cell,
ExcWrongFieldDimension(local_mass_matrix.n(),dofs_per_cell));
template <>
FEDG_P1<2>::FEDG_P1 () :
FEQ1Mapping<2> (0, 0, 3, 0, 1,
- vector<bool> (1, true))
+ std::vector<bool> (1, true))
{
// initialize_matrices ();
};
inline
double
FEDG_P1<2>::shape_value (const unsigned int i,
- const Point<2>& p) const
+ const Point<2>& p) const
{
Assert((i<dofs_per_cell), ExcIndexRange(i, 0, dofs_per_cell));
switch (i)
inline
Tensor<1,2>
FEDG_P1<2>::shape_grad (const unsigned int i,
- const Point<2>&) const
+ const Point<2>&) const
{
Assert((i<dofs_per_cell), ExcIndexRange(i, 0, dofs_per_cell));
// originally, the return type of the
inline
Tensor<2,2>
FEDG_P1<2>::shape_grad_grad (const unsigned int i,
- const Point<2> &) const
+ const Point<2> &) const
{
Assert((i<dofs_per_cell), ExcIndexRange(i, 0, dofs_per_cell));
return Tensor<2,2>();
template <>
void FEDG_P1<2>::get_local_mass_matrix (const DoFHandler<2>::cell_iterator &,
- FullMatrix<double> &local_mass_matrix) const
+ FullMatrix<double> &local_mass_matrix) const
{
Assert(false, ExcNotImplemented ());
Assert (local_mass_matrix.n() == dofs_per_cell,
template <>
-void FEDG_P1<2>::get_unit_support_points (vector<Point<2> > &unit_points) const
+void FEDG_P1<2>::get_unit_support_points (
std::vector<Point<2> > &unit_points) const
{
Assert (unit_points.size() == dofs_per_cell,
ExcWrongFieldDimension (unit_points.size(), dofs_per_cell));
template <>
FEDG_P1<3>::FEDG_P1 () :
FEQ1Mapping<3> (0, 0, 0, 4, 1,
- vector<bool> (1, true))
+ std::vector<bool> (1, true))
{
// initialize_matrices ();
};
inline
Tensor<1,3>
FEDG_P1<3>::shape_grad (const unsigned int i,
- const Point<3>&) const
+ const Point<3>&) const
{
Assert((i<dofs_per_cell), ExcIndexRange(i, 0, dofs_per_cell));
// originally, the return type of the
inline
Tensor<2,3>
FEDG_P1<3>::shape_grad_grad (const unsigned int i,
- const Point<3> &) const
+ const Point<3> &) const
{
Assert((i<dofs_per_cell), ExcIndexRange(i, 0, dofs_per_cell));
template <>
void FEDG_P1<3>::get_local_mass_matrix (const DoFHandler<3>::cell_iterator &,
- FullMatrix<double> &local_mass_matrix) const
+ FullMatrix<double> &local_mass_matrix) const
{
Assert (local_mass_matrix.n() == dofs_per_cell,
ExcWrongFieldDimension(local_mass_matrix.n(),dofs_per_cell));
template <>
-void FEDG_P1<3>::get_unit_support_points (vector<Point<3> > &unit_points) const
+void FEDG_P1<3>::get_unit_support_points (
std::vector<Point<3> > &unit_points) const
{
Assert (unit_points.size() == dofs_per_cell,
ExcWrongFieldDimension (unit_points.size(), dofs_per_cell));
template <int dim>
void
FEDG_P1<dim>::get_support_points (const typename DoFHandler<dim>::cell_iterator &cell,
-
vector<Point<dim> > &support_points) const
+
std::vector<Point<dim> > &support_points) const
{
Assert (support_points.size() == dofs_per_cell,
typename FiniteElementBase<dim>::ExcWrongFieldDimension (support_points.size(),
template <int dim>
void
FEDG_P1<dim>::get_face_support_points (const typename DoFHandler<dim>::face_iterator &face,
- vector<Point<dim> > &support_points) const
+
std::vector<Point<dim> > &support_points) const
{
Assert ((support_points.size() == dofs_per_face) &&
(support_points.size() == GeometryInfo<dim>::vertices_per_face),
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
template <>
FEDG_P2<1>::FEDG_P2 () :
FEQ1Mapping<1> (0, 3, 0, 0, 1,
- vector<bool> (1, true))
+ std::vector<bool> (1, true))
{
// initialize_matrices ();
};
template <>
double
FEDG_P2<1>::shape_value(const unsigned int i,
- const Point<1> &p) const
+ const Point<1> &p) const
{
Assert((i<dofs_per_cell), ExcIndexRange(i, 0, dofs_per_cell));
switch (i)
inline
Tensor<1,1>
FEDG_P2<1>::shape_grad(const unsigned int i,
- const Point<1>&p) const
+ const Point<1>&p) const
{
Assert((i<dofs_per_cell), ExcIndexRange(i, 0, dofs_per_cell));
// originally, the return type of the
template <>
-void FEDG_P2<1>::get_unit_support_points (vector<Point<1> > &support_points) const
+void FEDG_P2<1>::get_unit_support_points (
std::vector<Point<1> > &support_points) const
{
FiniteElement<1>::get_unit_support_points (support_points);
};
template <>
void FEDG_P2<1>::get_support_points (const DoFHandler<1>::cell_iterator &cell,
- vector<Point<1> > &support_points) const
+
std::vector<Point<1> > &support_points) const
{
FiniteElement<1>::get_support_points (cell, support_points);
};
template <>
void FEDG_P2<1>::get_face_support_points (const DoFHandler<1>::face_iterator &,
- vector<Point<1> > &) const
+
std::vector<Point<1> > &) const
{
Assert (false, ExcInternalError());
};
template <>
void FEDG_P2<1>::get_local_mass_matrix (const DoFHandler<1>::cell_iterator &,
- FullMatrix<double> &local_mass_matrix) const
+ FullMatrix<double> &local_mass_matrix) const
{
Assert(false, ExcNotImplemented());
Assert (local_mass_matrix.n() == dofs_per_cell,
template <>
FEDG_P2<2>::FEDG_P2 () :
FEQ1Mapping<2> (0, 0, 6, 0, 1,
- vector<bool> (1, true))
+ std::vector<bool> (1, true))
{
// initialize_matrices ();
};
inline
double
FEDG_P2<2>::shape_value (const unsigned int i,
- const Point<2>& p) const
+ const Point<2>& p) const
{
Assert((i<dofs_per_cell), ExcIndexRange(i, 0, dofs_per_cell));
switch (i)
inline
Tensor<1,2>
FEDG_P2<2>::shape_grad (const unsigned int i,
- const Point<2>& p) const
+ const Point<2>& p) const
{
Assert((i<dofs_per_cell), ExcIndexRange(i, 0, dofs_per_cell));
// originally, the return type of the
inline
Tensor<2,2>
FEDG_P2<2>::shape_grad_grad (const unsigned int i,
- const Point<2> &) const
+ const Point<2> &) const
{
Assert(false, ExcNotImplemented());
Assert((i<dofs_per_cell), ExcIndexRange(i, 0, dofs_per_cell));
template <>
void FEDG_P2<2>::get_local_mass_matrix (const DoFHandler<2>::cell_iterator &,
- FullMatrix<double> &) const
+ FullMatrix<double> &) const
{
Assert(false, ExcNotImplemented ());
};
template <>
-void FEDG_P2<2>::get_unit_support_points (vector<Point<2> > &unit_points) const
+void FEDG_P2<2>::get_unit_support_points (
std::vector<Point<2> > &unit_points) const
{
Assert (unit_points.size() == dofs_per_cell,
ExcWrongFieldDimension (unit_points.size(), dofs_per_cell));
template <>
FEDG_P2<3>::FEDG_P2 () :
FEQ1Mapping<3> (0, 0, 0, 4, 1,
- vector<bool> (1, true))
+ std::vector<bool> (1, true))
{
Assert(false, ExcNotImplemented ());
// initialize_matrices ();
inline
Tensor<1,3>
FEDG_P2<3>::shape_grad (const unsigned int i,
- const Point<3>&) const
+ const Point<3>&) const
{
Assert((i<dofs_per_cell), ExcIndexRange(i, 0, dofs_per_cell));
// originally, the return type of the
inline
Tensor<2,3>
FEDG_P2<3>::shape_grad_grad (const unsigned int i,
- const Point<3> &) const
+ const Point<3> &) const
{
Assert((i<dofs_per_cell), ExcIndexRange(i, 0, dofs_per_cell));
template <>
void FEDG_P2<3>::get_local_mass_matrix (const DoFHandler<3>::cell_iterator &,
- FullMatrix<double> &local_mass_matrix) const
+ FullMatrix<double> &local_mass_matrix) const
{
Assert (local_mass_matrix.n() == dofs_per_cell,
ExcWrongFieldDimension(local_mass_matrix.n(),dofs_per_cell));
template <>
-void FEDG_P2<3>::get_unit_support_points (vector<Point<3> > &unit_points) const {
+void FEDG_P2<3>::get_unit_support_points (
std::vector<Point<3> > &unit_points) const {
Assert (unit_points.size() == dofs_per_cell,
ExcWrongFieldDimension (unit_points.size(), dofs_per_cell));
template <int dim>
void
FEDG_P2<dim>::get_support_points (const typename DoFHandler<dim>::cell_iterator &cell,
-
vector<Point<dim> > &support_points) const
+
std::vector<Point<dim> > &support_points) const
{
Assert (support_points.size() == dofs_per_cell,
typename FiniteElementBase<dim>::ExcWrongFieldDimension (support_points.size(),
template <int dim>
void
FEDG_P2<dim>::get_face_support_points (const typename DoFHandler<dim>::face_iterator &face,
- vector<Point<dim> > &support_points) const
+
std::vector<Point<dim> > &support_points) const
{
Assert ((support_points.size() == dofs_per_face) &&
(support_points.size() == GeometryInfo<dim>::vertices_per_face),
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
template <>
FEDG_P3<1>::FEDG_P3 () :
FEQ1Mapping<1> (0, 4, 0, 0, 1,
- vector<bool> (1, true))
+ std::vector<bool> (1, true))
{
// initialize_matrices ();
};
template <>
double
FEDG_P3<1>::shape_value(const unsigned int i,
- const Point<1> &p) const
+ const Point<1> &p) const
{
Assert((i<dofs_per_cell), ExcIndexRange(i, 0, dofs_per_cell));
switch (i)
inline
Tensor<1,1>
FEDG_P3<1>::shape_grad(const unsigned int i,
- const Point<1>&p) const
+ const Point<1>&p) const
{
Assert((i<dofs_per_cell), ExcIndexRange(i, 0, dofs_per_cell));
// originally, the return type of the
template <>
-void FEDG_P3<1>::get_unit_support_points (vector<Point<1> > &support_points) const
+void FEDG_P3<1>::get_unit_support_points (
std::vector<Point<1> > &support_points) const
{
FiniteElement<1>::get_unit_support_points (support_points);
};
template <>
void FEDG_P3<1>::get_support_points (const DoFHandler<1>::cell_iterator &cell,
- vector<Point<1> > &support_points) const
+
std::vector<Point<1> > &support_points) const
{
FiniteElement<1>::get_support_points (cell, support_points);
};
template <>
void FEDG_P3<1>::get_face_support_points (const DoFHandler<1>::face_iterator &,
- vector<Point<1> > &) const
+
std::vector<Point<1> > &) const
{
Assert (false, ExcInternalError());
};
template <>
void FEDG_P3<1>::get_local_mass_matrix (const DoFHandler<1>::cell_iterator &/*cell*/,
- FullMatrix<double> &local_mass_matrix) const
+ FullMatrix<double> &local_mass_matrix) const
{
Assert(false, ExcNotImplemented());
Assert (local_mass_matrix.n() == dofs_per_cell,
template <>
FEDG_P3<2>::FEDG_P3 () :
FEQ1Mapping<2> (0, 0, 10, 0, 1,
- vector<bool> (1, true))
+ std::vector<bool> (1, true))
{
// initialize_matrices ();
};
inline
double
FEDG_P3<2>::shape_value (const unsigned int i,
- const Point<2>& p) const
+ const Point<2>& p) const
{
Assert((i<dofs_per_cell), ExcIndexRange(i, 0, dofs_per_cell));
switch (i)
inline
Tensor<1,2>
FEDG_P3<2>::shape_grad (const unsigned int i,
- const Point<2>& p) const
+ const Point<2>& p) const
{
Assert((i<dofs_per_cell), ExcIndexRange(i, 0, dofs_per_cell));
// originally, the return type of the
inline
Tensor<2,2>
FEDG_P3<2>::shape_grad_grad (const unsigned int i,
- const Point<2> &) const
+ const Point<2> &) const
{
Assert(false, ExcNotImplemented());
Assert((i<dofs_per_cell), ExcIndexRange(i, 0, dofs_per_cell));
template <>
void FEDG_P3<2>::get_local_mass_matrix (const DoFHandler<2>::cell_iterator &,
- FullMatrix<double> &) const
+ FullMatrix<double> &) const
{
Assert(false, ExcNotImplemented ());
};
template <>
-void FEDG_P3<2>::get_unit_support_points (vector<Point<2> > &unit_points) const
+void FEDG_P3<2>::get_unit_support_points (
std::vector<Point<2> > &unit_points) const
{
Assert(false, ExcNotImplemented ());
Assert (unit_points.size() == dofs_per_cell,
template <>
FEDG_P3<3>::FEDG_P3 () :
FEQ1Mapping<3> (0, 0, 0, 4, 1,
- vector<bool> (1, true))
+ std::vector<bool> (1, true))
{
Assert(false, ExcNotImplemented ());
// initialize_matrices ();
inline
Tensor<1,3>
FEDG_P3<3>::shape_grad (const unsigned int i,
- const Point<3>&) const
+ const Point<3>&) const
{
Assert((i<dofs_per_cell), ExcIndexRange(i, 0, dofs_per_cell));
// originally, the return type of the
inline
Tensor<2,3>
FEDG_P3<3>::shape_grad_grad (const unsigned int i,
- const Point<3> &) const
+ const Point<3> &) const
{
Assert((i<dofs_per_cell), ExcIndexRange(i, 0, dofs_per_cell));
template <>
void FEDG_P3<3>::get_local_mass_matrix (const DoFHandler<3>::cell_iterator &,
- FullMatrix<double> &local_mass_matrix) const
+ FullMatrix<double> &local_mass_matrix) const
{
Assert (local_mass_matrix.n() == dofs_per_cell,
ExcWrongFieldDimension(local_mass_matrix.n(),dofs_per_cell));
template <>
-void FEDG_P3<3>::get_unit_support_points (vector<Point<3> > &unit_points) const {
+void FEDG_P3<3>::get_unit_support_points (
std::vector<Point<3> > &unit_points) const {
Assert (unit_points.size() == dofs_per_cell,
ExcWrongFieldDimension (unit_points.size(), dofs_per_cell));
template <int dim>
void
FEDG_P3<dim>::get_support_points (const typename DoFHandler<dim>::cell_iterator &cell,
-
vector<Point<dim> > &support_points) const
+
std::vector<Point<dim> > &support_points) const
{
Assert (support_points.size() == dofs_per_cell,
typename FiniteElementBase<dim>::ExcWrongFieldDimension (support_points.size(),
template <int dim>
void
FEDG_P3<dim>::get_face_support_points (const typename DoFHandler<dim>::face_iterator &face,
- vector<Point<dim> > &support_points) const
+
std::vector<Point<dim> > &support_points) const
{
Assert ((support_points.size() == dofs_per_face) &&
(support_points.size() == GeometryInfo<dim>::vertices_per_face),
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
template <>
FEQ1<1>::FEQ1 () :
FEQ1Mapping<1> (1, 0, 0, 0, 1,
- vector<bool> (1, false))
+ std::vector<bool> (1, false))
{
initialize_matrices ();
};
template <>
FEQ1<1>::FEQ1 (const int) :
FEQ1Mapping<1> (0, 2, 0, 0, 1,
- vector<bool> (1, true))
+ std::vector<bool> (1, true))
{
initialize_matrices ();
};
template <>
double
FEQ1<1>::shape_value(const unsigned int i,
- const Point<1> &p) const
+ const Point<1> &p) const
{
Assert((i<dofs_per_cell), ExcIndexRange(i, 0, dofs_per_cell));
switch (i)
{
- case 0: return 1.-p(0);
- case 1: return p(0);
+ case 0: return 1.-p(0);
+ case 1: return p(0);
}
return 0.;
}
inline
Tensor<1,1>
FEQ1<1>::shape_grad(const unsigned int i,
- const Point<1>&) const
+ const Point<1>&) const
{
Assert((i<dofs_per_cell), ExcIndexRange(i, 0, dofs_per_cell));
// originally, the return type of the
// however
switch (i)
{
- case 0: return Point<1>(-1.);
- case 1: return Point<1>(1.);
+ case 0: return Point<1>(-1.);
+ case 1: return Point<1>(1.);
}
return Point<1>();
};
inline
Tensor<2,1>
FEQ1<1>::shape_grad_grad (const unsigned int i,
- const Point<1> &) const
+ const Point<1> &) const
{
Assert((i<dofs_per_cell), ExcIndexRange(i, 0, dofs_per_cell));
// second derivatives on the unit cell
template <>
-void FEQ1<1>::get_unit_support_points (vector<Point<1> > &support_points) const {
+void FEQ1<1>::get_unit_support_points (
std::vector<Point<1> > &support_points) const {
FiniteElement<1>::get_unit_support_points (support_points);
};
template <>
void FEQ1<1>::get_support_points (const DoFHandler<1>::cell_iterator &cell,
- vector<Point<1> > &support_points) const {
+
std::vector<Point<1> > &support_points) const {
FiniteElement<1>::get_support_points (cell, support_points);
};
template <>
void FEQ1<1>::get_face_support_points (const DoFHandler<1>::face_iterator &,
- vector<Point<1> > &) const {
+
std::vector<Point<1> > &) const {
Assert (false, ExcInternalError());
};
template <>
void FEQ1<1>::get_local_mass_matrix (const DoFHandler<1>::cell_iterator &cell,
- FullMatrix<double> &local_mass_matrix) const {
+ FullMatrix<double> &local_mass_matrix) const {
Assert (local_mass_matrix.n() == dofs_per_cell,
ExcWrongFieldDimension(local_mass_matrix.n(),dofs_per_cell));
Assert (local_mass_matrix.m() == dofs_per_cell,
template <>
FEQ1<2>::FEQ1 () :
FEQ1Mapping<2> (1, 0, 0, 0, 1,
- vector<bool> (1, false))
+ std::vector<bool> (1, false))
{
interface_constraints(0,0) = 1./2.;
interface_constraints(0,1) = 1./2.;
template <>
FEQ1<2>::FEQ1 (const int) :
FEQ1Mapping<2> (0, 0, 4, 0, 1,
- vector<bool> (1, true))
+ std::vector<bool> (1, true))
{
initialize_matrices ();
};
inline
double
FEQ1<2>::shape_value (const unsigned int i,
- const Point<2>& p) const
+ const Point<2>& p) const
{
Assert((i<dofs_per_cell), ExcIndexRange(i, 0, dofs_per_cell));
switch (i)
inline
Tensor<1,2>
FEQ1<2>::shape_grad (const unsigned int i,
- const Point<2>& p) const
+ const Point<2>& p) const
{
Assert((i<dofs_per_cell), ExcIndexRange(i, 0, dofs_per_cell));
// originally, the return type of the
inline
Tensor<2,2>
FEQ1<2>::shape_grad_grad (const unsigned int i,
- const Point<2> &) const
+ const Point<2> &) const
{
Assert((i<dofs_per_cell), ExcIndexRange(i, 0, dofs_per_cell));
case 0:
case 2:
{
- const double initializer[2][2] = {{0, 1},{1,0}};
- return Tensor<2,2>(initializer);
+ const double initializer[2][2] = {{0, 1},{1,0}};
+ return Tensor<2,2>(initializer);
};
case 1:
case 3:
{
- const double initializer[2][2] = {{0, -1},{-1,0}};
- return Tensor<2,2>(initializer);
+ const double initializer[2][2] = {{0, -1},{-1,0}};
+ return Tensor<2,2>(initializer);
};
};
template <>
void FEQ1<2>::get_local_mass_matrix (const DoFHandler<2>::cell_iterator &cell,
- FullMatrix<double> &local_mass_matrix) const {
+ FullMatrix<double> &local_mass_matrix) const {
Assert (local_mass_matrix.n() == dofs_per_cell,
ExcWrongFieldDimension(local_mass_matrix.n(),dofs_per_cell));
Assert (local_mass_matrix.m() == dofs_per_cell,
template <>
-void FEQ1<2>::get_unit_support_points (vector<Point<2> > &unit_points) const {
+void FEQ1<2>::get_unit_support_points (
std::vector<Point<2> > &unit_points) const {
Assert (unit_points.size() == dofs_per_cell,
ExcWrongFieldDimension (unit_points.size(), dofs_per_cell));
template <>
FEQ1<3>::FEQ1 () :
FEQ1Mapping<3> (1, 0, 0, 0, 1,
- vector<bool> (1, false))
+ std::vector<bool> (1, false))
{
interface_constraints(0,0) = 1.0/4.0;
interface_constraints(0,1) = 1.0/4.0;
template <>
FEQ1<3>::FEQ1 (const int) :
FEQ1Mapping<3> (0, 0, 0, 8, 1,
- vector<bool> (1, true))
+ std::vector<bool> (1, true))
{
initialize_matrices ();
};
inline
double
FEQ1<3>::shape_value (const unsigned int i,
- const Point<3>& p) const
+ const Point<3>& p) const
{
Assert((i<dofs_per_cell), ExcIndexRange(i, 0, dofs_per_cell));
switch (i)
inline
Tensor<1,3>
FEQ1<3>::shape_grad (const unsigned int i,
- const Point<3>& p) const
+ const Point<3>& p) const
{
Assert((i<dofs_per_cell), ExcIndexRange(i, 0, dofs_per_cell));
// originally, the return type of the
inline
Tensor<2,3>
FEQ1<3>::shape_grad_grad (const unsigned int i,
- const Point<3> &p) const
+ const Point<3> &p) const
{
Assert((i<dofs_per_cell), ExcIndexRange(i, 0, dofs_per_cell));
template <>
void FEQ1<3>::get_local_mass_matrix (const DoFHandler<3>::cell_iterator &,
- FullMatrix<double> &local_mass_matrix) const {
+ FullMatrix<double> &local_mass_matrix) const {
Assert (local_mass_matrix.n() == dofs_per_cell,
ExcWrongFieldDimension(local_mass_matrix.n(),dofs_per_cell));
Assert (local_mass_matrix.m() == dofs_per_cell,
template <>
-void FEQ1<3>::get_unit_support_points (vector<Point<3> > &unit_points) const {
+void FEQ1<3>::get_unit_support_points (
std::vector<Point<3> > &unit_points) const {
Assert (unit_points.size() == dofs_per_cell,
ExcWrongFieldDimension (unit_points.size(), dofs_per_cell));
template <int dim>
void
FEQ1<dim>::get_support_points (const typename DoFHandler<dim>::cell_iterator &cell,
-
vector<Point<dim> > &support_points) const {
+
std::vector<Point<dim> > &support_points) const {
Assert (support_points.size() == dofs_per_cell,
typename FiniteElementBase<dim>::ExcWrongFieldDimension (support_points.size(),
dofs_per_cell));
template <int dim>
void
FEQ1<dim>::get_face_support_points (const typename DoFHandler<dim>::face_iterator &face,
-
vector<Point<dim> > &support_points) const {
+
std::vector<Point<dim> > &support_points) const {
Assert ((support_points.size() == dofs_per_face) &&
(support_points.size() == GeometryInfo<dim>::vertices_per_face),
typename FiniteElementBase<dim>::
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
template <>
FEQ2<1>::FEQ2 () :
FEQ1Mapping<1> (1, 1, 0, 0, 1,
- vector<bool> (1, false))
+ std::vector<bool> (1, false))
{
initialize_matrices ();
};
template <>
FEQ2<1>::FEQ2 (const int) :
FEQ1Mapping<1> (0, 3, 0, 0, 1,
- vector<bool> (1, true))
+ std::vector<bool> (1, true))
{
initialize_matrices ();
};
restriction := array(0..1,0..2, 0..2);
for i from 0 to 1 do
- for j from 0 to 2 do
- for k from 0 to 2 do
- prolongation[i,j,k] := phi[k](points[i][j]);
- od;
- od;
+ for j from 0 to 2 do
+ for k from 0 to 2 do
+ prolongation[i,j,k] := phi[k](points[i][j]);
+ od;
+ od;
od;
global_points := array(0..2, [0,1,1/2]):
child_phi[0] := proc(i, point)
- if ((point<0) or (point>1/2)) then
- 0:
- else
- phi[i](2*point):
- fi:
- end:
+ if ((point<0) or (point>1/2)) then
+ 0:
+ else
+ phi[i](2*point):
+ fi:
+ end:
child_phi[1] := proc(i, point)
- if ((point<1/2) or (point>1)) then
- 0:
- else
- phi[i](2*point-1):
- fi:
- end:
+ if ((point<1/2) or (point>1)) then
+ 0:
+ else
+ phi[i](2*point-1):
+ fi:
+ end:
for child from 0 to 1 do
- for j from 0 to 2 do
- for k from 0 to 2 do
- restriction[child,j,k] := child_phi[child](k, global_points[j]):
- od:
- od:
+ for j from 0 to 2 do
+ for k from 0 to 2 do
+ restriction[child,j,k] := child_phi[child](k, global_points[j]):
+ od:
+ od:
od:
readlib(C);
template <>
-void FEQ2<1>::get_unit_support_points (vector<Point<1> > &unit_points) const
+void FEQ2<1>::get_unit_support_points (
std::vector<Point<1> > &unit_points) const
{
FiniteElement<1>::get_unit_support_points (unit_points);
};
template <>
void FEQ2<1>::get_support_points (const DoFHandler<1>::cell_iterator &cell,
- vector<Point<1> > &support_points) const
+
std::vector<Point<1> > &support_points) const
{
FiniteElement<1>::get_support_points (cell, support_points);
};
template <>
void FEQ2<1>::get_face_support_points (const DoFHandler<1>::face_iterator &,
- vector<Point<1> > &) const
+
std::vector<Point<1> > &) const
{
Assert (false, ExcInternalError());
};
template <>
FEQ2<2>::FEQ2 () :
FEQ1Mapping<2> (1, 1, 1, 0, 1,
- vector<bool> (1, false))
+ std::vector<bool> (1, false))
{
interface_constraints(0,2) = 1.0;
interface_constraints(1,0) = 3./8.;
template <>
FEQ2<2>::FEQ2 (const int) :
FEQ1Mapping<2> (0, 0, 9, 0, 1,
- vector<bool> (1, true))
+ std::vector<bool> (1, true))
{
initialize_matrices ();
};
prolongation := array(0..3,0..8, 0..8);
for i from 0 to 3 do
- for j from 0 to 8 do
- for k from 0 to 8 do
- prolongation[i,j,k] := phi[k](points_x[i][j], points_y[i][j]);
- od;
- od;
+ for j from 0 to 8 do
+ for k from 0 to 8 do
+ prolongation[i,j,k] := phi[k](points_x[i][j], points_y[i][j]);
+ od;
+ od;
od;
readlib(C);
return_value[0][1] = 16.0-32.0*xi+2.0*(-16.0+32.0*xi)*eta;
return_value[1][0] = 16.0-32.0*xi+2.0*(-16.0+32.0*xi)*eta;
return_value[1][1] = -32.0*xi+32.0*xi*xi;
- break;
+ break;
};
return return_value;
};
M := array(0..8,0..8);
for i from 0 to 8 do
- for j from 0 to 8 do
- M[i,j] := m(i,j);
- od;
+ for j from 0 to 8 do
+ M[i,j] := m(i,j);
+ od;
od;
readlib(C);
/* check that the Jacobi determinant
- t0 = (-x[0]*(1.0-eta)+x[1]*(1.0-eta)+x[2]*eta-x[3]*eta) *
- (-y[0]*(1.0-xi)-y[1]*xi+y[2]*xi+y[3]*(1.0-xi)) -
- (-x[0]*(1.0-xi)-x[1]*xi+x[2]*xi+x[3]*(1.0-xi)) *
- (-y[0]*(1.0-eta)+y[1]*(1.0-eta)+y[2]*eta-y[3]*eta)
+ t0 = (-x[0]*(1.0-eta)+x[1]*(1.0-eta)+x[2]*eta-x[3]*eta) *
+ (-y[0]*(1.0-xi)-y[1]*xi+y[2]*xi+y[3]*(1.0-xi)) -
+ (-x[0]*(1.0-xi)-x[1]*xi+x[2]*xi+x[3]*(1.0-xi)) *
+ (-y[0]*(1.0-eta)+y[1]*(1.0-eta)+y[2]*eta-y[3]*eta)
has the right sign.
template <>
-void FEQ2<2>::get_unit_support_points (vector<Point<2> > &unit_points) const
+void FEQ2<2>::get_unit_support_points (
std::vector<Point<2> > &unit_points) const
{
Assert (unit_points.size() == dofs_per_cell,
ExcWrongFieldDimension (unit_points.size(), dofs_per_cell));
template <>
void FEQ2<2>::get_support_points (const DoFHandler<2>::cell_iterator &cell,
- vector<Point<2> > &support_points) const
+
std::vector<Point<2> > &support_points) const
{
Assert (support_points.size() == dofs_per_cell,
ExcWrongFieldDimension (support_points.size(), dofs_per_cell));
template <>
void FEQ2<2>::get_face_support_points (const DoFHandler<2>::face_iterator &face,
- vector<Point<2> > &support_points) const
+
std::vector<Point<2> > &support_points) const
{
Assert (support_points.size() == dofs_per_face,
ExcWrongFieldDimension (support_points.size(), dofs_per_face));
template <>
FEQ2<3>::FEQ2 () :
FEQ1Mapping<3> (1, 1, 1, 1, 1,
- vector<bool> (1, false))
+ std::vector<bool> (1, false))
{
interface_constraints(0,8) = 1.0;
interface_constraints(1,4) = 1.0;
template <>
FEQ2<3>::FEQ2 (const int) :
FEQ1Mapping<3> (0, 0, 0, 27, 1,
- vector<bool> (1, true))
+ std::vector<bool> (1, true))
{
initialize_matrices ();
};
switch (i)
{
case 0: return 1.0-3.0*xi+2.0*xi*xi+(-3.0+9.0*xi-6.0*xi*xi)*eta+(2.0
--6.0*xi+4.0*xi*xi)*eta*eta+(-3.0+9.0*xi-6.0*xi*xi+(9.0-27.0*xi+18.0*xi*xi)*eta+
-(-6.0+18.0*xi-12.0*xi*xi)*eta*eta)*zeta+(2.0-6.0*xi+4.0*xi*xi+(-6.0+18.0*xi
--12.0*xi*xi)*eta+(4.0-12.0*xi+8.0*xi*xi)*eta*eta)*zeta*zeta;
+ -6.0*xi+4.0*xi*xi)*eta*eta+(-3.0+9.0*xi-6.0*xi*xi+(9.0-27.0*xi+18.0*xi*xi)*eta+
+ (-6.0+18.0*xi-12.0*xi*xi)*eta*eta)*zeta+(2.0-6.0*xi+4.0*xi*xi+(-6.0+18.0*xi
+ -12.0*xi*xi)*eta+(4.0-12.0*xi+8.0*xi*xi)*eta*eta)*zeta*zeta;
case 1: return -xi+2.0*xi*xi+(3.0*xi-6.0*xi*xi)*eta+(-2.0*xi+4.0*xi*xi)
-*eta*eta+(3.0*xi-6.0*xi*xi+(-9.0*xi+18.0*xi*xi)*eta+(6.0*xi-12.0*xi*xi)*eta*eta
-)*zeta+(-2.0*xi+4.0*xi*xi+(6.0*xi-12.0*xi*xi)*eta+(-4.0*xi+8.0*xi*xi)*eta*eta)*
-zeta*zeta;
+ *eta*eta+(3.0*xi-6.0*xi*xi+(-9.0*xi+18.0*xi*xi)*eta+(6.0*xi-12.0*xi*xi)*eta*eta
+ )*zeta+(-2.0*xi+4.0*xi*xi+(6.0*xi-12.0*xi*xi)*eta+(-4.0*xi+8.0*xi*xi)*eta*eta)*
+ zeta*zeta;
case 2: return (xi-2.0*xi*xi+(-3.0*xi+6.0*xi*xi)*eta+(2.0*xi-4.0*xi*xi)
-*eta*eta)*zeta+(-2.0*xi+4.0*xi*xi+(6.0*xi-12.0*xi*xi)*eta+(-4.0*xi+8.0*xi*xi)*
-eta*eta)*zeta*zeta;
+ *eta*eta)*zeta+(-2.0*xi+4.0*xi*xi+(6.0*xi-12.0*xi*xi)*eta+(-4.0*xi+8.0*xi*xi)*
+ eta*eta)*zeta*zeta;
case 3: return (-1.0+3.0*xi-2.0*xi*xi+(3.0-9.0*xi+6.0*xi*xi)*eta+(-2.0+
-6.0*xi-4.0*xi*xi)*eta*eta)*zeta+(2.0-6.0*xi+4.0*xi*xi+(-6.0+18.0*xi-12.0*xi*xi)
-*eta+(4.0-12.0*xi+8.0*xi*xi)*eta*eta)*zeta*zeta;
+ 6.0*xi-4.0*xi*xi)*eta*eta)*zeta+(2.0-6.0*xi+4.0*xi*xi+(-6.0+18.0*xi-12.0*xi*xi)
+ *eta+(4.0-12.0*xi+8.0*xi*xi)*eta*eta)*zeta*zeta;
case 4: return (-1.0+3.0*xi-2.0*xi*xi)*eta+(2.0-6.0*xi+4.0*xi*xi)*eta*
-eta+((3.0-9.0*xi+6.0*xi*xi)*eta+(-6.0+18.0*xi-12.0*xi*xi)*eta*eta)*zeta+((-2.0+
-6.0*xi-4.0*xi*xi)*eta+(4.0-12.0*xi+8.0*xi*xi)*eta*eta)*zeta*zeta;
+ eta+((3.0-9.0*xi+6.0*xi*xi)*eta+(-6.0+18.0*xi-12.0*xi*xi)*eta*eta)*zeta+((-2.0+
+ 6.0*xi-4.0*xi*xi)*eta+(4.0-12.0*xi+8.0*xi*xi)*eta*eta)*zeta*zeta;
case 5: return (xi-2.0*xi*xi)*eta+(-2.0*xi+4.0*xi*xi)*eta*eta+((-3.0*xi
-+6.0*xi*xi)*eta+(6.0*xi-12.0*xi*xi)*eta*eta)*zeta+((2.0*xi-4.0*xi*xi)*eta+(-4.0
-*xi+8.0*xi*xi)*eta*eta)*zeta*zeta;
+ +6.0*xi*xi)*eta+(6.0*xi-12.0*xi*xi)*eta*eta)*zeta+((2.0*xi-4.0*xi*xi)*eta+(-4.0
+ *xi+8.0*xi*xi)*eta*eta)*zeta*zeta;
case 6: return ((-xi+2.0*xi*xi)*eta+(2.0*xi-4.0*xi*xi)*eta*eta)*zeta+((
-2.0*xi-4.0*xi*xi)*eta+(-4.0*xi+8.0*xi*xi)*eta*eta)*zeta*zeta;
+ 2.0*xi-4.0*xi*xi)*eta+(-4.0*xi+8.0*xi*xi)*eta*eta)*zeta*zeta;
case 7: return ((1.0-3.0*xi+2.0*xi*xi)*eta+(-2.0+6.0*xi-4.0*xi*xi)*eta*
-eta)*zeta+((-2.0+6.0*xi-4.0*xi*xi)*eta+(4.0-12.0*xi+8.0*xi*xi)*eta*eta)*zeta*
-zeta;
+ eta)*zeta+((-2.0+6.0*xi-4.0*xi*xi)*eta+(4.0-12.0*xi+8.0*xi*xi)*eta*eta)*zeta*
+ zeta;
case 8: return 4.0*xi-4.0*xi*xi+(-12.0*xi+12.0*xi*xi)*eta+(8.0*xi-8.0*
-xi*xi)*eta*eta+(-12.0*xi+12.0*xi*xi+(36.0*xi-36.0*xi*xi)*eta+(-24.0*xi+24.0*xi*
-xi)*eta*eta)*zeta+(8.0*xi-8.0*xi*xi+(-24.0*xi+24.0*xi*xi)*eta+(16.0*xi-16.0*xi*
-xi)*eta*eta)*zeta*zeta;
+ xi*xi)*eta*eta+(-12.0*xi+12.0*xi*xi+(36.0*xi-36.0*xi*xi)*eta+(-24.0*xi+24.0*xi*
+ xi)*eta*eta)*zeta+(8.0*xi-8.0*xi*xi+(-24.0*xi+24.0*xi*xi)*eta+(16.0*xi-16.0*xi*
+ xi)*eta*eta)*zeta*zeta;
case 9: return (-4.0*xi+8.0*xi*xi+(12.0*xi-24.0*xi*xi)*eta+(-8.0*xi+
-16.0*xi*xi)*eta*eta)*zeta+(4.0*xi-8.0*xi*xi+(-12.0*xi+24.0*xi*xi)*eta+(8.0*xi
--16.0*xi*xi)*eta*eta)*zeta*zeta;
+ 16.0*xi*xi)*eta*eta)*zeta+(4.0*xi-8.0*xi*xi+(-12.0*xi+24.0*xi*xi)*eta+(8.0*xi
+ -16.0*xi*xi)*eta*eta)*zeta*zeta;
case 10: return (-4.0*xi+4.0*xi*xi+(12.0*xi-12.0*xi*xi)*eta+(-8.0*xi+
-8.0*xi*xi)*eta*eta)*zeta+(8.0*xi-8.0*xi*xi+(-24.0*xi+24.0*xi*xi)*eta+(16.0*xi
--16.0*xi*xi)*eta*eta)*zeta*zeta;
+ 8.0*xi*xi)*eta*eta)*zeta+(8.0*xi-8.0*xi*xi+(-24.0*xi+24.0*xi*xi)*eta+(16.0*xi
+ -16.0*xi*xi)*eta*eta)*zeta*zeta;
case 11: return (4.0-12.0*xi+8.0*xi*xi+(-12.0+36.0*xi-24.0*xi*xi)*eta+(
-8.0-24.0*xi+16.0*xi*xi)*eta*eta)*zeta+(-4.0+12.0*xi-8.0*xi*xi+(12.0-36.0*xi+
-24.0*xi*xi)*eta+(-8.0+24.0*xi-16.0*xi*xi)*eta*eta)*zeta*zeta;
+ 8.0-24.0*xi+16.0*xi*xi)*eta*eta)*zeta+(-4.0+12.0*xi-8.0*xi*xi+(12.0-36.0*xi+
+ 24.0*xi*xi)*eta+(-8.0+24.0*xi-16.0*xi*xi)*eta*eta)*zeta*zeta;
case 12: return (-4.0*xi+4.0*xi*xi)*eta+(8.0*xi-8.0*xi*xi)*eta*eta+((
-12.0*xi-12.0*xi*xi)*eta+(-24.0*xi+24.0*xi*xi)*eta*eta)*zeta+((-8.0*xi+8.0*xi*xi
-)*eta+(16.0*xi-16.0*xi*xi)*eta*eta)*zeta*zeta;
+ 12.0*xi-12.0*xi*xi)*eta+(-24.0*xi+24.0*xi*xi)*eta*eta)*zeta+((-8.0*xi+8.0*xi*xi
+ )*eta+(16.0*xi-16.0*xi*xi)*eta*eta)*zeta*zeta;
case 13: return ((4.0*xi-8.0*xi*xi)*eta+(-8.0*xi+16.0*xi*xi)*eta*eta)*
-zeta+((-4.0*xi+8.0*xi*xi)*eta+(8.0*xi-16.0*xi*xi)*eta*eta)*zeta*zeta;
+ zeta+((-4.0*xi+8.0*xi*xi)*eta+(8.0*xi-16.0*xi*xi)*eta*eta)*zeta*zeta;
case 14: return ((4.0*xi-4.0*xi*xi)*eta+(-8.0*xi+8.0*xi*xi)*eta*eta)*
-zeta+((-8.0*xi+8.0*xi*xi)*eta+(16.0*xi-16.0*xi*xi)*eta*eta)*zeta*zeta;
+ zeta+((-8.0*xi+8.0*xi*xi)*eta+(16.0*xi-16.0*xi*xi)*eta*eta)*zeta*zeta;
case 15: return ((-4.0+12.0*xi-8.0*xi*xi)*eta+(8.0-24.0*xi+16.0*xi*xi)*
-eta*eta)*zeta+((4.0-12.0*xi+8.0*xi*xi)*eta+(-8.0+24.0*xi-16.0*xi*xi)*eta*eta)*
-zeta*zeta;
+ eta*eta)*zeta+((4.0-12.0*xi+8.0*xi*xi)*eta+(-8.0+24.0*xi-16.0*xi*xi)*eta*eta)*
+ zeta*zeta;
case 16: return (4.0-12.0*xi+8.0*xi*xi)*eta+(-4.0+12.0*xi-8.0*xi*xi)*
-eta*eta+((-12.0+36.0*xi-24.0*xi*xi)*eta+(12.0-36.0*xi+24.0*xi*xi)*eta*eta)*zeta
-+((8.0-24.0*xi+16.0*xi*xi)*eta+(-8.0+24.0*xi-16.0*xi*xi)*eta*eta)*zeta*zeta;
+ eta*eta+((-12.0+36.0*xi-24.0*xi*xi)*eta+(12.0-36.0*xi+24.0*xi*xi)*eta*eta)*zeta
+ +((8.0-24.0*xi+16.0*xi*xi)*eta+(-8.0+24.0*xi-16.0*xi*xi)*eta*eta)*zeta*zeta;
case 17: return (-4.0*xi+8.0*xi*xi)*eta+(4.0*xi-8.0*xi*xi)*eta*eta+((
-12.0*xi-24.0*xi*xi)*eta+(-12.0*xi+24.0*xi*xi)*eta*eta)*zeta+((-8.0*xi+16.0*xi*
-xi)*eta+(8.0*xi-16.0*xi*xi)*eta*eta)*zeta*zeta;
+ 12.0*xi-24.0*xi*xi)*eta+(-12.0*xi+24.0*xi*xi)*eta*eta)*zeta+((-8.0*xi+16.0*xi*
+ xi)*eta+(8.0*xi-16.0*xi*xi)*eta*eta)*zeta*zeta;
case 18: return ((4.0*xi-8.0*xi*xi)*eta+(-4.0*xi+8.0*xi*xi)*eta*eta)*
-zeta+((-8.0*xi+16.0*xi*xi)*eta+(8.0*xi-16.0*xi*xi)*eta*eta)*zeta*zeta;
+ zeta+((-8.0*xi+16.0*xi*xi)*eta+(8.0*xi-16.0*xi*xi)*eta*eta)*zeta*zeta;
case 19: return ((-4.0+12.0*xi-8.0*xi*xi)*eta+(4.0-12.0*xi+8.0*xi*xi)*
-eta*eta)*zeta+((8.0-24.0*xi+16.0*xi*xi)*eta+(-8.0+24.0*xi-16.0*xi*xi)*eta*eta)*
-zeta*zeta;
+ eta*eta)*zeta+((8.0-24.0*xi+16.0*xi*xi)*eta+(-8.0+24.0*xi-16.0*xi*xi)*eta*eta)*
+ zeta*zeta;
case 20: return (16.0*xi-16.0*xi*xi+(-48.0*xi+48.0*xi*xi)*eta+(32.0*xi
--32.0*xi*xi)*eta*eta)*zeta+(-16.0*xi+16.0*xi*xi+(48.0*xi-48.0*xi*xi)*eta+(-32.0
-*xi+32.0*xi*xi)*eta*eta)*zeta*zeta;
+ -32.0*xi*xi)*eta*eta)*zeta+(-16.0*xi+16.0*xi*xi+(48.0*xi-48.0*xi*xi)*eta+(-32.0
+ *xi+32.0*xi*xi)*eta*eta)*zeta*zeta;
case 21: return ((-16.0*xi+16.0*xi*xi)*eta+(32.0*xi-32.0*xi*xi)*eta*eta
-)*zeta+((16.0*xi-16.0*xi*xi)*eta+(-32.0*xi+32.0*xi*xi)*eta*eta)*zeta*zeta;
+ )*zeta+((16.0*xi-16.0*xi*xi)*eta+(-32.0*xi+32.0*xi*xi)*eta*eta)*zeta*zeta;
case 22: return (16.0*xi-16.0*xi*xi)*eta+(-16.0*xi+16.0*xi*xi)*eta*eta+
-((-48.0*xi+48.0*xi*xi)*eta+(48.0*xi-48.0*xi*xi)*eta*eta)*zeta+((32.0*xi-32.0*xi
-*xi)*eta+(-32.0*xi+32.0*xi*xi)*eta*eta)*zeta*zeta;
+ ((-48.0*xi+48.0*xi*xi)*eta+(48.0*xi-48.0*xi*xi)*eta*eta)*zeta+((32.0*xi-32.0*xi
+ *xi)*eta+(-32.0*xi+32.0*xi*xi)*eta*eta)*zeta*zeta;
case 23: return ((-16.0*xi+32.0*xi*xi)*eta+(16.0*xi-32.0*xi*xi)*eta*eta
-)*zeta+((16.0*xi-32.0*xi*xi)*eta+(-16.0*xi+32.0*xi*xi)*eta*eta)*zeta*zeta;
+ )*zeta+((16.0*xi-32.0*xi*xi)*eta+(-16.0*xi+32.0*xi*xi)*eta*eta)*zeta*zeta;
case 24: return ((-16.0*xi+16.0*xi*xi)*eta+(16.0*xi-16.0*xi*xi)*eta*eta
-)*zeta+((32.0*xi-32.0*xi*xi)*eta+(-32.0*xi+32.0*xi*xi)*eta*eta)*zeta*zeta;
+ )*zeta+((32.0*xi-32.0*xi*xi)*eta+(-32.0*xi+32.0*xi*xi)*eta*eta)*zeta*zeta;
case 25: return ((16.0-48.0*xi+32.0*xi*xi)*eta+(-16.0+48.0*xi-32.0*xi*
-xi)*eta*eta)*zeta+((-16.0+48.0*xi-32.0*xi*xi)*eta+(16.0-48.0*xi+32.0*xi*xi)*eta
-*eta)*zeta*zeta;
+ xi)*eta*eta)*zeta+((-16.0+48.0*xi-32.0*xi*xi)*eta+(16.0-48.0*xi+32.0*xi*xi)*eta
+ *eta)*zeta*zeta;
case 26: return ((64.0*xi-64.0*xi*xi)*eta+(-64.0*xi+64.0*xi*xi)*eta*eta
-)*zeta+((-64.0*xi+64.0*xi*xi)*eta+(64.0*xi-64.0*xi*xi)*eta*eta)*zeta*zeta;
+ )*zeta+((-64.0*xi+64.0*xi*xi)*eta+(64.0*xi-64.0*xi*xi)*eta*eta)*zeta*zeta;
};
return 0;
};
switch (i)
{
case 0: return Point<3>(-3.0+4.0*xi+(9.0-12.0*xi)*eta+(-6.0+8.0*xi)*eta*eta+(9.0-12.0*xi+(-27.0+36.0*xi)*eta+(18.0-24.0*xi)*eta*eta)*zeta+(-6.0+8.0*xi+(18.0-24.0*xi)*eta+(-12.0+16.0*xi)*eta*eta)*zeta*zeta,
- -3.0+9.0*xi-6.0*xi*xi+2.0*(2.0-6.0*xi+4.0*xi*xi)*eta+(9.0-27.0*xi+18.0*xi*xi+2.0*(-6.0+18.0*xi-12.0*xi*xi)*eta)*zeta+(-6.0+18.0*xi-12.0*xi*xi+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta)*zeta*zeta,
- -3.0+9.0*xi-6.0*xi*xi+(9.0-27.0*xi+18.0*xi*xi)*eta+(-6.0+18.0*xi-12.0*xi*xi)*eta*eta+2.0*(2.0-6.0*xi+4.0*xi*xi+(-6.0+18.0*xi-12.0*xi*xi)*eta+(4.0-12.0*xi+8.0*xi*xi)*eta*eta)*zeta);
+ -3.0+9.0*xi-6.0*xi*xi+2.0*(2.0-6.0*xi+4.0*xi*xi)*eta+(9.0-27.0*xi+18.0*xi*xi+2.0*(-6.0+18.0*xi-12.0*xi*xi)*eta)*zeta+(-6.0+18.0*xi-12.0*xi*xi+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta)*zeta*zeta,
+ -3.0+9.0*xi-6.0*xi*xi+(9.0-27.0*xi+18.0*xi*xi)*eta+(-6.0+18.0*xi-12.0*xi*xi)*eta*eta+2.0*(2.0-6.0*xi+4.0*xi*xi+(-6.0+18.0*xi-12.0*xi*xi)*eta+(4.0-12.0*xi+8.0*xi*xi)*eta*eta)*zeta);
case 1: return Point<3>(-1.0+4.0*xi+(3.0-12.0*xi)*eta+(-2.0+8.0*xi)*eta*eta+(3.0-12.0*xi+(-9.0+36.0*xi)*eta+(6.0-24.0*xi)*eta*eta)*zeta+(-2.0+8.0*xi+(6.0-24.0*xi)*eta+(-4.0+16.0*xi)*eta*eta)*zeta*zeta,
- 3.0*xi-6.0*xi*xi+2.0*(-2.0*xi+4.0*xi*xi)*eta+(-9.0*xi+18.0*xi*xi+2.0*(6.0*xi-12.0*xi*xi)*eta)*zeta+(6.0*xi-12.0*xi*xi+2.0*(-4.0*xi+8.0*xi*xi)*eta)*zeta*zeta,
- 3.0*xi-6.0*xi*xi+(-9.0*xi+18.0*xi*xi)*eta+(6.0*xi-12.0*xi*xi)*eta*eta+2.0*(-2.0*xi+4.0*xi*xi+(6.0*xi-12.0*xi*xi)*eta+(-4.0*xi+8.0*xi*xi)*eta*eta)*zeta);
+ 3.0*xi-6.0*xi*xi+2.0*(-2.0*xi+4.0*xi*xi)*eta+(-9.0*xi+18.0*xi*xi+2.0*(6.0*xi-12.0*xi*xi)*eta)*zeta+(6.0*xi-12.0*xi*xi+2.0*(-4.0*xi+8.0*xi*xi)*eta)*zeta*zeta,
+ 3.0*xi-6.0*xi*xi+(-9.0*xi+18.0*xi*xi)*eta+(6.0*xi-12.0*xi*xi)*eta*eta+2.0*(-2.0*xi+4.0*xi*xi+(6.0*xi-12.0*xi*xi)*eta+(-4.0*xi+8.0*xi*xi)*eta*eta)*zeta);
case 2: return Point<3>((1.0-4.0*xi+(-3.0+12.0*xi)*eta+(2.0-8.0*xi)*eta*eta)*zeta+(-2.0+8.0*xi+(6.0-24.0*xi)*eta+(-4.0+16.0*xi)*eta*eta)*zeta*zeta,
- (-3.0*xi+6.0*xi*xi+2.0*(2.0*xi-4.0*xi*xi)*eta)*zeta+(6.0*xi-12.0*xi*xi+2.0*(-4.0*xi+8.0*xi*xi)*eta)*zeta*zeta,
- xi-2.0*xi*xi+(-3.0*xi+6.0*xi*xi)*eta+(2.0*xi-4.0*xi*xi)*eta*eta+2.0*(-2.0*xi+4.0*xi*xi+(6.0*xi-12.0*xi*xi)*eta+(-4.0*xi+8.0*xi*xi)*eta*eta)*zeta);
+ (-3.0*xi+6.0*xi*xi+2.0*(2.0*xi-4.0*xi*xi)*eta)*zeta+(6.0*xi-12.0*xi*xi+2.0*(-4.0*xi+8.0*xi*xi)*eta)*zeta*zeta,
+ xi-2.0*xi*xi+(-3.0*xi+6.0*xi*xi)*eta+(2.0*xi-4.0*xi*xi)*eta*eta+2.0*(-2.0*xi+4.0*xi*xi+(6.0*xi-12.0*xi*xi)*eta+(-4.0*xi+8.0*xi*xi)*eta*eta)*zeta);
case 3: return Point<3>((3.0-4.0*xi+(-9.0+12.0*xi)*eta+(6.0-8.0*xi)*eta*eta)*zeta+(-6.0+8.0*xi+(18.0-24.0*xi)*eta+(-12.0+16.0*xi)*eta*eta)*zeta*zeta,
- (3.0-9.0*xi+6.0*xi*xi+2.0*(-2.0+6.0*xi-4.0*xi*xi)*eta)*zeta+(-6.0+18.0*xi-12.0*xi*xi+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta)*zeta*zeta,
- -1.0+3.0*xi-2.0*xi*xi+(3.0-9.0*xi+6.0*xi*xi)*eta+(-2.0+6.0*xi-4.0*xi*xi)*eta*eta+2.0*(2.0-6.0*xi+4.0*xi*xi+(-6.0+18.0*xi-12.0*xi*xi)*eta+(4.0-12.0*xi+8.0*xi*xi)*eta*eta)*zeta);
+ (3.0-9.0*xi+6.0*xi*xi+2.0*(-2.0+6.0*xi-4.0*xi*xi)*eta)*zeta+(-6.0+18.0*xi-12.0*xi*xi+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta)*zeta*zeta,
+ -1.0+3.0*xi-2.0*xi*xi+(3.0-9.0*xi+6.0*xi*xi)*eta+(-2.0+6.0*xi-4.0*xi*xi)*eta*eta+2.0*(2.0-6.0*xi+4.0*xi*xi+(-6.0+18.0*xi-12.0*xi*xi)*eta+(4.0-12.0*xi+8.0*xi*xi)*eta*eta)*zeta);
case 4: return Point<3>((3.0-4.0*xi)*eta+(-6.0+8.0*xi)*eta*eta+((-9.0+12.0*xi)*eta+(18.0-24.0*xi)*eta*eta)*zeta+((6.0-8.0*xi)*eta+(-12.0+16.0*xi)*eta*eta)*zeta*zeta,
- -1.0+3.0*xi-2.0*xi*xi+2.0*(2.0-6.0*xi+4.0*xi*xi)*eta+(3.0-9.0*xi+6.0*xi*xi+2.0*(-6.0+18.0*xi-12.0*xi*xi)*eta)*zeta+(-2.0+6.0*xi-4.0*xi*xi+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta)*zeta*zeta,
- (3.0-9.0*xi+6.0*xi*xi)*eta+(-6.0+18.0*xi-12.0*xi*xi)*eta*eta+2.0*((-2.0+6.0*xi-4.0*xi*xi)*eta+(4.0-12.0*xi+8.0*xi*xi)*eta*eta)*zeta);
+ -1.0+3.0*xi-2.0*xi*xi+2.0*(2.0-6.0*xi+4.0*xi*xi)*eta+(3.0-9.0*xi+6.0*xi*xi+2.0*(-6.0+18.0*xi-12.0*xi*xi)*eta)*zeta+(-2.0+6.0*xi-4.0*xi*xi+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta)*zeta*zeta,
+ (3.0-9.0*xi+6.0*xi*xi)*eta+(-6.0+18.0*xi-12.0*xi*xi)*eta*eta+2.0*((-2.0+6.0*xi-4.0*xi*xi)*eta+(4.0-12.0*xi+8.0*xi*xi)*eta*eta)*zeta);
case 5: return Point<3>((1.0-4.0*xi)*eta+(-2.0+8.0*xi)*eta*eta+((-3.0+12.0*xi)*eta+(6.0-24.0*xi)*eta*eta)*zeta+((2.0-8.0*xi)*eta+(-4.0+16.0*xi)*eta*eta)*zeta*zeta,
- xi-2.0*xi*xi+2.0*(-2.0*xi+4.0*xi*xi)*eta+(-3.0*xi+6.0*xi*xi+2.0*(6.0*xi-12.0*xi*xi)*eta)*zeta+(2.0*xi-4.0*xi*xi+2.0*(-4.0*xi+8.0*xi*xi)*eta)*zeta*zeta,
- (-3.0*xi+6.0*xi*xi)*eta+(6.0*xi-12.0*xi*xi)*eta*eta+2.0*((2.0*xi-4.0*xi*xi)*eta+(-4.0*xi+8.0*xi*xi)*eta*eta)*zeta);
+ xi-2.0*xi*xi+2.0*(-2.0*xi+4.0*xi*xi)*eta+(-3.0*xi+6.0*xi*xi+2.0*(6.0*xi-12.0*xi*xi)*eta)*zeta+(2.0*xi-4.0*xi*xi+2.0*(-4.0*xi+8.0*xi*xi)*eta)*zeta*zeta,
+ (-3.0*xi+6.0*xi*xi)*eta+(6.0*xi-12.0*xi*xi)*eta*eta+2.0*((2.0*xi-4.0*xi*xi)*eta+(-4.0*xi+8.0*xi*xi)*eta*eta)*zeta);
case 6: return Point<3>(((-1.0+4.0*xi)*eta+(2.0-8.0*xi)*eta*eta)*zeta+((2.0-8.0*xi)*eta+(-4.0+16.0*xi)*eta*eta)*zeta*zeta,
- (-xi+2.0*xi*xi+2.0*(2.0*xi-4.0*xi*xi)*eta)*zeta+(2.0*xi-4.0*xi*xi+2.0*(-4.0*xi+8.0*xi*xi)*eta)*zeta*zeta,
- (-xi+2.0*xi*xi)*eta+(2.0*xi-4.0*xi*xi)*eta*eta+2.0*((2.0*xi-4.0*xi*xi)*eta+(-4.0*xi+8.0*xi*xi)*eta*eta)*zeta);
+ (-xi+2.0*xi*xi+2.0*(2.0*xi-4.0*xi*xi)*eta)*zeta+(2.0*xi-4.0*xi*xi+2.0*(-4.0*xi+8.0*xi*xi)*eta)*zeta*zeta,
+ (-xi+2.0*xi*xi)*eta+(2.0*xi-4.0*xi*xi)*eta*eta+2.0*((2.0*xi-4.0*xi*xi)*eta+(-4.0*xi+8.0*xi*xi)*eta*eta)*zeta);
case 7: return Point<3>(((-3.0+4.0*xi)*eta+(6.0-8.0*xi)*eta*eta)*zeta+((6.0-8.0*xi)*eta+(-12.0+16.0*xi)*eta*eta)*zeta*zeta,
- (1.0-3.0*xi+2.0*xi*xi+2.0*(-2.0+6.0*xi-4.0*xi*xi)*eta)*zeta+(-2.0+6.0*xi-4.0*xi*xi+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta)*zeta*zeta,
- (1.0-3.0*xi+2.0*xi*xi)*eta+(-2.0+6.0*xi-4.0*xi*xi)*eta*eta+2.0*((-2.0+6.0*xi-4.0*xi*xi)*eta+(4.0-12.0*xi+8.0*xi*xi)*eta*eta)*zeta);
+ (1.0-3.0*xi+2.0*xi*xi+2.0*(-2.0+6.0*xi-4.0*xi*xi)*eta)*zeta+(-2.0+6.0*xi-4.0*xi*xi+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta)*zeta*zeta,
+ (1.0-3.0*xi+2.0*xi*xi)*eta+(-2.0+6.0*xi-4.0*xi*xi)*eta*eta+2.0*((-2.0+6.0*xi-4.0*xi*xi)*eta+(4.0-12.0*xi+8.0*xi*xi)*eta*eta)*zeta);
case 8: return Point<3>(4.0-8.0*xi+(-12.0+24.0*xi)*eta+(8.0-16.0*xi)*eta*eta+(-12.0+24.0*xi+(36.0-72.0*xi)*eta+(-24.0+48.0*xi)*eta*eta)*zeta+(8.0-16.0*xi+(-24.0+48.0*xi)*eta+(16.0-32.0*xi)*eta*eta)*zeta*zeta,
- -12.0*xi+12.0*xi*xi+2.0*(8.0*xi-8.0*xi*xi)*eta+(36.0*xi-36.0*xi*xi+2.0*(-24.0*xi+24.0*xi*xi)*eta)*zeta+(-24.0*xi+24.0*xi*xi+2.0*(16.0*xi-16.0*xi*xi)*eta)*zeta*zeta,
- -12.0*xi+12.0*xi*xi+(36.0*xi-36.0*xi*xi)*eta+(-24.0*xi+24.0*xi*xi)*eta*eta+2.0*(8.0*xi-8.0*xi*xi+(-24.0*xi+24.0*xi*xi)*eta+(16.0*xi-16.0*xi*xi)*eta*eta)*zeta);
+ -12.0*xi+12.0*xi*xi+2.0*(8.0*xi-8.0*xi*xi)*eta+(36.0*xi-36.0*xi*xi+2.0*(-24.0*xi+24.0*xi*xi)*eta)*zeta+(-24.0*xi+24.0*xi*xi+2.0*(16.0*xi-16.0*xi*xi)*eta)*zeta*zeta,
+ -12.0*xi+12.0*xi*xi+(36.0*xi-36.0*xi*xi)*eta+(-24.0*xi+24.0*xi*xi)*eta*eta+2.0*(8.0*xi-8.0*xi*xi+(-24.0*xi+24.0*xi*xi)*eta+(16.0*xi-16.0*xi*xi)*eta*eta)*zeta);
case 9: return Point<3>((-4.0+16.0*xi+(12.0-48.0*xi)*eta+(-8.0+32.0*xi)*eta*eta)*zeta+(4.0-16.0*xi+(-12.0+48.0*xi)*eta+(8.0-32.0*xi)*eta*eta)*zeta*zeta,
- (12.0*xi-24.0*xi*xi+2.0*(-8.0*xi+16.0*xi*xi)*eta)*zeta+(-12.0*xi+24.0*xi*xi+2.0*(8.0*xi-16.0*xi*xi)*eta)*zeta*zeta,
- -4.0*xi+8.0*xi*xi+(12.0*xi-24.0*xi*xi)*eta+(-8.0*xi+16.0*xi*xi)*eta*eta+2.0*(4.0*xi-8.0*xi*xi+(-12.0*xi+24.0*xi*xi)*eta+(8.0*xi-16.0*xi*xi)*eta*eta)*zeta);
+ (12.0*xi-24.0*xi*xi+2.0*(-8.0*xi+16.0*xi*xi)*eta)*zeta+(-12.0*xi+24.0*xi*xi+2.0*(8.0*xi-16.0*xi*xi)*eta)*zeta*zeta,
+ -4.0*xi+8.0*xi*xi+(12.0*xi-24.0*xi*xi)*eta+(-8.0*xi+16.0*xi*xi)*eta*eta+2.0*(4.0*xi-8.0*xi*xi+(-12.0*xi+24.0*xi*xi)*eta+(8.0*xi-16.0*xi*xi)*eta*eta)*zeta);
case 10: return Point<3>((-4.0+8.0*xi+(12.0-24.0*xi)*eta+(-8.0+16.0*xi)*eta*eta)*zeta+(8.0-16.0*xi+(-24.0+48.0*xi)*eta+(16.0-32.0*xi)*eta*eta)*zeta*zeta,
- (12.0*xi-12.0*xi*xi+2.0*(-8.0*xi+8.0*xi*xi)*eta)*zeta+(-24.0*xi+24.0*xi*xi+2.0*(16.0*xi-16.0*xi*xi)*eta)*zeta*zeta,
- -4.0*xi+4.0*xi*xi+(12.0*xi-12.0*xi*xi)*eta+(-8.0*xi+8.0*xi*xi)*eta*eta+2.0*(8.0*xi-8.0*xi*xi+(-24.0*xi+24.0*xi*xi)*eta+(16.0*xi-16.0*xi*xi)*eta*eta)*zeta);
+ (12.0*xi-12.0*xi*xi+2.0*(-8.0*xi+8.0*xi*xi)*eta)*zeta+(-24.0*xi+24.0*xi*xi+2.0*(16.0*xi-16.0*xi*xi)*eta)*zeta*zeta,
+ -4.0*xi+4.0*xi*xi+(12.0*xi-12.0*xi*xi)*eta+(-8.0*xi+8.0*xi*xi)*eta*eta+2.0*(8.0*xi-8.0*xi*xi+(-24.0*xi+24.0*xi*xi)*eta+(16.0*xi-16.0*xi*xi)*eta*eta)*zeta);
case 11: return Point<3>((-12.0+16.0*xi+(36.0-48.0*xi)*eta+(-24.0+32.0*xi)*eta*eta)*zeta+(12.0-16.0*xi+(-36.0+48.0*xi)*eta+(24.0-32.0*xi)*eta*eta)*zeta*zeta,
- (-12.0+36.0*xi-24.0*xi*xi+2.0*(8.0-24.0*xi+16.0*xi*xi)*eta)*zeta+(12.0-36.0*xi+24.0*xi*xi+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta)*zeta*zeta,
- 4.0-12.0*xi+8.0*xi*xi+(-12.0+36.0*xi-24.0*xi*xi)*eta+(8.0-24.0*xi+16.0*xi*xi)*eta*eta+2.0*(-4.0+12.0*xi-8.0*xi*xi+(12.0-36.0*xi+24.0*xi*xi)*eta+(-8.0+24.0*xi-16.0*xi*xi)*eta*eta)*zeta);
+ (-12.0+36.0*xi-24.0*xi*xi+2.0*(8.0-24.0*xi+16.0*xi*xi)*eta)*zeta+(12.0-36.0*xi+24.0*xi*xi+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta)*zeta*zeta,
+ 4.0-12.0*xi+8.0*xi*xi+(-12.0+36.0*xi-24.0*xi*xi)*eta+(8.0-24.0*xi+16.0*xi*xi)*eta*eta+2.0*(-4.0+12.0*xi-8.0*xi*xi+(12.0-36.0*xi+24.0*xi*xi)*eta+(-8.0+24.0*xi-16.0*xi*xi)*eta*eta)*zeta);
case 12: return Point<3>((-4.0+8.0*xi)*eta+(8.0-16.0*xi)*eta*eta+((12.0-24.0*xi)*eta+(-24.0+48.0*xi)*eta*eta)*zeta+((-8.0+16.0*xi)*eta+(16.0-32.0*xi)*eta*eta)*zeta*zeta,
- -4.0*xi+4.0*xi*xi+2.0*(8.0*xi-8.0*xi*xi)*eta+(12.0*xi-12.0*xi*xi+2.0*(-24.0*xi+24.0*xi*xi)*eta)*zeta+(-8.0*xi+8.0*xi*xi+2.0*(16.0*xi-16.0*xi*xi)*eta)*zeta*zeta,
- (12.0*xi-12.0*xi*xi)*eta+(-24.0*xi+24.0*xi*xi)*eta*eta+2.0*((-8.0*xi+8.0*xi*xi)*eta+(16.0*xi-16.0*xi*xi)*eta*eta)*zeta);
+ -4.0*xi+4.0*xi*xi+2.0*(8.0*xi-8.0*xi*xi)*eta+(12.0*xi-12.0*xi*xi+2.0*(-24.0*xi+24.0*xi*xi)*eta)*zeta+(-8.0*xi+8.0*xi*xi+2.0*(16.0*xi-16.0*xi*xi)*eta)*zeta*zeta,
+ (12.0*xi-12.0*xi*xi)*eta+(-24.0*xi+24.0*xi*xi)*eta*eta+2.0*((-8.0*xi+8.0*xi*xi)*eta+(16.0*xi-16.0*xi*xi)*eta*eta)*zeta);
case 13: return Point<3>(((4.0-16.0*xi)*eta+(-8.0+32.0*xi)*eta*eta)*zeta+((-4.0+16.0*xi)*eta+(8.0-32.0*xi)*eta*eta)*zeta*zeta,
- (4.0*xi-8.0*xi*xi+2.0*(-8.0*xi+16.0*xi*xi)*eta)*zeta+(-4.0*xi+8.0*xi*xi+2.0*(8.0*xi-16.0*xi*xi)*eta)*zeta*zeta,
- (4.0*xi-8.0*xi*xi)*eta+(-8.0*xi+16.0*xi*xi)*eta*eta+2.0*((-4.0*xi+8.0*xi*xi)*eta+(8.0*xi-16.0*xi*xi)*eta*eta)*zeta);
+ (4.0*xi-8.0*xi*xi+2.0*(-8.0*xi+16.0*xi*xi)*eta)*zeta+(-4.0*xi+8.0*xi*xi+2.0*(8.0*xi-16.0*xi*xi)*eta)*zeta*zeta,
+ (4.0*xi-8.0*xi*xi)*eta+(-8.0*xi+16.0*xi*xi)*eta*eta+2.0*((-4.0*xi+8.0*xi*xi)*eta+(8.0*xi-16.0*xi*xi)*eta*eta)*zeta);
case 14: return Point<3>(((4.0-8.0*xi)*eta+(-8.0+16.0*xi)*eta*eta)*zeta+((-8.0+16.0*xi)*eta+(16.0-32.0*xi)*eta*eta)*zeta*zeta,
- (4.0*xi-4.0*xi*xi+2.0*(-8.0*xi+8.0*xi*xi)*eta)*zeta+(-8.0*xi+8.0*xi*xi+2.0*(16.0*xi-16.0*xi*xi)*eta)*zeta*zeta,
- (4.0*xi-4.0*xi*xi)*eta+(-8.0*xi+8.0*xi*xi)*eta*eta+2.0*((-8.0*xi+8.0*xi*xi)*eta+(16.0*xi-16.0*xi*xi)*eta*eta)*zeta);
+ (4.0*xi-4.0*xi*xi+2.0*(-8.0*xi+8.0*xi*xi)*eta)*zeta+(-8.0*xi+8.0*xi*xi+2.0*(16.0*xi-16.0*xi*xi)*eta)*zeta*zeta,
+ (4.0*xi-4.0*xi*xi)*eta+(-8.0*xi+8.0*xi*xi)*eta*eta+2.0*((-8.0*xi+8.0*xi*xi)*eta+(16.0*xi-16.0*xi*xi)*eta*eta)*zeta);
case 15: return Point<3>(((12.0-16.0*xi)*eta+(-24.0+32.0*xi)*eta*eta)*zeta+((-12.0+16.0*xi)*eta+(24.0-32.0*xi)*eta*eta)*zeta*zeta,
- (-4.0+12.0*xi-8.0*xi*xi+2.0*(8.0-24.0*xi+16.0*xi*xi)*eta)*zeta+(4.0-12.0*xi+8.0*xi*xi+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta)*zeta*zeta,
- (-4.0+12.0*xi-8.0*xi*xi)*eta+(8.0-24.0*xi+16.0*xi*xi)*eta*eta+2.0*((4.0-12.0*xi+8.0*xi*xi)*eta+(-8.0+24.0*xi-16.0*xi*xi)*eta*eta)*zeta);
+ (-4.0+12.0*xi-8.0*xi*xi+2.0*(8.0-24.0*xi+16.0*xi*xi)*eta)*zeta+(4.0-12.0*xi+8.0*xi*xi+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta)*zeta*zeta,
+ (-4.0+12.0*xi-8.0*xi*xi)*eta+(8.0-24.0*xi+16.0*xi*xi)*eta*eta+2.0*((4.0-12.0*xi+8.0*xi*xi)*eta+(-8.0+24.0*xi-16.0*xi*xi)*eta*eta)*zeta);
case 16: return Point<3>((-12.0+16.0*xi)*eta+(12.0-16.0*xi)*eta*eta+((36.0-48.0*xi)*eta+(-36.0+48.0*xi)*eta*eta)*zeta+((-24.0+32.0*xi)*eta+(24.0-32.0*xi)*eta*eta)*zeta*zeta,
- 4.0-12.0*xi+8.0*xi*xi+2.0*(-4.0+12.0*xi-8.0*xi*xi)*eta+(-12.0+36.0*xi-24.0*xi*xi+2.0*(12.0-36.0*xi+24.0*xi*xi)*eta)*zeta+(8.0-24.0*xi+16.0*xi*xi+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta)*zeta*zeta,
- (-12.0+36.0*xi-24.0*xi*xi)*eta+(12.0-36.0*xi+24.0*xi*xi)*eta*eta+2.0*((8.0-24.0*xi+16.0*xi*xi)*eta+(-8.0+24.0*xi-16.0*xi*xi)*eta*eta)*zeta);
+ 4.0-12.0*xi+8.0*xi*xi+2.0*(-4.0+12.0*xi-8.0*xi*xi)*eta+(-12.0+36.0*xi-24.0*xi*xi+2.0*(12.0-36.0*xi+24.0*xi*xi)*eta)*zeta+(8.0-24.0*xi+16.0*xi*xi+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta)*zeta*zeta,
+ (-12.0+36.0*xi-24.0*xi*xi)*eta+(12.0-36.0*xi+24.0*xi*xi)*eta*eta+2.0*((8.0-24.0*xi+16.0*xi*xi)*eta+(-8.0+24.0*xi-16.0*xi*xi)*eta*eta)*zeta);
case 17: return Point<3>((-4.0+16.0*xi)*eta+(4.0-16.0*xi)*eta*eta+((12.0-48.0*xi)*eta+(-12.0+48.0*xi)*eta*eta)*zeta+((-8.0+32.0*xi)*eta+(8.0-32.0*xi)*eta*eta)*zeta*zeta,
- -4.0*xi+8.0*xi*xi+2.0*(4.0*xi-8.0*xi*xi)*eta+(12.0*xi-24.0*xi*xi+2.0*(-12.0*xi+24.0*xi*xi)*eta)*zeta+(-8.0*xi+16.0*xi*xi+2.0*(8.0*xi-16.0*xi*xi)*eta)*zeta*zeta,
- (12.0*xi-24.0*xi*xi)*eta+(-12.0*xi+24.0*xi*xi)*eta*eta+2.0*((-8.0*xi+16.0*xi*xi)*eta+(8.0*xi-16.0*xi*xi)*eta*eta)*zeta);
+ -4.0*xi+8.0*xi*xi+2.0*(4.0*xi-8.0*xi*xi)*eta+(12.0*xi-24.0*xi*xi+2.0*(-12.0*xi+24.0*xi*xi)*eta)*zeta+(-8.0*xi+16.0*xi*xi+2.0*(8.0*xi-16.0*xi*xi)*eta)*zeta*zeta,
+ (12.0*xi-24.0*xi*xi)*eta+(-12.0*xi+24.0*xi*xi)*eta*eta+2.0*((-8.0*xi+16.0*xi*xi)*eta+(8.0*xi-16.0*xi*xi)*eta*eta)*zeta);
case 18: return Point<3>(((4.0-16.0*xi)*eta+(-4.0+16.0*xi)*eta*eta)*zeta+((-8.0+32.0*xi)*eta+(8.0-32.0*xi)*eta*eta)*zeta*zeta,
- (4.0*xi-8.0*xi*xi+2.0*(-4.0*xi+8.0*xi*xi)*eta)*zeta+(-8.0*xi+16.0*xi*xi+2.0*(8.0*xi-16.0*xi*xi)*eta)*zeta*zeta,
- (4.0*xi-8.0*xi*xi)*eta+(-4.0*xi+8.0*xi*xi)*eta*eta+2.0*((-8.0*xi+16.0*xi*xi)*eta+(8.0*xi-16.0*xi*xi)*eta*eta)*zeta);
+ (4.0*xi-8.0*xi*xi+2.0*(-4.0*xi+8.0*xi*xi)*eta)*zeta+(-8.0*xi+16.0*xi*xi+2.0*(8.0*xi-16.0*xi*xi)*eta)*zeta*zeta,
+ (4.0*xi-8.0*xi*xi)*eta+(-4.0*xi+8.0*xi*xi)*eta*eta+2.0*((-8.0*xi+16.0*xi*xi)*eta+(8.0*xi-16.0*xi*xi)*eta*eta)*zeta);
case 19: return Point<3>(((12.0-16.0*xi)*eta+(-12.0+16.0*xi)*eta*eta)*zeta+((-24.0+32.0*xi)*eta+(24.0-32.0*xi)*eta*eta)*zeta*zeta,
- (-4.0+12.0*xi-8.0*xi*xi+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta)*zeta+(8.0-24.0*xi+16.0*xi*xi+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta)*zeta*zeta,
- (-4.0+12.0*xi-8.0*xi*xi)*eta+(4.0-12.0*xi+8.0*xi*xi)*eta*eta+2.0*((8.0-24.0*xi+16.0*xi*xi)*eta+(-8.0+24.0*xi-16.0*xi*xi)*eta*eta)*zeta);
+ (-4.0+12.0*xi-8.0*xi*xi+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta)*zeta+(8.0-24.0*xi+16.0*xi*xi+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta)*zeta*zeta,
+ (-4.0+12.0*xi-8.0*xi*xi)*eta+(4.0-12.0*xi+8.0*xi*xi)*eta*eta+2.0*((8.0-24.0*xi+16.0*xi*xi)*eta+(-8.0+24.0*xi-16.0*xi*xi)*eta*eta)*zeta);
case 20: return Point<3>((16.0-32.0*xi+(-48.0+96.0*xi)*eta+(32.0-64.0*xi)*eta*eta)*zeta+(-16.0+32.0*xi+(48.0-96.0*xi)*eta+(-32.0+64.0*xi)*eta*eta)*zeta*zeta,
- (-48.0*xi+48.0*xi*xi+2.0*(32.0*xi-32.0*xi*xi)*eta)*zeta+(48.0*xi-48.0*xi*xi+2.0*(-32.0*xi+32.0*xi*xi)*eta)*zeta*zeta,
- 16.0*xi-16.0*xi*xi+(-48.0*xi+48.0*xi*xi)*eta+(32.0*xi-32.0*xi*xi)*eta*eta+2.0*(-16.0*xi+16.0*xi*xi+(48.0*xi-48.0*xi*xi)*eta+(-32.0*xi+32.0*xi*xi)*eta*eta)*zeta);
+ (-48.0*xi+48.0*xi*xi+2.0*(32.0*xi-32.0*xi*xi)*eta)*zeta+(48.0*xi-48.0*xi*xi+2.0*(-32.0*xi+32.0*xi*xi)*eta)*zeta*zeta,
+ 16.0*xi-16.0*xi*xi+(-48.0*xi+48.0*xi*xi)*eta+(32.0*xi-32.0*xi*xi)*eta*eta+2.0*(-16.0*xi+16.0*xi*xi+(48.0*xi-48.0*xi*xi)*eta+(-32.0*xi+32.0*xi*xi)*eta*eta)*zeta);
case 21: return Point<3>(((-16.0+32.0*xi)*eta+(32.0-64.0*xi)*eta*eta)*zeta+((16.0-32.0*xi)*eta+(-32.0+64.0*xi)*eta*eta)*zeta*zeta,
- (-16.0*xi+16.0*xi*xi+2.0*(32.0*xi-32.0*xi*xi)*eta)*zeta+(16.0*xi-16.0*xi*xi+2.0*(-32.0*xi+32.0*xi*xi)*eta)*zeta*zeta,
- (-16.0*xi+16.0*xi*xi)*eta+(32.0*xi-32.0*xi*xi)*eta*eta+2.0*((16.0*xi-16.0*xi*xi)*eta+(-32.0*xi+32.0*xi*xi)*eta*eta)*zeta);
+ (-16.0*xi+16.0*xi*xi+2.0*(32.0*xi-32.0*xi*xi)*eta)*zeta+(16.0*xi-16.0*xi*xi+2.0*(-32.0*xi+32.0*xi*xi)*eta)*zeta*zeta,
+ (-16.0*xi+16.0*xi*xi)*eta+(32.0*xi-32.0*xi*xi)*eta*eta+2.0*((16.0*xi-16.0*xi*xi)*eta+(-32.0*xi+32.0*xi*xi)*eta*eta)*zeta);
case 22: return Point<3>((16.0-32.0*xi)*eta+(-16.0+32.0*xi)*eta*eta+((-48.0+96.0*xi)*eta+(48.0-96.0*xi)*eta*eta)*zeta+((32.0-64.0*xi)*eta+(-32.0+64.0*xi)*eta*eta)*zeta*zeta,
- 16.0*xi-16.0*xi*xi+2.0*(-16.0*xi+16.0*xi*xi)*eta+(-48.0*xi+48.0*xi*xi+2.0*(48.0*xi-48.0*xi*xi)*eta)*zeta+(32.0*xi-32.0*xi*xi+2.0*(-32.0*xi+32.0*xi*xi)*eta)*zeta*zeta,
- (-48.0*xi+48.0*xi*xi)*eta+(48.0*xi-48.0*xi*xi)*eta*eta+2.0*((32.0*xi-32.0*xi*xi)*eta+(-32.0*xi+32.0*xi*xi)*eta*eta)*zeta);
+ 16.0*xi-16.0*xi*xi+2.0*(-16.0*xi+16.0*xi*xi)*eta+(-48.0*xi+48.0*xi*xi+2.0*(48.0*xi-48.0*xi*xi)*eta)*zeta+(32.0*xi-32.0*xi*xi+2.0*(-32.0*xi+32.0*xi*xi)*eta)*zeta*zeta,
+ (-48.0*xi+48.0*xi*xi)*eta+(48.0*xi-48.0*xi*xi)*eta*eta+2.0*((32.0*xi-32.0*xi*xi)*eta+(-32.0*xi+32.0*xi*xi)*eta*eta)*zeta);
case 23: return Point<3>(((-16.0+64.0*xi)*eta+(16.0-64.0*xi)*eta*eta)*zeta+((16.0-64.0*xi)*eta+(-16.0+64.0*xi)*eta*eta)*zeta*zeta,
- (-16.0*xi+32.0*xi*xi+2.0*(16.0*xi-32.0*xi*xi)*eta)*zeta+(16.0*xi-32.0*xi*xi+2.0*(-16.0*xi+32.0*xi*xi)*eta)*zeta*zeta,
- (-16.0*xi+32.0*xi*xi)*eta+(16.0*xi-32.0*xi*xi)*eta*eta+2.0*((16.0*xi-32.0*xi*xi)*eta+(-16.0*xi+32.0*xi*xi)*eta*eta)*zeta);
+ (-16.0*xi+32.0*xi*xi+2.0*(16.0*xi-32.0*xi*xi)*eta)*zeta+(16.0*xi-32.0*xi*xi+2.0*(-16.0*xi+32.0*xi*xi)*eta)*zeta*zeta,
+ (-16.0*xi+32.0*xi*xi)*eta+(16.0*xi-32.0*xi*xi)*eta*eta+2.0*((16.0*xi-32.0*xi*xi)*eta+(-16.0*xi+32.0*xi*xi)*eta*eta)*zeta);
case 24: return Point<3>(((-16.0+32.0*xi)*eta+(16.0-32.0*xi)*eta*eta)*zeta+((32.0-64.0*xi)*eta+(-32.0+64.0*xi)*eta*eta)*zeta*zeta,
- (-16.0*xi+16.0*xi*xi+2.0*(16.0*xi-16.0*xi*xi)*eta)*zeta+(32.0*xi-32.0*xi*xi+2.0*(-32.0*xi+32.0*xi*xi)*eta)*zeta*zeta,
- (-16.0*xi+16.0*xi*xi)*eta+(16.0*xi-16.0*xi*xi)*eta*eta+2.0*((32.0*xi-32.0*xi*xi)*eta+(-32.0*xi+32.0*xi*xi)*eta*eta)*zeta);
+ (-16.0*xi+16.0*xi*xi+2.0*(16.0*xi-16.0*xi*xi)*eta)*zeta+(32.0*xi-32.0*xi*xi+2.0*(-32.0*xi+32.0*xi*xi)*eta)*zeta*zeta,
+ (-16.0*xi+16.0*xi*xi)*eta+(16.0*xi-16.0*xi*xi)*eta*eta+2.0*((32.0*xi-32.0*xi*xi)*eta+(-32.0*xi+32.0*xi*xi)*eta*eta)*zeta);
case 25: return Point<3>(((-48.0+64.0*xi)*eta+(48.0-64.0*xi)*eta*eta)*zeta+((48.0-64.0*xi)*eta+(-48.0+64.0*xi)*eta*eta)*zeta*zeta,
- (16.0-48.0*xi+32.0*xi*xi+2.0*(-16.0+48.0*xi-32.0*xi*xi)*eta)*zeta+(-16.0+48.0*xi-32.0*xi*xi+2.0*(16.0-48.0*xi+32.0*xi*xi)*eta)*zeta*zeta,
- (16.0-48.0*xi+32.0*xi*xi)*eta+(-16.0+48.0*xi-32.0*xi*xi)*eta*eta+2.0*((-16.0+48.0*xi-32.0*xi*xi)*eta+(16.0-48.0*xi+32.0*xi*xi)*eta*eta)*zeta);
+ (16.0-48.0*xi+32.0*xi*xi+2.0*(-16.0+48.0*xi-32.0*xi*xi)*eta)*zeta+(-16.0+48.0*xi-32.0*xi*xi+2.0*(16.0-48.0*xi+32.0*xi*xi)*eta)*zeta*zeta,
+ (16.0-48.0*xi+32.0*xi*xi)*eta+(-16.0+48.0*xi-32.0*xi*xi)*eta*eta+2.0*((-16.0+48.0*xi-32.0*xi*xi)*eta+(16.0-48.0*xi+32.0*xi*xi)*eta*eta)*zeta);
case 26: return Point<3>(((64.0-128.0*xi)*eta+(-64.0+128.0*xi)*eta*eta)*zeta+((-64.0+128.0*xi)*eta+(64.0-128.0*xi)*eta*eta)*zeta*zeta,
- (64.0*xi-64.0*xi*xi+2.0*(-64.0*xi+64.0*xi*xi)*eta)*zeta+(-64.0*xi+64.0*xi*xi+2.0*(64.0*xi-64.0*xi*xi)*eta)*zeta*zeta,
- (64.0*xi-64.0*xi*xi)*eta+(-64.0*xi+64.0*xi*xi)*eta*eta+2.0*((-64.0*xi+64.0*xi*xi)*eta+(64.0*xi-64.0*xi*xi)*eta*eta)*zeta);
+ (64.0*xi-64.0*xi*xi+2.0*(-64.0*xi+64.0*xi*xi)*eta)*zeta+(-64.0*xi+64.0*xi*xi+2.0*(64.0*xi-64.0*xi*xi)*eta)*zeta*zeta,
+ (64.0*xi-64.0*xi*xi)*eta+(-64.0*xi+64.0*xi*xi)*eta*eta+2.0*((-64.0*xi+64.0*xi*xi)*eta+(64.0*xi-64.0*xi*xi)*eta*eta)*zeta);
};
return Point<3> ();
};
switch (i)
{
-case 0:
-return_value[0][0] = 4.0-12.0*eta+8.0*eta*eta+(-12.0+36.0*eta-24.0*eta*eta)*zeta+(8.0-24.0*eta+16.0*eta*eta)*zeta*zeta;
-return_value[0][1] = 9.0-12.0*xi+2.0*(-6.0+8.0*xi)*eta+(-27.0+36.0*xi+2.0*(18.0-24.0*xi)*eta)*zeta+(18.0-24.0*xi+2.0*(-12.0+16.0*xi)*eta)*zeta*zeta;
-return_value[0][2] = 9.0-12.0*xi+(-27.0+36.0*xi)*eta+(18.0-24.0*xi)*eta*eta+2.0*(-6.0+8.0*xi+(18.0-24.0*xi)*eta+(-12.0+16.0*xi)*eta*eta)*zeta;
-return_value[1][0] = 9.0-12.0*xi+2.0*(-6.0+8.0*xi)*eta+(-27.0+36.0*xi+2.0*(18.0-24.0*xi)*eta)*zeta+(18.0-24.0*xi+2.0*(-12.0+16.0*xi)*eta)*zeta*zeta;
-return_value[1][1] = 4.0-12.0*xi+8.0*xi*xi+(-12.0+36.0*xi-24.0*xi*xi)*zeta+(8.0-24.0*xi+16.0*xi*xi)*zeta*zeta;
-return_value[1][2] = 9.0-27.0*xi+18.0*xi*xi+2.0*(-6.0+18.0*xi-12.0*xi*xi)*eta+2.0*(-6.0+18.0*xi-12.0*xi*xi+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta)*zeta;
-return_value[2][0] = 9.0-12.0*xi+(-27.0+36.0*xi)*eta+(18.0-24.0*xi)*eta*eta+2.0*(-6.0+8.0*xi+(18.0-24.0*xi)*eta+(-12.0+16.0*xi)*eta*eta)*zeta;
-return_value[2][1] = 9.0-27.0*xi+18.0*xi*xi+2.0*(-6.0+18.0*xi-12.0*xi*xi)*eta+2.0*(-6.0+18.0*xi-12.0*xi*xi+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta)*zeta;
-return_value[2][2] = 4.0-12.0*xi+8.0*xi*xi+2.0*(-6.0+18.0*xi-12.0*xi*xi)*eta+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta*eta;
-break;
-case 1:
-return_value[0][0] = 4.0-12.0*eta+8.0*eta*eta+(-12.0+36.0*eta-24.0*eta*eta)*zeta+(8.0-24.0*eta+16.0*eta*eta)*zeta*zeta;
-return_value[0][1] = 3.0-12.0*xi+2.0*(-2.0+8.0*xi)*eta+(-9.0+36.0*xi+2.0*(6.0-24.0*xi)*eta)*zeta+(6.0-24.0*xi+2.0*(-4.0+16.0*xi)*eta)*zeta*zeta;
-return_value[0][2] = 3.0-12.0*xi+(-9.0+36.0*xi)*eta+(6.0-24.0*xi)*eta*eta+2.0*(-2.0+8.0*xi+(6.0-24.0*xi)*eta+(-4.0+16.0*xi)*eta*eta)*zeta;
-return_value[1][0] = 3.0-12.0*xi+2.0*(-2.0+8.0*xi)*eta+(-9.0+36.0*xi+2.0*(6.0-24.0*xi)*eta)*zeta+(6.0-24.0*xi+2.0*(-4.0+16.0*xi)*eta)*zeta*zeta;
-return_value[1][1] = -4.0*xi+8.0*xi*xi+(12.0*xi-24.0*xi*xi)*zeta+(-8.0*xi+16.0*xi*xi)*zeta*zeta;
-return_value[1][2] = -9.0*xi+18.0*xi*xi+2.0*(6.0*xi-12.0*xi*xi)*eta+2.0*(6.0*xi-12.0*xi*xi+2.0*(-4.0*xi+8.0*xi*xi)*eta)*zeta;
-return_value[2][0] = 3.0-12.0*xi+(-9.0+36.0*xi)*eta+(6.0-24.0*xi)*eta*eta+2.0*(-2.0+8.0*xi+(6.0-24.0*xi)*eta+(-4.0+16.0*xi)*eta*eta)*zeta;
-return_value[2][1] = -9.0*xi+18.0*xi*xi+2.0*(6.0*xi-12.0*xi*xi)*eta+2.0*(6.0*xi-12.0*xi*xi+2.0*(-4.0*xi+8.0*xi*xi)*eta)*zeta;
-return_value[2][2] = -4.0*xi+8.0*xi*xi+2.0*(6.0*xi-12.0*xi*xi)*eta+2.0*(-4.0*xi+8.0*xi*xi)*eta*eta;
-break;
-case 2:
-return_value[0][0] = (-4.0+12.0*eta-8.0*eta*eta)*zeta+(8.0-24.0*eta+16.0*eta*eta)*zeta*zeta;
-return_value[0][1] = (-3.0+12.0*xi+2.0*(2.0-8.0*xi)*eta)*zeta+(6.0-24.0*xi+2.0*(-4.0+16.0*xi)*eta)*zeta*zeta;
-return_value[0][2] = 1.0-4.0*xi+(-3.0+12.0*xi)*eta+(2.0-8.0*xi)*eta*eta+2.0*(-2.0+8.0*xi+(6.0-24.0*xi)*eta+(-4.0+16.0*xi)*eta*eta)*zeta;
-return_value[1][0] = (-3.0+12.0*xi+2.0*(2.0-8.0*xi)*eta)*zeta+(6.0-24.0*xi+2.0*(-4.0+16.0*xi)*eta)*zeta*zeta;
-return_value[1][1] = (4.0*xi-8.0*xi*xi)*zeta+(-8.0*xi+16.0*xi*xi)*zeta*zeta;
-return_value[1][2] = -3.0*xi+6.0*xi*xi+2.0*(2.0*xi-4.0*xi*xi)*eta+2.0*(6.0*xi-12.0*xi*xi+2.0*(-4.0*xi+8.0*xi*xi)*eta)*zeta;
-return_value[2][0] = 1.0-4.0*xi+(-3.0+12.0*xi)*eta+(2.0-8.0*xi)*eta*eta+2.0*(-2.0+8.0*xi+(6.0-24.0*xi)*eta+(-4.0+16.0*xi)*eta*eta)*zeta;
-return_value[2][1] = -3.0*xi+6.0*xi*xi+2.0*(2.0*xi-4.0*xi*xi)*eta+2.0*(6.0*xi-12.0*xi*xi+2.0*(-4.0*xi+8.0*xi*xi)*eta)*zeta;
-return_value[2][2] = -4.0*xi+8.0*xi*xi+2.0*(6.0*xi-12.0*xi*xi)*eta+2.0*(-4.0*xi+8.0*xi*xi)*eta*eta;
-break;
-case 3:
-return_value[0][0] = (-4.0+12.0*eta-8.0*eta*eta)*zeta+(8.0-24.0*eta+16.0*eta*eta)*zeta*zeta;
-return_value[0][1] = (-9.0+12.0*xi+2.0*(6.0-8.0*xi)*eta)*zeta+(18.0-24.0*xi+2.0*(-12.0+16.0*xi)*eta)*zeta*zeta;
-return_value[0][2] = 3.0-4.0*xi+(-9.0+12.0*xi)*eta+(6.0-8.0*xi)*eta*eta+2.0*(-6.0+8.0*xi+(18.0-24.0*xi)*eta+(-12.0+16.0*xi)*eta*eta)*zeta;
-return_value[1][0] = (-9.0+12.0*xi+2.0*(6.0-8.0*xi)*eta)*zeta+(18.0-24.0*xi+2.0*(-12.0+16.0*xi)*eta)*zeta*zeta;
-return_value[1][1] = (-4.0+12.0*xi-8.0*xi*xi)*zeta+(8.0-24.0*xi+16.0*xi*xi)*zeta*zeta;
-return_value[1][2] = 3.0-9.0*xi+6.0*xi*xi+2.0*(-2.0+6.0*xi-4.0*xi*xi)*eta+2.0*(-6.0+18.0*xi-12.0*xi*xi+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta)*zeta;
-return_value[2][0] = 3.0-4.0*xi+(-9.0+12.0*xi)*eta+(6.0-8.0*xi)*eta*eta+2.0*(-6.0+8.0*xi+(18.0-24.0*xi)*eta+(-12.0+16.0*xi)*eta*eta)*zeta;
-return_value[2][1] = 3.0-9.0*xi+6.0*xi*xi+2.0*(-2.0+6.0*xi-4.0*xi*xi)*eta+2.0*(-6.0+18.0*xi-12.0*xi*xi+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta)*zeta;
-return_value[2][2] = 4.0-12.0*xi+8.0*xi*xi+2.0*(-6.0+18.0*xi-12.0*xi*xi)*eta+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta*eta;
-break;
-case 4:
-return_value[0][0] = -4.0*eta+8.0*eta*eta+(12.0*eta-24.0*eta*eta)*zeta+(-8.0*eta+16.0*eta*eta)*zeta*zeta;
-return_value[0][1] = 3.0-4.0*xi+2.0*(-6.0+8.0*xi)*eta+(-9.0+12.0*xi+2.0*(18.0-24.0*xi)*eta)*zeta+(6.0-8.0*xi+2.0*(-12.0+16.0*xi)*eta)*zeta*zeta;
-return_value[0][2] = (-9.0+12.0*xi)*eta+(18.0-24.0*xi)*eta*eta+2.0*((6.0-8.0*xi)*eta+(-12.0+16.0*xi)*eta*eta)*zeta;
-return_value[1][0] = 3.0-4.0*xi+2.0*(-6.0+8.0*xi)*eta+(-9.0+12.0*xi+2.0*(18.0-24.0*xi)*eta)*zeta+(6.0-8.0*xi+2.0*(-12.0+16.0*xi)*eta)*zeta*zeta;
-return_value[1][1] = 4.0-12.0*xi+8.0*xi*xi+(-12.0+36.0*xi-24.0*xi*xi)*zeta+(8.0-24.0*xi+16.0*xi*xi)*zeta*zeta;
-return_value[1][2] = 3.0-9.0*xi+6.0*xi*xi+2.0*(-6.0+18.0*xi-12.0*xi*xi)*eta+2.0*(-2.0+6.0*xi-4.0*xi*xi+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta)*zeta;
-return_value[2][0] = (-9.0+12.0*xi)*eta+(18.0-24.0*xi)*eta*eta+2.0*((6.0-8.0*xi)*eta+(-12.0+16.0*xi)*eta*eta)*zeta;
-return_value[2][1] = 3.0-9.0*xi+6.0*xi*xi+2.0*(-6.0+18.0*xi-12.0*xi*xi)*eta+2.0*(-2.0+6.0*xi-4.0*xi*xi+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta)*zeta;
-return_value[2][2] = 2.0*(-2.0+6.0*xi-4.0*xi*xi)*eta+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta*eta;
-break;
-case 5:
-return_value[0][0] = -4.0*eta+8.0*eta*eta+(12.0*eta-24.0*eta*eta)*zeta+(-8.0*eta+16.0*eta*eta)*zeta*zeta;
-return_value[0][1] = 1.0-4.0*xi+2.0*(-2.0+8.0*xi)*eta+(-3.0+12.0*xi+2.0*(6.0-24.0*xi)*eta)*zeta+(2.0-8.0*xi+2.0*(-4.0+16.0*xi)*eta)*zeta*zeta;
-return_value[0][2] = (-3.0+12.0*xi)*eta+(6.0-24.0*xi)*eta*eta+2.0*((2.0-8.0*xi)*eta+(-4.0+16.0*xi)*eta*eta)*zeta;
-return_value[1][0] = 1.0-4.0*xi+2.0*(-2.0+8.0*xi)*eta+(-3.0+12.0*xi+2.0*(6.0-24.0*xi)*eta)*zeta+(2.0-8.0*xi+2.0*(-4.0+16.0*xi)*eta)*zeta*zeta;
-return_value[1][1] = -4.0*xi+8.0*xi*xi+(12.0*xi-24.0*xi*xi)*zeta+(-8.0*xi+16.0*xi*xi)*zeta*zeta;
-return_value[1][2] = -3.0*xi+6.0*xi*xi+2.0*(6.0*xi-12.0*xi*xi)*eta+2.0*(2.0*xi-4.0*xi*xi+2.0*(-4.0*xi+8.0*xi*xi)*eta)*zeta;
-return_value[2][0] = (-3.0+12.0*xi)*eta+(6.0-24.0*xi)*eta*eta+2.0*((2.0-8.0*xi)*eta+(-4.0+16.0*xi)*eta*eta)*zeta;
-return_value[2][1] = -3.0*xi+6.0*xi*xi+2.0*(6.0*xi-12.0*xi*xi)*eta+2.0*(2.0*xi-4.0*xi*xi+2.0*(-4.0*xi+8.0*xi*xi)*eta)*zeta;
-return_value[2][2] = 2.0*(2.0*xi-4.0*xi*xi)*eta+2.0*(-4.0*xi+8.0*xi*xi)*eta*eta;
-break;
-case 6:
-return_value[0][0] = (4.0*eta-8.0*eta*eta)*zeta+(-8.0*eta+16.0*eta*eta)*zeta*zeta;
-return_value[0][1] = (-1.0+4.0*xi+2.0*(2.0-8.0*xi)*eta)*zeta+(2.0-8.0*xi+2.0*(-4.0+16.0*xi)*eta)*zeta*zeta;
-return_value[0][2] = (-1.0+4.0*xi)*eta+(2.0-8.0*xi)*eta*eta+2.0*((2.0-8.0*xi)*eta+(-4.0+16.0*xi)*eta*eta)*zeta;
-return_value[1][0] = (-1.0+4.0*xi+2.0*(2.0-8.0*xi)*eta)*zeta+(2.0-8.0*xi+2.0*(-4.0+16.0*xi)*eta)*zeta*zeta;
-return_value[1][1] = (4.0*xi-8.0*xi*xi)*zeta+(-8.0*xi+16.0*xi*xi)*zeta*zeta;
-return_value[1][2] = -xi+2.0*xi*xi+2.0*(2.0*xi-4.0*xi*xi)*eta+2.0*(2.0*xi-4.0*xi*xi+2.0*(-4.0*xi+8.0*xi*xi)*eta)*zeta;
-return_value[2][0] = (-1.0+4.0*xi)*eta+(2.0-8.0*xi)*eta*eta+2.0*((2.0-8.0*xi)*eta+(-4.0+16.0*xi)*eta*eta)*zeta;
-return_value[2][1] = -xi+2.0*xi*xi+2.0*(2.0*xi-4.0*xi*xi)*eta+2.0*(2.0*xi-4.0*xi*xi+2.0*(-4.0*xi+8.0*xi*xi)*eta)*zeta;
-return_value[2][2] = 2.0*(2.0*xi-4.0*xi*xi)*eta+2.0*(-4.0*xi+8.0*xi*xi)*eta*eta;
-break;
-case 7:
-return_value[0][0] = (4.0*eta-8.0*eta*eta)*zeta+(-8.0*eta+16.0*eta*eta)*zeta*zeta;
-return_value[0][1] = (-3.0+4.0*xi+2.0*(6.0-8.0*xi)*eta)*zeta+(6.0-8.0*xi+2.0*(-12.0+16.0*xi)*eta)*zeta*zeta;
-return_value[0][2] = (-3.0+4.0*xi)*eta+(6.0-8.0*xi)*eta*eta+2.0*((6.0-8.0*xi)*eta+(-12.0+16.0*xi)*eta*eta)*zeta;
-return_value[1][0] = (-3.0+4.0*xi+2.0*(6.0-8.0*xi)*eta)*zeta+(6.0-8.0*xi+2.0*(-12.0+16.0*xi)*eta)*zeta*zeta;
-return_value[1][1] = (-4.0+12.0*xi-8.0*xi*xi)*zeta+(8.0-24.0*xi+16.0*xi*xi)*zeta*zeta;
-return_value[1][2] = 1.0-3.0*xi+2.0*xi*xi+2.0*(-2.0+6.0*xi-4.0*xi*xi)*eta+2.0*(-2.0+6.0*xi-4.0*xi*xi+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta)*zeta;
-return_value[2][0] = (-3.0+4.0*xi)*eta+(6.0-8.0*xi)*eta*eta+2.0*((6.0-8.0*xi)*eta+(-12.0+16.0*xi)*eta*eta)*zeta;
-return_value[2][1] = 1.0-3.0*xi+2.0*xi*xi+2.0*(-2.0+6.0*xi-4.0*xi*xi)*eta+2.0*(-2.0+6.0*xi-4.0*xi*xi+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta)*zeta;
-return_value[2][2] = 2.0*(-2.0+6.0*xi-4.0*xi*xi)*eta+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta*eta;
-break;
-case 8:
-return_value[0][0] = -8.0+24.0*eta-16.0*eta*eta+(24.0-72.0*eta+48.0*eta*eta)*zeta+(-16.0+48.0*eta-32.0*eta*eta)*zeta*zeta;
-return_value[0][1] = -12.0+24.0*xi+2.0*(8.0-16.0*xi)*eta+(36.0-72.0*xi+2.0*(-24.0+48.0*xi)*eta)*zeta+(-24.0+48.0*xi+2.0*(16.0-32.0*xi)*eta)*zeta*zeta;
-return_value[0][2] = -12.0+24.0*xi+(36.0-72.0*xi)*eta+(-24.0+48.0*xi)*eta*eta+2.0*(8.0-16.0*xi+(-24.0+48.0*xi)*eta+(16.0-32.0*xi)*eta*eta)*zeta;
-return_value[1][0] = -12.0+24.0*xi+2.0*(8.0-16.0*xi)*eta+(36.0-72.0*xi+2.0*(-24.0+48.0*xi)*eta)*zeta+(-24.0+48.0*xi+2.0*(16.0-32.0*xi)*eta)*zeta*zeta;
-return_value[1][1] = 16.0*xi-16.0*xi*xi+(-48.0*xi+48.0*xi*xi)*zeta+(32.0*xi-32.0*xi*xi)*zeta*zeta;
-return_value[1][2] = 36.0*xi-36.0*xi*xi+2.0*(-24.0*xi+24.0*xi*xi)*eta+2.0*(-24.0*xi+24.0*xi*xi+2.0*(16.0*xi-16.0*xi*xi)*eta)*zeta;
-return_value[2][0] = -12.0+24.0*xi+(36.0-72.0*xi)*eta+(-24.0+48.0*xi)*eta*eta+2.0*(8.0-16.0*xi+(-24.0+48.0*xi)*eta+(16.0-32.0*xi)*eta*eta)*zeta;
-return_value[2][1] = 36.0*xi-36.0*xi*xi+2.0*(-24.0*xi+24.0*xi*xi)*eta+2.0*(-24.0*xi+24.0*xi*xi+2.0*(16.0*xi-16.0*xi*xi)*eta)*zeta;
-return_value[2][2] = 16.0*xi-16.0*xi*xi+2.0*(-24.0*xi+24.0*xi*xi)*eta+2.0*(16.0*xi-16.0*xi*xi)*eta*eta;
-break;
-case 9:
-return_value[0][0] = (16.0-48.0*eta+32.0*eta*eta)*zeta+(-16.0+48.0*eta-32.0*eta*eta)*zeta*zeta;
-return_value[0][1] = (12.0-48.0*xi+2.0*(-8.0+32.0*xi)*eta)*zeta+(-12.0+48.0*xi+2.0*(8.0-32.0*xi)*eta)*zeta*zeta;
-return_value[0][2] = -4.0+16.0*xi+(12.0-48.0*xi)*eta+(-8.0+32.0*xi)*eta*eta+2.0*(4.0-16.0*xi+(-12.0+48.0*xi)*eta+(8.0-32.0*xi)*eta*eta)*zeta;
-return_value[1][0] = (12.0-48.0*xi+2.0*(-8.0+32.0*xi)*eta)*zeta+(-12.0+48.0*xi+2.0*(8.0-32.0*xi)*eta)*zeta*zeta;
-return_value[1][1] = (-16.0*xi+32.0*xi*xi)*zeta+(16.0*xi-32.0*xi*xi)*zeta*zeta;
-return_value[1][2] = 12.0*xi-24.0*xi*xi+2.0*(-8.0*xi+16.0*xi*xi)*eta+2.0*(-12.0*xi+24.0*xi*xi+2.0*(8.0*xi-16.0*xi*xi)*eta)*zeta;
-return_value[2][0] = -4.0+16.0*xi+(12.0-48.0*xi)*eta+(-8.0+32.0*xi)*eta*eta+2.0*(4.0-16.0*xi+(-12.0+48.0*xi)*eta+(8.0-32.0*xi)*eta*eta)*zeta;
-return_value[2][1] = 12.0*xi-24.0*xi*xi+2.0*(-8.0*xi+16.0*xi*xi)*eta+2.0*(-12.0*xi+24.0*xi*xi+2.0*(8.0*xi-16.0*xi*xi)*eta)*zeta;
-return_value[2][2] = 8.0*xi-16.0*xi*xi+2.0*(-12.0*xi+24.0*xi*xi)*eta+2.0*(8.0*xi-16.0*xi*xi)*eta*eta;
-return_value[0][0] = (8.0-24.0*eta+16.0*eta*eta)*zeta+(-16.0+48.0*eta-32.0*eta*eta)*zeta*zeta;
-return_value[0][1] = (12.0-24.0*xi+2.0*(-8.0+16.0*xi)*eta)*zeta+(-24.0+48.0*xi+2.0*(16.0-32.0*xi)*eta)*zeta*zeta;
-return_value[0][2] = -4.0+8.0*xi+(12.0-24.0*xi)*eta+(-8.0+16.0*xi)*eta*eta+2.0*(8.0-16.0*xi+(-24.0+48.0*xi)*eta+(16.0-32.0*xi)*eta*eta)*zeta;
-return_value[1][0] = (12.0-24.0*xi+2.0*(-8.0+16.0*xi)*eta)*zeta+(-24.0+48.0*xi+2.0*(16.0-32.0*xi)*eta)*zeta*zeta;
-return_value[1][1] = (-16.0*xi+16.0*xi*xi)*zeta+(32.0*xi-32.0*xi*xi)*zeta*zeta;
-return_value[1][2] = 12.0*xi-12.0*xi*xi+2.0*(-8.0*xi+8.0*xi*xi)*eta+2.0*(-24.0*xi+24.0*xi*xi+2.0*(16.0*xi-16.0*xi*xi)*eta)*zeta;
-return_value[2][0] = -4.0+8.0*xi+(12.0-24.0*xi)*eta+(-8.0+16.0*xi)*eta*eta+2.0*(8.0-16.0*xi+(-24.0+48.0*xi)*eta+(16.0-32.0*xi)*eta*eta)*zeta;
-return_value[2][1] = 12.0*xi-12.0*xi*xi+2.0*(-8.0*xi+8.0*xi*xi)*eta+2.0*(-24.0*xi+24.0*xi*xi+2.0*(16.0*xi-16.0*xi*xi)*eta)*zeta;
-return_value[2][2] = 16.0*xi-16.0*xi*xi+2.0*(-24.0*xi+24.0*xi*xi)*eta+2.0*(16.0*xi-16.0*xi*xi)*eta*eta;
-return_value[0][0] = (16.0-48.0*eta+32.0*eta*eta)*zeta+(-16.0+48.0*eta-32.0*eta*eta)*zeta*zeta;
-return_value[0][1] = (36.0-48.0*xi+2.0*(-24.0+32.0*xi)*eta)*zeta+(-36.0+48.0*xi+2.0*(24.0-32.0*xi)*eta)*zeta*zeta;
-return_value[0][2] = -12.0+16.0*xi+(36.0-48.0*xi)*eta+(-24.0+32.0*xi)*eta*eta+2.0*(12.0-16.0*xi+(-36.0+48.0*xi)*eta+(24.0-32.0*xi)*eta*eta)*zeta;
-return_value[1][0] = (36.0-48.0*xi+2.0*(-24.0+32.0*xi)*eta)*zeta+(-36.0+48.0*xi+2.0*(24.0-32.0*xi)*eta)*zeta*zeta;
-return_value[1][1] = (16.0-48.0*xi+32.0*xi*xi)*zeta+(-16.0+48.0*xi-32.0*xi*xi)*zeta*zeta;
-return_value[1][2] = -12.0+36.0*xi-24.0*xi*xi+2.0*(8.0-24.0*xi+16.0*xi*xi)*eta+2.0*(12.0-36.0*xi+24.0*xi*xi+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta)*zeta;
-return_value[2][0] = -12.0+16.0*xi+(36.0-48.0*xi)*eta+(-24.0+32.0*xi)*eta*eta+2.0*(12.0-16.0*xi+(-36.0+48.0*xi)*eta+(24.0-32.0*xi)*eta*eta)*zeta;
-return_value[2][1] = -12.0+36.0*xi-24.0*xi*xi+2.0*(8.0-24.0*xi+16.0*xi*xi)*eta+2.0*(12.0-36.0*xi+24.0*xi*xi+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta)*zeta;
-return_value[2][2] = -8.0+24.0*xi-16.0*xi*xi+2.0*(12.0-36.0*xi+24.0*xi*xi)*eta+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta*eta;
-return_value[0][0] = 8.0*eta-16.0*eta*eta+(-24.0*eta+48.0*eta*eta)*zeta+(16.0*eta-32.0*eta*eta)*zeta*zeta;
-return_value[0][1] = -4.0+8.0*xi+2.0*(8.0-16.0*xi)*eta+(12.0-24.0*xi+2.0*(-24.0+48.0*xi)*eta)*zeta+(-8.0+16.0*xi+2.0*(16.0-32.0*xi)*eta)*zeta*zeta;
-return_value[0][2] = (12.0-24.0*xi)*eta+(-24.0+48.0*xi)*eta*eta+2.0*((-8.0+16.0*xi)*eta+(16.0-32.0*xi)*eta*eta)*zeta;
-return_value[1][0] = -4.0+8.0*xi+2.0*(8.0-16.0*xi)*eta+(12.0-24.0*xi+2.0*(-24.0+48.0*xi)*eta)*zeta+(-8.0+16.0*xi+2.0*(16.0-32.0*xi)*eta)*zeta*zeta;
-return_value[1][1] = 16.0*xi-16.0*xi*xi+(-48.0*xi+48.0*xi*xi)*zeta+(32.0*xi-32.0*xi*xi)*zeta*zeta;
-return_value[1][2] = 12.0*xi-12.0*xi*xi+2.0*(-24.0*xi+24.0*xi*xi)*eta+2.0*(-8.0*xi+8.0*xi*xi+2.0*(16.0*xi-16.0*xi*xi)*eta)*zeta;
-return_value[2][0] = (12.0-24.0*xi)*eta+(-24.0+48.0*xi)*eta*eta+2.0*((-8.0+16.0*xi)*eta+(16.0-32.0*xi)*eta*eta)*zeta;
-return_value[2][1] = 12.0*xi-12.0*xi*xi+2.0*(-24.0*xi+24.0*xi*xi)*eta+2.0*(-8.0*xi+8.0*xi*xi+2.0*(16.0*xi-16.0*xi*xi)*eta)*zeta;
-return_value[2][2] = 2.0*(-8.0*xi+8.0*xi*xi)*eta+2.0*(16.0*xi-16.0*xi*xi)*eta*eta;
-return_value[0][0] = (-16.0*eta+32.0*eta*eta)*zeta+(16.0*eta-32.0*eta*eta)*zeta*zeta;
-return_value[0][1] = (4.0-16.0*xi+2.0*(-8.0+32.0*xi)*eta)*zeta+(-4.0+16.0*xi+2.0*(8.0-32.0*xi)*eta)*zeta*zeta;
-return_value[0][2] = (4.0-16.0*xi)*eta+(-8.0+32.0*xi)*eta*eta+2.0*((-4.0+16.0*xi)*eta+(8.0-32.0*xi)*eta*eta)*zeta;
-return_value[1][0] = (4.0-16.0*xi+2.0*(-8.0+32.0*xi)*eta)*zeta+(-4.0+16.0*xi+2.0*(8.0-32.0*xi)*eta)*zeta*zeta;
-return_value[1][1] = (-16.0*xi+32.0*xi*xi)*zeta+(16.0*xi-32.0*xi*xi)*zeta*zeta;
-return_value[1][2] = 4.0*xi-8.0*xi*xi+2.0*(-8.0*xi+16.0*xi*xi)*eta+2.0*(-4.0*xi+8.0*xi*xi+2.0*(8.0*xi-16.0*xi*xi)*eta)*zeta;
-return_value[2][0] = (4.0-16.0*xi)*eta+(-8.0+32.0*xi)*eta*eta+2.0*((-4.0+16.0*xi)*eta+(8.0-32.0*xi)*eta*eta)*zeta;
-return_value[2][1] = 4.0*xi-8.0*xi*xi+2.0*(-8.0*xi+16.0*xi*xi)*eta+2.0*(-4.0*xi+8.0*xi*xi+2.0*(8.0*xi-16.0*xi*xi)*eta)*zeta;
-return_value[2][2] = 2.0*(-4.0*xi+8.0*xi*xi)*eta+2.0*(8.0*xi-16.0*xi*xi)*eta*eta;
-return_value[0][0] = (-8.0*eta+16.0*eta*eta)*zeta+(16.0*eta-32.0*eta*eta)*zeta*zeta;
-return_value[0][1] = (4.0-8.0*xi+2.0*(-8.0+16.0*xi)*eta)*zeta+(-8.0+16.0*xi+2.0*(16.0-32.0*xi)*eta)*zeta*zeta;
-return_value[0][2] = (4.0-8.0*xi)*eta+(-8.0+16.0*xi)*eta*eta+2.0*((-8.0+16.0*xi)*eta+(16.0-32.0*xi)*eta*eta)*zeta;
-return_value[1][0] = (4.0-8.0*xi+2.0*(-8.0+16.0*xi)*eta)*zeta+(-8.0+16.0*xi+2.0*(16.0-32.0*xi)*eta)*zeta*zeta;
-return_value[1][1] = (-16.0*xi+16.0*xi*xi)*zeta+(32.0*xi-32.0*xi*xi)*zeta*zeta;
-return_value[1][2] = 4.0*xi-4.0*xi*xi+2.0*(-8.0*xi+8.0*xi*xi)*eta+2.0*(-8.0*xi+8.0*xi*xi+2.0*(16.0*xi-16.0*xi*xi)*eta)*zeta;
-return_value[2][0] = (4.0-8.0*xi)*eta+(-8.0+16.0*xi)*eta*eta+2.0*((-8.0+16.0*xi)*eta+(16.0-32.0*xi)*eta*eta)*zeta;
-return_value[2][1] = 4.0*xi-4.0*xi*xi+2.0*(-8.0*xi+8.0*xi*xi)*eta+2.0*(-8.0*xi+8.0*xi*xi+2.0*(16.0*xi-16.0*xi*xi)*eta)*zeta;
-return_value[2][2] = 2.0*(-8.0*xi+8.0*xi*xi)*eta+2.0*(16.0*xi-16.0*xi*xi)*eta*eta;
-return_value[0][0] = (-16.0*eta+32.0*eta*eta)*zeta+(16.0*eta-32.0*eta*eta)*zeta*zeta;
-return_value[0][1] = (12.0-16.0*xi+2.0*(-24.0+32.0*xi)*eta)*zeta+(-12.0+16.0*xi+2.0*(24.0-32.0*xi)*eta)*zeta*zeta;
-return_value[0][2] = (12.0-16.0*xi)*eta+(-24.0+32.0*xi)*eta*eta+2.0*((-12.0+16.0*xi)*eta+(24.0-32.0*xi)*eta*eta)*zeta;
-return_value[1][0] = (12.0-16.0*xi+2.0*(-24.0+32.0*xi)*eta)*zeta+(-12.0+16.0*xi+2.0*(24.0-32.0*xi)*eta)*zeta*zeta;
-return_value[1][1] = (16.0-48.0*xi+32.0*xi*xi)*zeta+(-16.0+48.0*xi-32.0*xi*xi)*zeta*zeta;
-return_value[1][2] = -4.0+12.0*xi-8.0*xi*xi+2.0*(8.0-24.0*xi+16.0*xi*xi)*eta+2.0*(4.0-12.0*xi+8.0*xi*xi+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta)*zeta;
-return_value[2][0] = (12.0-16.0*xi)*eta+(-24.0+32.0*xi)*eta*eta+2.0*((-12.0+16.0*xi)*eta+(24.0-32.0*xi)*eta*eta)*zeta;
-return_value[2][1] = -4.0+12.0*xi-8.0*xi*xi+2.0*(8.0-24.0*xi+16.0*xi*xi)*eta+2.0*(4.0-12.0*xi+8.0*xi*xi+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta)*zeta;
-return_value[2][2] = 2.0*(4.0-12.0*xi+8.0*xi*xi)*eta+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta*eta;
-return_value[0][0] = 16.0*eta-16.0*eta*eta+(-48.0*eta+48.0*eta*eta)*zeta+(32.0*eta-32.0*eta*eta)*zeta*zeta;
-return_value[0][1] = -12.0+16.0*xi+2.0*(12.0-16.0*xi)*eta+(36.0-48.0*xi+2.0*(-36.0+48.0*xi)*eta)*zeta+(-24.0+32.0*xi+2.0*(24.0-32.0*xi)*eta)*zeta*zeta;
-return_value[0][2] = (36.0-48.0*xi)*eta+(-36.0+48.0*xi)*eta*eta+2.0*((-24.0+32.0*xi)*eta+(24.0-32.0*xi)*eta*eta)*zeta;
-return_value[1][0] = -12.0+16.0*xi+2.0*(12.0-16.0*xi)*eta+(36.0-48.0*xi+2.0*(-36.0+48.0*xi)*eta)*zeta+(-24.0+32.0*xi+2.0*(24.0-32.0*xi)*eta)*zeta*zeta;
-return_value[1][1] = -8.0+24.0*xi-16.0*xi*xi+(24.0-72.0*xi+48.0*xi*xi)*zeta+(-16.0+48.0*xi-32.0*xi*xi)*zeta*zeta;
-return_value[1][2] = -12.0+36.0*xi-24.0*xi*xi+2.0*(12.0-36.0*xi+24.0*xi*xi)*eta+2.0*(8.0-24.0*xi+16.0*xi*xi+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta)*zeta;
-return_value[2][0] = (36.0-48.0*xi)*eta+(-36.0+48.0*xi)*eta*eta+2.0*((-24.0+32.0*xi)*eta+(24.0-32.0*xi)*eta*eta)*zeta;
-return_value[2][1] = -12.0+36.0*xi-24.0*xi*xi+2.0*(12.0-36.0*xi+24.0*xi*xi)*eta+2.0*(8.0-24.0*xi+16.0*xi*xi+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta)*zeta;
-return_value[2][2] = 2.0*(8.0-24.0*xi+16.0*xi*xi)*eta+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta*eta;
-return_value[0][0] = 16.0*eta-16.0*eta*eta+(-48.0*eta+48.0*eta*eta)*zeta+(32.0*eta-32.0*eta*eta)*zeta*zeta;
-return_value[0][1] = -4.0+16.0*xi+2.0*(4.0-16.0*xi)*eta+(12.0-48.0*xi+2.0*(-12.0+48.0*xi)*eta)*zeta+(-8.0+32.0*xi+2.0*(8.0-32.0*xi)*eta)*zeta*zeta;
-return_value[0][2] = (12.0-48.0*xi)*eta+(-12.0+48.0*xi)*eta*eta+2.0*((-8.0+32.0*xi)*eta+(8.0-32.0*xi)*eta*eta)*zeta;
-return_value[1][0] = -4.0+16.0*xi+2.0*(4.0-16.0*xi)*eta+(12.0-48.0*xi+2.0*(-12.0+48.0*xi)*eta)*zeta+(-8.0+32.0*xi+2.0*(8.0-32.0*xi)*eta)*zeta*zeta;
-return_value[1][1] = 8.0*xi-16.0*xi*xi+(-24.0*xi+48.0*xi*xi)*zeta+(16.0*xi-32.0*xi*xi)*zeta*zeta;
-return_value[1][2] = 12.0*xi-24.0*xi*xi+2.0*(-12.0*xi+24.0*xi*xi)*eta+2.0*(-8.0*xi+16.0*xi*xi+2.0*(8.0*xi-16.0*xi*xi)*eta)*zeta;
-return_value[2][0] = (12.0-48.0*xi)*eta+(-12.0+48.0*xi)*eta*eta+2.0*((-8.0+32.0*xi)*eta+(8.0-32.0*xi)*eta*eta)*zeta;
-return_value[2][1] = 12.0*xi-24.0*xi*xi+2.0*(-12.0*xi+24.0*xi*xi)*eta+2.0*(-8.0*xi+16.0*xi*xi+2.0*(8.0*xi-16.0*xi*xi)*eta)*zeta;
-return_value[2][2] = 2.0*(-8.0*xi+16.0*xi*xi)*eta+2.0*(8.0*xi-16.0*xi*xi)*eta*eta;
-return_value[0][0] = (-16.0*eta+16.0*eta*eta)*zeta+(32.0*eta-32.0*eta*eta)*zeta*zeta;
-return_value[0][1] = (4.0-16.0*xi+2.0*(-4.0+16.0*xi)*eta)*zeta+(-8.0+32.0*xi+2.0*(8.0-32.0*xi)*eta)*zeta*zeta;
-return_value[0][2] = (4.0-16.0*xi)*eta+(-4.0+16.0*xi)*eta*eta+2.0*((-8.0+32.0*xi)*eta+(8.0-32.0*xi)*eta*eta)*zeta;
-return_value[1][0] = (4.0-16.0*xi+2.0*(-4.0+16.0*xi)*eta)*zeta+(-8.0+32.0*xi+2.0*(8.0-32.0*xi)*eta)*zeta*zeta;
-return_value[1][1] = (-8.0*xi+16.0*xi*xi)*zeta+(16.0*xi-32.0*xi*xi)*zeta*zeta;
-return_value[1][2] = 4.0*xi-8.0*xi*xi+2.0*(-4.0*xi+8.0*xi*xi)*eta+2.0*(-8.0*xi+16.0*xi*xi+2.0*(8.0*xi-16.0*xi*xi)*eta)*zeta;
-return_value[2][0] = (4.0-16.0*xi)*eta+(-4.0+16.0*xi)*eta*eta+2.0*((-8.0+32.0*xi)*eta+(8.0-32.0*xi)*eta*eta)*zeta;
-return_value[2][1] = 4.0*xi-8.0*xi*xi+2.0*(-4.0*xi+8.0*xi*xi)*eta+2.0*(-8.0*xi+16.0*xi*xi+2.0*(8.0*xi-16.0*xi*xi)*eta)*zeta;
-return_value[2][2] = 2.0*(-8.0*xi+16.0*xi*xi)*eta+2.0*(8.0*xi-16.0*xi*xi)*eta*eta;
-return_value[0][0] = (-16.0*eta+16.0*eta*eta)*zeta+(32.0*eta-32.0*eta*eta)*zeta*zeta;
-return_value[0][1] = (12.0-16.0*xi+2.0*(-12.0+16.0*xi)*eta)*zeta+(-24.0+32.0*xi+2.0*(24.0-32.0*xi)*eta)*zeta*zeta;
-return_value[0][2] = (12.0-16.0*xi)*eta+(-12.0+16.0*xi)*eta*eta+2.0*((-24.0+32.0*xi)*eta+(24.0-32.0*xi)*eta*eta)*zeta;
-return_value[1][0] = (12.0-16.0*xi+2.0*(-12.0+16.0*xi)*eta)*zeta+(-24.0+32.0*xi+2.0*(24.0-32.0*xi)*eta)*zeta*zeta;
-return_value[1][1] = (8.0-24.0*xi+16.0*xi*xi)*zeta+(-16.0+48.0*xi-32.0*xi*xi)*zeta*zeta;
-return_value[1][2] = -4.0+12.0*xi-8.0*xi*xi+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta+2.0*(8.0-24.0*xi+16.0*xi*xi+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta)*zeta;
-return_value[2][0] = (12.0-16.0*xi)*eta+(-12.0+16.0*xi)*eta*eta+2.0*((-24.0+32.0*xi)*eta+(24.0-32.0*xi)*eta*eta)*zeta;
-return_value[2][1] = -4.0+12.0*xi-8.0*xi*xi+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta+2.0*(8.0-24.0*xi+16.0*xi*xi+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta)*zeta;
-return_value[2][2] = 2.0*(8.0-24.0*xi+16.0*xi*xi)*eta+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta*eta;
-return_value[0][0] = (-32.0+96.0*eta-64.0*eta*eta)*zeta+(32.0-96.0*eta+64.0*eta*eta)*zeta*zeta;
-return_value[0][1] = (-48.0+96.0*xi+2.0*(32.0-64.0*xi)*eta)*zeta+(48.0-96.0*xi+2.0*(-32.0+64.0*xi)*eta)*zeta*zeta;
-return_value[0][2] = 16.0-32.0*xi+(-48.0+96.0*xi)*eta+(32.0-64.0*xi)*eta*eta+2.0*(-16.0+32.0*xi+(48.0-96.0*xi)*eta+(-32.0+64.0*xi)*eta*eta)*zeta;
-return_value[1][0] = (-48.0+96.0*xi+2.0*(32.0-64.0*xi)*eta)*zeta+(48.0-96.0*xi+2.0*(-32.0+64.0*xi)*eta)*zeta*zeta;
-return_value[1][1] = (64.0*xi-64.0*xi*xi)*zeta+(-64.0*xi+64.0*xi*xi)*zeta*zeta;
-return_value[1][2] = -48.0*xi+48.0*xi*xi+2.0*(32.0*xi-32.0*xi*xi)*eta+2.0*(48.0*xi-48.0*xi*xi+2.0*(-32.0*xi+32.0*xi*xi)*eta)*zeta;
-return_value[2][0] = 16.0-32.0*xi+(-48.0+96.0*xi)*eta+(32.0-64.0*xi)*eta*eta+2.0*(-16.0+32.0*xi+(48.0-96.0*xi)*eta+(-32.0+64.0*xi)*eta*eta)*zeta;
-return_value[2][1] = -48.0*xi+48.0*xi*xi+2.0*(32.0*xi-32.0*xi*xi)*eta+2.0*(48.0*xi-48.0*xi*xi+2.0*(-32.0*xi+32.0*xi*xi)*eta)*zeta;
-return_value[2][2] = -32.0*xi+32.0*xi*xi+2.0*(48.0*xi-48.0*xi*xi)*eta+2.0*(-32.0*xi+32.0*xi*xi)*eta*eta;
-return_value[0][0] = (32.0*eta-64.0*eta*eta)*zeta+(-32.0*eta+64.0*eta*eta)*zeta*zeta;
-return_value[0][1] = (-16.0+32.0*xi+2.0*(32.0-64.0*xi)*eta)*zeta+(16.0-32.0*xi+2.0*(-32.0+64.0*xi)*eta)*zeta*zeta;
-return_value[0][2] = (-16.0+32.0*xi)*eta+(32.0-64.0*xi)*eta*eta+2.0*((16.0-32.0*xi)*eta+(-32.0+64.0*xi)*eta*eta)*zeta;
-return_value[1][0] = (-16.0+32.0*xi+2.0*(32.0-64.0*xi)*eta)*zeta+(16.0-32.0*xi+2.0*(-32.0+64.0*xi)*eta)*zeta*zeta;
-return_value[1][1] = (64.0*xi-64.0*xi*xi)*zeta+(-64.0*xi+64.0*xi*xi)*zeta*zeta;
-return_value[1][2] = -16.0*xi+16.0*xi*xi+2.0*(32.0*xi-32.0*xi*xi)*eta+2.0*(16.0*xi-16.0*xi*xi+2.0*(-32.0*xi+32.0*xi*xi)*eta)*zeta;
-return_value[2][0] = (-16.0+32.0*xi)*eta+(32.0-64.0*xi)*eta*eta+2.0*((16.0-32.0*xi)*eta+(-32.0+64.0*xi)*eta*eta)*zeta;
-return_value[2][1] = -16.0*xi+16.0*xi*xi+2.0*(32.0*xi-32.0*xi*xi)*eta+2.0*(16.0*xi-16.0*xi*xi+2.0*(-32.0*xi+32.0*xi*xi)*eta)*zeta;
-return_value[2][2] = 2.0*(16.0*xi-16.0*xi*xi)*eta+2.0*(-32.0*xi+32.0*xi*xi)*eta*eta;
-return_value[0][0] = -32.0*eta+32.0*eta*eta+(96.0*eta-96.0*eta*eta)*zeta+(-64.0*eta+64.0*eta*eta)*zeta*zeta;
-return_value[0][1] = 16.0-32.0*xi+2.0*(-16.0+32.0*xi)*eta+(-48.0+96.0*xi+2.0*(48.0-96.0*xi)*eta)*zeta+(32.0-64.0*xi+2.0*(-32.0+64.0*xi)*eta)*zeta*zeta;
-return_value[0][2] = (-48.0+96.0*xi)*eta+(48.0-96.0*xi)*eta*eta+2.0*((32.0-64.0*xi)*eta+(-32.0+64.0*xi)*eta*eta)*zeta;
-return_value[1][0] = 16.0-32.0*xi+2.0*(-16.0+32.0*xi)*eta+(-48.0+96.0*xi+2.0*(48.0-96.0*xi)*eta)*zeta+(32.0-64.0*xi+2.0*(-32.0+64.0*xi)*eta)*zeta*zeta;
-return_value[1][1] = -32.0*xi+32.0*xi*xi+(96.0*xi-96.0*xi*xi)*zeta+(-64.0*xi+64.0*xi*xi)*zeta*zeta;
-return_value[1][2] = -48.0*xi+48.0*xi*xi+2.0*(48.0*xi-48.0*xi*xi)*eta+2.0*(32.0*xi-32.0*xi*xi+2.0*(-32.0*xi+32.0*xi*xi)*eta)*zeta;
-return_value[2][0] = (-48.0+96.0*xi)*eta+(48.0-96.0*xi)*eta*eta+2.0*((32.0-64.0*xi)*eta+(-32.0+64.0*xi)*eta*eta)*zeta;
-return_value[2][1] = -48.0*xi+48.0*xi*xi+2.0*(48.0*xi-48.0*xi*xi)*eta+2.0*(32.0*xi-32.0*xi*xi+2.0*(-32.0*xi+32.0*xi*xi)*eta)*zeta;
-return_value[2][2] = 2.0*(32.0*xi-32.0*xi*xi)*eta+2.0*(-32.0*xi+32.0*xi*xi)*eta*eta;
-return_value[0][0] = (64.0*eta-64.0*eta*eta)*zeta+(-64.0*eta+64.0*eta*eta)*zeta*zeta;
-return_value[0][1] = (-16.0+64.0*xi+2.0*(16.0-64.0*xi)*eta)*zeta+(16.0-64.0*xi+2.0*(-16.0+64.0*xi)*eta)*zeta*zeta;
-return_value[0][2] = (-16.0+64.0*xi)*eta+(16.0-64.0*xi)*eta*eta+2.0*((16.0-64.0*xi)*eta+(-16.0+64.0*xi)*eta*eta)*zeta;
-return_value[1][0] = (-16.0+64.0*xi+2.0*(16.0-64.0*xi)*eta)*zeta+(16.0-64.0*xi+2.0*(-16.0+64.0*xi)*eta)*zeta*zeta;
-return_value[1][1] = (32.0*xi-64.0*xi*xi)*zeta+(-32.0*xi+64.0*xi*xi)*zeta*zeta;
-return_value[1][2] = -16.0*xi+32.0*xi*xi+2.0*(16.0*xi-32.0*xi*xi)*eta+2.0*(16.0*xi-32.0*xi*xi+2.0*(-16.0*xi+32.0*xi*xi)*eta)*zeta;
-return_value[2][0] = (-16.0+64.0*xi)*eta+(16.0-64.0*xi)*eta*eta+2.0*((16.0-64.0*xi)*eta+(-16.0+64.0*xi)*eta*eta)*zeta;
-return_value[2][1] = -16.0*xi+32.0*xi*xi+2.0*(16.0*xi-32.0*xi*xi)*eta+2.0*(16.0*xi-32.0*xi*xi+2.0*(-16.0*xi+32.0*xi*xi)*eta)*zeta;
-return_value[2][2] = 2.0*(16.0*xi-32.0*xi*xi)*eta+2.0*(-16.0*xi+32.0*xi*xi)*eta*eta;
-return_value[0][0] = (32.0*eta-32.0*eta*eta)*zeta+(-64.0*eta+64.0*eta*eta)*zeta*zeta;
-return_value[0][1] = (-16.0+32.0*xi+2.0*(16.0-32.0*xi)*eta)*zeta+(32.0-64.0*xi+2.0*(-32.0+64.0*xi)*eta)*zeta*zeta;
-return_value[0][2] = (-16.0+32.0*xi)*eta+(16.0-32.0*xi)*eta*eta+2.0*((32.0-64.0*xi)*eta+(-32.0+64.0*xi)*eta*eta)*zeta;
-return_value[1][0] = (-16.0+32.0*xi+2.0*(16.0-32.0*xi)*eta)*zeta+(32.0-64.0*xi+2.0*(-32.0+64.0*xi)*eta)*zeta*zeta;
-return_value[1][1] = (32.0*xi-32.0*xi*xi)*zeta+(-64.0*xi+64.0*xi*xi)*zeta*zeta;
-return_value[1][2] = -16.0*xi+16.0*xi*xi+2.0*(16.0*xi-16.0*xi*xi)*eta+2.0*(32.0*xi-32.0*xi*xi+2.0*(-32.0*xi+32.0*xi*xi)*eta)*zeta;
-return_value[2][0] = (-16.0+32.0*xi)*eta+(16.0-32.0*xi)*eta*eta+2.0*((32.0-64.0*xi)*eta+(-32.0+64.0*xi)*eta*eta)*zeta;
-return_value[2][1] = -16.0*xi+16.0*xi*xi+2.0*(16.0*xi-16.0*xi*xi)*eta+2.0*(32.0*xi-32.0*xi*xi+2.0*(-32.0*xi+32.0*xi*xi)*eta)*zeta;
-return_value[2][2] = 2.0*(32.0*xi-32.0*xi*xi)*eta+2.0*(-32.0*xi+32.0*xi*xi)*eta*eta;
-return_value[0][0] = (64.0*eta-64.0*eta*eta)*zeta+(-64.0*eta+64.0*eta*eta)*zeta*zeta;
-return_value[0][1] = (-48.0+64.0*xi+2.0*(48.0-64.0*xi)*eta)*zeta+(48.0-64.0*xi+2.0*(-48.0+64.0*xi)*eta)*zeta*zeta;
-return_value[0][2] = (-48.0+64.0*xi)*eta+(48.0-64.0*xi)*eta*eta+2.0*((48.0-64.0*xi)*eta+(-48.0+64.0*xi)*eta*eta)*zeta;
-return_value[1][0] = (-48.0+64.0*xi+2.0*(48.0-64.0*xi)*eta)*zeta+(48.0-64.0*xi+2.0*(-48.0+64.0*xi)*eta)*zeta*zeta;
-return_value[1][1] = (-32.0+96.0*xi-64.0*xi*xi)*zeta+(32.0-96.0*xi+64.0*xi*xi)*zeta*zeta;
-return_value[1][2] = 16.0-48.0*xi+32.0*xi*xi+2.0*(-16.0+48.0*xi-32.0*xi*xi)*eta+2.0*(-16.0+48.0*xi-32.0*xi*xi+2.0*(16.0-48.0*xi+32.0*xi*xi)*eta)*zeta;
-return_value[2][0] = (-48.0+64.0*xi)*eta+(48.0-64.0*xi)*eta*eta+2.0*((48.0-64.0*xi)*eta+(-48.0+64.0*xi)*eta*eta)*zeta;
-return_value[2][1] = 16.0-48.0*xi+32.0*xi*xi+2.0*(-16.0+48.0*xi-32.0*xi*xi)*eta+2.0*(-16.0+48.0*xi-32.0*xi*xi+2.0*(16.0-48.0*xi+32.0*xi*xi)*eta)*zeta;
-return_value[2][2] = 2.0*(-16.0+48.0*xi-32.0*xi*xi)*eta+2.0*(16.0-48.0*xi+32.0*xi*xi)*eta*eta;
-return_value[0][0] = (-128.0*eta+128.0*eta*eta)*zeta+(128.0*eta-128.0*eta*eta)*zeta*zeta;
-return_value[0][1] = (64.0-128.0*xi+2.0*(-64.0+128.0*xi)*eta)*zeta+(-64.0+128.0*xi+2.0*(64.0-128.0*xi)*eta)*zeta*zeta;
-return_value[0][2] = (64.0-128.0*xi)*eta+(-64.0+128.0*xi)*eta*eta+2.0*((-64.0+128.0*xi)*eta+(64.0-128.0*xi)*eta*eta)*zeta;
-return_value[1][0] = (64.0-128.0*xi+2.0*(-64.0+128.0*xi)*eta)*zeta+(-64.0+128.0*xi+2.0*(64.0-128.0*xi)*eta)*zeta*zeta;
-return_value[1][1] = (-128.0*xi+128.0*xi*xi)*zeta+(128.0*xi-128.0*xi*xi)*zeta*zeta;
-return_value[1][2] = 64.0*xi-64.0*xi*xi+2.0*(-64.0*xi+64.0*xi*xi)*eta+2.0*(-64.0*xi+64.0*xi*xi+2.0*(64.0*xi-64.0*xi*xi)*eta)*zeta;
-return_value[2][0] = (64.0-128.0*xi)*eta+(-64.0+128.0*xi)*eta*eta+2.0*((-64.0+128.0*xi)*eta+(64.0-128.0*xi)*eta*eta)*zeta;
-return_value[2][1] = 64.0*xi-64.0*xi*xi+2.0*(-64.0*xi+64.0*xi*xi)*eta+2.0*(-64.0*xi+64.0*xi*xi+2.0*(64.0*xi-64.0*xi*xi)*eta)*zeta;
-return_value[2][2] = 2.0*(-64.0*xi+64.0*xi*xi)*eta+2.0*(64.0*xi-64.0*xi*xi)*eta*eta;
- break;
+ case 0:
+ return_value[0][0] = 4.0-12.0*eta+8.0*eta*eta+(-12.0+36.0*eta-24.0*eta*eta)*zeta+(8.0-24.0*eta+16.0*eta*eta)*zeta*zeta;
+ return_value[0][1] = 9.0-12.0*xi+2.0*(-6.0+8.0*xi)*eta+(-27.0+36.0*xi+2.0*(18.0-24.0*xi)*eta)*zeta+(18.0-24.0*xi+2.0*(-12.0+16.0*xi)*eta)*zeta*zeta;
+ return_value[0][2] = 9.0-12.0*xi+(-27.0+36.0*xi)*eta+(18.0-24.0*xi)*eta*eta+2.0*(-6.0+8.0*xi+(18.0-24.0*xi)*eta+(-12.0+16.0*xi)*eta*eta)*zeta;
+ return_value[1][0] = 9.0-12.0*xi+2.0*(-6.0+8.0*xi)*eta+(-27.0+36.0*xi+2.0*(18.0-24.0*xi)*eta)*zeta+(18.0-24.0*xi+2.0*(-12.0+16.0*xi)*eta)*zeta*zeta;
+ return_value[1][1] = 4.0-12.0*xi+8.0*xi*xi+(-12.0+36.0*xi-24.0*xi*xi)*zeta+(8.0-24.0*xi+16.0*xi*xi)*zeta*zeta;
+ return_value[1][2] = 9.0-27.0*xi+18.0*xi*xi+2.0*(-6.0+18.0*xi-12.0*xi*xi)*eta+2.0*(-6.0+18.0*xi-12.0*xi*xi+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta)*zeta;
+ return_value[2][0] = 9.0-12.0*xi+(-27.0+36.0*xi)*eta+(18.0-24.0*xi)*eta*eta+2.0*(-6.0+8.0*xi+(18.0-24.0*xi)*eta+(-12.0+16.0*xi)*eta*eta)*zeta;
+ return_value[2][1] = 9.0-27.0*xi+18.0*xi*xi+2.0*(-6.0+18.0*xi-12.0*xi*xi)*eta+2.0*(-6.0+18.0*xi-12.0*xi*xi+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta)*zeta;
+ return_value[2][2] = 4.0-12.0*xi+8.0*xi*xi+2.0*(-6.0+18.0*xi-12.0*xi*xi)*eta+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta*eta;
+ break;
+ case 1:
+ return_value[0][0] = 4.0-12.0*eta+8.0*eta*eta+(-12.0+36.0*eta-24.0*eta*eta)*zeta+(8.0-24.0*eta+16.0*eta*eta)*zeta*zeta;
+ return_value[0][1] = 3.0-12.0*xi+2.0*(-2.0+8.0*xi)*eta+(-9.0+36.0*xi+2.0*(6.0-24.0*xi)*eta)*zeta+(6.0-24.0*xi+2.0*(-4.0+16.0*xi)*eta)*zeta*zeta;
+ return_value[0][2] = 3.0-12.0*xi+(-9.0+36.0*xi)*eta+(6.0-24.0*xi)*eta*eta+2.0*(-2.0+8.0*xi+(6.0-24.0*xi)*eta+(-4.0+16.0*xi)*eta*eta)*zeta;
+ return_value[1][0] = 3.0-12.0*xi+2.0*(-2.0+8.0*xi)*eta+(-9.0+36.0*xi+2.0*(6.0-24.0*xi)*eta)*zeta+(6.0-24.0*xi+2.0*(-4.0+16.0*xi)*eta)*zeta*zeta;
+ return_value[1][1] = -4.0*xi+8.0*xi*xi+(12.0*xi-24.0*xi*xi)*zeta+(-8.0*xi+16.0*xi*xi)*zeta*zeta;
+ return_value[1][2] = -9.0*xi+18.0*xi*xi+2.0*(6.0*xi-12.0*xi*xi)*eta+2.0*(6.0*xi-12.0*xi*xi+2.0*(-4.0*xi+8.0*xi*xi)*eta)*zeta;
+ return_value[2][0] = 3.0-12.0*xi+(-9.0+36.0*xi)*eta+(6.0-24.0*xi)*eta*eta+2.0*(-2.0+8.0*xi+(6.0-24.0*xi)*eta+(-4.0+16.0*xi)*eta*eta)*zeta;
+ return_value[2][1] = -9.0*xi+18.0*xi*xi+2.0*(6.0*xi-12.0*xi*xi)*eta+2.0*(6.0*xi-12.0*xi*xi+2.0*(-4.0*xi+8.0*xi*xi)*eta)*zeta;
+ return_value[2][2] = -4.0*xi+8.0*xi*xi+2.0*(6.0*xi-12.0*xi*xi)*eta+2.0*(-4.0*xi+8.0*xi*xi)*eta*eta;
+ break;
+ case 2:
+ return_value[0][0] = (-4.0+12.0*eta-8.0*eta*eta)*zeta+(8.0-24.0*eta+16.0*eta*eta)*zeta*zeta;
+ return_value[0][1] = (-3.0+12.0*xi+2.0*(2.0-8.0*xi)*eta)*zeta+(6.0-24.0*xi+2.0*(-4.0+16.0*xi)*eta)*zeta*zeta;
+ return_value[0][2] = 1.0-4.0*xi+(-3.0+12.0*xi)*eta+(2.0-8.0*xi)*eta*eta+2.0*(-2.0+8.0*xi+(6.0-24.0*xi)*eta+(-4.0+16.0*xi)*eta*eta)*zeta;
+ return_value[1][0] = (-3.0+12.0*xi+2.0*(2.0-8.0*xi)*eta)*zeta+(6.0-24.0*xi+2.0*(-4.0+16.0*xi)*eta)*zeta*zeta;
+ return_value[1][1] = (4.0*xi-8.0*xi*xi)*zeta+(-8.0*xi+16.0*xi*xi)*zeta*zeta;
+ return_value[1][2] = -3.0*xi+6.0*xi*xi+2.0*(2.0*xi-4.0*xi*xi)*eta+2.0*(6.0*xi-12.0*xi*xi+2.0*(-4.0*xi+8.0*xi*xi)*eta)*zeta;
+ return_value[2][0] = 1.0-4.0*xi+(-3.0+12.0*xi)*eta+(2.0-8.0*xi)*eta*eta+2.0*(-2.0+8.0*xi+(6.0-24.0*xi)*eta+(-4.0+16.0*xi)*eta*eta)*zeta;
+ return_value[2][1] = -3.0*xi+6.0*xi*xi+2.0*(2.0*xi-4.0*xi*xi)*eta+2.0*(6.0*xi-12.0*xi*xi+2.0*(-4.0*xi+8.0*xi*xi)*eta)*zeta;
+ return_value[2][2] = -4.0*xi+8.0*xi*xi+2.0*(6.0*xi-12.0*xi*xi)*eta+2.0*(-4.0*xi+8.0*xi*xi)*eta*eta;
+ break;
+ case 3:
+ return_value[0][0] = (-4.0+12.0*eta-8.0*eta*eta)*zeta+(8.0-24.0*eta+16.0*eta*eta)*zeta*zeta;
+ return_value[0][1] = (-9.0+12.0*xi+2.0*(6.0-8.0*xi)*eta)*zeta+(18.0-24.0*xi+2.0*(-12.0+16.0*xi)*eta)*zeta*zeta;
+ return_value[0][2] = 3.0-4.0*xi+(-9.0+12.0*xi)*eta+(6.0-8.0*xi)*eta*eta+2.0*(-6.0+8.0*xi+(18.0-24.0*xi)*eta+(-12.0+16.0*xi)*eta*eta)*zeta;
+ return_value[1][0] = (-9.0+12.0*xi+2.0*(6.0-8.0*xi)*eta)*zeta+(18.0-24.0*xi+2.0*(-12.0+16.0*xi)*eta)*zeta*zeta;
+ return_value[1][1] = (-4.0+12.0*xi-8.0*xi*xi)*zeta+(8.0-24.0*xi+16.0*xi*xi)*zeta*zeta;
+ return_value[1][2] = 3.0-9.0*xi+6.0*xi*xi+2.0*(-2.0+6.0*xi-4.0*xi*xi)*eta+2.0*(-6.0+18.0*xi-12.0*xi*xi+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta)*zeta;
+ return_value[2][0] = 3.0-4.0*xi+(-9.0+12.0*xi)*eta+(6.0-8.0*xi)*eta*eta+2.0*(-6.0+8.0*xi+(18.0-24.0*xi)*eta+(-12.0+16.0*xi)*eta*eta)*zeta;
+ return_value[2][1] = 3.0-9.0*xi+6.0*xi*xi+2.0*(-2.0+6.0*xi-4.0*xi*xi)*eta+2.0*(-6.0+18.0*xi-12.0*xi*xi+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta)*zeta;
+ return_value[2][2] = 4.0-12.0*xi+8.0*xi*xi+2.0*(-6.0+18.0*xi-12.0*xi*xi)*eta+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta*eta;
+ break;
+ case 4:
+ return_value[0][0] = -4.0*eta+8.0*eta*eta+(12.0*eta-24.0*eta*eta)*zeta+(-8.0*eta+16.0*eta*eta)*zeta*zeta;
+ return_value[0][1] = 3.0-4.0*xi+2.0*(-6.0+8.0*xi)*eta+(-9.0+12.0*xi+2.0*(18.0-24.0*xi)*eta)*zeta+(6.0-8.0*xi+2.0*(-12.0+16.0*xi)*eta)*zeta*zeta;
+ return_value[0][2] = (-9.0+12.0*xi)*eta+(18.0-24.0*xi)*eta*eta+2.0*((6.0-8.0*xi)*eta+(-12.0+16.0*xi)*eta*eta)*zeta;
+ return_value[1][0] = 3.0-4.0*xi+2.0*(-6.0+8.0*xi)*eta+(-9.0+12.0*xi+2.0*(18.0-24.0*xi)*eta)*zeta+(6.0-8.0*xi+2.0*(-12.0+16.0*xi)*eta)*zeta*zeta;
+ return_value[1][1] = 4.0-12.0*xi+8.0*xi*xi+(-12.0+36.0*xi-24.0*xi*xi)*zeta+(8.0-24.0*xi+16.0*xi*xi)*zeta*zeta;
+ return_value[1][2] = 3.0-9.0*xi+6.0*xi*xi+2.0*(-6.0+18.0*xi-12.0*xi*xi)*eta+2.0*(-2.0+6.0*xi-4.0*xi*xi+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta)*zeta;
+ return_value[2][0] = (-9.0+12.0*xi)*eta+(18.0-24.0*xi)*eta*eta+2.0*((6.0-8.0*xi)*eta+(-12.0+16.0*xi)*eta*eta)*zeta;
+ return_value[2][1] = 3.0-9.0*xi+6.0*xi*xi+2.0*(-6.0+18.0*xi-12.0*xi*xi)*eta+2.0*(-2.0+6.0*xi-4.0*xi*xi+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta)*zeta;
+ return_value[2][2] = 2.0*(-2.0+6.0*xi-4.0*xi*xi)*eta+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta*eta;
+ break;
+ case 5:
+ return_value[0][0] = -4.0*eta+8.0*eta*eta+(12.0*eta-24.0*eta*eta)*zeta+(-8.0*eta+16.0*eta*eta)*zeta*zeta;
+ return_value[0][1] = 1.0-4.0*xi+2.0*(-2.0+8.0*xi)*eta+(-3.0+12.0*xi+2.0*(6.0-24.0*xi)*eta)*zeta+(2.0-8.0*xi+2.0*(-4.0+16.0*xi)*eta)*zeta*zeta;
+ return_value[0][2] = (-3.0+12.0*xi)*eta+(6.0-24.0*xi)*eta*eta+2.0*((2.0-8.0*xi)*eta+(-4.0+16.0*xi)*eta*eta)*zeta;
+ return_value[1][0] = 1.0-4.0*xi+2.0*(-2.0+8.0*xi)*eta+(-3.0+12.0*xi+2.0*(6.0-24.0*xi)*eta)*zeta+(2.0-8.0*xi+2.0*(-4.0+16.0*xi)*eta)*zeta*zeta;
+ return_value[1][1] = -4.0*xi+8.0*xi*xi+(12.0*xi-24.0*xi*xi)*zeta+(-8.0*xi+16.0*xi*xi)*zeta*zeta;
+ return_value[1][2] = -3.0*xi+6.0*xi*xi+2.0*(6.0*xi-12.0*xi*xi)*eta+2.0*(2.0*xi-4.0*xi*xi+2.0*(-4.0*xi+8.0*xi*xi)*eta)*zeta;
+ return_value[2][0] = (-3.0+12.0*xi)*eta+(6.0-24.0*xi)*eta*eta+2.0*((2.0-8.0*xi)*eta+(-4.0+16.0*xi)*eta*eta)*zeta;
+ return_value[2][1] = -3.0*xi+6.0*xi*xi+2.0*(6.0*xi-12.0*xi*xi)*eta+2.0*(2.0*xi-4.0*xi*xi+2.0*(-4.0*xi+8.0*xi*xi)*eta)*zeta;
+ return_value[2][2] = 2.0*(2.0*xi-4.0*xi*xi)*eta+2.0*(-4.0*xi+8.0*xi*xi)*eta*eta;
+ break;
+ case 6:
+ return_value[0][0] = (4.0*eta-8.0*eta*eta)*zeta+(-8.0*eta+16.0*eta*eta)*zeta*zeta;
+ return_value[0][1] = (-1.0+4.0*xi+2.0*(2.0-8.0*xi)*eta)*zeta+(2.0-8.0*xi+2.0*(-4.0+16.0*xi)*eta)*zeta*zeta;
+ return_value[0][2] = (-1.0+4.0*xi)*eta+(2.0-8.0*xi)*eta*eta+2.0*((2.0-8.0*xi)*eta+(-4.0+16.0*xi)*eta*eta)*zeta;
+ return_value[1][0] = (-1.0+4.0*xi+2.0*(2.0-8.0*xi)*eta)*zeta+(2.0-8.0*xi+2.0*(-4.0+16.0*xi)*eta)*zeta*zeta;
+ return_value[1][1] = (4.0*xi-8.0*xi*xi)*zeta+(-8.0*xi+16.0*xi*xi)*zeta*zeta;
+ return_value[1][2] = -xi+2.0*xi*xi+2.0*(2.0*xi-4.0*xi*xi)*eta+2.0*(2.0*xi-4.0*xi*xi+2.0*(-4.0*xi+8.0*xi*xi)*eta)*zeta;
+ return_value[2][0] = (-1.0+4.0*xi)*eta+(2.0-8.0*xi)*eta*eta+2.0*((2.0-8.0*xi)*eta+(-4.0+16.0*xi)*eta*eta)*zeta;
+ return_value[2][1] = -xi+2.0*xi*xi+2.0*(2.0*xi-4.0*xi*xi)*eta+2.0*(2.0*xi-4.0*xi*xi+2.0*(-4.0*xi+8.0*xi*xi)*eta)*zeta;
+ return_value[2][2] = 2.0*(2.0*xi-4.0*xi*xi)*eta+2.0*(-4.0*xi+8.0*xi*xi)*eta*eta;
+ break;
+ case 7:
+ return_value[0][0] = (4.0*eta-8.0*eta*eta)*zeta+(-8.0*eta+16.0*eta*eta)*zeta*zeta;
+ return_value[0][1] = (-3.0+4.0*xi+2.0*(6.0-8.0*xi)*eta)*zeta+(6.0-8.0*xi+2.0*(-12.0+16.0*xi)*eta)*zeta*zeta;
+ return_value[0][2] = (-3.0+4.0*xi)*eta+(6.0-8.0*xi)*eta*eta+2.0*((6.0-8.0*xi)*eta+(-12.0+16.0*xi)*eta*eta)*zeta;
+ return_value[1][0] = (-3.0+4.0*xi+2.0*(6.0-8.0*xi)*eta)*zeta+(6.0-8.0*xi+2.0*(-12.0+16.0*xi)*eta)*zeta*zeta;
+ return_value[1][1] = (-4.0+12.0*xi-8.0*xi*xi)*zeta+(8.0-24.0*xi+16.0*xi*xi)*zeta*zeta;
+ return_value[1][2] = 1.0-3.0*xi+2.0*xi*xi+2.0*(-2.0+6.0*xi-4.0*xi*xi)*eta+2.0*(-2.0+6.0*xi-4.0*xi*xi+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta)*zeta;
+ return_value[2][0] = (-3.0+4.0*xi)*eta+(6.0-8.0*xi)*eta*eta+2.0*((6.0-8.0*xi)*eta+(-12.0+16.0*xi)*eta*eta)*zeta;
+ return_value[2][1] = 1.0-3.0*xi+2.0*xi*xi+2.0*(-2.0+6.0*xi-4.0*xi*xi)*eta+2.0*(-2.0+6.0*xi-4.0*xi*xi+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta)*zeta;
+ return_value[2][2] = 2.0*(-2.0+6.0*xi-4.0*xi*xi)*eta+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta*eta;
+ break;
+ case 8:
+ return_value[0][0] = -8.0+24.0*eta-16.0*eta*eta+(24.0-72.0*eta+48.0*eta*eta)*zeta+(-16.0+48.0*eta-32.0*eta*eta)*zeta*zeta;
+ return_value[0][1] = -12.0+24.0*xi+2.0*(8.0-16.0*xi)*eta+(36.0-72.0*xi+2.0*(-24.0+48.0*xi)*eta)*zeta+(-24.0+48.0*xi+2.0*(16.0-32.0*xi)*eta)*zeta*zeta;
+ return_value[0][2] = -12.0+24.0*xi+(36.0-72.0*xi)*eta+(-24.0+48.0*xi)*eta*eta+2.0*(8.0-16.0*xi+(-24.0+48.0*xi)*eta+(16.0-32.0*xi)*eta*eta)*zeta;
+ return_value[1][0] = -12.0+24.0*xi+2.0*(8.0-16.0*xi)*eta+(36.0-72.0*xi+2.0*(-24.0+48.0*xi)*eta)*zeta+(-24.0+48.0*xi+2.0*(16.0-32.0*xi)*eta)*zeta*zeta;
+ return_value[1][1] = 16.0*xi-16.0*xi*xi+(-48.0*xi+48.0*xi*xi)*zeta+(32.0*xi-32.0*xi*xi)*zeta*zeta;
+ return_value[1][2] = 36.0*xi-36.0*xi*xi+2.0*(-24.0*xi+24.0*xi*xi)*eta+2.0*(-24.0*xi+24.0*xi*xi+2.0*(16.0*xi-16.0*xi*xi)*eta)*zeta;
+ return_value[2][0] = -12.0+24.0*xi+(36.0-72.0*xi)*eta+(-24.0+48.0*xi)*eta*eta+2.0*(8.0-16.0*xi+(-24.0+48.0*xi)*eta+(16.0-32.0*xi)*eta*eta)*zeta;
+ return_value[2][1] = 36.0*xi-36.0*xi*xi+2.0*(-24.0*xi+24.0*xi*xi)*eta+2.0*(-24.0*xi+24.0*xi*xi+2.0*(16.0*xi-16.0*xi*xi)*eta)*zeta;
+ return_value[2][2] = 16.0*xi-16.0*xi*xi+2.0*(-24.0*xi+24.0*xi*xi)*eta+2.0*(16.0*xi-16.0*xi*xi)*eta*eta;
+ break;
+ case 9:
+ return_value[0][0] = (16.0-48.0*eta+32.0*eta*eta)*zeta+(-16.0+48.0*eta-32.0*eta*eta)*zeta*zeta;
+ return_value[0][1] = (12.0-48.0*xi+2.0*(-8.0+32.0*xi)*eta)*zeta+(-12.0+48.0*xi+2.0*(8.0-32.0*xi)*eta)*zeta*zeta;
+ return_value[0][2] = -4.0+16.0*xi+(12.0-48.0*xi)*eta+(-8.0+32.0*xi)*eta*eta+2.0*(4.0-16.0*xi+(-12.0+48.0*xi)*eta+(8.0-32.0*xi)*eta*eta)*zeta;
+ return_value[1][0] = (12.0-48.0*xi+2.0*(-8.0+32.0*xi)*eta)*zeta+(-12.0+48.0*xi+2.0*(8.0-32.0*xi)*eta)*zeta*zeta;
+ return_value[1][1] = (-16.0*xi+32.0*xi*xi)*zeta+(16.0*xi-32.0*xi*xi)*zeta*zeta;
+ return_value[1][2] = 12.0*xi-24.0*xi*xi+2.0*(-8.0*xi+16.0*xi*xi)*eta+2.0*(-12.0*xi+24.0*xi*xi+2.0*(8.0*xi-16.0*xi*xi)*eta)*zeta;
+ return_value[2][0] = -4.0+16.0*xi+(12.0-48.0*xi)*eta+(-8.0+32.0*xi)*eta*eta+2.0*(4.0-16.0*xi+(-12.0+48.0*xi)*eta+(8.0-32.0*xi)*eta*eta)*zeta;
+ return_value[2][1] = 12.0*xi-24.0*xi*xi+2.0*(-8.0*xi+16.0*xi*xi)*eta+2.0*(-12.0*xi+24.0*xi*xi+2.0*(8.0*xi-16.0*xi*xi)*eta)*zeta;
+ return_value[2][2] = 8.0*xi-16.0*xi*xi+2.0*(-12.0*xi+24.0*xi*xi)*eta+2.0*(8.0*xi-16.0*xi*xi)*eta*eta;
+ return_value[0][0] = (8.0-24.0*eta+16.0*eta*eta)*zeta+(-16.0+48.0*eta-32.0*eta*eta)*zeta*zeta;
+ return_value[0][1] = (12.0-24.0*xi+2.0*(-8.0+16.0*xi)*eta)*zeta+(-24.0+48.0*xi+2.0*(16.0-32.0*xi)*eta)*zeta*zeta;
+ return_value[0][2] = -4.0+8.0*xi+(12.0-24.0*xi)*eta+(-8.0+16.0*xi)*eta*eta+2.0*(8.0-16.0*xi+(-24.0+48.0*xi)*eta+(16.0-32.0*xi)*eta*eta)*zeta;
+ return_value[1][0] = (12.0-24.0*xi+2.0*(-8.0+16.0*xi)*eta)*zeta+(-24.0+48.0*xi+2.0*(16.0-32.0*xi)*eta)*zeta*zeta;
+ return_value[1][1] = (-16.0*xi+16.0*xi*xi)*zeta+(32.0*xi-32.0*xi*xi)*zeta*zeta;
+ return_value[1][2] = 12.0*xi-12.0*xi*xi+2.0*(-8.0*xi+8.0*xi*xi)*eta+2.0*(-24.0*xi+24.0*xi*xi+2.0*(16.0*xi-16.0*xi*xi)*eta)*zeta;
+ return_value[2][0] = -4.0+8.0*xi+(12.0-24.0*xi)*eta+(-8.0+16.0*xi)*eta*eta+2.0*(8.0-16.0*xi+(-24.0+48.0*xi)*eta+(16.0-32.0*xi)*eta*eta)*zeta;
+ return_value[2][1] = 12.0*xi-12.0*xi*xi+2.0*(-8.0*xi+8.0*xi*xi)*eta+2.0*(-24.0*xi+24.0*xi*xi+2.0*(16.0*xi-16.0*xi*xi)*eta)*zeta;
+ return_value[2][2] = 16.0*xi-16.0*xi*xi+2.0*(-24.0*xi+24.0*xi*xi)*eta+2.0*(16.0*xi-16.0*xi*xi)*eta*eta;
+ return_value[0][0] = (16.0-48.0*eta+32.0*eta*eta)*zeta+(-16.0+48.0*eta-32.0*eta*eta)*zeta*zeta;
+ return_value[0][1] = (36.0-48.0*xi+2.0*(-24.0+32.0*xi)*eta)*zeta+(-36.0+48.0*xi+2.0*(24.0-32.0*xi)*eta)*zeta*zeta;
+ return_value[0][2] = -12.0+16.0*xi+(36.0-48.0*xi)*eta+(-24.0+32.0*xi)*eta*eta+2.0*(12.0-16.0*xi+(-36.0+48.0*xi)*eta+(24.0-32.0*xi)*eta*eta)*zeta;
+ return_value[1][0] = (36.0-48.0*xi+2.0*(-24.0+32.0*xi)*eta)*zeta+(-36.0+48.0*xi+2.0*(24.0-32.0*xi)*eta)*zeta*zeta;
+ return_value[1][1] = (16.0-48.0*xi+32.0*xi*xi)*zeta+(-16.0+48.0*xi-32.0*xi*xi)*zeta*zeta;
+ return_value[1][2] = -12.0+36.0*xi-24.0*xi*xi+2.0*(8.0-24.0*xi+16.0*xi*xi)*eta+2.0*(12.0-36.0*xi+24.0*xi*xi+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta)*zeta;
+ return_value[2][0] = -12.0+16.0*xi+(36.0-48.0*xi)*eta+(-24.0+32.0*xi)*eta*eta+2.0*(12.0-16.0*xi+(-36.0+48.0*xi)*eta+(24.0-32.0*xi)*eta*eta)*zeta;
+ return_value[2][1] = -12.0+36.0*xi-24.0*xi*xi+2.0*(8.0-24.0*xi+16.0*xi*xi)*eta+2.0*(12.0-36.0*xi+24.0*xi*xi+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta)*zeta;
+ return_value[2][2] = -8.0+24.0*xi-16.0*xi*xi+2.0*(12.0-36.0*xi+24.0*xi*xi)*eta+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta*eta;
+ return_value[0][0] = 8.0*eta-16.0*eta*eta+(-24.0*eta+48.0*eta*eta)*zeta+(16.0*eta-32.0*eta*eta)*zeta*zeta;
+ return_value[0][1] = -4.0+8.0*xi+2.0*(8.0-16.0*xi)*eta+(12.0-24.0*xi+2.0*(-24.0+48.0*xi)*eta)*zeta+(-8.0+16.0*xi+2.0*(16.0-32.0*xi)*eta)*zeta*zeta;
+ return_value[0][2] = (12.0-24.0*xi)*eta+(-24.0+48.0*xi)*eta*eta+2.0*((-8.0+16.0*xi)*eta+(16.0-32.0*xi)*eta*eta)*zeta;
+ return_value[1][0] = -4.0+8.0*xi+2.0*(8.0-16.0*xi)*eta+(12.0-24.0*xi+2.0*(-24.0+48.0*xi)*eta)*zeta+(-8.0+16.0*xi+2.0*(16.0-32.0*xi)*eta)*zeta*zeta;
+ return_value[1][1] = 16.0*xi-16.0*xi*xi+(-48.0*xi+48.0*xi*xi)*zeta+(32.0*xi-32.0*xi*xi)*zeta*zeta;
+ return_value[1][2] = 12.0*xi-12.0*xi*xi+2.0*(-24.0*xi+24.0*xi*xi)*eta+2.0*(-8.0*xi+8.0*xi*xi+2.0*(16.0*xi-16.0*xi*xi)*eta)*zeta;
+ return_value[2][0] = (12.0-24.0*xi)*eta+(-24.0+48.0*xi)*eta*eta+2.0*((-8.0+16.0*xi)*eta+(16.0-32.0*xi)*eta*eta)*zeta;
+ return_value[2][1] = 12.0*xi-12.0*xi*xi+2.0*(-24.0*xi+24.0*xi*xi)*eta+2.0*(-8.0*xi+8.0*xi*xi+2.0*(16.0*xi-16.0*xi*xi)*eta)*zeta;
+ return_value[2][2] = 2.0*(-8.0*xi+8.0*xi*xi)*eta+2.0*(16.0*xi-16.0*xi*xi)*eta*eta;
+ return_value[0][0] = (-16.0*eta+32.0*eta*eta)*zeta+(16.0*eta-32.0*eta*eta)*zeta*zeta;
+ return_value[0][1] = (4.0-16.0*xi+2.0*(-8.0+32.0*xi)*eta)*zeta+(-4.0+16.0*xi+2.0*(8.0-32.0*xi)*eta)*zeta*zeta;
+ return_value[0][2] = (4.0-16.0*xi)*eta+(-8.0+32.0*xi)*eta*eta+2.0*((-4.0+16.0*xi)*eta+(8.0-32.0*xi)*eta*eta)*zeta;
+ return_value[1][0] = (4.0-16.0*xi+2.0*(-8.0+32.0*xi)*eta)*zeta+(-4.0+16.0*xi+2.0*(8.0-32.0*xi)*eta)*zeta*zeta;
+ return_value[1][1] = (-16.0*xi+32.0*xi*xi)*zeta+(16.0*xi-32.0*xi*xi)*zeta*zeta;
+ return_value[1][2] = 4.0*xi-8.0*xi*xi+2.0*(-8.0*xi+16.0*xi*xi)*eta+2.0*(-4.0*xi+8.0*xi*xi+2.0*(8.0*xi-16.0*xi*xi)*eta)*zeta;
+ return_value[2][0] = (4.0-16.0*xi)*eta+(-8.0+32.0*xi)*eta*eta+2.0*((-4.0+16.0*xi)*eta+(8.0-32.0*xi)*eta*eta)*zeta;
+ return_value[2][1] = 4.0*xi-8.0*xi*xi+2.0*(-8.0*xi+16.0*xi*xi)*eta+2.0*(-4.0*xi+8.0*xi*xi+2.0*(8.0*xi-16.0*xi*xi)*eta)*zeta;
+ return_value[2][2] = 2.0*(-4.0*xi+8.0*xi*xi)*eta+2.0*(8.0*xi-16.0*xi*xi)*eta*eta;
+ return_value[0][0] = (-8.0*eta+16.0*eta*eta)*zeta+(16.0*eta-32.0*eta*eta)*zeta*zeta;
+ return_value[0][1] = (4.0-8.0*xi+2.0*(-8.0+16.0*xi)*eta)*zeta+(-8.0+16.0*xi+2.0*(16.0-32.0*xi)*eta)*zeta*zeta;
+ return_value[0][2] = (4.0-8.0*xi)*eta+(-8.0+16.0*xi)*eta*eta+2.0*((-8.0+16.0*xi)*eta+(16.0-32.0*xi)*eta*eta)*zeta;
+ return_value[1][0] = (4.0-8.0*xi+2.0*(-8.0+16.0*xi)*eta)*zeta+(-8.0+16.0*xi+2.0*(16.0-32.0*xi)*eta)*zeta*zeta;
+ return_value[1][1] = (-16.0*xi+16.0*xi*xi)*zeta+(32.0*xi-32.0*xi*xi)*zeta*zeta;
+ return_value[1][2] = 4.0*xi-4.0*xi*xi+2.0*(-8.0*xi+8.0*xi*xi)*eta+2.0*(-8.0*xi+8.0*xi*xi+2.0*(16.0*xi-16.0*xi*xi)*eta)*zeta;
+ return_value[2][0] = (4.0-8.0*xi)*eta+(-8.0+16.0*xi)*eta*eta+2.0*((-8.0+16.0*xi)*eta+(16.0-32.0*xi)*eta*eta)*zeta;
+ return_value[2][1] = 4.0*xi-4.0*xi*xi+2.0*(-8.0*xi+8.0*xi*xi)*eta+2.0*(-8.0*xi+8.0*xi*xi+2.0*(16.0*xi-16.0*xi*xi)*eta)*zeta;
+ return_value[2][2] = 2.0*(-8.0*xi+8.0*xi*xi)*eta+2.0*(16.0*xi-16.0*xi*xi)*eta*eta;
+ return_value[0][0] = (-16.0*eta+32.0*eta*eta)*zeta+(16.0*eta-32.0*eta*eta)*zeta*zeta;
+ return_value[0][1] = (12.0-16.0*xi+2.0*(-24.0+32.0*xi)*eta)*zeta+(-12.0+16.0*xi+2.0*(24.0-32.0*xi)*eta)*zeta*zeta;
+ return_value[0][2] = (12.0-16.0*xi)*eta+(-24.0+32.0*xi)*eta*eta+2.0*((-12.0+16.0*xi)*eta+(24.0-32.0*xi)*eta*eta)*zeta;
+ return_value[1][0] = (12.0-16.0*xi+2.0*(-24.0+32.0*xi)*eta)*zeta+(-12.0+16.0*xi+2.0*(24.0-32.0*xi)*eta)*zeta*zeta;
+ return_value[1][1] = (16.0-48.0*xi+32.0*xi*xi)*zeta+(-16.0+48.0*xi-32.0*xi*xi)*zeta*zeta;
+ return_value[1][2] = -4.0+12.0*xi-8.0*xi*xi+2.0*(8.0-24.0*xi+16.0*xi*xi)*eta+2.0*(4.0-12.0*xi+8.0*xi*xi+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta)*zeta;
+ return_value[2][0] = (12.0-16.0*xi)*eta+(-24.0+32.0*xi)*eta*eta+2.0*((-12.0+16.0*xi)*eta+(24.0-32.0*xi)*eta*eta)*zeta;
+ return_value[2][1] = -4.0+12.0*xi-8.0*xi*xi+2.0*(8.0-24.0*xi+16.0*xi*xi)*eta+2.0*(4.0-12.0*xi+8.0*xi*xi+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta)*zeta;
+ return_value[2][2] = 2.0*(4.0-12.0*xi+8.0*xi*xi)*eta+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta*eta;
+ return_value[0][0] = 16.0*eta-16.0*eta*eta+(-48.0*eta+48.0*eta*eta)*zeta+(32.0*eta-32.0*eta*eta)*zeta*zeta;
+ return_value[0][1] = -12.0+16.0*xi+2.0*(12.0-16.0*xi)*eta+(36.0-48.0*xi+2.0*(-36.0+48.0*xi)*eta)*zeta+(-24.0+32.0*xi+2.0*(24.0-32.0*xi)*eta)*zeta*zeta;
+ return_value[0][2] = (36.0-48.0*xi)*eta+(-36.0+48.0*xi)*eta*eta+2.0*((-24.0+32.0*xi)*eta+(24.0-32.0*xi)*eta*eta)*zeta;
+ return_value[1][0] = -12.0+16.0*xi+2.0*(12.0-16.0*xi)*eta+(36.0-48.0*xi+2.0*(-36.0+48.0*xi)*eta)*zeta+(-24.0+32.0*xi+2.0*(24.0-32.0*xi)*eta)*zeta*zeta;
+ return_value[1][1] = -8.0+24.0*xi-16.0*xi*xi+(24.0-72.0*xi+48.0*xi*xi)*zeta+(-16.0+48.0*xi-32.0*xi*xi)*zeta*zeta;
+ return_value[1][2] = -12.0+36.0*xi-24.0*xi*xi+2.0*(12.0-36.0*xi+24.0*xi*xi)*eta+2.0*(8.0-24.0*xi+16.0*xi*xi+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta)*zeta;
+ return_value[2][0] = (36.0-48.0*xi)*eta+(-36.0+48.0*xi)*eta*eta+2.0*((-24.0+32.0*xi)*eta+(24.0-32.0*xi)*eta*eta)*zeta;
+ return_value[2][1] = -12.0+36.0*xi-24.0*xi*xi+2.0*(12.0-36.0*xi+24.0*xi*xi)*eta+2.0*(8.0-24.0*xi+16.0*xi*xi+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta)*zeta;
+ return_value[2][2] = 2.0*(8.0-24.0*xi+16.0*xi*xi)*eta+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta*eta;
+ return_value[0][0] = 16.0*eta-16.0*eta*eta+(-48.0*eta+48.0*eta*eta)*zeta+(32.0*eta-32.0*eta*eta)*zeta*zeta;
+ return_value[0][1] = -4.0+16.0*xi+2.0*(4.0-16.0*xi)*eta+(12.0-48.0*xi+2.0*(-12.0+48.0*xi)*eta)*zeta+(-8.0+32.0*xi+2.0*(8.0-32.0*xi)*eta)*zeta*zeta;
+ return_value[0][2] = (12.0-48.0*xi)*eta+(-12.0+48.0*xi)*eta*eta+2.0*((-8.0+32.0*xi)*eta+(8.0-32.0*xi)*eta*eta)*zeta;
+ return_value[1][0] = -4.0+16.0*xi+2.0*(4.0-16.0*xi)*eta+(12.0-48.0*xi+2.0*(-12.0+48.0*xi)*eta)*zeta+(-8.0+32.0*xi+2.0*(8.0-32.0*xi)*eta)*zeta*zeta;
+ return_value[1][1] = 8.0*xi-16.0*xi*xi+(-24.0*xi+48.0*xi*xi)*zeta+(16.0*xi-32.0*xi*xi)*zeta*zeta;
+ return_value[1][2] = 12.0*xi-24.0*xi*xi+2.0*(-12.0*xi+24.0*xi*xi)*eta+2.0*(-8.0*xi+16.0*xi*xi+2.0*(8.0*xi-16.0*xi*xi)*eta)*zeta;
+ return_value[2][0] = (12.0-48.0*xi)*eta+(-12.0+48.0*xi)*eta*eta+2.0*((-8.0+32.0*xi)*eta+(8.0-32.0*xi)*eta*eta)*zeta;
+ return_value[2][1] = 12.0*xi-24.0*xi*xi+2.0*(-12.0*xi+24.0*xi*xi)*eta+2.0*(-8.0*xi+16.0*xi*xi+2.0*(8.0*xi-16.0*xi*xi)*eta)*zeta;
+ return_value[2][2] = 2.0*(-8.0*xi+16.0*xi*xi)*eta+2.0*(8.0*xi-16.0*xi*xi)*eta*eta;
+ return_value[0][0] = (-16.0*eta+16.0*eta*eta)*zeta+(32.0*eta-32.0*eta*eta)*zeta*zeta;
+ return_value[0][1] = (4.0-16.0*xi+2.0*(-4.0+16.0*xi)*eta)*zeta+(-8.0+32.0*xi+2.0*(8.0-32.0*xi)*eta)*zeta*zeta;
+ return_value[0][2] = (4.0-16.0*xi)*eta+(-4.0+16.0*xi)*eta*eta+2.0*((-8.0+32.0*xi)*eta+(8.0-32.0*xi)*eta*eta)*zeta;
+ return_value[1][0] = (4.0-16.0*xi+2.0*(-4.0+16.0*xi)*eta)*zeta+(-8.0+32.0*xi+2.0*(8.0-32.0*xi)*eta)*zeta*zeta;
+ return_value[1][1] = (-8.0*xi+16.0*xi*xi)*zeta+(16.0*xi-32.0*xi*xi)*zeta*zeta;
+ return_value[1][2] = 4.0*xi-8.0*xi*xi+2.0*(-4.0*xi+8.0*xi*xi)*eta+2.0*(-8.0*xi+16.0*xi*xi+2.0*(8.0*xi-16.0*xi*xi)*eta)*zeta;
+ return_value[2][0] = (4.0-16.0*xi)*eta+(-4.0+16.0*xi)*eta*eta+2.0*((-8.0+32.0*xi)*eta+(8.0-32.0*xi)*eta*eta)*zeta;
+ return_value[2][1] = 4.0*xi-8.0*xi*xi+2.0*(-4.0*xi+8.0*xi*xi)*eta+2.0*(-8.0*xi+16.0*xi*xi+2.0*(8.0*xi-16.0*xi*xi)*eta)*zeta;
+ return_value[2][2] = 2.0*(-8.0*xi+16.0*xi*xi)*eta+2.0*(8.0*xi-16.0*xi*xi)*eta*eta;
+ return_value[0][0] = (-16.0*eta+16.0*eta*eta)*zeta+(32.0*eta-32.0*eta*eta)*zeta*zeta;
+ return_value[0][1] = (12.0-16.0*xi+2.0*(-12.0+16.0*xi)*eta)*zeta+(-24.0+32.0*xi+2.0*(24.0-32.0*xi)*eta)*zeta*zeta;
+ return_value[0][2] = (12.0-16.0*xi)*eta+(-12.0+16.0*xi)*eta*eta+2.0*((-24.0+32.0*xi)*eta+(24.0-32.0*xi)*eta*eta)*zeta;
+ return_value[1][0] = (12.0-16.0*xi+2.0*(-12.0+16.0*xi)*eta)*zeta+(-24.0+32.0*xi+2.0*(24.0-32.0*xi)*eta)*zeta*zeta;
+ return_value[1][1] = (8.0-24.0*xi+16.0*xi*xi)*zeta+(-16.0+48.0*xi-32.0*xi*xi)*zeta*zeta;
+ return_value[1][2] = -4.0+12.0*xi-8.0*xi*xi+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta+2.0*(8.0-24.0*xi+16.0*xi*xi+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta)*zeta;
+ return_value[2][0] = (12.0-16.0*xi)*eta+(-12.0+16.0*xi)*eta*eta+2.0*((-24.0+32.0*xi)*eta+(24.0-32.0*xi)*eta*eta)*zeta;
+ return_value[2][1] = -4.0+12.0*xi-8.0*xi*xi+2.0*(4.0-12.0*xi+8.0*xi*xi)*eta+2.0*(8.0-24.0*xi+16.0*xi*xi+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta)*zeta;
+ return_value[2][2] = 2.0*(8.0-24.0*xi+16.0*xi*xi)*eta+2.0*(-8.0+24.0*xi-16.0*xi*xi)*eta*eta;
+ return_value[0][0] = (-32.0+96.0*eta-64.0*eta*eta)*zeta+(32.0-96.0*eta+64.0*eta*eta)*zeta*zeta;
+ return_value[0][1] = (-48.0+96.0*xi+2.0*(32.0-64.0*xi)*eta)*zeta+(48.0-96.0*xi+2.0*(-32.0+64.0*xi)*eta)*zeta*zeta;
+ return_value[0][2] = 16.0-32.0*xi+(-48.0+96.0*xi)*eta+(32.0-64.0*xi)*eta*eta+2.0*(-16.0+32.0*xi+(48.0-96.0*xi)*eta+(-32.0+64.0*xi)*eta*eta)*zeta;
+ return_value[1][0] = (-48.0+96.0*xi+2.0*(32.0-64.0*xi)*eta)*zeta+(48.0-96.0*xi+2.0*(-32.0+64.0*xi)*eta)*zeta*zeta;
+ return_value[1][1] = (64.0*xi-64.0*xi*xi)*zeta+(-64.0*xi+64.0*xi*xi)*zeta*zeta;
+ return_value[1][2] = -48.0*xi+48.0*xi*xi+2.0*(32.0*xi-32.0*xi*xi)*eta+2.0*(48.0*xi-48.0*xi*xi+2.0*(-32.0*xi+32.0*xi*xi)*eta)*zeta;
+ return_value[2][0] = 16.0-32.0*xi+(-48.0+96.0*xi)*eta+(32.0-64.0*xi)*eta*eta+2.0*(-16.0+32.0*xi+(48.0-96.0*xi)*eta+(-32.0+64.0*xi)*eta*eta)*zeta;
+ return_value[2][1] = -48.0*xi+48.0*xi*xi+2.0*(32.0*xi-32.0*xi*xi)*eta+2.0*(48.0*xi-48.0*xi*xi+2.0*(-32.0*xi+32.0*xi*xi)*eta)*zeta;
+ return_value[2][2] = -32.0*xi+32.0*xi*xi+2.0*(48.0*xi-48.0*xi*xi)*eta+2.0*(-32.0*xi+32.0*xi*xi)*eta*eta;
+ return_value[0][0] = (32.0*eta-64.0*eta*eta)*zeta+(-32.0*eta+64.0*eta*eta)*zeta*zeta;
+ return_value[0][1] = (-16.0+32.0*xi+2.0*(32.0-64.0*xi)*eta)*zeta+(16.0-32.0*xi+2.0*(-32.0+64.0*xi)*eta)*zeta*zeta;
+ return_value[0][2] = (-16.0+32.0*xi)*eta+(32.0-64.0*xi)*eta*eta+2.0*((16.0-32.0*xi)*eta+(-32.0+64.0*xi)*eta*eta)*zeta;
+ return_value[1][0] = (-16.0+32.0*xi+2.0*(32.0-64.0*xi)*eta)*zeta+(16.0-32.0*xi+2.0*(-32.0+64.0*xi)*eta)*zeta*zeta;
+ return_value[1][1] = (64.0*xi-64.0*xi*xi)*zeta+(-64.0*xi+64.0*xi*xi)*zeta*zeta;
+ return_value[1][2] = -16.0*xi+16.0*xi*xi+2.0*(32.0*xi-32.0*xi*xi)*eta+2.0*(16.0*xi-16.0*xi*xi+2.0*(-32.0*xi+32.0*xi*xi)*eta)*zeta;
+ return_value[2][0] = (-16.0+32.0*xi)*eta+(32.0-64.0*xi)*eta*eta+2.0*((16.0-32.0*xi)*eta+(-32.0+64.0*xi)*eta*eta)*zeta;
+ return_value[2][1] = -16.0*xi+16.0*xi*xi+2.0*(32.0*xi-32.0*xi*xi)*eta+2.0*(16.0*xi-16.0*xi*xi+2.0*(-32.0*xi+32.0*xi*xi)*eta)*zeta;
+ return_value[2][2] = 2.0*(16.0*xi-16.0*xi*xi)*eta+2.0*(-32.0*xi+32.0*xi*xi)*eta*eta;
+ return_value[0][0] = -32.0*eta+32.0*eta*eta+(96.0*eta-96.0*eta*eta)*zeta+(-64.0*eta+64.0*eta*eta)*zeta*zeta;
+ return_value[0][1] = 16.0-32.0*xi+2.0*(-16.0+32.0*xi)*eta+(-48.0+96.0*xi+2.0*(48.0-96.0*xi)*eta)*zeta+(32.0-64.0*xi+2.0*(-32.0+64.0*xi)*eta)*zeta*zeta;
+ return_value[0][2] = (-48.0+96.0*xi)*eta+(48.0-96.0*xi)*eta*eta+2.0*((32.0-64.0*xi)*eta+(-32.0+64.0*xi)*eta*eta)*zeta;
+ return_value[1][0] = 16.0-32.0*xi+2.0*(-16.0+32.0*xi)*eta+(-48.0+96.0*xi+2.0*(48.0-96.0*xi)*eta)*zeta+(32.0-64.0*xi+2.0*(-32.0+64.0*xi)*eta)*zeta*zeta;
+ return_value[1][1] = -32.0*xi+32.0*xi*xi+(96.0*xi-96.0*xi*xi)*zeta+(-64.0*xi+64.0*xi*xi)*zeta*zeta;
+ return_value[1][2] = -48.0*xi+48.0*xi*xi+2.0*(48.0*xi-48.0*xi*xi)*eta+2.0*(32.0*xi-32.0*xi*xi+2.0*(-32.0*xi+32.0*xi*xi)*eta)*zeta;
+ return_value[2][0] = (-48.0+96.0*xi)*eta+(48.0-96.0*xi)*eta*eta+2.0*((32.0-64.0*xi)*eta+(-32.0+64.0*xi)*eta*eta)*zeta;
+ return_value[2][1] = -48.0*xi+48.0*xi*xi+2.0*(48.0*xi-48.0*xi*xi)*eta+2.0*(32.0*xi-32.0*xi*xi+2.0*(-32.0*xi+32.0*xi*xi)*eta)*zeta;
+ return_value[2][2] = 2.0*(32.0*xi-32.0*xi*xi)*eta+2.0*(-32.0*xi+32.0*xi*xi)*eta*eta;
+ return_value[0][0] = (64.0*eta-64.0*eta*eta)*zeta+(-64.0*eta+64.0*eta*eta)*zeta*zeta;
+ return_value[0][1] = (-16.0+64.0*xi+2.0*(16.0-64.0*xi)*eta)*zeta+(16.0-64.0*xi+2.0*(-16.0+64.0*xi)*eta)*zeta*zeta;
+ return_value[0][2] = (-16.0+64.0*xi)*eta+(16.0-64.0*xi)*eta*eta+2.0*((16.0-64.0*xi)*eta+(-16.0+64.0*xi)*eta*eta)*zeta;
+ return_value[1][0] = (-16.0+64.0*xi+2.0*(16.0-64.0*xi)*eta)*zeta+(16.0-64.0*xi+2.0*(-16.0+64.0*xi)*eta)*zeta*zeta;
+ return_value[1][1] = (32.0*xi-64.0*xi*xi)*zeta+(-32.0*xi+64.0*xi*xi)*zeta*zeta;
+ return_value[1][2] = -16.0*xi+32.0*xi*xi+2.0*(16.0*xi-32.0*xi*xi)*eta+2.0*(16.0*xi-32.0*xi*xi+2.0*(-16.0*xi+32.0*xi*xi)*eta)*zeta;
+ return_value[2][0] = (-16.0+64.0*xi)*eta+(16.0-64.0*xi)*eta*eta+2.0*((16.0-64.0*xi)*eta+(-16.0+64.0*xi)*eta*eta)*zeta;
+ return_value[2][1] = -16.0*xi+32.0*xi*xi+2.0*(16.0*xi-32.0*xi*xi)*eta+2.0*(16.0*xi-32.0*xi*xi+2.0*(-16.0*xi+32.0*xi*xi)*eta)*zeta;
+ return_value[2][2] = 2.0*(16.0*xi-32.0*xi*xi)*eta+2.0*(-16.0*xi+32.0*xi*xi)*eta*eta;
+ return_value[0][0] = (32.0*eta-32.0*eta*eta)*zeta+(-64.0*eta+64.0*eta*eta)*zeta*zeta;
+ return_value[0][1] = (-16.0+32.0*xi+2.0*(16.0-32.0*xi)*eta)*zeta+(32.0-64.0*xi+2.0*(-32.0+64.0*xi)*eta)*zeta*zeta;
+ return_value[0][2] = (-16.0+32.0*xi)*eta+(16.0-32.0*xi)*eta*eta+2.0*((32.0-64.0*xi)*eta+(-32.0+64.0*xi)*eta*eta)*zeta;
+ return_value[1][0] = (-16.0+32.0*xi+2.0*(16.0-32.0*xi)*eta)*zeta+(32.0-64.0*xi+2.0*(-32.0+64.0*xi)*eta)*zeta*zeta;
+ return_value[1][1] = (32.0*xi-32.0*xi*xi)*zeta+(-64.0*xi+64.0*xi*xi)*zeta*zeta;
+ return_value[1][2] = -16.0*xi+16.0*xi*xi+2.0*(16.0*xi-16.0*xi*xi)*eta+2.0*(32.0*xi-32.0*xi*xi+2.0*(-32.0*xi+32.0*xi*xi)*eta)*zeta;
+ return_value[2][0] = (-16.0+32.0*xi)*eta+(16.0-32.0*xi)*eta*eta+2.0*((32.0-64.0*xi)*eta+(-32.0+64.0*xi)*eta*eta)*zeta;
+ return_value[2][1] = -16.0*xi+16.0*xi*xi+2.0*(16.0*xi-16.0*xi*xi)*eta+2.0*(32.0*xi-32.0*xi*xi+2.0*(-32.0*xi+32.0*xi*xi)*eta)*zeta;
+ return_value[2][2] = 2.0*(32.0*xi-32.0*xi*xi)*eta+2.0*(-32.0*xi+32.0*xi*xi)*eta*eta;
+ return_value[0][0] = (64.0*eta-64.0*eta*eta)*zeta+(-64.0*eta+64.0*eta*eta)*zeta*zeta;
+ return_value[0][1] = (-48.0+64.0*xi+2.0*(48.0-64.0*xi)*eta)*zeta+(48.0-64.0*xi+2.0*(-48.0+64.0*xi)*eta)*zeta*zeta;
+ return_value[0][2] = (-48.0+64.0*xi)*eta+(48.0-64.0*xi)*eta*eta+2.0*((48.0-64.0*xi)*eta+(-48.0+64.0*xi)*eta*eta)*zeta;
+ return_value[1][0] = (-48.0+64.0*xi+2.0*(48.0-64.0*xi)*eta)*zeta+(48.0-64.0*xi+2.0*(-48.0+64.0*xi)*eta)*zeta*zeta;
+ return_value[1][1] = (-32.0+96.0*xi-64.0*xi*xi)*zeta+(32.0-96.0*xi+64.0*xi*xi)*zeta*zeta;
+ return_value[1][2] = 16.0-48.0*xi+32.0*xi*xi+2.0*(-16.0+48.0*xi-32.0*xi*xi)*eta+2.0*(-16.0+48.0*xi-32.0*xi*xi+2.0*(16.0-48.0*xi+32.0*xi*xi)*eta)*zeta;
+ return_value[2][0] = (-48.0+64.0*xi)*eta+(48.0-64.0*xi)*eta*eta+2.0*((48.0-64.0*xi)*eta+(-48.0+64.0*xi)*eta*eta)*zeta;
+ return_value[2][1] = 16.0-48.0*xi+32.0*xi*xi+2.0*(-16.0+48.0*xi-32.0*xi*xi)*eta+2.0*(-16.0+48.0*xi-32.0*xi*xi+2.0*(16.0-48.0*xi+32.0*xi*xi)*eta)*zeta;
+ return_value[2][2] = 2.0*(-16.0+48.0*xi-32.0*xi*xi)*eta+2.0*(16.0-48.0*xi+32.0*xi*xi)*eta*eta;
+ return_value[0][0] = (-128.0*eta+128.0*eta*eta)*zeta+(128.0*eta-128.0*eta*eta)*zeta*zeta;
+ return_value[0][1] = (64.0-128.0*xi+2.0*(-64.0+128.0*xi)*eta)*zeta+(-64.0+128.0*xi+2.0*(64.0-128.0*xi)*eta)*zeta*zeta;
+ return_value[0][2] = (64.0-128.0*xi)*eta+(-64.0+128.0*xi)*eta*eta+2.0*((-64.0+128.0*xi)*eta+(64.0-128.0*xi)*eta*eta)*zeta;
+ return_value[1][0] = (64.0-128.0*xi+2.0*(-64.0+128.0*xi)*eta)*zeta+(-64.0+128.0*xi+2.0*(64.0-128.0*xi)*eta)*zeta*zeta;
+ return_value[1][1] = (-128.0*xi+128.0*xi*xi)*zeta+(128.0*xi-128.0*xi*xi)*zeta*zeta;
+ return_value[1][2] = 64.0*xi-64.0*xi*xi+2.0*(-64.0*xi+64.0*xi*xi)*eta+2.0*(-64.0*xi+64.0*xi*xi+2.0*(64.0*xi-64.0*xi*xi)*eta)*zeta;
+ return_value[2][0] = (64.0-128.0*xi)*eta+(-64.0+128.0*xi)*eta*eta+2.0*((-64.0+128.0*xi)*eta+(64.0-128.0*xi)*eta*eta)*zeta;
+ return_value[2][1] = 64.0*xi-64.0*xi*xi+2.0*(-64.0*xi+64.0*xi*xi)*eta+2.0*(-64.0*xi+64.0*xi*xi+2.0*(64.0*xi-64.0*xi*xi)*eta)*zeta;
+ return_value[2][2] = 2.0*(-64.0*xi+64.0*xi*xi)*eta+2.0*(64.0*xi-64.0*xi*xi)*eta*eta;
+ break;
};
return return_value;
template <>
-void FEQ2<3>::get_unit_support_points (vector<Point<3> > &unit_points) const
+void FEQ2<3>::get_unit_support_points (
std::vector<Point<3> > &unit_points) const
{
Assert (unit_points.size() == dofs_per_cell,
ExcWrongFieldDimension (unit_points.size(), dofs_per_cell));
template <>
void FEQ2<3>::get_support_points (const DoFHandler<3>::cell_iterator &cell,
- vector<Point<3> > &support_points) const
+
std::vector<Point<3> > &support_points) const
{
Assert (support_points.size() == dofs_per_cell,
ExcWrongFieldDimension (support_points.size(), dofs_per_cell));
const Point<3> vertices[8] = { cell->vertex(0),
- cell->vertex(1),
- cell->vertex(2),
- cell->vertex(3),
- cell->vertex(4),
- cell->vertex(5),
- cell->vertex(6),
- cell->vertex(7) };
+ cell->vertex(1),
+ cell->vertex(2),
+ cell->vertex(3),
+ cell->vertex(4),
+ cell->vertex(5),
+ cell->vertex(6),
+ cell->vertex(7) };
support_points[0](0) = vertices[0](0);
support_points[0](1) = vertices[0](1);
template <>
void FEQ2<3>::get_face_support_points (const DoFHandler<3>::face_iterator &face,
- vector<Point<3> > &support_points) const
+
std::vector<Point<3> > &support_points) const
{
Assert (support_points.size() == dofs_per_face,
ExcWrongFieldDimension (support_points.size(), dofs_per_face));
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
template <>
FEQ4<1>::FEQ4 () :
FEQ1Mapping<1> (1, 3, 0, 0, 1,
- vector<bool> (1, false))
+ std::vector<bool> (1, false))
{
initialize_matrices ();
};
template <>
FEQ4<1>::FEQ4 (const int) :
FEQ1Mapping<1> (0, 5, 0, 0, 1,
- vector<bool> (1, true))
+ std::vector<bool> (1, true))
{
initialize_matrices ();
};
template <>
double
FEQ4<1>::shape_value(const unsigned int i,
- const Point<1> &p) const
+ const Point<1> &p) const
{
Assert((i<dofs_per_cell), ExcIndexRange(i, 0, dofs_per_cell));
const double xi = p(0);
template <>
Tensor<1,1>
FEQ4<1>::shape_grad(const unsigned int i,
- const Point<1> &p) const
+ const Point<1> &p) const
{
Assert((i<dofs_per_cell), ExcIndexRange(i, 0, dofs_per_cell));
const double xi = p(0);
template <>
Tensor<2,1>
FEQ4<1>::shape_grad_grad (const unsigned int i,
- const Point<1> &p) const
+ const Point<1> &p) const
{
Assert (i<dofs_per_cell, ExcIndexRange(i, 0, dofs_per_cell));
template <>
-void FEQ4<1>::get_unit_support_points (vector<Point<1> > &unit_points) const {
+void FEQ4<1>::get_unit_support_points (
std::vector<Point<1> > &unit_points) const {
FiniteElement<1>::get_unit_support_points (unit_points);
};
template <>
void FEQ4<1>::get_support_points (const DoFHandler<1>::cell_iterator &cell,
- vector<Point<1> > &support_points) const {
+
std::vector<Point<1> > &support_points) const {
FiniteElement<1>::get_support_points (cell, support_points);
};
template <>
void FEQ4<1>::get_face_support_points (const DoFHandler<1>::face_iterator &,
- vector<Point<1> > &) const {
+
std::vector<Point<1> > &) const {
Assert (false, ExcInternalError());
};
template <>
void FEQ4<1>::get_local_mass_matrix (const DoFHandler<1>::cell_iterator &cell,
- FullMatrix<double> &local_mass_matrix) const {
+ FullMatrix<double> &local_mass_matrix) const {
Assert (local_mass_matrix.n() == dofs_per_cell,
ExcWrongFieldDimension(local_mass_matrix.n(),dofs_per_cell));
Assert (local_mass_matrix.m() == dofs_per_cell,
template <>
FEQ4<2>::FEQ4 () :
FEQ1Mapping<2> (1, 3, 9, 0, 1,
- vector<bool> (1, false))
+ std::vector<bool> (1, false))
{
interface_constraints(0,3) = 1.0;
interface_constraints(1,0) = 35.0/128.0;
template <>
FEQ4<2>::FEQ4 (const int) :
FEQ1Mapping<2> (0, 0, 25, 0, 1,
- vector<bool> (1, true))
+ std::vector<bool> (1, true))
{
initialize_matrices ();
};
template <>
double
FEQ4<2>::shape_value (const unsigned int i,
- const Point<2> &p) const
+ const Point<2> &p) const
{
Assert (i<dofs_per_cell, ExcIndexRange(i, 0, dofs_per_cell));
template <>
Tensor<1,2>
FEQ4<2>::shape_grad (const unsigned int i,
- const Point<2> &p) const
+ const Point<2> &p) const
{
Assert (i<dofs_per_cell, ExcIndexRange(i, 0, dofs_per_cell));
template <>
Tensor<2,2>
FEQ4<2>::shape_grad_grad (const unsigned int i,
- const Point<2> &p) const
+ const Point<2> &p) const
{
Assert (i<dofs_per_cell, ExcIndexRange(i, 0, dofs_per_cell));
template <>
void FEQ4<2>::get_local_mass_matrix (const DoFHandler<2>::cell_iterator &cell,
- FullMatrix<double> &local_mass_matrix) const {
+ FullMatrix<double> &local_mass_matrix) const {
Assert (local_mass_matrix.n() == dofs_per_cell,
ExcWrongFieldDimension(local_mass_matrix.n(),dofs_per_cell));
Assert (local_mass_matrix.m() == dofs_per_cell,
template <>
-void FEQ4<2>::get_unit_support_points (vector<Point<2> > &unit_points) const {
+void FEQ4<2>::get_unit_support_points (
std::vector<Point<2> > &unit_points) const {
Assert (unit_points.size() == dofs_per_cell,
ExcWrongFieldDimension (unit_points.size(), dofs_per_cell));
template <>
void FEQ4<2>::get_support_points (const DoFHandler<2>::cell_iterator &cell,
- vector<Point<2> > &support_points) const {
+
std::vector<Point<2> > &support_points) const {
Assert (support_points.size() == dofs_per_cell,
ExcWrongFieldDimension (support_points.size(), dofs_per_cell));
template <>
void FEQ4<2>::get_face_support_points (const DoFHandler<2>::face_iterator &face,
- vector<Point<2> > &support_points) const {
+
std::vector<Point<2> > &support_points) const {
Assert (support_points.size() == dofs_per_face,
ExcWrongFieldDimension (support_points.size(), dofs_per_face));
template <>
FEQ4<3>::FEQ4 () :
FEQ1Mapping<3> (1, 3, 9, 27, 1,
- vector<bool> (1, false))
+ std::vector<bool> (1, false))
{
Assert (false, ExcNotImplemented());
};
template <>
FEQ4<3>::FEQ4 (const int) :
FEQ1Mapping<3> (0, 0, 0, 64, 1,
- vector<bool> (1, true))
+ std::vector<bool> (1, true))
{
Assert (false, ExcNotImplemented());
};
template <>
-void FEQ4<3>::get_unit_support_points (vector<Point<3> > &) const
+void FEQ4<3>::get_unit_support_points (
std::vector<Point<3> > &) const
{
Assert (false, ExcNotImplemented());
};
template <>
void FEQ4<3>::get_support_points (const DoFHandler<3>::cell_iterator &,
- vector<Point<3> > &) const
+
std::vector<Point<3> > &) const
{
Assert (false, ExcNotImplemented());
};
template <>
void FEQ4<3>::get_face_support_points (const DoFHandler<3>::face_iterator &,
- vector<Point<3> > &) const
+
std::vector<Point<3> > &) const
{
Assert (false, ExcNotImplemented());
};
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
++local_index)
{
system_to_component_table[total_index++]
- = make_pair (comp_start+m,
- vertex_number*base_element(base).dofs_per_vertex
- +local_index);
+ = std::make_pair (comp_start+m,
+ vertex_number*base_element(base).dofs_per_vertex
+ +local_index);
}
}
comp_start += element_multiplicity(base);
// 2. Lines
for (unsigned int line_number= 0 ; ((line_number != GeometryInfo<dim>::lines_per_cell) &&
- (GeometryInfo<dim>::lines_per_cell > 0));
+ (GeometryInfo<dim>::lines_per_cell > 0));
++line_number)
{
unsigned comp_start = 0;
++local_index)
{
system_to_component_table[total_index++]
- = pair<unsigned,unsigned>
+ = std::pair<unsigned,unsigned>
(comp_start+m,
line_number*base_element(base).dofs_per_line
+local_index+base_element(base).first_line_index);
++local_index)
{
system_to_component_table[total_index++]
- = make_pair (comp_start+m,
- quad_number*base_element(base).dofs_per_quad
- +local_index+base_element(base).first_quad_index);
+ = std::make_pair (comp_start+m,
+ quad_number*base_element(base).dofs_per_quad
+ +local_index+base_element(base).first_quad_index);
}
}
comp_start += element_multiplicity(base);
++local_index)
{
system_to_component_table[total_index++]
- = make_pair (comp_start+m,
- hex_number*base_element(base).dofs_per_hex
- +local_index+base_element(base).first_hex_index);
+ = std::make_pair (comp_start+m,
+ hex_number*base_element(base).dofs_per_hex
+ +local_index+base_element(base).first_hex_index);
}
}
comp_start += element_multiplicity(base);
++local_index)
{
face_system_to_component_table[total_index++]
- = pair<unsigned,unsigned>
+ = std::pair<unsigned,unsigned>
(comp_start+m,
vertex_number*base_element(base).dofs_per_vertex+local_index);
}
++local_index)
{
face_system_to_component_table[total_index++]
- = pair<unsigned,unsigned>
+ = std::pair<unsigned,unsigned>
(comp_start+m,
line_number*base_element(base).dofs_per_line
+local_index+base_element(base).first_face_line_index);
++local_index)
{
face_system_to_component_table[total_index++]
- = pair<unsigned,unsigned>
+ = std::pair<unsigned,unsigned>
(comp_start+m,
quad_number*base_element(base).dofs_per_quad
+local_index+base_element(base).first_face_quad_index);
//
// first value in pair is component,
// second is index
- const pair<unsigned int, unsigned int> n_index
+ const std::pair<unsigned int, unsigned int> n_index
= face_system_to_component_index (n);
- pair<unsigned int, unsigned int> m_index;
+ std::pair<unsigned int, unsigned int> m_index;
switch (dim)
{
case 1:
(GeometryInfo<2>::vertices_per_cell * dofs_per_vertex
+ index_in_line).second
- base_element (component_to_base_table[m_index.first]).first_line_index)
- // then add the number of dofs
- // per vertex to get the index
- // on the first line
+ // then add the number of dofs
+ // per vertex to get the index
+ // on the first line
+ base_element(component_to_base_table[m_index.first]).dofs_per_vertex
- // if on the second line: add
- // some more
+ // if on the second line: add
+ // some more
+ base_element(component_to_base_table[m_index.first]).dofs_per_line * sub_line;
};
break;
template <int dim>
-vector<bool>
+std::vector<bool>
FESystem<dim>::compute_restriction_is_additive_flags (const FiniteElement<dim> &fe,
const unsigned int n_elements)
{
- vector<bool> tmp;
+ std::vector<bool> tmp;
for (unsigned int i=0; i<n_elements; ++i)
for (unsigned int component=0; component<fe.n_components(); ++component)
tmp.push_back (fe.restriction_is_additive (component));
template <int dim>
-vector<bool>
+std::vector<bool>
FESystem<dim>::compute_restriction_is_additive_flags (const FiniteElement<dim> &fe1,
const unsigned int N1,
const FiniteElement<dim> &fe2,
const unsigned int N2)
{
- vector<bool> tmp;
+ std::vector<bool> tmp;
for (unsigned int i=0; i<N1; ++i)
for (unsigned int component=0; component<fe1.n_components(); ++component)
tmp.push_back (fe1.restriction_is_additive (component));
template <int dim>
-vector<bool>
+std::vector<bool>
FESystem<dim>::compute_restriction_is_additive_flags (const FiniteElement<dim> &fe1,
const unsigned int N1,
const FiniteElement<dim> &fe2,
const FiniteElement<dim> &fe3,
const unsigned int N3)
{
- vector<bool> tmp;
+ std::vector<bool> tmp;
for (unsigned int i=0; i<N1; ++i)
for (unsigned int component=0; component<fe1.n_components(); ++component)
tmp.push_back (fe1.restriction_is_additive (component));
{
Assert((i<dofs_per_cell), ExcIndexRange(i, 0, dofs_per_cell));
- pair<unsigned,unsigned> comp = system_to_component_index(i);
+ std::pair<unsigned,unsigned> comp = system_to_component_index(i);
return base_element(component_to_base_table[comp.first])
.shape_value(comp.second, p);
{
Assert((i<dofs_per_cell), ExcIndexRange(i, 0, dofs_per_cell));
- pair<unsigned,unsigned> comp = system_to_component_index(i);
+ std::pair<unsigned,unsigned> comp = system_to_component_index(i);
return base_element(component_to_base_table[comp.first])
.shape_grad(comp.second, p);
Tensor<2,dim>
FESystem<dim>::shape_grad_grad (const unsigned int i,
const Point<dim> &p) const
- {
+{
Assert((i<dofs_per_cell), ExcIndexRange(i, 0, dofs_per_cell));
- pair<unsigned,unsigned> comp = system_to_component_index(i);
+ std::pair<unsigned,unsigned> comp = system_to_component_index(i);
return base_element(component_to_base_table[comp.first])
.shape_grad_grad(comp.second, p);
template <int dim>
void FESystem<dim>::get_unit_support_points (
- vector<Point<dim> > &unit_support_points) const
+
std::vector<Point<dim> > &unit_support_points) const
{
Assert(unit_support_points.size() == dofs_per_cell,
typename FiniteElementBase<dim>::
ExcWrongFieldDimension (unit_support_points.size(),
dofs_per_cell));
- vector<Point<dim> > base_unit_support_points (base_element(0).dofs_per_cell);
+
std::vector<Point<dim> > base_unit_support_points (base_element(0).dofs_per_cell);
unsigned int component = 0;
for (unsigned int base_el=0 ; base_el<n_base_elements(); ++base_el)
{
template <int dim>
void FESystem<dim>::get_support_points (const DoFHandler<dim>::cell_iterator &cell,
- vector<Point<dim> > &support_points) const
+
std::vector<Point<dim> > &support_points) const
{
Assert(support_points.size() == dofs_per_cell,
typename FiniteElementBase<dim>::
ExcWrongFieldDimension (support_points.size(),
dofs_per_cell));
- vector<Point<dim> > base_support_points (base_element(0).dofs_per_cell);
+
std::vector<Point<dim> > base_support_points (base_element(0).dofs_per_cell);
unsigned int component = 0;
for (unsigned int base_el=0 ; base_el<n_base_elements(); ++base_el)
{
template <int dim>
void FESystem<dim>::get_face_support_points (const DoFHandler<dim>::face_iterator & face,
- vector<Point<dim> > & support_points) const
+
std::vector<Point<dim> > & support_points) const
{
Assert (support_points.size() == dofs_per_face,
typename FiniteElementBase<dim>::
ExcWrongFieldDimension (support_points.size(),
dofs_per_face));
- vector<Point<dim> > base_support_points (base_element(0).dofs_per_face);
+
std::vector<Point<dim> > base_support_points (base_element(0).dofs_per_face);
unsigned int comp = 0;
for (unsigned int base=0 ; base<n_base_elements(); ++base)
{
= base_support_points[i];
}
- ++comp;
+ ++comp;
}
}
}
{
for (unsigned int i=0; i<base_element_dofs_per_cell; ++i)
for (unsigned int j=0; j<base_element_dofs_per_cell; ++j)
- // only fill diagonals of the blocks
+ // only fill diagonals of the blocks
local_mass_matrix (component_to_system_index(component,i),
component_to_system_index(component,j))
= base_mass_matrix (i,j);
template <int dim>
void FESystem<dim>::get_face_jacobians (const DoFHandler<dim>::face_iterator &face,
- const vector<Point<dim-1> > &unit_points,
- vector<double> &face_jacobi_determinants) const
+ const
std::vector<Point<dim-1> > &unit_points,
+ std::vector<double> &face_jacobi_determinants) const
{
base_elements[0].first->get_face_jacobians (face, unit_points,
face_jacobi_determinants);
template <int dim>
void FESystem<dim>::get_subface_jacobians (const DoFHandler<dim>::face_iterator &face,
const unsigned int subface_no,
- const vector<Point<dim-1> > &unit_points,
- vector<double> &face_jacobi_determinants) const
+ const
std::vector<Point<dim-1> > &unit_points,
+ std::vector<double> &face_jacobi_determinants) const
{
base_elements[0].first->get_subface_jacobians (face, subface_no, unit_points,
- face_jacobi_determinants);
+ face_jacobi_determinants);
};
template <int dim>
void FESystem<dim>::get_normal_vectors (const DoFHandler<dim>::cell_iterator &cell,
const unsigned int face_no,
- const vector<Point<dim-1> > &unit_points,
- vector<Point<dim> > &normal_vectors) const
+ const
std::vector<Point<dim-1> > &unit_points,
+
std::vector<Point<dim> > &normal_vectors) const
{
base_elements[0].first->get_normal_vectors (cell, face_no, unit_points,
- normal_vectors);
+ normal_vectors);
};
void FESystem<dim>::get_normal_vectors (const DoFHandler<dim>::cell_iterator &cell,
const unsigned int face_no,
const unsigned int subface_no,
- const vector<Point<dim-1> > &unit_points,
- vector<Point<dim> > &normal_vectors) const
+ const
std::vector<Point<dim-1> > &unit_points,
+
std::vector<Point<dim> > &normal_vectors) const
{
base_elements[0].first->get_normal_vectors (cell, face_no, subface_no, unit_points,
- normal_vectors);
+ normal_vectors);
};
template <int dim>
void
FESystem<dim>::fill_fe_values (const DoFHandler<dim>::cell_iterator &cell,
- const vector<Point<dim> > &unit_points,
- vector<Tensor<2,dim> > &jacobians,
+ const
std::vector<Point<dim> > &unit_points,
+ std::vector<Tensor<2,dim> > &jacobians,
const bool compute_jacobians,
- vector<Tensor<3,dim> > &jacobians_grad,
+ std::vector<Tensor<3,dim> > &jacobians_grad,
const bool compute_jacobians_grad,
- vector<Point<dim> > &support_points,
+
std::vector<Point<dim> > &support_points,
const bool compute_support_points,
- vector<Point<dim> > &q_points,
+
std::vector<Point<dim> > &q_points,
const bool compute_q_points,
const FullMatrix<double> &shape_values_transform,
- const vector<vector<Tensor<1,dim> > > &shape_grad_transform) const
+ const std::vector<std::vector<Tensor<1,dim> > > &shape_grad_transform) const
{
// if we are to compute the support
// points, then we need to get them
// from each base element. the
// following variable is used as
// temporary
- vector<Point<dim> > supp(compute_support_points ?
- base_elements[0].first->dofs_per_cell :
- 0);
+
std::vector<Point<dim> > supp(compute_support_points ?
+ base_elements[0].first->dofs_per_cell :
+ 0);
base_elements[0].first->fill_fe_values (cell, unit_points, jacobians, compute_jacobians,
jacobians_grad, compute_jacobians_grad,
// $Id$
// Version: $Name$
//
-// Copyright (C) 2000 by the deal.II authors
+// Copyright (C) 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// Initialize FEValues for fe1 at
// the unit support points of the
// fe2 element.
- vector<double> phantom_weights(fe2.dofs_per_cell,1.);
- vector<Point<dim> > fe2_support_points (fe2.dofs_per_cell);
+ std::vector<double> phantom_weights(fe2.dofs_per_cell,1.);
+
std::vector<Point<dim> > fe2_support_points (fe2.dofs_per_cell);
fe2.get_unit_support_points (fe2_support_points);
Quadrature<dim> fe2_support_points_quadrature(fe2_support_points,
phantom_weights);
for (unsigned int i=0; i<fe1.dofs_per_cell; ++i)
difference_matrix(i,i) = 1.;
- // compute difference
+ // compute difference
difference_matrix.add (-1, interpolation_matrix);
}
cell2 = dof2.begin_active(),
endc2 = dof2.end();
- vector<unsigned int> index_multiplicity(dof2.n_dofs(),0);
- vector<unsigned int> dofs (dofs_per_cell2);
+ std::vector<unsigned int> index_multiplicity(dof2.n_dofs(),0);
+ std::vector<unsigned int> dofs (dofs_per_cell2);
u2.clear ();
for (; cell1!=endc1, cell2!=endc2; ++cell1, ++cell2)
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
dofs_per_cell (dofs_per_cell),
n_transform_functions (n_transform_functions),
shape_values (n_values_arrays, FullMatrix<double>(dofs_per_cell, n_q_points)),
- shape_gradients (dofs_per_cell, vector<Tensor<1,dim> >(n_q_points)),
- shape_2nd_derivatives (dofs_per_cell, vector<Tensor<2,dim> >(n_q_points)),
+ shape_gradients (dofs_per_cell, std::vector<Tensor<1,dim> >(n_q_points)),
+ shape_2nd_derivatives (dofs_per_cell, std::vector<Tensor<2,dim> >(n_q_points)),
weights (n_q_points, 0),
JxW_values (n_q_points, 0),
quadrature_points (n_q_points, Point<dim>()),
template <int dim>
template <class InputVector, typename number>
void FEValuesBase<dim>::get_function_values (const InputVector &fe_function,
- vector<number> &values) const
+ std::vector<number> &values) const
{
Assert (fe->n_components() == 1,
ExcWrongNoOfComponents());
template <int dim>
template <class InputVector, typename number>
void FEValuesBase<dim>::get_function_values (const InputVector &fe_function,
- vector<Vector<number> > &values) const
+ std::vector<Vector<number> > &values) const
{
Assert (n_quadrature_points == values.size(),
ExcWrongVectorSize(values.size(), n_quadrature_points));
// initialize with zero
for (unsigned i=0;i<values.size();++i)
- fill_n (values[i].begin(), values[i].size(), 0);
+ std::fill_n (values[i].begin(), values[i].size(), 0);
// add up contributions of trial
// functions
template <int dim>
template <class InputVector>
void FEValuesBase<dim>::get_function_grads (const InputVector &fe_function,
- vector<Tensor<1,dim> > &gradients) const
+ std::vector<Tensor<1,dim> > &gradients) const
{
Assert (fe->n_components() == 1,
ExcWrongNoOfComponents());
template <int dim>
template <class InputVector>
void FEValuesBase<dim>::get_function_grads (const InputVector &fe_function,
- vector<vector<Tensor<1,dim> > > &gradients) const
+ std::vector<std::vector<Tensor<1,dim> > > &gradients) const
{
Assert (n_quadrature_points == gradients.size(),
ExcWrongNoOfComponents());
template <int dim>
template <class InputVector>
void FEValuesBase<dim>::get_function_2nd_derivatives (const InputVector &fe_function,
- vector<Tensor<2,dim> > &second_derivatives) const
+ std::vector<Tensor<2,dim> > &second_derivatives) const
{
Assert (fe->n_components() == 1,
ExcWrongNoOfComponents());
void
FEValuesBase<dim>::
get_function_2nd_derivatives (const InputVector &fe_function,
- vector<vector<Tensor<2,dim> > > &second_derivs) const
+ std::vector<std::vector<Tensor<2,dim> > > &second_derivs) const
{
Assert (n_quadrature_points == second_derivs.size(),
ExcWrongNoOfComponents());
1,
update_flags,
fe),
- unit_shape_gradients(fe.dofs_per_cell,
- vector<Tensor<1,dim> >(quadrature.n_quadrature_points)),
- unit_shape_2nd_derivatives(fe.dofs_per_cell,
- vector<Tensor<2,dim> >(quadrature.n_quadrature_points)),
- unit_shape_gradients_transform(fe.n_transform_functions(),
- vector<Tensor<1,dim> >(quadrature.n_quadrature_points)),
- unit_quadrature_points(quadrature.get_points())
+ unit_shape_gradients(fe.dofs_per_cell,
+ std::vector<Tensor<1,dim> >(quadrature.n_quadrature_points)),
+ unit_shape_2nd_derivatives(fe.dofs_per_cell,
+ std::vector<Tensor<2,dim> >(quadrature.n_quadrature_points)),
+ unit_shape_gradients_transform(fe.n_transform_functions(),
+ std::vector<Tensor<1,dim> >(quadrature.n_quadrature_points)),
+ unit_quadrature_points(quadrature.get_points())
{
Assert ((update_flags & update_normal_vectors) == false,
typename FEValuesBase<dim>::ExcInvalidUpdateFlag());
for (unsigned int i=0; i<fe->dofs_per_cell; ++i)
for (unsigned int j=0; j<n_quadrature_points; ++j)
{
- // tmp1 := (d_k d_l phi) J_lj
+ // tmp1 := (d_k d_l phi) J_lj
contract (tmp1, unit_shape_2nd_derivatives[i][j], jacobi_matrices[j]);
// tmp2 := tmp1_kj J_ki
contract (tmp2, tmp1, 1, jacobi_matrices[j], 1);
n_faces_or_subfaces,
update_flags,
fe),
- unit_shape_gradients (n_faces_or_subfaces,
- vector<vector<Tensor<1,dim> > >(dofs_per_cell,
- vector<Tensor<1,dim> >(n_q_points))),
- unit_shape_2nd_derivatives(n_faces_or_subfaces,
- vector<vector<Tensor<2,dim> > >(dofs_per_cell,
- vector<Tensor<2,dim> >(n_q_points))),
- unit_shape_gradients_transform (n_faces_or_subfaces,
- vector<vector<Tensor<1,dim> > >(n_transform_functions,
- vector<Tensor<1,dim> >(n_q_points))),
- unit_face_quadrature_points (n_q_points, Point<dim-1>()),
- unit_quadrature_points (n_faces_or_subfaces,
- vector<Point<dim> >(n_q_points, Point<dim>())),
- face_jacobi_determinants (n_q_points, 0),
- normal_vectors (n_q_points)
+ unit_shape_gradients (n_faces_or_subfaces,
+ std::vector<std::vector<Tensor<1,dim> > >(dofs_per_cell,
+ std::vector<Tensor<1,dim> >(n_q_points))),
+ unit_shape_2nd_derivatives(n_faces_or_subfaces,
+ std::vector<std::vector<Tensor<2,dim> > >(dofs_per_cell,
+ std::vector<Tensor<2,dim> >(n_q_points))),
+ unit_shape_gradients_transform (n_faces_or_subfaces,
+ std::vector<std::vector<Tensor<1,dim> > >(n_transform_functions,
+ std::vector<Tensor<1,dim> >(n_q_points))),
+ unit_face_quadrature_points (n_q_points, Point<dim-1>()),
+ unit_quadrature_points (n_faces_or_subfaces,
+
std::vector<Point<dim> >(n_q_points, Point<dim>())),
+ face_jacobi_determinants (n_q_points, 0),
+ normal_vectors (n_q_points)
{};
if (update_flags & update_second_derivatives)
unit_shape_2nd_derivatives[face*GeometryInfo<dim>::subfaces_per_face+subface][i][j]
= fe.shape_grad_grad(i, unit_quadrature_points[face *
- GeometryInfo<dim>::
- subfaces_per_face+subface][j]);
+ GeometryInfo<dim>::
+ subfaces_per_face+subface][j]);
};
for (unsigned int i=0; i<n_transform_functions; ++i)
for (unsigned int j=0; j<n_quadrature_points; ++j)
template
void FEValuesBase<deal_II_dimension>::get_function_values (const Vector<double> &,
- vector<double> &) const;
+ std::vector<double> &) const;
template
void FEValuesBase<deal_II_dimension>::get_function_values (const Vector<float> &,
- vector<float> &) const;
+ std::vector<float> &) const;
template
void FEValuesBase<deal_II_dimension>::get_function_values (const BlockVector<double> &,
- vector<double> &) const;
+ std::vector<double> &) const;
//-----------------------------------------------------------------------------
template
void FEValuesBase<deal_II_dimension>::get_function_values (const Vector<double> &,
- vector<Vector<double> > &) const;
+ std::vector<Vector<double> > &) const;
template
void FEValuesBase<deal_II_dimension>::get_function_values (const Vector<float> &,
- vector<Vector<float> > &) const;
+ std::vector<Vector<float> > &) const;
template
void FEValuesBase<deal_II_dimension>::get_function_values (const BlockVector<double> &,
- vector<Vector<double> > &) const;
+ std::vector<Vector<double> > &) const;
//-----------------------------------------------------------------------------
template
void FEValuesBase<deal_II_dimension>::get_function_grads (const Vector<double> &,
- vector<Tensor<1,deal_II_dimension> > &) const;
+ std::vector<Tensor<1,deal_II_dimension> > &) const;
template
void FEValuesBase<deal_II_dimension>::get_function_grads (const Vector<float> &,
- vector<Tensor<1,deal_II_dimension> > &) const;
+ std::vector<Tensor<1,deal_II_dimension> > &) const;
template
void FEValuesBase<deal_II_dimension>::get_function_grads (const BlockVector<double> &,
- vector<Tensor<1,deal_II_dimension> > &) const;
+ std::vector<Tensor<1,deal_II_dimension> > &) const;
//-----------------------------------------------------------------------------
template
void FEValuesBase<deal_II_dimension>::get_function_grads (const Vector<double> &,
- vector<vector<Tensor<1,deal_II_dimension> > > &) const;
+ std::vector<std::vector<Tensor<1,deal_II_dimension> > > &) const;
template
void FEValuesBase<deal_II_dimension>::get_function_grads (const Vector<float> &,
- vector<vector<Tensor<1,deal_II_dimension> > > &) const;
+ std::vector<std::vector<Tensor<1,deal_II_dimension> > > &) const;
template
void FEValuesBase<deal_II_dimension>::get_function_grads (const BlockVector<double> &,
- vector<vector<Tensor<1,deal_II_dimension> > > &) const;
+ std::vector<std::vector<Tensor<1,deal_II_dimension> > > &) const;
//-----------------------------------------------------------------------------
template
void FEValuesBase<deal_II_dimension>::get_function_2nd_derivatives (const Vector<double> &,
- vector<Tensor<2,deal_II_dimension> > &) const;
+ std::vector<Tensor<2,deal_II_dimension> > &) const;
template
void FEValuesBase<deal_II_dimension>::get_function_2nd_derivatives (const Vector<float> &,
- vector<Tensor<2,deal_II_dimension> > &) const;
+ std::vector<Tensor<2,deal_II_dimension> > &) const;
template
void FEValuesBase<deal_II_dimension>::get_function_2nd_derivatives (const BlockVector<double> &,
- vector<Tensor<2,deal_II_dimension> > &) const;
+ std::vector<Tensor<2,deal_II_dimension> > &) const;
//-----------------------------------------------------------------------------
template
void FEValuesBase<deal_II_dimension>::get_function_2nd_derivatives (const Vector<double> &,
- vector<vector<Tensor<2,deal_II_dimension> > > &) const;
+ std::vector<std::vector<Tensor<2,deal_II_dimension> > > &) const;
template
void FEValuesBase<deal_II_dimension>::get_function_2nd_derivatives (const Vector<float> &,
- vector<vector<Tensor<2,deal_II_dimension> > > &) const;
+ std::vector<std::vector<Tensor<2,deal_II_dimension> > > &) const;
template
void FEValuesBase<deal_II_dimension>::get_function_2nd_derivatives (const BlockVector<double> &,
- vector<vector<Tensor<2,deal_II_dimension> > > &) const;
+ std::vector<std::vector<Tensor<2,deal_II_dimension> > > &) const;
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
const unsigned int dofs_per_quad,
const unsigned int dofs_per_hex,
const unsigned int n_components,
- const vector<bool> &restriction_is_additive_flags) :
+ const std::vector<bool> &restriction_is_additive_flags) :
FiniteElement<1> (FiniteElementData<1> (dofs_per_vertex,
dofs_per_line,
GeometryInfo<1>::vertices_per_cell,
template <>
void FEQ1Mapping<1>::get_face_jacobians (const DoFHandler<1>::face_iterator &,
- const vector<Point<0> > &,
- vector<double> &) const {
+ const
std::vector<Point<0> > &,
+ std::vector<double> &) const {
Assert (false, ExcInternalError());
};
template <>
void FEQ1Mapping<1>::get_subface_jacobians (const DoFHandler<1>::face_iterator &,
const unsigned int ,
- const vector<Point<0> > &,
- vector<double> &) const {
+ const
std::vector<Point<0> > &,
+ std::vector<double> &) const {
Assert (false, ExcInternalError());
};
template <>
void FEQ1Mapping<1>::get_normal_vectors (const DoFHandler<1>::cell_iterator &,
const unsigned int,
- const vector<Point<0> > &,
- vector<Point<1> > &) const {
+ const
std::vector<Point<0> > &,
+
std::vector<Point<1> > &) const {
Assert (false, ExcInternalError());
};
void FEQ1Mapping<1>::get_normal_vectors (const DoFHandler<1>::cell_iterator &,
const unsigned int,
const unsigned int,
- const vector<Point<0> > &,
- vector<Point<1> > &) const {
+ const
std::vector<Point<0> > &,
+
std::vector<Point<1> > &) const {
Assert (false, ExcInternalError());
};
template <>
void FEQ1Mapping<1>::fill_fe_values (const DoFHandler<1>::cell_iterator &cell,
- const vector<Point<1> > &unit_points,
- vector<Tensor<2,1> > &jacobians,
+ const
std::vector<Point<1> > &unit_points,
+ std::vector<Tensor<2,1> > &jacobians,
const bool compute_jacobians,
- vector<Tensor<3,1> > &jacobians_grad,
+ std::vector<Tensor<3,1> > &jacobians_grad,
const bool compute_jacobians_grad,
- vector<Point<1> > &support_points,
+
std::vector<Point<1> > &support_points,
const bool compute_support_points,
- vector<Point<1> > &q_points,
+
std::vector<Point<1> > &q_points,
const bool compute_q_points,
const FullMatrix<double> &shape_values_transform,
- const vector<vector<Tensor<1,1> > > &shape_gradients_transform) const {
+ const std::vector<std::vector<Tensor<1,1> > > &shape_gradients_transform) const {
// simply pass down
FiniteElement<1>::fill_fe_values (cell, unit_points,
jacobians, compute_jacobians,
const unsigned int dofs_per_quad,
const unsigned int dofs_per_hex,
const unsigned int n_components,
- const vector<bool> &restriction_is_additive_flags) :
+ const std::vector<bool> &restriction_is_additive_flags) :
FiniteElement<2> (FiniteElementData<2> (dofs_per_vertex,
dofs_per_line,
dofs_per_quad,
template <>
void FEQ1Mapping<2>::get_face_jacobians (const DoFHandler<2>::face_iterator &face,
- const vector<Point<1> > &unit_points,
- vector<double> &face_jacobians) const {
+ const
std::vector<Point<1> > &unit_points,
+ std::vector<double> &face_jacobians) const {
// more or less copied from the linear
// finite element
Assert (unit_points.size() == face_jacobians.size(),
template <>
void FEQ1Mapping<2>::get_subface_jacobians (const DoFHandler<2>::face_iterator &face,
const unsigned int ,
- const vector<Point<1> > &unit_points,
- vector<double> &face_jacobians) const {
+ const
std::vector<Point<1> > &unit_points,
+ std::vector<double> &face_jacobians) const {
// more or less copied from the linear
// finite element
Assert (unit_points.size() == face_jacobians.size(),
template <>
void FEQ1Mapping<2>::get_normal_vectors (const DoFHandler<2>::cell_iterator &cell,
const unsigned int face_no,
- const vector<Point<1> > &unit_points,
- vector<Point<2> > &normal_vectors) const {
+ const
std::vector<Point<1> > &unit_points,
+
std::vector<Point<2> > &normal_vectors) const {
// more or less copied from the linear
// finite element
Assert (unit_points.size() == normal_vectors.size(),
void FEQ1Mapping<2>::get_normal_vectors (const DoFHandler<2>::cell_iterator &cell,
const unsigned int face_no,
const unsigned int,
- const vector<Point<1> > &unit_points,
- vector<Point<2> > &normal_vectors) const {
+ const
std::vector<Point<1> > &unit_points,
+
std::vector<Point<2> > &normal_vectors) const {
// more or less copied from the linear
// finite element
// note, that in 2D the normal vectors to the
const unsigned int dofs_per_quad,
const unsigned int dofs_per_hex,
const unsigned int n_components,
- const vector<bool> &restriction_is_additive_flags) :
+ const std::vector<bool> &restriction_is_additive_flags) :
FiniteElement<3> (FiniteElementData<3> (dofs_per_vertex,
dofs_per_line,
dofs_per_quad,
template <>
void FEQ1Mapping<3>::get_face_jacobians (const DoFHandler<3>::face_iterator &face,
- const vector<Point<2> > &unit_points,
- vector<double> &face_jacobians) const {
+ const
std::vector<Point<2> > &unit_points,
+ std::vector<double> &face_jacobians) const {
Assert (unit_points.size() == face_jacobians.size(),
ExcWrongFieldDimension (unit_points.size(), face_jacobians.size()));
template <>
void FEQ1Mapping<3>::get_subface_jacobians (const DoFHandler<3>::face_iterator &/*face*/,
const unsigned int ,
- const vector<Point<2> > &unit_points,
- vector<double> &face_jacobians) const {
+ const
std::vector<Point<2> > &unit_points,
+ std::vector<double> &face_jacobians) const {
Assert (false,
ExcWrongFieldDimension (unit_points.size(), face_jacobians.size()));
};
template <>
void FEQ1Mapping<3>::get_normal_vectors (const DoFHandler<3>::cell_iterator &cell,
const unsigned int face_no,
- const vector<Point<2> > &unit_points,
- vector<Point<3> > &normal_vectors) const {
+ const
std::vector<Point<2> > &unit_points,
+
std::vector<Point<3> > &normal_vectors) const {
Assert (unit_points.size() == normal_vectors.size(),
ExcWrongFieldDimension (unit_points.size(), normal_vectors.size()));
void FEQ1Mapping<3>::get_normal_vectors (const DoFHandler<3>::cell_iterator &/*cell*/,
const unsigned int /*face_no*/,
const unsigned int,
- const vector<Point<2> > &unit_points,
- vector<Point<3> > &normal_vectors) const {
+ const
std::vector<Point<2> > &unit_points,
+
std::vector<Point<3> > &normal_vectors) const {
// more or less copied from the linear
// finite element
// note, that in 2D the normal vectors to the
contract (d, df_1, f);
p_unit -= d;
- // f(x)
+ // f(x)
p_real=transform_unit_to_real_cell(cell, p_unit);
f = p_real-p;
}
template <int dim>
void FEQ1Mapping<dim>::fill_fe_values (const DoFHandler<dim>::cell_iterator &cell,
- const vector<Point<dim> > &unit_points,
- vector<Tensor<2,dim> > &jacobians,
+ const
std::vector<Point<dim> > &unit_points,
+ std::vector<Tensor<2,dim> > &jacobians,
const bool compute_jacobians,
- vector<Tensor<3,dim> > &jacobians_grad,
+ std::vector<Tensor<3,dim> > &jacobians_grad,
const bool compute_jacobians_grad,
- vector<Point<dim> > &support_points,
+
std::vector<Point<dim> > &support_points,
const bool compute_support_points,
- vector<Point<dim> > &q_points,
+
std::vector<Point<dim> > &q_points,
const bool compute_q_points,
const FullMatrix<double> &shape_values_transform,
- const vector<vector<Tensor<1,dim> > > &shape_grad_transform) const
+ const std::vector<std::vector<Tensor<1,dim> > > &shape_grad_transform) const
{
Assert ((!compute_jacobians) || (jacobians.size() == unit_points.size()),
typename FiniteElementBase<dim>::ExcWrongFieldDimension(jacobians.size(),
/* jacobi matrices: compute d(x)/d(xi) and invert this
Let M(l) be the inverse of J at the quadrature point l, then
- M_{ij}(l) = sum_s p_i(s) d(N_s(l))/d(xi_j)
- where p_i(s) is the i-th coordinate of the s-th vertex vector,
+ M_{ij}(l) = sum_s p_i(s) d(N_s(l))/d(xi_j)
+ where p_i(s) is the i-th coordinate of the s-th vertex std::vector,
N_s(l) is the value of the s-th vertex shape function at the
quadrature point l.
We could therefore write:
l=0..n_points-1
- i=0..dim-1
- j=0..dim-1
- M_{ij}(l) = 0
- s=0..n_vertices
- M_{ij}(l) += p_i(s) d(N_s(l))/d(xi_j)
-
- However, we rewrite the loops to only compute the gradient once for
- each integration point and basis function.
-
- One last note regarding whether we have to invert M or M transposed: it is
- easy to try out, by computing the gradients of a function on a distorted
- cell (just move one vertex) where the nodal values for linear elements
- are one for the moved vertex and zero otherwise. Please also note that
- when computing the gradients on the real cell, the jacobian matrix
- is multiplied to the unit cell gradient *from the right*! be very careful
- with these things.
-
- The following little program tests the correct behaviour. The program can
- also be found in the <tests> directory.
-
- -------------------------------------------
- #include <grid/tria.h>
- #include <grid/tria_boundary.h>
- #include <dofs/dof_handler.h>
- #include <fe/fe_values.h>
- #include <fe/fe_lib.lagrange.h>
- #include <base/quadrature_lib.h>
- #include <grid/tria_iterator.h>
- #include <dofs/dof_accessor.h>
- #include <lac/vector.h>
-
- int main () {
- Triangulation<2> tria;
- tria.create_hypercube (0,1);
- tria.begin_active()->vertex(2)(0) = 2;
-
- DoFHandler<2> dof(&tria);
- FELinear<2> fe;
- dof.distribute_dofs(fe);
-
- StraightBoundary<2> b;
- QTrapez<2> q;
- FEValues<2> fevalues(fe,q,update_gradients);
- fevalues.reinit (dof.begin_active(),b);
-
-
- Vector<double> val(4);
- val(2) = 1;
-
-
vector<Point<2> > grads(4);
- fevalues.get_function_grads (val, grads);
-
- for (unsigned int i=0; i<4; ++i)
- cout << "Vertex " << i
- << " grad=" << grads[i] << endl;
- };
- ---------------------------------------------
+ i=0..dim-1
+ j=0..dim-1
+ M_{ij}(l) = 0
+ s=0..n_vertices
+ M_{ij}(l) += p_i(s) d(N_s(l))/d(xi_j)
+
+ However, we rewrite the loops to only compute the gradient once for
+ each integration point and basis function.
+
+ One last note regarding whether we have to invert M or M transposed: it is
+ easy to try out, by computing the gradients of a function on a distorted
+ cell (just move one vertex) where the nodal values for linear elements
+ are one for the moved vertex and zero otherwise. Please also note that
+ when computing the gradients on the real cell, the jacobian matrix
+ is multiplied to the unit cell gradient *from the right*! be very careful
+ with these things.
+
+ The following little program tests the correct behaviour. The program can
+ also be found in the <tests> directory.
+
+ -------------------------------------------
+ #include <grid/tria.h>
+ #include <grid/tria_boundary.h>
+ #include <dofs/dof_handler.h>
+ #include <fe/fe_values.h>
+ #include <fe/fe_lib.lagrange.h>
+ #include <base/quadrature_lib.h>
+ #include <grid/tria_iterator.h>
+ #include <dofs/dof_accessor.h>
+ #include <lac/vector.h>
+
+ int main () {
+ Triangulation<2> tria;
+ tria.create_hypercube (0,1);
+ tria.begin_active()->vertex(2)(0) = 2;
+
+ DoFHandler<2> dof(&tria);
+ FELinear<2> fe;
+ dof.distribute_dofs(fe);
+
+ StraightBoundary<2> b;
+ QTrapez<2> q;
+ FEValues<2> fevalues(fe,q,update_gradients);
+ fevalues.reinit (dof.begin_active(),b);
+
+
+ Vector<double> val(4);
+ val(2) = 1;
+
+
std::vector<Point<2> > grads(4);
+ fevalues.get_function_grads (val, grads);
+
+ for (unsigned int i=0; i<4; ++i)
+ std::cout << "Vertex " << i
+ << " grad=" << grads[i] << std::endl;
+ };
+ ---------------------------------------------
- The correct output should be
- --------------------------------
- Vertex 0 grad=0 0
- Vertex 1 grad=0.5 0
- Vertex 2 grad=0 1
- Vertex 3 grad=0.5 0.5
- --------------------------------
- and the wrong would be
- --------------------------------
- Vertex 0 grad=0 0
- Vertex 1 grad=0.5 0
- Vertex 2 grad=-1 1
- Vertex 3 grad=0 1
- --------------------------------
+ The correct output should be
+ --------------------------------
+ Vertex 0 grad=0 0
+ Vertex 1 grad=0.5 0
+ Vertex 2 grad=0 1
+ Vertex 3 grad=0.5 0.5
+ --------------------------------
+ and the wrong would be
+ --------------------------------
+ Vertex 0 grad=0 0
+ Vertex 1 grad=0.5 0
+ Vertex 2 grad=-1 1
+ Vertex 3 grad=0 1
+ --------------------------------
*/
if (compute_jacobians)
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
template <>
void FEQ1Mapping<1>::compute_jacobian_gradients (const DoFHandler<1>::cell_iterator &,
- const vector<Point<1> > &unit_points,
- vector<Tensor<3,1> > &jacobians_grad)
+ const
std::vector<Point<1> > &unit_points,
+ std::vector<Tensor<3,1> > &jacobians_grad)
{
Assert (unit_points.size() == jacobians_grad.size(),
ExcWrongFieldDimension(jacobians_grad.size(), unit_points.size()));
template <>
void FEQ1Mapping<2>::compute_jacobian_gradients (const DoFHandler<2>::cell_iterator &cell,
- const vector<Point<2> > &unit_points,
- vector<Tensor<3,2> > &jacobians_grad)
+ const
std::vector<Point<2> > &unit_points,
+ std::vector<Tensor<3,2> > &jacobians_grad)
{
Assert (unit_points.size() == jacobians_grad.size(),
ExcWrongFieldDimension(jacobians_grad.size(), unit_points.size()));
template <>
void FEQ1Mapping<3>::compute_jacobian_gradients (const DoFHandler<3>::cell_iterator &cell,
- const vector<Point<3> > &unit_points,
- vector<Tensor<3,3> > &jacobians_grad)
+ const
std::vector<Point<3> > &unit_points,
+ std::vector<Tensor<3,3> > &jacobians_grad)
{
Assert (unit_points.size() == jacobians_grad.size(),
ExcWrongFieldDimension(jacobians_grad.size(), unit_points.size()));
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// to mirror from the .h file. rather, we omit it here
#if ! ((__GNUC__==2) && (__GNUC_MINOR__ < 95))
- const unsigned int GeometryInfo<deal_II_dimension>::vertices_per_cell;
- const unsigned int GeometryInfo<deal_II_dimension>::lines_per_cell;
- const unsigned int GeometryInfo<deal_II_dimension>::quads_per_cell;
- const unsigned int GeometryInfo<deal_II_dimension>::hexes_per_cell;
- const unsigned int GeometryInfo<deal_II_dimension>::children_per_cell;
+const unsigned int GeometryInfo<deal_II_dimension>::vertices_per_cell;
+const unsigned int GeometryInfo<deal_II_dimension>::lines_per_cell;
+const unsigned int GeometryInfo<deal_II_dimension>::quads_per_cell;
+const unsigned int GeometryInfo<deal_II_dimension>::hexes_per_cell;
+const unsigned int GeometryInfo<deal_II_dimension>::children_per_cell;
#endif
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
const double left,
const double right) {
const Point<1> vertices[2] = { Point<1>(left), Point<1>(right) };
- vector<CellData<1> > cells (1, CellData<1>());
+ std::vector<CellData<1> > cells (1, CellData<1>());
cells[0].vertices[0] = 0;
cells[0].vertices[1] = 1;
cells[0].material_id = 0;
- tria.create_triangulation (vector<Point<1> >(&vertices[0], &vertices[2]),
+ tria.create_triangulation (
std::vector<Point<1> >(&vertices[0], &vertices[2]),
cells,
SubCellData()); // no boundary information
};
const double right)
{
const Point<2> vertices[4] = { Point<2>(left,left),
- Point<2>(right,left),
- Point<2>(right,right),
- Point<2>(left,right) };
+ Point<2>(right,left),
+ Point<2>(right,right),
+ Point<2>(left,right) };
const int cell_vertices[1][4] = { { 0,1,2,3 } };
- vector<CellData<2> > cells (1, CellData<2>());
+ std::vector<CellData<2> > cells (1, CellData<2>());
for (unsigned int j=0; j<4; ++j)
cells[0].vertices[j] = cell_vertices[0][j];
cells[0].material_id = 0;
- tria.create_triangulation (vector<Point<2> >(&vertices[0], &vertices[4]),
+ tria.create_triangulation (
std::vector<Point<2> >(&vertices[0], &vertices[4]),
cells,
SubCellData()); // no boundary information
}
const double d,
bool colorize)
{
- vector<Point<2> > vertices(16);
+
std::vector<Point<2> > vertices(16);
double coords[4];
coords[0] = l-d;
coords[1] = l;
9, 8,10
};
- vector<CellData<2> > cells(9);
+ std::vector<CellData<2> > cells(9);
k = 0;
for (unsigned int i0=0;i0<3;++i0)
for (unsigned int i1=0;i1<3;++i1)
const double right) {
const double rl2=(right+left)/2;
const Point<2> vertices[10] = { Point<2>(left, left ),
- Point<2>(rl2, left ),
- Point<2>(rl2, rl2 ),
- Point<2>(left, rl2 ),
- Point<2>(right,left ),
- Point<2>(right,rl2 ),
- Point<2>(rl2, right),
- Point<2>(left, right),
- Point<2>(right,right),
- Point<2>(rl2, left ) };
+ Point<2>(rl2, left ),
+ Point<2>(rl2, rl2 ),
+ Point<2>(left, rl2 ),
+ Point<2>(right,left ),
+ Point<2>(right,rl2 ),
+ Point<2>(rl2, right),
+ Point<2>(left, right),
+ Point<2>(right,right),
+ Point<2>(rl2, left ) };
const int cell_vertices[4][4] = { { 0,1,2,3 },
{ 9,4,5,2 },
{ 3,2,6,7 },
{ 2,5,8,6 } };
- vector<CellData<2> > cells (4, CellData<2>());
+ std::vector<CellData<2> > cells (4, CellData<2>());
for (unsigned int i=0; i<4; ++i)
{
for (unsigned int j=0; j<4; ++j)
cells[i].vertices[j] = cell_vertices[i][j];
cells[i].material_id = 0;
};
- tria.create_triangulation (vector<Point<2> >(&vertices[0], &vertices[10]),
+ tria.create_triangulation (
std::vector<Point<2> >(&vertices[0], &vertices[10]),
cells,
SubCellData()); // no boundary information
};
const double b) {
const unsigned int dim=2;
const Point<dim> vertices[8] = { Point<dim> (a,a),
- Point<dim> ((a+b)/2,a),
- Point<dim> (b,a),
- Point<dim> (a,(a+b)/2),
- Point<dim> ((a+b)/2,(a+b)/2),
- Point<dim> (b,(a+b)/2),
- Point<dim> (a,b),
- Point<dim> ((a+b)/2,b) };
+ Point<dim> ((a+b)/2,a),
+ Point<dim> (b,a),
+ Point<dim> (a,(a+b)/2),
+ Point<dim> ((a+b)/2,(a+b)/2),
+ Point<dim> (b,(a+b)/2),
+ Point<dim> (a,b),
+ Point<dim> ((a+b)/2,b) };
const int cell_vertices[3][4] = {{0, 1, 4, 3},
{1, 2, 5, 4},
{3, 4, 7, 6}};
- vector<CellData<2> > cells (3, CellData<2>());
+ std::vector<CellData<2> > cells (3, CellData<2>());
for (unsigned int i=0; i<3; ++i)
{
cells[i].material_id = 0;
};
- tria.create_triangulation (vector<Point<dim> >(&vertices[0], &vertices[8]),
+ tria.create_triangulation (
std::vector<Point<dim> >(&vertices[0], &vertices[8]),
cells,
SubCellData()); // no boundary information
};
// from the inner part to the radial
// cells
const Point<2> vertices[8] = { p+Point<2>(-1,-1)*(radius/sqrt(2)),
- p+Point<2>(+1,-1)*(radius/sqrt(2)),
- p+Point<2>(-1,-1)*(radius/sqrt(2)*a),
- p+Point<2>(+1,-1)*(radius/sqrt(2)*a),
- p+Point<2>(-1,+1)*(radius/sqrt(2)*a),
- p+Point<2>(+1,+1)*(radius/sqrt(2)*a),
- p+Point<2>(-1,+1)*(radius/sqrt(2)),
- p+Point<2>(+1,+1)*(radius/sqrt(2)) };
+ p+Point<2>(+1,-1)*(radius/sqrt(2)),
+ p+Point<2>(-1,-1)*(radius/sqrt(2)*a),
+ p+Point<2>(+1,-1)*(radius/sqrt(2)*a),
+ p+Point<2>(-1,+1)*(radius/sqrt(2)*a),
+ p+Point<2>(+1,+1)*(radius/sqrt(2)*a),
+ p+Point<2>(-1,+1)*(radius/sqrt(2)),
+ p+Point<2>(+1,+1)*(radius/sqrt(2)) };
const int cell_vertices[5][4] = {{0, 1, 3, 2},
{0, 2, 4, 6},
{1, 7, 5, 3},
{6, 4, 5, 7}};
- vector<CellData<2> > cells (5, CellData<2>());
+ std::vector<CellData<2> > cells (5, CellData<2>());
for (unsigned int i=0; i<5; ++i)
{
cells[i].material_id = 0;
};
- tria.create_triangulation (vector<Point<2> >(&vertices[0], &vertices[8]),
+ tria.create_triangulation (
std::vector<Point<2> >(&vertices[0], &vertices[8]),
cells,
SubCellData()); // no boundary information
};
// first N ones are on the
// outer one, and all are
// numbered counter-clockwise
- vector<Point<2> > vertices(2*N);
+
std::vector<Point<2> > vertices(2*N);
for (unsigned int i=0; i<N; ++i)
{
vertices[i] = Point<2>( cos(2*pi * i/N),
vertices[i+N] += center;
};
- vector<CellData<2> > cells (N, CellData<2>());
+ std::vector<CellData<2> > cells (N, CellData<2>());
for (unsigned int i=0; i<N; ++i)
{
// first N+1 ones are on the
// outer one, and all are
// numbered counter-clockwise
- vector<Point<2> > vertices(2*(N+1));
+
std::vector<Point<2> > vertices(2*(N+1));
for (unsigned int i=0; i<=N; ++i)
{
- // enforce that the x-coordinates
- // of the first and last point of
- // each half-circle are exactly
- // zero (contrary to what we may
- // compute using the imprecise
- // value of pi)
+ // enforce that the x-coordinates
+ // of the first and last point of
+ // each half-circle are exactly
+ // zero (contrary to what we may
+ // compute using the imprecise
+ // value of pi)
vertices[i] = Point<2>( ( (i==0) || (i==N) ?
0 :
cos(pi * i/N - pi/2) ),
};
- vector<CellData<2> > cells (N, CellData<2>());
+ std::vector<CellData<2> > cells (N, CellData<2>());
for (unsigned int i=0; i<N; ++i)
{
const double left,
const double right) {
const Point<3> vertices[8] = { Point<3>(left,left,left),
- Point<3>(right,left,left),
- Point<3>(right,left,right),
- Point<3>(left,left,right),
-
- Point<3>(left,right,left),
- Point<3>(right,right,left),
- Point<3>(right,right,right),
- Point<3>(left,right,right)};
+ Point<3>(right,left,left),
+ Point<3>(right,left,right),
+ Point<3>(left,left,right),
+
+ Point<3>(left,right,left),
+ Point<3>(right,right,left),
+ Point<3>(right,right,right),
+ Point<3>(left,right,right)};
const int cell_vertices[1][8] = { { 0,1,2,3,4,5,6,7 } };
- vector<CellData<3> > cells (1, CellData<3>());
+ std::vector<CellData<3> > cells (1, CellData<3>());
for (unsigned int j=0; j<8; ++j)
cells[0].vertices[j] = cell_vertices[0][j];
cells[0].material_id = 0;
- tria.create_triangulation (vector<Point<3> >(&vertices[0], &vertices[8]),
- cells,
- SubCellData()); // no boundary information
+ tria.create_triangulation (
std::vector<Point<3> >(&vertices[0], &vertices[8]),
+ cells,
+ SubCellData()); // no boundary information
};
const double d,
bool colorize)
{
- vector<Point<3> > vertices(64);
+
std::vector<Point<3> > vertices(64);
double coords[4];
coords[0] = l-d;
coords[1] = l;
41,40,42
};
- vector<CellData<3> > cells(27);
+ std::vector<CellData<3> > cells(27);
k = 0;
for (unsigned int i0=0;i0<3;++i0)
for (unsigned int i1=0;i1<3;++i1)
// part of the cube
const Point<dim> vertices[26]
= {
- // front face of the big cube
- Point<dim> (a, a,a),
- Point<dim> ((a+b)/2,a,a),
- Point<dim> (b, a,a),
- Point<dim> (a, a,(a+b)/2),
- Point<dim> ((a+b)/2,a,(a+b)/2),
- Point<dim> (b, a,(a+b)/2),
- Point<dim> (a, a,b),
- Point<dim> ((a+b)/2,a,b),
- Point<dim> (b, a,b),
- // middle face of the big cube
- Point<dim> (a, (a+b)/2,a),
- Point<dim> ((a+b)/2,(a+b)/2,a),
- Point<dim> (b, (a+b)/2,a),
- Point<dim> (a, (a+b)/2,(a+b)/2),
- Point<dim> ((a+b)/2,(a+b)/2,(a+b)/2),
- Point<dim> (b, (a+b)/2,(a+b)/2),
- Point<dim> (a, (a+b)/2,b),
- Point<dim> ((a+b)/2,(a+b)/2,b),
- Point<dim> (b, (a+b)/2,b),
- // back face of the big cube
- // last (top right) point is missing
- Point<dim> (a, b,a),
- Point<dim> ((a+b)/2,b,a),
- Point<dim> (b, b,a),
- Point<dim> (a, b,(a+b)/2),
- Point<dim> ((a+b)/2,b,(a+b)/2),
- Point<dim> (b, b,(a+b)/2),
- Point<dim> (a, b,b),
- Point<dim> ((a+b)/2,b,b)
- };
+ // front face of the big cube
+ Point<dim> (a, a,a),
+ Point<dim> ((a+b)/2,a,a),
+ Point<dim> (b, a,a),
+ Point<dim> (a, a,(a+b)/2),
+ Point<dim> ((a+b)/2,a,(a+b)/2),
+ Point<dim> (b, a,(a+b)/2),
+ Point<dim> (a, a,b),
+ Point<dim> ((a+b)/2,a,b),
+ Point<dim> (b, a,b),
+ // middle face of the big cube
+ Point<dim> (a, (a+b)/2,a),
+ Point<dim> ((a+b)/2,(a+b)/2,a),
+ Point<dim> (b, (a+b)/2,a),
+ Point<dim> (a, (a+b)/2,(a+b)/2),
+ Point<dim> ((a+b)/2,(a+b)/2,(a+b)/2),
+ Point<dim> (b, (a+b)/2,(a+b)/2),
+ Point<dim> (a, (a+b)/2,b),
+ Point<dim> ((a+b)/2,(a+b)/2,b),
+ Point<dim> (b, (a+b)/2,b),
+ // back face of the big cube
+ // last (top right) point is missing
+ Point<dim> (a, b,a),
+ Point<dim> ((a+b)/2,b,a),
+ Point<dim> (b, b,a),
+ Point<dim> (a, b,(a+b)/2),
+ Point<dim> ((a+b)/2,b,(a+b)/2),
+ Point<dim> (b, b,(a+b)/2),
+ Point<dim> (a, b,b),
+ Point<dim> ((a+b)/2,b,b)
+ };
const int cell_vertices[7][8] = {{0, 1, 4, 3, 9, 10, 13, 12},
{1, 2, 5, 4, 10, 11, 14, 13},
{3, 4, 7, 6, 12, 13, 16, 15},
{10, 11, 14, 13, 19, 20, 23, 22},
{12, 13, 16, 15, 21, 22, 25, 24}};
- vector<CellData<3> > cells (7, CellData<3>());
+ std::vector<CellData<3> > cells (7, CellData<3>());
for (unsigned int i=0; i<7; ++i)
{
cells[i].material_id = 0;
};
- tria.create_triangulation (vector<Point<dim> >(&vertices[0], &vertices[26]),
+ tria.create_triangulation (
std::vector<Point<dim> >(&vertices[0], &vertices[26]),
cells,
SubCellData()); // no boundary information
};
const unsigned int n_vertices = 16;
const Point<3> vertices[n_vertices]
= {
- // first the vertices of the inner
- // cell
- p+Point<3>(-1,-1,-1)*(radius/sqrt(3)*a),
- p+Point<3>(+1,-1,-1)*(radius/sqrt(3)*a),
- p+Point<3>(+1,+1,-1)*(radius/sqrt(3)*a),
- p+Point<3>(-1,+1,-1)*(radius/sqrt(3)*a),
- p+Point<3>(-1,-1,+1)*(radius/sqrt(3)*a),
- p+Point<3>(+1,-1,+1)*(radius/sqrt(3)*a),
- p+Point<3>(+1,+1,+1)*(radius/sqrt(3)*a),
- p+Point<3>(-1,+1,+1)*(radius/sqrt(3)*a),
- // now the eight vertices at
- // the outer sphere
- p+Point<3>(-1,-1,-1)*(radius/sqrt(3)),
- p+Point<3>(+1,-1,-1)*(radius/sqrt(3)),
- p+Point<3>(+1,+1,-1)*(radius/sqrt(3)),
- p+Point<3>(-1,+1,-1)*(radius/sqrt(3)),
- p+Point<3>(-1,-1,+1)*(radius/sqrt(3)),
- p+Point<3>(+1,-1,+1)*(radius/sqrt(3)),
- p+Point<3>(+1,+1,+1)*(radius/sqrt(3)),
- p+Point<3>(-1,+1,+1)*(radius/sqrt(3))
- };
+ // first the vertices of the inner
+ // cell
+ p+Point<3>(-1,-1,-1)*(radius/sqrt(3)*a),
+ p+Point<3>(+1,-1,-1)*(radius/sqrt(3)*a),
+ p+Point<3>(+1,+1,-1)*(radius/sqrt(3)*a),
+ p+Point<3>(-1,+1,-1)*(radius/sqrt(3)*a),
+ p+Point<3>(-1,-1,+1)*(radius/sqrt(3)*a),
+ p+Point<3>(+1,-1,+1)*(radius/sqrt(3)*a),
+ p+Point<3>(+1,+1,+1)*(radius/sqrt(3)*a),
+ p+Point<3>(-1,+1,+1)*(radius/sqrt(3)*a),
+ // now the eight vertices at
+ // the outer sphere
+ p+Point<3>(-1,-1,-1)*(radius/sqrt(3)),
+ p+Point<3>(+1,-1,-1)*(radius/sqrt(3)),
+ p+Point<3>(+1,+1,-1)*(radius/sqrt(3)),
+ p+Point<3>(-1,+1,-1)*(radius/sqrt(3)),
+ p+Point<3>(-1,-1,+1)*(radius/sqrt(3)),
+ p+Point<3>(+1,-1,+1)*(radius/sqrt(3)),
+ p+Point<3>(+1,+1,+1)*(radius/sqrt(3)),
+ p+Point<3>(-1,+1,+1)*(radius/sqrt(3))
+ };
// one needs to draw the seven cubes to
// understand what's going on here
{11, 10,14, 15, 3, 2, 6, 7},
{8, 9, 13, 12, 0, 1, 5, 4}};
- vector<CellData<3> > cells (n_cells, CellData<3>());
+ std::vector<CellData<3> > cells (n_cells, CellData<3>());
for (unsigned int i=0; i<n_cells; ++i)
{
cells[i].material_id = 0;
};
- tria.create_triangulation (vector<Point<3> >(&vertices[0], &vertices[n_vertices]),
+ tria.create_triangulation (
std::vector<Point<3> >(&vertices[0], &vertices[n_vertices]),
cells,
SubCellData()); // no boundary information
};
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
template <int dim>
-void GridIn<dim>::read_ucd (istream &in)
+void GridIn<dim>::read_ucd (std::istream &in)
{
Assert (tria != 0, ExcNoTriangulationSelected());
AssertThrow (in, ExcIO());
>> dummy; // model data
// set up array of vertices
- vector<Point<dim> > vertices (n_vertices);
+
std::vector<Point<dim> > vertices (n_vertices);
// set up mapping between numbering
// in ucd-file (key) and in the
// vertices vector
- map<int,int> vertex_indices;
+ std::map<int,int> vertex_indices;
for (unsigned int vertex=0; vertex<n_vertices; ++vertex)
{
};
// set up array of cells
- vector<CellData<dim> > cells;
- SubCellData subcelldata;
+ std::vector<CellData<dim> > cells;
+ SubCellData subcelldata;
for (unsigned int cell=0; cell<n_cells; ++cell)
{
- string cell_type;
+ std::string cell_type;
int material_id;
in >> dummy // cell number
template <int dim>
-void GridIn<dim>::read_dbmesh (istream &in)
+void GridIn<dim>::read_dbmesh (std::istream &in)
{
Assert (tria != 0, ExcNoTriangulationSelected());
Assert (dim==2, ExcNotImplemented());
// first read in identifier string
- string line;
+ std::string line;
getline (in, line);
AssertThrow (line=="MeshVersionFormatted 0",
// knowledge to parse and interpret
// the other fields in between as
// well...
- while (getline(in,line), line.find("# END")==string::npos);
+ while (getline(in,line), line.find("# END")==std::string::npos);
skip_empty_lines (in);
double dummy;
in >> n_vertices;
- vector<Point<dim> > vertices (n_vertices);
+
std::vector<Point<dim> > vertices (n_vertices);
for (unsigned int vertex=0; vertex<n_vertices; ++vertex)
{
// read vertex coordinates
getline (in, line);
AssertThrow (line=="Quadrilaterals", ExcInvalidDBMESHInput(line));
- vector<CellData<dim> > cells;
+ std::vector<CellData<dim> > cells;
SubCellData subcelldata;
unsigned int n_cells;
in >> n_cells;
// clue what they mean. skip them
// all and leave the interpretation
// to other implementors...
- while (getline(in,line), ((line.find("End")==string::npos) && (in)));
+ while (getline(in,line), ((line.find("End")==std::string::npos) && (in)));
// ok, so we are not at the end of
// the file, that's it, mostly
template <int dim>
-void GridIn<dim>::skip_empty_lines (istream &in)
+void GridIn<dim>::skip_empty_lines (std::istream &in)
{
- string line;
+ std::string line;
while (in)
{
// get line
template <int dim>
-void GridIn<dim>::skip_comment_lines (istream &in,
- const char comment_start)
+void GridIn<dim>::skip_comment_lines (std::istream &in,
+ const char comment_start)
{
char c;
while (in.get(c), c==comment_start)
template <int dim>
void
-GridIn<dim>::delete_unused_vertices (vector<Point<dim> > &vertices,
- vector<CellData<dim> > &cells,
- SubCellData &subcelldata)
+GridIn<dim>::delete_unused_vertices (
std::vector<Point<dim> > &vertices,
+ std::vector<CellData<dim> > &cells,
+ SubCellData &subcelldata)
{
// first check which vertices are
// actually used
- vector<bool> vertex_used (vertices.size(), false);
+ std::vector<bool> vertex_used (vertices.size(), false);
for (unsigned int c=0; c<cells.size(); ++c)
for (unsigned int v=0; v<GeometryInfo<dim>::vertices_per_cell; ++v)
vertex_used[cells[c].vertices[v]] = true;
// are actually used in the same
// order as they were beforehand
const unsigned int invalid_vertex = static_cast<unsigned int>(-1);
- vector<unsigned int> new_vertex_numbers (vertices.size(), invalid_vertex);
+ std::vector<unsigned int> new_vertex_numbers (vertices.size(), invalid_vertex);
unsigned int next_free_number = 0;
for (unsigned int i=0; i<vertices.size(); ++i)
if (vertex_used[i] == true)
// which we really need to a new
// array and replace the old one by
// the new one
- vector<Point<dim> > tmp;
+
std::vector<Point<dim> > tmp;
tmp.reserve (count(vertex_used.begin(), vertex_used.end(), true));
for (unsigned int v=0; v<vertices.size(); ++v)
if (vertex_used[v] == true)
template <int dim>
-void GridIn<dim>::debug_output_grid (const vector<CellData<dim> > &/*cells*/,
- const vector<Point<dim> > &/*vertices*/,
- ostream &/*out*/)
+void GridIn<dim>::debug_output_grid (const std::vector<CellData<dim> > &/*cells*/,
+ const
std::vector<Point<dim> > &/*vertices*/,
+ std::ostream &/*out*/)
{
Assert (false, ExcNotImplemented());
};
template <>
void
-GridIn<2>::debug_output_grid (const vector<CellData<2> > &cells,
- const vector<Point<2> > &vertices,
- ostream &out)
+GridIn<2>::debug_output_grid (const std::vector<CellData<2> > &cells,
+ const
std::vector<Point<2> > &vertices,
+ std::ostream &out)
{
double min_x = vertices[cells[0].vertices[0]](0),
max_x = vertices[cells[0].vertices[0]](0),
max_y = p(1);
};
- out << "# cell " << i << endl;
+ out << "# cell " << i << std::endl;
Point<2> center;
for (unsigned int f=0; f<4; ++f)
center += vertices[cells[i].vertices[f]];
out << "set label \"" << i << "\" at "
<< center(0) << ',' << center(1)
<< " center"
- << endl;
+ << std::endl;
// first two line right direction
for (unsigned int f=0; f<2; ++f)
<< " to "
<< vertices[cells[i].vertices[(f+1)%4]](0) << ','
<< vertices[cells[i].vertices[(f+1)%4]](1)
- << endl;
+ << std::endl;
// other two lines reverse direction
for (unsigned int f=2; f<4; ++f)
out << "set arrow from "
<< " to "
<< vertices[cells[i].vertices[f]](0) << ','
<< vertices[cells[i].vertices[f]](1)
- << endl;
- out << endl;
+ << std::endl;
+ out << std::endl;
};
- out << endl
- << "set nokey" << endl
+ out << std::endl
+ << "set nokey" << std::endl
<< "pl [" << min_x << ':' << max_x << "]["
<< min_y << ':' << max_y << "] "
- << min_y << endl
- << "pause -1" << endl;
+ << min_y << std::endl
+ << "pause -1" << std::endl;
};
#endif
template <>
void
-GridIn<3>::debug_output_grid (const vector<CellData<3> > &cells,
- const vector<Point<3> > &vertices,
- ostream &out)
+GridIn<3>::debug_output_grid (const std::vector<CellData<3> > &cells,
+ const
std::vector<Point<3> > &vertices,
+ std::ostream &out)
{
for (unsigned int cell=0; cell<cells.size(); ++cell)
{
// line 0
out << vertices[cells[cell].vertices[0]]
- << endl
+ << std::endl
<< vertices[cells[cell].vertices[1]]
- << endl << endl << endl;
+ << std::endl << std::endl << std::endl;
// line 1
out << vertices[cells[cell].vertices[1]]
- << endl
+ << std::endl
<< vertices[cells[cell].vertices[2]]
- << endl << endl << endl;
+ << std::endl << std::endl << std::endl;
// line 2
out << vertices[cells[cell].vertices[3]]
- << endl
+ << std::endl
<< vertices[cells[cell].vertices[2]]
- << endl << endl << endl;
+ << std::endl << std::endl << std::endl;
// line 3
out << vertices[cells[cell].vertices[0]]
- << endl
+ << std::endl
<< vertices[cells[cell].vertices[3]]
- << endl << endl << endl;
+ << std::endl << std::endl << std::endl;
// line 4
out << vertices[cells[cell].vertices[4]]
- << endl
+ << std::endl
<< vertices[cells[cell].vertices[5]]
- << endl << endl << endl;
+ << std::endl << std::endl << std::endl;
// line 5
out << vertices[cells[cell].vertices[5]]
- << endl
+ << std::endl
<< vertices[cells[cell].vertices[6]]
- << endl << endl << endl;
+ << std::endl << std::endl << std::endl;
// line 6
out << vertices[cells[cell].vertices[7]]
- << endl
+ << std::endl
<< vertices[cells[cell].vertices[6]]
- << endl << endl << endl;
+ << std::endl << std::endl << std::endl;
// line 7
out << vertices[cells[cell].vertices[4]]
- << endl
+ << std::endl
<< vertices[cells[cell].vertices[7]]
- << endl << endl << endl;
+ << std::endl << std::endl << std::endl;
// line 8
out << vertices[cells[cell].vertices[0]]
- << endl
+ << std::endl
<< vertices[cells[cell].vertices[4]]
- << endl << endl << endl;
+ << std::endl << std::endl << std::endl;
// line 9
out << vertices[cells[cell].vertices[1]]
- << endl
+ << std::endl
<< vertices[cells[cell].vertices[5]]
- << endl << endl << endl;
+ << std::endl << std::endl << std::endl;
// line 10
out << vertices[cells[cell].vertices[2]]
- << endl
+ << std::endl
<< vertices[cells[cell].vertices[6]]
- << endl << endl << endl;
+ << std::endl << std::endl << std::endl;
// line 11
out << vertices[cells[cell].vertices[3]]
- << endl
+ << std::endl
<< vertices[cells[cell].vertices[7]]
- << endl << endl << endl;
+ << std::endl << std::endl << std::endl;
};
};
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
};
-string GridOut::default_suffix (const OutputFormat output_format)
+std::string GridOut::default_suffix (const OutputFormat output_format)
{
switch (output_format)
{
GridOut::OutputFormat
-GridOut::parse_output_format (const string &format_name)
+GridOut::parse_output_format (const std::string &format_name)
{
if (format_name == "ucd")
return ucd;
};
-string GridOut::get_output_format_names ()
+std::string GridOut::get_output_format_names ()
{
return "gnuplot|eps";
};
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
template <int dim>
void GridOut::write_ucd (const Triangulation<dim> &tria,
- ostream &out)
+ std::ostream &out)
{
AssertThrow (out, ExcIO());
// find out the vertices which
// are in use. copy them for fast
// output
- vector<Point<dim> > vertices (tria.n_vertices());
- vector<bool> vertex_used (tria.n_vertices(), false);
+
std::vector<Point<dim> > vertices (tria.n_vertices());
+ std::vector<bool> vertex_used (tria.n_vertices(), false);
unsigned int n_vertices = 0;
for (cell=tria.begin_active(); cell!=endc; ++cell)
// use
time_t time1= time (0);
tm *time = localtime(&time1);
- out << "# This file was generated by the deal.II library." << endl
+ out << "# This file was generated by the deal.II library." << std::endl
<< "# Date = "
<< time->tm_year+1900 << "/"
<< time->tm_mon+1 << "/"
- << time->tm_mday << endl
+ << time->tm_mday << std::endl
<< "# Time = "
<< time->tm_hour << ":"
- << setw(2) << time->tm_min << ":"
- << setw(2) << time->tm_sec << endl
- << "#" << endl
+ << std::setw(2) << time->tm_min << ":"
+ << std::setw(2) << time->tm_sec << std::endl
+ << "#" << std::endl
<< "# For a description of the UCD format see the AVS Developer's guide."
- << endl
- << "#" << endl;
+ << std::endl
+ << "#" << std::endl;
};
// start with ucd data
n_boundary_faces(tria) :
0)
<< " 0 0 0" // no data
- << endl;
+ << std::endl;
// actually write the vertices.
// note that we shall number them
<< vertices[i];
for (unsigned int d=dim+1; d<=3; ++d)
out << " 0"; // fill with zeroes
- out << endl;
+ out << std::endl;
};
// write cells. Enumerate cells
for (unsigned int vertex=0; vertex<GeometryInfo<dim>::vertices_per_cell;
++vertex)
out << cell->vertex_index(vertex)+1 << ' ';
- out << endl;
+ out << std::endl;
};
// write faces with non-zero boundary
template <>
void GridOut::write_ucd_faces (const Triangulation<1> &,
const unsigned int,
- ostream &) const
+ std::ostream &) const
{
return;
};
template <int dim>
void GridOut::write_ucd_faces (const Triangulation<dim> &tria,
const unsigned int starting_index,
- ostream &out) const
+ std::ostream &out) const
{
typename Triangulation<dim>::active_face_iterator face, endf;
unsigned int index=starting_index;
};
for (unsigned int vertex=0; vertex<GeometryInfo<dim>::vertices_per_face; ++vertex)
out << face->vertex_index(vertex) << ' ';
- out << endl;
+ out << std::endl;
++index;
};
template <int dim>
void GridOut::write_gnuplot (const Triangulation<dim> &tria,
- ostream &out)
+ std::ostream &out)
{
AssertThrow (out, ExcIO());
for (; cell!=endc; ++cell)
{
if (gnuplot_flags.write_cell_numbers)
- out << "# cell " << cell << endl;
+ out << "# cell " << cell << std::endl;
//TODO: plot level and material according to switches
switch (dim)
{
case 1:
out << cell->vertex(0)
<< ' ' << cell->level()
- << ' ' << (unsigned int) cell->material_id() << endl
+ << ' ' << (unsigned int) cell->material_id() << std::endl
<< cell->vertex(1)
<< ' ' << cell->level()
- << ' ' << (unsigned int) cell->material_id() << endl
- << endl;
+ << ' ' << (unsigned int) cell->material_id() << std::endl
+ << std::endl;
break;
case 2:
out << cell->vertex(0)
<< ' ' << cell->level()
- << ' ' << (unsigned int) cell->material_id() << endl
+ << ' ' << (unsigned int) cell->material_id() << std::endl
<< cell->vertex(1)
<< ' ' << cell->level()
- << ' ' << (unsigned int) cell->material_id() << endl
+ << ' ' << (unsigned int) cell->material_id() << std::endl
<< cell->vertex(2)
<< ' ' << cell->level()
- << ' ' << (unsigned int) cell->material_id() << endl
+ << ' ' << (unsigned int) cell->material_id() << std::endl
<< cell->vertex(3)
<< ' ' << cell->level()
- << ' ' << (unsigned int) cell->material_id() << endl
+ << ' ' << (unsigned int) cell->material_id() << std::endl
<< cell->vertex(0)
<< ' ' << cell->level()
- << ' ' << (unsigned int) cell->material_id() << endl
- << endl // double new line for gnuplot 3d plots
- << endl;
+ << ' ' << (unsigned int) cell->material_id() << std::endl
+ << std::endl // double new line for gnuplot 3d plots
+ << std::endl;
break;
case 3:
// front face
out << cell->vertex(0)
<< ' ' << cell->level()
- << ' ' << (unsigned int) cell->material_id() << endl
+ << ' ' << (unsigned int) cell->material_id() << std::endl
<< cell->vertex(1)
<< ' ' << cell->level()
- << ' ' << (unsigned int) cell->material_id() << endl
+ << ' ' << (unsigned int) cell->material_id() << std::endl
<< cell->vertex(2)
<< ' ' << cell->level()
- << ' ' << (unsigned int) cell->material_id() << endl
+ << ' ' << (unsigned int) cell->material_id() << std::endl
<< cell->vertex(3)
<< ' ' << cell->level()
- << ' ' << (unsigned int) cell->material_id() << endl
+ << ' ' << (unsigned int) cell->material_id() << std::endl
<< cell->vertex(0)
<< ' ' << cell->level()
- << ' ' << (unsigned int) cell->material_id() << endl
- << endl;
+ << ' ' << (unsigned int) cell->material_id() << std::endl
+ << std::endl;
// back face
out << cell->vertex(4)
<< ' ' << cell->level()
- << ' ' << (unsigned int) cell->material_id() << endl
+ << ' ' << (unsigned int) cell->material_id() << std::endl
<< cell->vertex(5)
<< ' ' << cell->level()
- << ' ' << (unsigned int) cell->material_id() << endl
+ << ' ' << (unsigned int) cell->material_id() << std::endl
<< cell->vertex(6)
<< ' ' << cell->level()
- << ' ' << (unsigned int) cell->material_id() << endl
+ << ' ' << (unsigned int) cell->material_id() << std::endl
<< cell->vertex(7)
<< ' ' << cell->level()
- << ' ' << (unsigned int) cell->material_id() << endl
+ << ' ' << (unsigned int) cell->material_id() << std::endl
<< cell->vertex(4)
<< ' ' << cell->level()
- << ' ' << (unsigned int) cell->material_id() << endl
- << endl;
+ << ' ' << (unsigned int) cell->material_id() << std::endl
+ << std::endl;
// now for the four connecting lines
out << cell->vertex(0)
<< ' ' << cell->level()
- << ' ' << (unsigned int) cell->material_id() << endl
+ << ' ' << (unsigned int) cell->material_id() << std::endl
<< cell->vertex(4)
<< ' ' << cell->level()
- << ' ' << (unsigned int) cell->material_id() << endl
- << endl;
+ << ' ' << (unsigned int) cell->material_id() << std::endl
+ << std::endl;
out << cell->vertex(1)
<< ' ' << cell->level()
- << ' ' << (unsigned int) cell->material_id() << endl
+ << ' ' << (unsigned int) cell->material_id() << std::endl
<< cell->vertex(5)
<< ' ' << cell->level()
- << ' ' << (unsigned int) cell->material_id() << endl
- << endl;
+ << ' ' << (unsigned int) cell->material_id() << std::endl
+ << std::endl;
out << cell->vertex(2)
<< ' ' << cell->level()
- << ' ' << (unsigned int) cell->material_id() << endl
+ << ' ' << (unsigned int) cell->material_id() << std::endl
<< cell->vertex(6)
<< ' ' << cell->level()
- << ' ' << (unsigned int) cell->material_id() << endl
- << endl;
+ << ' ' << (unsigned int) cell->material_id() << std::endl
+ << std::endl;
out << cell->vertex(3)
<< ' ' << cell->level()
- << ' ' << (unsigned int) cell->material_id() << endl
+ << ' ' << (unsigned int) cell->material_id() << std::endl
<< cell->vertex(7)
<< ' ' << cell->level()
- << ' ' << (unsigned int) cell->material_id() << endl
- << endl;
+ << ' ' << (unsigned int) cell->material_id() << std::endl
+ << std::endl;
break;
};
};
template <int dim>
void GridOut::write_eps (const Triangulation<dim> &tria,
- ostream &out)
+ std::ostream &out)
{
- typedef list<LineEntry> LineList;
+ typedef std::list<LineEntry> LineList;
// get a pointer to the flags
// common to all dimensions,
for (LineList::const_iterator line=line_list.begin();
line!=line_list.end(); ++line)
{
- x_min = min (x_min, line->first(0));
- x_min = min (x_min, line->second(0));
+ x_min = std::min (x_min, line->first(0));
+ x_min = std::min (x_min, line->second(0));
- x_max = max (x_max, line->first(0));
- x_max = max (x_max, line->second(0));
+ x_max = std::max (x_max, line->first(0));
+ x_max = std::max (x_max, line->second(0));
- y_min = min (y_min, line->first(1));
- y_min = min (y_min, line->second(1));
+ y_min = std::min (y_min, line->first(1));
+ y_min = std::min (y_min, line->second(1));
- y_max = max (y_max, line->first(1));
- y_max = max (y_max, line->second(1));
+ y_max = std::max (y_max, line->first(1));
+ y_max = std::max (y_max, line->second(1));
};
// scale in x-direction such that
// use
time_t time1= time (0);
tm *time = localtime(&time1);
- out << "%!PS-Adobe-2.0 EPSF-1.2" << endl
- << "%%Title: deal.II Output" << endl
- << "%%Creator: the deal.II library" << endl
+ out << "%!PS-Adobe-2.0 EPSF-1.2" << std::endl
+ << "%%Title: deal.II Output" << std::endl
+ << "%%Creator: the deal.II library" << std::endl
<< "%%Creation Date: "
<< time->tm_year+1900 << "/"
<< time->tm_mon+1 << "/"
<< time->tm_mday << " - "
<< time->tm_hour << ":"
- << setw(2) << time->tm_min << ":"
- << setw(2) << time->tm_sec << endl
+ << std::setw(2) << time->tm_min << ":"
+ << std::setw(2) << time->tm_sec << std::endl
<< "%%BoundingBox: "
// lower left corner
<< "0 0 "
<< static_cast<unsigned int>( (x_max-x_min) * scale )
<< ' '
<< static_cast<unsigned int>( (y_max-y_min) * scale )
- << endl;
+ << std::endl;
// define some abbreviations to keep
// the output small:
// x=execute line stroke
// b=black pen
// r=red pen
- out << "/m {moveto} bind def" << endl
- << "/x {lineto stroke} bind def" << endl
- << "/b {0 0 0 setrgbcolor} def" << endl
- << "/r {1 0 0 setrgbcolor} def" << endl;
+ out << "/m {moveto} bind def" << std::endl
+ << "/x {lineto stroke} bind def" << std::endl
+ << "/b {0 0 0 setrgbcolor} def" << std::endl
+ << "/r {1 0 0 setrgbcolor} def" << std::endl;
- out << "%%EndProlog" << endl
- << endl;
+ out << "%%EndProlog" << std::endl
+ << std::endl;
// set fine lines
- out << eps_flags_base.line_width << " setlinewidth" << endl;
+ out << eps_flags_base.line_width << " setlinewidth" << std::endl;
};
// now write the lines
line!=line_list.end(); ++line)
out << ((line->colorize && eps_flags_base.color_lines_on_user_flag) ? "r " : "b ")
<< (line->first - offset) * scale << " m "
- << (line->second - offset) * scale << " x" << endl;
+ << (line->second - offset) * scale << " x" << std::endl;
- out << "showpage" << endl;
+ out << "showpage" << std::endl;
AssertThrow (out, ExcIO());
};
template <int dim>
void GridOut::write (const Triangulation<dim> &tria,
- ostream &out,
+ std::ostream &out,
OutputFormat output_format)
{
switch (output_format)
// explicit instantiations
template void GridOut::write_ucd (const Triangulation<deal_II_dimension> &,
- ostream &);
+ std::ostream &);
template void GridOut::write_gnuplot (const Triangulation<deal_II_dimension> &,
- ostream &);
+ std::ostream &);
template void GridOut::write_eps (const Triangulation<deal_II_dimension> &,
- ostream &);
+ std::ostream &);
template void GridOut::write (const Triangulation<deal_II_dimension> &,
- ostream &,
+ std::ostream &,
OutputFormat);
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <fstream>
template<typename number>
-void GridRefinement::qsort_index(const Vector<number> &a,
- vector<unsigned int> &ind,
- int l,
- int r)
+void GridRefinement::qsort_index(const Vector<number> &a,
+ std::vector<unsigned int> &ind,
+ int l,
+ int r)
{
int i,j,t;
number v;
{
Assert (criteria.size() == tria.n_active_cells(),
ExcInvalidVectorSize(criteria.size(), tria.n_active_cells()));
- Assert (*min_element(criteria.begin(), criteria.end()) >= 0,
+ Assert (*std::min_element(criteria.begin(), criteria.end()) >= 0,
ExcInvalidParameterValue());
// nothing to do; especially we
{
Assert (criteria.size() == tria.n_active_cells(),
ExcInvalidVectorSize(criteria.size(), tria.n_active_cells()));
- Assert (*min_element(criteria.begin(), criteria.end()) >= 0,
+ Assert (*std::min_element(criteria.begin(), criteria.end()) >= 0,
ExcInvalidParameterValue());
Triangulation<dim>::active_cell_iterator cell = tria.begin_active();
Assert ((top_fraction>=0) && (top_fraction<=1), ExcInvalidParameterValue());
Assert ((bottom_fraction>=0) && (bottom_fraction<=1), ExcInvalidParameterValue());
Assert (top_fraction+bottom_fraction <= 1, ExcInvalidParameterValue());
- Assert (*min_element(criteria.begin(), criteria.end()) >= 0,
+ Assert (*std::min_element(criteria.begin(), criteria.end()) >= 0,
ExcInvalidParameterValue());
const int refine_cells=static_cast<int>(top_fraction*criteria.size());
Vector<number> tmp(criteria);
if (refine_cells)
{
- nth_element (tmp.begin(), tmp.begin()+refine_cells,
- tmp.end(),
- greater<double>());
+ std::nth_element (tmp.begin(), tmp.begin()+refine_cells,
+ tmp.end(),
+ std::greater<double>());
refine (tria, criteria, *(tmp.begin() + refine_cells));
};
if (coarsen_cells)
{
- nth_element (tmp.begin(), tmp.begin()+tmp.size()-coarsen_cells,
- tmp.end(),
- greater<double>());
+ std::nth_element (tmp.begin(), tmp.begin()+tmp.size()-coarsen_cells,
+ tmp.end(),
+ std::greater<double>());
coarsen (tria, criteria, *(tmp.begin() + tmp.size() - coarsen_cells));
};
};
Assert ((top_fraction>=0) && (top_fraction<=1), ExcInvalidParameterValue());
Assert ((bottom_fraction>=0) && (bottom_fraction<=1), ExcInvalidParameterValue());
Assert (top_fraction+bottom_fraction <= 1, ExcInvalidParameterValue());
- Assert (*min_element(criteria.begin(), criteria.end()) >= 0,
+ Assert (*std::min_element(criteria.begin(), criteria.end()) >= 0,
ExcInvalidParameterValue());
// let tmp be the cellwise square of the
// sort the largest criteria to the
// beginning of the vector
- sort (tmp.begin(), tmp.end(), greater<double>());
- partial_sum (tmp.begin(), tmp.end(), partial_sums.begin());
+ std::sort (tmp.begin(), tmp.end(), std::greater<double>());
+ std::partial_sum (tmp.begin(), tmp.end(), partial_sums.begin());
// compute thresholds
const typename Vector<number>::const_iterator
- q = lower_bound (partial_sums.begin(), partial_sums.end(),
- top_fraction*total_error),
- p = upper_bound (partial_sums.begin(), partial_sums.end(),
- total_error*(1-bottom_fraction));
+ q = std::lower_bound (partial_sums.begin(), partial_sums.end(),
+ static_cast<number>(top_fraction*total_error)),
+ p = std::upper_bound (partial_sums.begin(), partial_sums.end(),
+ static_cast<number>(total_error*(1-bottom_fraction)));
double bottom_threshold = tmp(p != partial_sums.end() ?
p-partial_sums.begin() :
// threshold if it equals the
// largest indicator and the
// top_fraction!=1
- if ((top_threshold == *max_element(criteria.begin(), criteria.end())) &&
+ if ((top_threshold == *std::max_element(criteria.begin(), criteria.end())) &&
(top_fraction != 1))
top_threshold *= 0.999;
bottom_threshold = 0.999*top_threshold;
// actually flag cells
- if (top_threshold < *max_element(criteria.begin(), criteria.end()))
+ if (top_threshold < *std::max_element(criteria.begin(), criteria.end()))
refine (tria, criteria, top_threshold);
- if (bottom_threshold > *min_element(criteria.begin(), criteria.end()))
+ if (bottom_threshold > *std::min_element(criteria.begin(), criteria.end()))
coarsen (tria, criteria, bottom_threshold);
};
{
Assert (criteria.size() == tria.n_active_cells(),
ExcInvalidVectorSize(criteria.size(), tria.n_active_cells()));
- Assert (*min_element(criteria.begin(), criteria.end()) >= 0,
+ Assert (*std::min_element(criteria.begin(), criteria.end()) >= 0,
ExcInvalidParameterValue());
// get an increasing order on
// the error indicator
- vector<unsigned int> tmp(criteria.size());
+ std::vector<unsigned int> tmp(criteria.size());
for (unsigned int i=0;i<criteria.size();++i)
tmp[i] = i;
// $Id$
// Version: $Name$
//
-// Copyright (C) 2000 by the deal.II authors
+// Copyright (C) 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
template <int dim>
void
-GridReordering<dim>::Cell::insert_faces (map<Face,FaceData> &/*global_faces*/)
+GridReordering<dim>::Cell::insert_faces (std::map<Face,FaceData> &/*global_faces*/)
{
Assert (false, ExcNotImplemented());
};
template <>
void
-GridReordering<2>::Cell::insert_faces (map<Face,FaceData> &global_faces)
+GridReordering<2>::Cell::insert_faces (std::map<Face,FaceData> &global_faces)
{
const unsigned int dim = 2;
// already exists, then the stored
// data is not touched.
for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
- faces[0][face] = global_faces.insert (make_pair(new_faces[face],
- FaceData())).first;
+ faces[0][face] = global_faces.insert (std::make_pair(new_faces[face],
+ FaceData())).first;
// then for each of the faces also
// `2'
for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
{
- swap (new_faces[face].vertices[0],
- new_faces[face].vertices[1]);
- faces[2][face] = global_faces.insert (make_pair(new_faces[face],
- FaceData())).first;
+ std::swap (new_faces[face].vertices[0],
+ new_faces[face].vertices[1]);
+ faces[2][face] = global_faces.insert (std::make_pair(new_faces[face],
+ FaceData())).first;
};
// then finally fill in rotational
template <>
void
-GridReordering<3>::Cell::insert_faces (map<Face,FaceData> &global_faces)
+GridReordering<3>::Cell::insert_faces (std::map<Face,FaceData> &global_faces)
{
const unsigned int dim = 3;
{ { vertices[0], vertices[4], vertices[7], vertices[3] } } };
Face new_faces[GeometryInfo<dim>::faces_per_cell][rotational_states_of_faces]
= { { new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0],
- new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0] },
- { new_faces_tmp[1], new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0],
+ new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0] },
+ { new_faces_tmp[1], new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0],
new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0] },
{ new_faces_tmp[2], new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0],
- new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0] },
- { new_faces_tmp[3], new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0],
- new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0] },
- { new_faces_tmp[4], new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0],
- new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0] },
- { new_faces_tmp[5], new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0],
- new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0] }};
+ new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0] },
+ { new_faces_tmp[3], new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0],
+ new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0] },
+ { new_faces_tmp[4], new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0],
+ new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0] },
+ { new_faces_tmp[5], new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0],
+ new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0], new_faces_tmp[0] }};
// first do the faces in their
// usual direction
for (unsigned int v=0; v<GeometryInfo<dim>::vertices_per_face; ++v)
new_faces[face][rot].vertices[v]
= new_faces[face][rot-rotational_states_of_faces/2].vertices[v];
- swap (new_faces[face][rot].vertices[1],
- new_faces[face][rot].vertices[3]);
+ std::swap (new_faces[face][rot].vertices[1],
+ new_faces[face][rot].vertices[3]);
};
// newighbor has already inserted
// it or not. we don't care about
// that here, though
- map<Face,FaceData>::iterator
+ std::map<Face,FaceData>::iterator
new_faces_ptr[rotational_states_of_faces][GeometryInfo<dim>::faces_per_cell];
for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
for (unsigned int rot=0; rot<rotational_states_of_faces; ++rot)
new_faces_ptr[rot][face]
- = global_faces.insert (make_pair(new_faces[face][rot], FaceData())).first;
+ = global_faces.insert (std::make_pair(new_faces[face][rot], FaceData())).first;
// and crosslink them to each other
for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
// cout << new_faces_ptr[0][face]->first.vertices[i] << ' ';
// cout << '>';
- if (new_faces_ptr[0][face]->second.adjacent_cells[0] ==
- FaceData::invalid_adjacent_cell)
- {
+ if (new_faces_ptr[0][face]->second.adjacent_cells[0] ==
+ FaceData::invalid_adjacent_cell)
+ {
// cout << " as neighbor 0" << endl;
- // no, faces had not been
- // used before, so we are the
- // first adjacent cell
- for (unsigned int rot=0; rot<rotational_states_of_faces; ++rot)
- {
- Assert (new_faces_ptr[rot][face]->second.adjacent_cells[0]
- == FaceData::invalid_adjacent_cell,
- ExcInternalError());
- new_faces_ptr[rot][face]->second.adjacent_cells[0] = cell_no;
- };
- }
- else
- {
- // otherwise: cell had been
- // entered before, so we are
- // the second neighbor
- const unsigned int
- previous_neighbor = new_faces_ptr[0][face]->second.adjacent_cells[0];
+ // no, faces had not been
+ // used before, so we are the
+ // first adjacent cell
+ for (unsigned int rot=0; rot<rotational_states_of_faces; ++rot)
+ {
+ Assert (new_faces_ptr[rot][face]->second.adjacent_cells[0]
+ == FaceData::invalid_adjacent_cell,
+ ExcInternalError());
+ new_faces_ptr[rot][face]->second.adjacent_cells[0] = cell_no;
+ };
+ }
+ else
+ {
+ // otherwise: cell had been
+ // entered before, so we are
+ // the second neighbor
+ const unsigned int
+ previous_neighbor = new_faces_ptr[0][face]->second.adjacent_cells[0];
// cout << " as neighbor 1 (previous: " << previous_neighbor << ")" << endl;
- for (unsigned int rot=0; rot<rotational_states_of_faces; ++rot)
- {
- Assert (new_faces_ptr[rot][face]->second.adjacent_cells[0] ==
- previous_neighbor,
- ExcInternalError());
- Assert (new_faces_ptr[rot][face]->second.adjacent_cells[1] ==
- FaceData::invalid_adjacent_cell,
- ExcInternalError());
- new_faces_ptr[rot][face]->second.adjacent_cells[1] = cell_no;
- };
- };
+ for (unsigned int rot=0; rot<rotational_states_of_faces; ++rot)
+ {
+ Assert (new_faces_ptr[rot][face]->second.adjacent_cells[0] ==
+ previous_neighbor,
+ ExcInternalError());
+ Assert (new_faces_ptr[rot][face]->second.adjacent_cells[1] ==
+ FaceData::invalid_adjacent_cell,
+ ExcInternalError());
+ new_faces_ptr[rot][face]->second.adjacent_cells[1] = cell_no;
+ };
+ };
};
// each of the six faces build the
// cell (store which face and which
// orientation):
- static pair<unsigned int, unsigned int>
+ static std::pair<unsigned int, unsigned int>
cell_orientation_faces[rotational_states_of_cells][GeometryInfo<dim>::faces_per_cell];
if (already_initialized == false)
for (unsigned int r=0; r<rotational_states_of_faces; ++r)
if (standard_faces[face] == new_faces[f][r])
{
- cell_orientation_faces[rot][face] = make_pair(f,r);
+ cell_orientation_faces[rot][face] = std::make_pair(f,r);
face_found = true;
break;
};
// often, don't make
// differences between
// debug and optimized mode
- vector<bool> face_used(GeometryInfo<dim>::faces_per_cell, false);
+ std::vector<bool> face_used(GeometryInfo<dim>::faces_per_cell, false);
for (unsigned int face=0; face<GeometryInfo<dim>::faces_per_cell; ++face)
{
// ups, face already
template <int dim>
inline
-void GridReordering<dim>::track_back (vector<Cell> &cells,
- RotationStack &rotation_states,
- unsigned int track_back_to_cell)
+void GridReordering<dim>::track_back (std::vector<Cell> &cells,
+ RotationStack &rotation_states,
+ unsigned int track_back_to_cell)
{
top_of_function:
// last cell can't be rotated
// further. go on with
// backtracking
- const typename vector<Cell>::iterator
+ const typename std::vector<Cell>::iterator
try_cell = cells.begin() + rotation_states.size();
track_back_to_cell = try_cell->track_back_to_cell;
template <int dim>
-bool GridReordering<dim>::try_rotate_single_neighbors (vector<Cell> &cells,
- RotationStack &rotation_states)
+bool GridReordering<dim>::try_rotate_single_neighbors (std::vector<Cell> &cells,
+ RotationStack &rotation_states)
{
// the rotation state of the cell
// which we try to add by rotating
template <int dim>
-void GridReordering<dim>::find_reordering (vector<Cell<dim> > &cells,
- vector<CellData<dim> > &original_cells,
- const vector<unsigned int> &new_cell_numbers)
+void GridReordering<dim>::find_reordering (std::vector<Cell> &cells,
+ std::vector<CellData<dim> > &original_cells,
+ const std::vector<unsigned int> &new_cell_numbers)
{
// cout << "Starting..." << flush;
// cout << "New max size " << rotation_states.size() << endl;
};
- const typename vector<Cell>::iterator
+ const typename std::vector<Cell>::iterator
try_cell = cells.begin() + rotation_states.size()-1;
if (try_cell->check_consistency (rotation_states.back()))
{
template <int dim>
-vector<unsigned int>
-GridReordering<dim>::presort_cells (vector<Cell<dim> > &cells,
- map<Face,FaceData> &faces)
+std::vector<unsigned int>
+GridReordering<dim>::presort_cells (std::vector<Cell> &cells,
+ std::map<Face,FaceData> &faces)
{
// first find the cell with the
// least neighbors
// insert the new cells numbers of
// each cell
const unsigned int invalid_cell_number = static_cast<unsigned int>(-1);
- vector<unsigned int> new_cell_numbers (cells.size(), invalid_cell_number);
+ std::vector<unsigned int> new_cell_numbers (cells.size(), invalid_cell_number);
// and have an array of the next
// cells to be numbered (old numbers)
- vector<unsigned int> next_round_cells (1, cell_with_min_neighbors);
+ std::vector<unsigned int> next_round_cells (1, cell_with_min_neighbors);
unsigned int next_free_new_number = 0;
// neighbors of the cells of
// this round which have not
// yet been renumbered
- vector<unsigned int> new_next_round_cells;
+ std::vector<unsigned int> new_next_round_cells;
for (unsigned int i=0; i<next_round_cells.size(); ++i)
for (unsigned int n=0; n<GeometryInfo<dim>::faces_per_cell; ++n)
- if (cells[next_round_cells[i]].neighbors[n] != Cell<dim>::invalid_neighbor)
+ if (cells[next_round_cells[i]].neighbors[n] != Cell::invalid_neighbor)
if (new_cell_numbers[cells[next_round_cells[i]].neighbors[n]]
== invalid_cell_number)
new_next_round_cells.push_back (cells[next_round_cells[i]].neighbors[n]);
// now that we know in which order
// to sort the cells, do so:
- vector<Cell<dim> > new_cells (cells.size());
+ std::vector<Cell> new_cells (cells.size());
for (unsigned int i=0; i<cells.size(); ++i)
new_cells[new_cell_numbers[i]] = cells[i];
// then switch old and new array
cells[c].neighbors[n] = new_cell_numbers[cells[c].neighbors[n]];
};
- for (typename map<Face,FaceData>::iterator i=faces.begin(); i!=faces.end(); ++i)
+ for (typename std::map<Face,FaceData>::iterator i=faces.begin(); i!=faces.end(); ++i)
for (unsigned int k=0; k<2; ++k)
if (i->second.adjacent_cells[k] != FaceData::invalid_adjacent_cell)
i->second.adjacent_cells[k] = new_cell_numbers[i->second.adjacent_cells[k]];
template <int dim>
-void GridReordering<dim>::reorder_cells (vector<CellData<dim> > &original_cells)
+void GridReordering<dim>::reorder_cells (std::vector<CellData<dim> > &original_cells)
{
// we need more information than
// provided by the input parameter,
// old cells to another class that
// provides space to these
// informations
- vector<Cell<dim> > cells;
+ std::vector<Cell> cells;
cells.reserve (original_cells.size());
for (unsigned int i=0; i<original_cells.size(); ++i)
- cells.push_back (Cell<dim>(original_cells[i], i));
+ cells.push_back (Cell(original_cells[i], i));
// first generate all the faces
// possible, i.e. in each possible
// direction and rotational state
- map<Face,FaceData> faces;
+ std::map<Face,FaceData> faces;
for (unsigned int cell_no=0; cell_no<cells.size(); ++cell_no)
cells[cell_no].insert_faces (faces);
// do a preordering step in order
// to make further backtracking
// more local
- const vector<unsigned int>
+ const std::vector<unsigned int>
new_cell_numbers = presort_cells (cells, faces);
// finally do some preliminary work
// find_reordering function has
// cleared all used marks it knows
// of
- for (typename map<Face,FaceData>::iterator i=faces.begin(); i!=faces.end(); ++i)
+ for (typename std::map<Face,FaceData>::iterator i=faces.begin(); i!=faces.end(); ++i)
Assert (i->second.use_count == 0, ExcInternalError());
};
#if deal_II_dimension == 1
template <>
-void GridReordering<1>::reorder_cells (vector<CellData<1> > &)
+void GridReordering<1>::reorder_cells (std::vector<CellData<1> > &)
{
// there should not be much to do
// in 1d...
template
void
GridReordering<deal_II_dimension>::
-reorder_cells (vector<CellData<deal_II_dimension> > &);
+reorder_cells (std::vector<CellData<deal_II_dimension> > &);
#endif
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// tria, i.e. it will be
// empty on first use
Triangulation<dim> (),
- coarse_grid (old_tria.coarse_grid),
- refine_flags (old_tria.refine_flags),
- coarsen_flags (old_tria.coarsen_flags)
+ coarse_grid (old_tria.coarse_grid),
+ refine_flags (old_tria.refine_flags),
+ coarsen_flags (old_tria.coarsen_flags)
{
Assert (old_tria.n_levels() == 0, ExcTriaNotEmpty ());
};
PersistentTriangulation<dim>::execute_coarsening_and_refinement ()
{
// first save flags
- refine_flags.push_back (vector<bool>());
- coarsen_flags.push_back (vector<bool>());
+ refine_flags.push_back (std::vector<bool>());
+ coarsen_flags.push_back (std::vector<bool>());
save_refine_flags (refine_flags.back());
save_coarsen_flags (coarsen_flags.back());
template <int dim>
void
-PersistentTriangulation<dim>::create_triangulation (const vector<Point<dim> > &,
- const vector<CellData<dim> > &,
- const SubCellData &)
+PersistentTriangulation<dim>::create_triangulation (const
std::vector<Point<dim> > &,
+ const std::vector<CellData<dim> > &,
+ const SubCellData &)
{
Assert (false, ExcFunctionNotUseful());
};
template <int dim>
void
-PersistentTriangulation<dim>::write_flags(ostream &out) const
+PersistentTriangulation<dim>::write_flags(std::ostream &out) const
{
const unsigned int n_flag_levels=refine_flags.size();
AssertThrow (out, ExcIO());
- out << mn_persistent_tria_flags_begin << ' ' << n_flag_levels << endl;
+ out << mn_persistent_tria_flags_begin << ' ' << n_flag_levels << std::endl;
for (unsigned int i=0; i<n_flag_levels; ++i)
{
mn_tria_coarsen_flags_end, out);
}
- out << mn_persistent_tria_flags_end << endl;
+ out << mn_persistent_tria_flags_end << std::endl;
AssertThrow (out, ExcIO());
}
template <int dim>
void
-PersistentTriangulation<dim>::read_flags(istream &in)
+PersistentTriangulation<dim>::read_flags(std::istream &in)
{
Assert(refine_flags.size()==0 && coarsen_flags.size()==0,
ExcTriaNotEmpty());
in >> n_flag_levels;
for (unsigned int i=0; i<n_flag_levels; ++i)
{
- refine_flags.push_back (vector<bool>());
- coarsen_flags.push_back (vector<bool>());
+ refine_flags.push_back (std::vector<bool>());
+ coarsen_flags.push_back (std::vector<bool>());
read_bool_vector (mn_tria_refine_flags_begin, refine_flags.back(),
mn_tria_refine_flags_end, in);
read_bool_vector (mn_tria_coarsen_flags_begin, coarsen_flags.back(),
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
neighbors.reserve (total_cells*(2*dimension));
neighbors.insert (neighbors.end(),
total_cells*(2*dimension) - neighbors.size(),
- make_pair(-1,-1));
+ std::make_pair(-1,-1));
};
};
void TriangulationLevel<1>::reserve_space (const unsigned int new_lines)
{
const unsigned int new_size = new_lines +
- count_if (lines.used.begin(),
- lines.used.end(),
- bind2nd (equal_to<bool>(), true));
+ std::count_if (lines.used.begin(),
+ lines.used.end(),
+ std::bind2nd (std::equal_to<bool>(), true));
// same as in @p{reserve_space<0>}: only
// allocate space if necessary
void TriangulationLevel<2>::reserve_space (const unsigned int new_quads)
{
const unsigned int new_size = new_quads +
- count_if (quads.used.begin(),
- quads.used.end(),
- bind2nd (equal_to<bool>(), true));
+ std::count_if (quads.used.begin(),
+ quads.used.end(),
+ std::bind2nd (std::equal_to<bool>(), true));
// see above...
if (new_size>quads.quads.size())
void TriangulationLevel<3>::reserve_space (const unsigned int new_hexes)
{
const unsigned int new_size = new_hexes +
- count_if (hexes.used.begin(),
- hexes.used.end(),
- bind2nd (equal_to<bool>(), true));
+ std::count_if (hexes.used.begin(),
+ hexes.used.end(),
+ std::bind2nd (std::equal_to<bool>(), true));
// see above...
if (new_size>hexes.hexes.size())
TriaNumberCache<1>::TriaNumberCache () :
n_lines (0),
n_active_lines (0)
- // all other fields are
- // default constructed
+ // all other fields are
+ // default constructed
{};
TriaNumberCache<2>::TriaNumberCache () :
n_quads (0),
n_active_quads (0)
- // all other fields are
- // default constructed
+ // all other fields are
+ // default constructed
{};
TriaNumberCache<3>::TriaNumberCache () :
n_hexes (0),
n_active_hexes (0)
- // all other fields are
- // default constructed
+ // all other fields are
+ // default constructed
{};
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
Triangulation<dim>::Triangulation (const Triangulation<dim> &)
:
Subscriptor () // do not set any subscriptors; anyway,
- // calling this constructor is an error!
+ // calling this constructor is an error!
{
Assert (false, ExcInternalError());
};
#if deal_II_dimension == 1
template <>
-void Triangulation<1>::create_triangulation (const vector<Point<1> > &v,
- const vector<CellData<1> > &cells,
+void Triangulation<1>::create_triangulation (const
std::vector<Point<1> > &v,
+ const std::vector<CellData<1> > &cells,
const SubCellData &subcelldata)
{
// note: since no boundary information
// copy vertices
vertices = v;
- vertices_used = vector<bool> (v.size(), true);
+ vertices_used = std::vector<bool> (v.size(), true);
// store the indices of the lines which
// are adjacent to a given vertex
- vector<vector<int> > lines_at_vertex (v.size());
+ std::vector<std::vector<int> > lines_at_vertex (v.size());
// reserve enough space
levels.push_back (new TriangulationLevel<dim>);
#if deal_II_dimension == 2
template <>
-void Triangulation<2>::create_triangulation (const vector<Point<2> > &v,
- const vector<CellData<2> > &c,
- const SubCellData &subcelldata)
+void Triangulation<2>::create_triangulation (const
std::vector<Point<2> > &v,
+ const std::vector<CellData<2> > &c,
+ const SubCellData &subcelldata)
{
const unsigned int dim=2;
// copy vertices
vertices = v;
- vertices_used = vector<bool> (v.size(), true);
+ vertices_used = std::vector<bool> (v.size(), true);
// copy cells. This is needed since we
// may need to change entries
- vector<CellData<2> > cells(c);
+ std::vector<CellData<2> > cells(c);
// make up a list of the needed lines
// object itself. In the first run, these
// iterators are all invalid ones, but they
// are filled afterwards
- map<pair<int,int>,line_iterator> needed_lines;
+ std::map<std::pair<int,int>,line_iterator> needed_lines;
for (unsigned int cell=0; cell<cells.size(); ++cell)
{
for (unsigned int vertex=0; vertex<4; ++vertex)
};
- pair<int,int> line_vertices[4] = { // note the order of the vertices
- make_pair (cells[cell].vertices[0], cells[cell].vertices[1]),
- make_pair (cells[cell].vertices[1], cells[cell].vertices[2]),
- make_pair (cells[cell].vertices[3], cells[cell].vertices[2]),
- make_pair (cells[cell].vertices[0], cells[cell].vertices[3])};
+ std::pair<int,int> line_vertices[4] = { // note the order of the vertices
+ std::make_pair (cells[cell].vertices[0], cells[cell].vertices[1]),
+ std::make_pair (cells[cell].vertices[1], cells[cell].vertices[2]),
+ std::make_pair (cells[cell].vertices[3], cells[cell].vertices[2]),
+ std::make_pair (cells[cell].vertices[0], cells[cell].vertices[3]) };
// note the following: if the sense
// of the vertices of a cell is correct,
// direction 1->4, while in
// the second it would be 4->1.
// This will cause the exception.
- if (! (needed_lines.find(make_pair(line_vertices[line].second,
- line_vertices[line].first))
+ if (! (needed_lines.find(std::make_pair(line_vertices[line].second,
+ line_vertices[line].first))
==
needed_lines.end()))
{
// at least two adjacent lines
if (true)
{
- vector<unsigned short int> vertex_touch_count (v.size(), 0);
- map<pair<int,int>,line_iterator>::iterator i;
+ std::vector<unsigned short int> vertex_touch_count (v.size(), 0);
+ std::map<std::pair<int,int>,line_iterator>::iterator i;
for (i=needed_lines.begin(); i!=needed_lines.end(); i++)
{
// touch the vertices of this line
if (true)
{
raw_line_iterator line = begin_raw_line();
- map<pair<int,int>,line_iterator>::iterator i;
+ std::map<std::pair<int,int>,line_iterator>::iterator i;
for (i = needed_lines.begin(); line!=end_line(); ++line, ++i)
{
line->set (Line(i->first.first, i->first.second));
// store for each line index
// the adjacent cells
- map<int,vector<cell_iterator> > adjacent_cells;
+ std::map<int,std::vector<cell_iterator> > adjacent_cells;
// finally make up cells
if (true)
{
// list of iterators of lines
const line_iterator lines[4] = {
- needed_lines[make_pair(cells[c].vertices[0], cells[c].vertices[1])],
- needed_lines[make_pair(cells[c].vertices[1], cells[c].vertices[2])],
- needed_lines[make_pair(cells[c].vertices[3], cells[c].vertices[2])],
- needed_lines[make_pair(cells[c].vertices[0], cells[c].vertices[3])]};
+ needed_lines[std::make_pair(cells[c].vertices[0], cells[c].vertices[1])],
+ needed_lines[std::make_pair(cells[c].vertices[1], cells[c].vertices[2])],
+ needed_lines[std::make_pair(cells[c].vertices[3], cells[c].vertices[2])],
+ needed_lines[std::make_pair(cells[c].vertices[0], cells[c].vertices[3])]};
cell->set (Quad(lines[0]->index(),
lines[1]->index(),
};
// set boundary indicators where given
- vector<CellData<1> >::const_iterator boundary_line
+ std::vector<CellData<1> >::const_iterator boundary_line
= subcelldata.boundary_lines.begin();
- vector<CellData<1> >::const_iterator end_boundary_line
+ std::vector<CellData<1> >::const_iterator end_boundary_line
= subcelldata.boundary_lines.end();
for (; boundary_line!=end_boundary_line; ++boundary_line)
{
line_iterator line;
- pair<int,int> line_vertices(make_pair(boundary_line->vertices[0],
- boundary_line->vertices[1]));
+ std::pair<int,int> line_vertices(std::make_pair(boundary_line->vertices[0],
+ boundary_line->vertices[1]));
if (needed_lines.find(line_vertices) != needed_lines.end())
// line found in this direction
line = needed_lines[line_vertices];
{
// look whether it exists in
// reverse direction
- swap (line_vertices.first, line_vertices.second);
+ std::swap (line_vertices.first, line_vertices.second);
if (needed_lines.find(line_vertices) != needed_lines.end())
line = needed_lines[line_vertices];
else
template <>
-void Triangulation<3>::create_triangulation (const vector<Point<3> > &v,
- const vector<CellData<3> > &c,
- const SubCellData &subcelldata) {
+void Triangulation<3>::create_triangulation (const std::vector<Point<3> > &v,
+ const std::vector<CellData<3> > &c,
+ const SubCellData &subcelldata)
+{
const unsigned int dim=3;
Assert (vertices.size() == 0, ExcTriangulationNotEmpty());
// copy vertices
vertices = v;
- vertices_used = vector<bool> (v.size(), true);
+ vertices_used = std::vector<bool> (v.size(), true);
// copy cells. This is needed since we
// may need to change entries
- vector<CellData<3> > cells(c);
+ std::vector<CellData<3> > cells(c);
///////////////////////////////////////
// first set up some collections of data
// iterators are all invalid ones, but they
// are filled afterwards
// same applies for the quads
- map<pair<int,int>,line_iterator> needed_lines;
+ std::map<std::pair<int,int>,line_iterator> needed_lines;
for (unsigned int cell=0; cell<cells.size(); ++cell)
{
};
- pair<int,int> line_vertices[12] = { // note the order of the vertices
- // front face
- make_pair (cells[cell].vertices[0], cells[cell].vertices[1]),
- make_pair (cells[cell].vertices[1], cells[cell].vertices[2]),
- make_pair (cells[cell].vertices[3], cells[cell].vertices[2]),
- make_pair (cells[cell].vertices[0], cells[cell].vertices[3]),
- // back face
- make_pair (cells[cell].vertices[4], cells[cell].vertices[5]),
- make_pair (cells[cell].vertices[5], cells[cell].vertices[6]),
- make_pair (cells[cell].vertices[7], cells[cell].vertices[6]),
- make_pair (cells[cell].vertices[4], cells[cell].vertices[7]),
- // connects of front and back face
- make_pair (cells[cell].vertices[0], cells[cell].vertices[4]),
- make_pair (cells[cell].vertices[1], cells[cell].vertices[5]),
- make_pair (cells[cell].vertices[2], cells[cell].vertices[6]),
- make_pair (cells[cell].vertices[3], cells[cell].vertices[7])
- };
+ std::pair<int,int> line_vertices[12] = { // note the order of the vertices
+ // front face
+ std::make_pair (cells[cell].vertices[0], cells[cell].vertices[1]),
+ std::make_pair (cells[cell].vertices[1], cells[cell].vertices[2]),
+ std::make_pair (cells[cell].vertices[3], cells[cell].vertices[2]),
+ std::make_pair (cells[cell].vertices[0], cells[cell].vertices[3]),
+ // back face
+ std::make_pair (cells[cell].vertices[4], cells[cell].vertices[5]),
+ std::make_pair (cells[cell].vertices[5], cells[cell].vertices[6]),
+ std::make_pair (cells[cell].vertices[7], cells[cell].vertices[6]),
+ std::make_pair (cells[cell].vertices[4], cells[cell].vertices[7]),
+ // connects of front and back face
+ std::make_pair (cells[cell].vertices[0], cells[cell].vertices[4]),
+ std::make_pair (cells[cell].vertices[1], cells[cell].vertices[5]),
+ std::make_pair (cells[cell].vertices[2], cells[cell].vertices[6]),
+ std::make_pair (cells[cell].vertices[3], cells[cell].vertices[7])
+ };
// in the 2d code, some tests were performed
// which may heal a problem with quads that
// assert that the line was not
// already inserted in reverse
// order.
- if (! (needed_lines.find(make_pair(line_vertices[line].second,
- line_vertices[line].first))
+ if (! (needed_lines.find(std::make_pair(line_vertices[line].second,
+ line_vertices[line].first))
==
needed_lines.end()))
{
// at least two adjacent lines
if (true)
{
- vector<unsigned short int> vertex_touch_count (v.size(), 0);
- map<pair<int,int>,line_iterator>::iterator i;
+ std::vector<unsigned short int> vertex_touch_count (v.size(), 0);
+ std::map<std::pair<int,int>,line_iterator>::iterator i;
for (i=needed_lines.begin(); i!=needed_lines.end(); i++)
{
// touch the vertices of this line
if (true)
{
raw_line_iterator line = begin_raw_line();
- map<pair<int,int>,line_iterator>::iterator i;
+ std::map<std::pair<int,int>,line_iterator>::iterator i;
for (i = needed_lines.begin(); line!=end_line(); ++line, ++i)
{
line->set (Line(i->first.first, i->first.second));
// note that QuadComparator is a class
// declared and defined in this file
- map<Quad,quad_iterator,QuadComparator> needed_quads;
+ std::map<Quad,quad_iterator,QuadComparator> needed_quads;
for (unsigned int cell=0; cell<cells.size(); ++cell)
{
// the faces are quads which consist
// vertex indices) in place, but before
// they are really needed. This is just
// copied from above.
- pair<int,int> line_list[12] = { // note the order of the vertices
- // front face
- make_pair (cells[cell].vertices[0], cells[cell].vertices[1]),
- make_pair (cells[cell].vertices[1], cells[cell].vertices[2]),
- make_pair (cells[cell].vertices[3], cells[cell].vertices[2]),
- make_pair (cells[cell].vertices[0], cells[cell].vertices[3]),
- // back face
- make_pair (cells[cell].vertices[4], cells[cell].vertices[5]),
- make_pair (cells[cell].vertices[5], cells[cell].vertices[6]),
- make_pair (cells[cell].vertices[7], cells[cell].vertices[6]),
- make_pair (cells[cell].vertices[4], cells[cell].vertices[7]),
- // connects of front and back face
- make_pair (cells[cell].vertices[0], cells[cell].vertices[4]),
- make_pair (cells[cell].vertices[1], cells[cell].vertices[5]),
- make_pair (cells[cell].vertices[2], cells[cell].vertices[6]),
- make_pair (cells[cell].vertices[3], cells[cell].vertices[7])
- };
+ std::pair<int,int> line_list[12] = { // note the order of the vertices
+ // front face
+ std::make_pair (cells[cell].vertices[0], cells[cell].vertices[1]),
+ std::make_pair (cells[cell].vertices[1], cells[cell].vertices[2]),
+ std::make_pair (cells[cell].vertices[3], cells[cell].vertices[2]),
+ std::make_pair (cells[cell].vertices[0], cells[cell].vertices[3]),
+ // back face
+ std::make_pair (cells[cell].vertices[4], cells[cell].vertices[5]),
+ std::make_pair (cells[cell].vertices[5], cells[cell].vertices[6]),
+ std::make_pair (cells[cell].vertices[7], cells[cell].vertices[6]),
+ std::make_pair (cells[cell].vertices[4], cells[cell].vertices[7]),
+ // connects of front and back face
+ std::make_pair (cells[cell].vertices[0], cells[cell].vertices[4]),
+ std::make_pair (cells[cell].vertices[1], cells[cell].vertices[5]),
+ std::make_pair (cells[cell].vertices[2], cells[cell].vertices[6]),
+ std::make_pair (cells[cell].vertices[3], cells[cell].vertices[7])
+ };
Quad faces[6]
= {
// insert quad, with invalid iterator
// if quad already exists, then
// nothing bad happens here
- needed_quads[faces[quad]] = end_quad();
+ needed_quads[faces[quad]] = end_quad();
};
if (true)
{
raw_quad_iterator quad = begin_raw_quad();
- map<Quad,quad_iterator>::iterator q;
+ std::map<Quad,quad_iterator,QuadComparator>::iterator q;
for (q = needed_quads.begin(); quad!=end_quad(); ++quad, ++q)
{
quad->set (q->first);
// store for each quad index
// the adjacent cells
- map<int,vector<cell_iterator> > adjacent_cells;
+ std::map<int,std::vector<cell_iterator> > adjacent_cells;
// finally make up cells
if (true)
// the quads that are bounded by
// these lines; these are then
// the faces of the present cell
- pair<int,int> line_list[12] = { // note the order of the vertices
- // front face
- make_pair (cells[c].vertices[0], cells[c].vertices[1]),
- make_pair (cells[c].vertices[1], cells[c].vertices[2]),
- make_pair (cells[c].vertices[3], cells[c].vertices[2]),
- make_pair (cells[c].vertices[0], cells[c].vertices[3]),
- // back face
- make_pair (cells[c].vertices[4], cells[c].vertices[5]),
- make_pair (cells[c].vertices[5], cells[c].vertices[6]),
- make_pair (cells[c].vertices[7], cells[c].vertices[6]),
- make_pair (cells[c].vertices[4], cells[c].vertices[7]),
- // connects of front and back face
- make_pair (cells[c].vertices[0], cells[c].vertices[4]),
- make_pair (cells[c].vertices[1], cells[c].vertices[5]),
- make_pair (cells[c].vertices[2], cells[c].vertices[6]),
- make_pair (cells[c].vertices[3], cells[c].vertices[7])
- };
+ std::pair<int,int> line_list[12] = { // note the order of the vertices
+ // front face
+ std::make_pair (cells[c].vertices[0], cells[c].vertices[1]),
+ std::make_pair (cells[c].vertices[1], cells[c].vertices[2]),
+ std::make_pair (cells[c].vertices[3], cells[c].vertices[2]),
+ std::make_pair (cells[c].vertices[0], cells[c].vertices[3]),
+ // back face
+ std::make_pair (cells[c].vertices[4], cells[c].vertices[5]),
+ std::make_pair (cells[c].vertices[5], cells[c].vertices[6]),
+ std::make_pair (cells[c].vertices[7], cells[c].vertices[6]),
+ std::make_pair (cells[c].vertices[4], cells[c].vertices[7]),
+ // connects of front and back face
+ std::make_pair (cells[c].vertices[0], cells[c].vertices[4]),
+ std::make_pair (cells[c].vertices[1], cells[c].vertices[5]),
+ std::make_pair (cells[c].vertices[2], cells[c].vertices[6]),
+ std::make_pair (cells[c].vertices[3], cells[c].vertices[7])
+ };
Quad faces[6]
= {
// where given
//
// first do so for lines
- vector<CellData<1> >::const_iterator boundary_line
+ std::vector<CellData<1> >::const_iterator boundary_line
= subcelldata.boundary_lines.begin();
- vector<CellData<1> >::const_iterator end_boundary_line
+ std::vector<CellData<1> >::const_iterator end_boundary_line
= subcelldata.boundary_lines.end();
for (; boundary_line!=end_boundary_line; ++boundary_line)
{
line_iterator line;
- pair <int, int> line_vertices(make_pair(boundary_line->vertices[0],
- boundary_line->vertices[1]));
+ std::pair <int, int> line_vertices(std::make_pair(boundary_line->vertices[0],
+ boundary_line->vertices[1]));
if (needed_lines.find(line_vertices) != needed_lines.end())
// line found in this
// direction
{
// look wether it exists in
// reverse direction
- swap (line_vertices.first, line_vertices.second);
+ std::swap (line_vertices.first, line_vertices.second);
if (needed_lines.find(line_vertices) != needed_lines.end())
line = needed_lines[line_vertices];
else
// now go on with boundary faces
- vector<CellData<2> >::const_iterator boundary_quad
+ std::vector<CellData<2> >::const_iterator boundary_quad
= subcelldata.boundary_quads.begin();
- vector<CellData<2> >::const_iterator end_boundary_quad
+ std::vector<CellData<2> >::const_iterator end_boundary_quad
= subcelldata.boundary_quads.end();
for (; boundary_quad!=end_boundary_quad; ++boundary_quad)
{
quad_iterator quad;
line_iterator line[4];
- vector <int> quad_vertices(4);
+ std::vector <int> quad_vertices(4);
// first find the lines that
// are made up of the given
// finally use the find
// function of the map template
// to find the quad
- pair <int, int> line_vertices[4]
- = { make_pair (boundary_quad->vertices[0], boundary_quad->vertices[1]),
- make_pair (boundary_quad->vertices[1], boundary_quad->vertices[2]),
- make_pair (boundary_quad->vertices[3], boundary_quad->vertices[2]),
- make_pair (boundary_quad->vertices[0], boundary_quad->vertices[3]) };
+ std::pair <int, int> line_vertices[4]
+ = { std::make_pair (boundary_quad->vertices[0], boundary_quad->vertices[1]),
+ std::make_pair (boundary_quad->vertices[1], boundary_quad->vertices[2]),
+ std::make_pair (boundary_quad->vertices[3], boundary_quad->vertices[2]),
+ std::make_pair (boundary_quad->vertices[0], boundary_quad->vertices[3]) };
for (unsigned int i=0; i<4; ++i)
{
else
// look wether it exists
// in reverse direction
- {
- swap (line_vertices[i].first, line_vertices[i].second);
- if (needed_lines.find(line_vertices[i]) != needed_lines.end())
- line[i] = needed_lines[line_vertices[i]];
- else
- {
- // line does not exist
- AssertThrow (false, ExcLineInexistant(line_vertices[i].first,
- line_vertices[i].second));
- line[i] = end_line();
- };
- };
+ {
+ std::swap (line_vertices[i].first, line_vertices[i].second);
+ if (needed_lines.find(line_vertices[i]) != needed_lines.end())
+ line[i] = needed_lines[line_vertices[i]];
+ else
+ {
+ // line does not exist
+ AssertThrow (false, ExcLineInexistant(line_vertices[i].first,
+ line_vertices[i].second));
+ line[i] = end_line();
+ };
+ };
};
for (cell_iterator cell=begin(0); cell!=end(0); ++cell)
almost_infinite_length += cell->diameter();
- vector<double> minimal_length (vertices.size(),
- almost_infinite_length);
+ std::vector<double> minimal_length (vertices.size(),
+ almost_infinite_length);
// also note if a vertex is at
// the boundary
- vector<bool> at_boundary (vertices.size(), false);
+ std::vector<bool> at_boundary (vertices.size(), false);
for (active_line_iterator line=begin_active_line();
line != end_line(); ++line)
};
minimal_length[line->vertex_index(0)]
- = min(line->diameter(), minimal_length[line->vertex_index(0)]);
+ = std::min(line->diameter(),
+ minimal_length[line->vertex_index(0)]);
minimal_length[line->vertex_index(1)]
- = min(line->diameter(), minimal_length[line->vertex_index(1)]);
+ = std::min(line->diameter(),
+ minimal_length[line->vertex_index(1)]);
};
for (cell_iterator cell=begin(0); cell!=end(0); ++cell)
almost_infinite_length += cell->diameter();
- vector<double> minimal_length (vertices.size(),
- almost_infinite_length);
+ std::vector<double> minimal_length (vertices.size(),
+ almost_infinite_length);
// also note if a vertex is at
// the boundary
- vector<bool> at_boundary (vertices.size(), false);
+ std::vector<bool> at_boundary (vertices.size(), false);
for (active_line_iterator line=begin_active_line();
line != end_line(); ++line)
};
minimal_length[line->vertex_index(0)]
- = min(line->diameter(), minimal_length[line->vertex_index(0)]);
+ = std::min(line->diameter(),
+ minimal_length[line->vertex_index(0)]);
minimal_length[line->vertex_index(1)]
- = min(line->diameter(), minimal_length[line->vertex_index(1)]);
+ = std::min(line->diameter(),
+ minimal_length[line->vertex_index(1)]);
};
template <int dim>
-void Triangulation<dim>::save_refine_flags (vector<bool> &v) const {
+void Triangulation<dim>::save_refine_flags (std::vector<bool> &v) const {
v.resize (n_active_cells(), false);
- vector<bool>::iterator i = v.begin();
+ std::vector<bool>::iterator i = v.begin();
active_cell_iterator cell = begin_active(),
endc = end();
for (; cell!=endc; ++cell, ++i)
template <int dim>
-void Triangulation<dim>::save_refine_flags (ostream &out) const {
- vector<bool> v;
+void Triangulation<dim>::save_refine_flags (std::ostream &out) const {
+ std::vector<bool> v;
save_refine_flags (v);
write_bool_vector (mn_tria_refine_flags_begin, v, mn_tria_refine_flags_end,
out);
template <int dim>
-void Triangulation<dim>::load_refine_flags (istream &in) {
- vector<bool> v;
+void Triangulation<dim>::load_refine_flags (std::istream &in) {
+ std::vector<bool> v;
read_bool_vector (mn_tria_refine_flags_begin, v, mn_tria_refine_flags_end,
in);
load_refine_flags (v);
template <int dim>
-void Triangulation<dim>::load_refine_flags (const vector<bool> &v) {
+void Triangulation<dim>::load_refine_flags (const std::vector<bool> &v) {
Assert (v.size() == n_active_cells(), ExcGridReadError());
active_cell_iterator cell = begin_active(),
endc = end();
- vector<bool>::const_iterator i = v.begin();
+ std::vector<bool>::const_iterator i = v.begin();
for (; cell!=endc; ++cell, ++i)
if (*i == true)
cell->set_refine_flag();
template <int dim>
-void Triangulation<dim>::save_coarsen_flags (vector<bool> &v) const {
+void Triangulation<dim>::save_coarsen_flags (std::vector<bool> &v) const {
v.resize (n_active_cells(), false);
- vector<bool>::iterator i = v.begin();
+ std::vector<bool>::iterator i = v.begin();
active_cell_iterator cell = begin_active(),
endc = end();
for (; cell!=endc; ++cell, ++i)
template <int dim>
-void Triangulation<dim>::save_coarsen_flags (ostream &out) const {
- vector<bool> v;
+void Triangulation<dim>::save_coarsen_flags (std::ostream &out) const {
+ std::vector<bool> v;
save_coarsen_flags (v);
write_bool_vector (mn_tria_coarsen_flags_begin, v, mn_tria_coarsen_flags_end,
out);
template <int dim>
-void Triangulation<dim>::load_coarsen_flags (istream &in) {
- vector<bool> v;
+void Triangulation<dim>::load_coarsen_flags (std::istream &in) {
+ std::vector<bool> v;
read_bool_vector (mn_tria_coarsen_flags_begin, v, mn_tria_coarsen_flags_end,
in);
load_coarsen_flags (v);
template <int dim>
-void Triangulation<dim>::load_coarsen_flags (const vector<bool> &v) {
+void Triangulation<dim>::load_coarsen_flags (const std::vector<bool> &v) {
Assert (v.size() == n_active_cells(), ExcGridReadError());
active_cell_iterator cell = begin_active(),
endc = end();
- vector<bool>::const_iterator i = v.begin();
+ std::vector<bool>::const_iterator i = v.begin();
for (; cell!=endc; ++cell, ++i)
if (*i == true)
cell->set_coarsen_flag();
template <int dim>
-void Triangulation<dim>::save_user_flags (ostream &out) const {
+void Triangulation<dim>::save_user_flags (std::ostream &out) const {
save_user_flags_line (out);
if (dim>=2)
template <int dim>
-void Triangulation<dim>::save_user_flags (vector<bool> &v) const {
+void Triangulation<dim>::save_user_flags (std::vector<bool> &v) const {
// clear vector and append
// all the stuff later on
v.clear ();
- vector<bool> tmp;
+ std::vector<bool> tmp;
save_user_flags_line (tmp);
v.insert (v.end(), tmp.begin(), tmp.end());
template <int dim>
-void Triangulation<dim>::load_user_flags (istream &in)
+void Triangulation<dim>::load_user_flags (std::istream &in)
{
load_user_flags_line (in);
template <int dim>
-void Triangulation<dim>::load_user_flags (const vector<bool> &v)
+void Triangulation<dim>::load_user_flags (const std::vector<bool> &v)
{
Assert (v.size() == n_lines()+n_quads()+n_hexs(), ExcInternalError());
- vector<bool> tmp;
+ std::vector<bool> tmp;
// first extract the flags belonging
// to lines
template <int dim>
-void Triangulation<dim>::save_user_flags_line (vector<bool> &v) const {
+void Triangulation<dim>::save_user_flags_line (std::vector<bool> &v) const {
v.resize (n_lines(), false);
- vector<bool>::iterator i = v.begin();
+ std::vector<bool>::iterator i = v.begin();
line_iterator line = begin_line(),
endl = end_line();
for (; line!=endl; ++line, ++i)
template <int dim>
-void Triangulation<dim>::save_user_flags_line (ostream &out) const {
- vector<bool> v;
+void Triangulation<dim>::save_user_flags_line (std::ostream &out) const {
+ std::vector<bool> v;
save_user_flags_line (v);
write_bool_vector (mn_tria_line_user_flags_begin, v, mn_tria_line_user_flags_end,
out);
template <int dim>
-void Triangulation<dim>::load_user_flags_line (istream &in) {
- vector<bool> v;
+void Triangulation<dim>::load_user_flags_line (std::istream &in) {
+ std::vector<bool> v;
read_bool_vector (mn_tria_line_user_flags_begin, v, mn_tria_line_user_flags_end,
in);
load_user_flags_line (v);
template <int dim>
-void Triangulation<dim>::load_user_flags_line (const vector<bool> &v) {
+void Triangulation<dim>::load_user_flags_line (const std::vector<bool> &v) {
Assert (v.size() == n_lines(), ExcGridReadError());
line_iterator line = begin_line(),
endl = end_line();
- vector<bool>::const_iterator i = v.begin();
+ std::vector<bool>::const_iterator i = v.begin();
for (; line!=endl; ++line, ++i)
if (*i == true)
line->set_user_flag();
#if deal_II_dimension == 1
template <>
-void Triangulation<1>::save_user_flags_quad (ostream &) const {
+void Triangulation<1>::save_user_flags_quad (std::ostream &) const {
Assert (false, ExcFunctionNotUseful());
};
template <>
-void Triangulation<1>::save_user_flags_quad (vector<bool> &) const {
+void Triangulation<1>::save_user_flags_quad (std::vector<bool> &) const {
Assert (false, ExcFunctionNotUseful());
};
template <>
-void Triangulation<1>::load_user_flags_quad (istream &) {
+void Triangulation<1>::load_user_flags_quad (std::istream &) {
Assert (false, ExcFunctionNotUseful());
};
template <>
-void Triangulation<1>::load_user_flags_quad (const vector<bool> &) {
+void Triangulation<1>::load_user_flags_quad (const std::vector<bool> &) {
Assert (false, ExcFunctionNotUseful());
};
template <>
-void Triangulation<1>::save_user_flags_hex (ostream &) const {
+void Triangulation<1>::save_user_flags_hex (std::ostream &) const {
Assert (false, ExcFunctionNotUseful());
};
template <>
-void Triangulation<1>::save_user_flags_hex (vector<bool> &) const {
+void Triangulation<1>::save_user_flags_hex (std::vector<bool> &) const {
Assert (false, ExcFunctionNotUseful());
};
template <>
-void Triangulation<1>::load_user_flags_hex (istream &) {
+void Triangulation<1>::load_user_flags_hex (std::istream &) {
Assert (false, ExcFunctionNotUseful());
};
template <>
-void Triangulation<1>::load_user_flags_hex (const vector<bool> &) {
+void Triangulation<1>::load_user_flags_hex (const std::vector<bool> &) {
Assert (false, ExcFunctionNotUseful());
};
template <int dim>
-void Triangulation<dim>::save_user_flags_quad (vector<bool> &v) const {
+void Triangulation<dim>::save_user_flags_quad (std::vector<bool> &v) const {
v.resize (n_quads(), false);
- vector<bool>::iterator i = v.begin();
+ std::vector<bool>::iterator i = v.begin();
quad_iterator quad = begin_quad(),
endq = end_quad();
for (; quad!=endq; ++quad, ++i)
template <int dim>
-void Triangulation<dim>::save_user_flags_quad (ostream &out) const {
- vector<bool> v;
+void Triangulation<dim>::save_user_flags_quad (std::ostream &out) const {
+ std::vector<bool> v;
save_user_flags_quad (v);
write_bool_vector (mn_tria_quad_user_flags_begin, v, mn_tria_quad_user_flags_end,
out);
template <int dim>
-void Triangulation<dim>::load_user_flags_quad (istream &in) {
- vector<bool> v;
+void Triangulation<dim>::load_user_flags_quad (std::istream &in) {
+ std::vector<bool> v;
read_bool_vector (mn_tria_quad_user_flags_begin, v, mn_tria_quad_user_flags_end,
in);
load_user_flags_quad (v);
template <int dim>
-void Triangulation<dim>::load_user_flags_quad (const vector<bool> &v) {
+void Triangulation<dim>::load_user_flags_quad (const std::vector<bool> &v) {
Assert (v.size() == n_quads(), ExcGridReadError());
quad_iterator quad = begin_quad(),
endq = end_quad();
- vector<bool>::const_iterator i = v.begin();
+ std::vector<bool>::const_iterator i = v.begin();
for (; quad!=endq; ++quad, ++i)
if (*i == true)
quad->set_user_flag();
#if deal_II_dimension == 2
template <>
-void Triangulation<2>::save_user_flags_hex (ostream &) const {
+void Triangulation<2>::save_user_flags_hex (std::ostream &) const {
Assert (false, ExcFunctionNotUseful());
};
template <>
-void Triangulation<2>::save_user_flags_hex (vector<bool> &) const {
+void Triangulation<2>::save_user_flags_hex (std::vector<bool> &) const {
Assert (false, ExcFunctionNotUseful());
};
template <>
-void Triangulation<2>::load_user_flags_hex (istream &) {
+void Triangulation<2>::load_user_flags_hex (std::istream &) {
Assert (false, ExcFunctionNotUseful());
};
template <>
-void Triangulation<2>::load_user_flags_hex (const vector<bool> &) {
+void Triangulation<2>::load_user_flags_hex (const std::vector<bool> &) {
Assert (false, ExcFunctionNotUseful());
};
template <int dim>
-void Triangulation<dim>::save_user_flags_hex (vector<bool> &v) const {
+void Triangulation<dim>::save_user_flags_hex (std::vector<bool> &v) const {
v.resize (n_hexs(), false);
- vector<bool>::iterator i = v.begin();
+ std::vector<bool>::iterator i = v.begin();
hex_iterator hex = begin_hex(),
endh = end_hex();
for (; hex!=endh; ++hex, ++i)
template <int dim>
-void Triangulation<dim>::save_user_flags_hex (ostream &out) const {
- vector<bool> v;
+void Triangulation<dim>::save_user_flags_hex (std::ostream &out) const {
+ std::vector<bool> v;
save_user_flags_hex (v);
write_bool_vector (mn_tria_hex_user_flags_begin, v, mn_tria_hex_user_flags_end,
out);
template <int dim>
-void Triangulation<dim>::load_user_flags_hex (istream &in) {
- vector<bool> v;
+void Triangulation<dim>::load_user_flags_hex (std::istream &in) {
+ std::vector<bool> v;
read_bool_vector (mn_tria_hex_user_flags_begin, v, mn_tria_hex_user_flags_end,
in);
load_user_flags_hex (v);
template <int dim>
-void Triangulation<dim>::load_user_flags_hex (const vector<bool> &v) {
+void Triangulation<dim>::load_user_flags_hex (const std::vector<bool> &v) {
Assert (v.size() == n_hexs(), ExcGridReadError());
hex_iterator hex = begin_hex(),
endh = end_hex();
- vector<bool>::const_iterator i = v.begin();
+ std::vector<bool>::const_iterator i = v.begin();
for (; hex!=endh; ++hex, ++i)
if (*i == true)
hex->set_user_flag();
unsigned int
Triangulation<dim>::n_used_vertices () const
{
- return count_if (vertices_used.begin(), vertices_used.end(),
- bind2nd (equal_to<bool>(), true));
+ return std::count_if (vertices_used.begin(), vertices_used.end(),
+ std::bind2nd (std::equal_to<bool>(), true));
};
// store the number of times a cell touches
// a vertex. An unsigned int should suffice,
// even for larger dimensions
- vector<unsigned short int> usage_count (max_vertex_index+1, 0);
+ std::vector<unsigned short int> usage_count (max_vertex_index+1, 0);
// touch a vertex's usage count everytime
// we find an adjacent element
for (cell=begin(); cell!=endc; ++cell)
for (unsigned vertex=0; vertex<GeometryInfo<dim>::vertices_per_cell; ++vertex)
++usage_count[cell->vertex_index(vertex)];
- return max (GeometryInfo<dim>::vertices_per_cell,
- static_cast<unsigned int>(*(max_element (usage_count.begin(),
- usage_count.end()))));
+ return std::max (GeometryInfo<dim>::vertices_per_cell,
+ static_cast<unsigned int>(*std::max_element (usage_count.begin(),
+ usage_count.end())));
};
// count number of used cells on
// the next higher level
const unsigned int used_cells
- = count_if (levels[level+1]->lines.used.begin(),
- levels[level+1]->lines.used.end(),
- bind2nd (equal_to<bool>(), true));
+ = std::count_if (levels[level+1]->lines.used.begin(),
+ levels[level+1]->lines.used.end(),
+ std::bind2nd (std::equal_to<bool>(), true));
// reserve space for the used_cells
// cells already existing on the next
// add to needed vertices how
// many vertices are already in use
- needed_vertices += count_if (vertices_used.begin(), vertices_used.end(),
- bind2nd (equal_to<bool>(), true));
+ needed_vertices += std::count_if (vertices_used.begin(), vertices_used.end(),
+ std::bind2nd (std::equal_to<bool>(), true));
// if we need more vertices: create them,
// if not: leave the array as is, since
// shrinking is not really possible because
// case 1
if (((neighbor->refine_flag_set() == true) &&
(acell->index() < neighbor->index()))
- // case 1a
- // we need one more vertex
- // and two more lines, but
- // we must only count them
- // once. Convention: count
- // them for the cell with
- // the lower index
+ // case 1a
+ // we need one more vertex
+ // and two more lines, but
+ // we must only count them
+ // once. Convention: count
+ // them for the cell with
+ // the lower index
||
(neighbor->refine_flag_set() == false))
// case 1b
// count number of used cells on
// the next higher level
const unsigned int used_cells
- = count_if (levels[level+1]->quads.used.begin(),
- levels[level+1]->quads.used.end(),
- bind2nd (equal_to<bool>(), true));
-
+ = std::count_if (levels[level+1]->quads.used.begin(),
+ levels[level+1]->quads.used.end(),
+ std::bind2nd (std::equal_to<bool>(), true));
+
// reserve space for the used_cells
// cells already existing on the next
// add to needed vertices how
// many vertices are already in use
- needed_vertices += count_if (vertices_used.begin(), vertices_used.end(),
- bind2nd (equal_to<bool>(), true));
+ needed_vertices += std::count_if (vertices_used.begin(), vertices_used.end(),
+ std::bind2nd (std::equal_to<bool>(), true));
// if we need more vertices: create them,
// if not: leave the array as is, since
// shrinking is not really possible because
First:
Set up an array of the 3x3 vertices, which are distributed on the cell
- (the array consists of indices into the @p{vertices} vector
+ (the array consists of indices into the @p{vertices} std::vector
- 6--5--4
- | | |
- 7--8--3
- | | |
- 0--1--2
+ 6--5--4
+ | | |
+ 7--8--3
+ | | |
+ 0--1--2
Second:
Set up an array of the new lines (the array consists of iterator pointers
into the lines arrays)
- .-5-.-4-. The directions are: .->-.->-.
- 6 9 3 ^ ^ ^
- .-10.11- . .->-.->-.
- 7 8 2 ^ ^ ^
- .-0-.-1-. .->-.->-.
+ .-5-.-4-. The directions are: .->-.->-.
+ 6 9 3 ^ ^ ^
+ .-10.11- . .->-.->-.
+ 7 8 2 ^ ^ ^
+ .-0-.-1-. .->-.->-.
Please note that since the children of line are created in the direction of
that line, the lines 4,5 and 6,7 are created in the wrong time order. This
Third:
Set up an array of neighbors:
- 5 4
- .--.--.
- 6| | |3
- .--.--.
- 7| | |2
- .--.--.
- 0 1
+ 5 4
+ .--.--.
+ 6| | |3
+ .--.--.
+ 7| | |2
+ .--.--.
+ 0 1
We need this array for two reasons: first to get the lines which will
bound the four subcells (if the neighboring cell is refined, these
Convention:
The created children are numbered like this:
- .--.--.
- |3 . 2|
- .--.--.
- |0 | 1|
- .--.--.
- */
+ .--.--.
+ |3 . 2|
+ .--.--.
+ |0 | 1|
+ .--.--.
+*/
int new_vertices[9] = {cell->vertex_index(0), -1,
cell->vertex_index(1), -1,
bool neighbor_refined=false;
if (cell->neighbor(nb).state() == valid)
if (cell->neighbor(nb)->active() == false)
- // (ask in two if-statements,
- // since otherwise both
- // conditions would be executed,
- // but the second will throw an
- // error if the first fails!)
+ // (ask in two if-statements,
+ // since otherwise both
+ // conditions would be executed,
+ // but the second will throw an
+ // error if the first fails!)
neighbor_refined=true;
if (neighbor_refined)
// two children which
// we can use.
cell_iterator neighbor = cell->neighbor(nb);
- // this cell is the nb_nb-th
- // neighbor or neighbor(nb)
+ // this cell is the nb_nb-th
+ // neighbor or neighbor(nb)
const unsigned int nb_nb = cell->neighbor_of_neighbor (nb);
neighbors_neighbor[2*nb] = neighbors_neighbor[2*nb+1] = nb_nb;
if ( face->boundary_indicator() != 255 )
{
- // boundary vertex
- new_point = boundary[face->boundary_indicator()]->
- get_new_point_on_line (face);
+ // boundary vertex
+ new_point = boundary[face->boundary_indicator()]->
+ get_new_point_on_line (face);
} else {
// vertex between two
// normal cells
new_lines[nb*2] = next_unused_line;
new_lines[nb*2]->set(Line(new_vertices[2*nb+1],
- new_vertices[2*nb]));
+ new_vertices[2*nb]));
new_lines[nb*2]->set_used_flag ();
new_lines[nb*2]->clear_children ();
new_lines[nb*2]->clear_user_pointer ();
// count number of used cells on
// the next higher level
const unsigned int used_cells
- = count_if (levels[level+1]->quads.used.begin(),
- levels[level+1]->quads.used.end(),
- bind2nd (equal_to<bool>(), true));
+ = std::count_if (levels[level+1]->quads.used.begin(),
+ levels[level+1]->quads.used.end(),
+ std::bind2nd (std::equal_to<bool>(), true));
// reserve space for the used_cells
// add to needed vertices how
// many vertices are already in use
- needed_vertices += count_if (vertices_used.begin(), vertices_used.end(),
- bind2nd (equal_to<bool>(), true));
+ needed_vertices += std::count_if (vertices_used.begin(), vertices_used.end(),
+ std::bind2nd (std::equal_to<bool>(), true));
// if we need more vertices: create them,
// if not: leave the array as is, since
// shrinking is not really possible because
line_indices[25],
line_indices[12]));
new_quads[10]->set (Quad(line_indices[25],
- line_indices[18],
- line_indices[23],
- line_indices[14]));
+ line_indices[18],
+ line_indices[23],
+ line_indices[14]));
new_quads[11]->set (Quad(line_indices[24],
- line_indices[14],
- line_indices[22],
- line_indices[2]));
+ line_indices[14],
+ line_indices[22],
+ line_indices[2]));
for (unsigned int i=0; i<12; ++i)
{
new_quads[i]->set_used_flag();
};
};
- // there is another thing here:
- // if any of the lines if refined,
- // we may not coarsen this cell.
- // this also holds true if the
- // line is not yet refined, but
- // will be
- //
- // this is not totally true,
- // since the neighbors' children
- // may also be all coarsened,
- // but we do not catch these
- // aspects here; in effect, we
- // disallow to coarsen sharp
- // edges where the refinement
- // level decreases from each cell
- // to the next
+ // there is another thing here:
+ // if any of the lines if refined,
+ // we may not coarsen this cell.
+ // this also holds true if the
+ // line is not yet refined, but
+ // will be
+ //
+ // this is not totally true,
+ // since the neighbors' children
+ // may also be all coarsened,
+ // but we do not catch these
+ // aspects here; in effect, we
+ // disallow to coarsen sharp
+ // edges where the refinement
+ // level decreases from each cell
+ // to the next
if (cell->line(line)->has_children() ||
cell->line(line)->user_flag_set())
if (cell->coarsen_flag_set())
for (unsigned int c=0; c<GeometryInfo<dim>::children_per_cell; ++c)
{
Assert (cell->child(c)->refine_flag_set()==false,
- ExcInternalError());
+ ExcInternalError());
cell->child(c)->set_coarsen_flag();
};
// save the flags to determine whether
// something was changed in the course
// of this function
- vector<bool> flags_before[2];
+ std::vector<bool> flags_before[2];
save_coarsen_flags (flags_before[0]);
save_refine_flags (flags_before[1]);
{
fix_coarsen_flags ();
- vector<bool> flags_after[2];
+ std::vector<bool> flags_after[2];
save_coarsen_flags (flags_after[0]);
save_refine_flags (flags_after[1]);
// is enough. Unfortunately, each
// loop is rather expensive, so
// we chose the way presented here
- vector<bool> flags_before_loop[2] = {flags_before[0],
- flags_before[1]};
+ std::vector<bool> flags_before_loop[2] = {flags_before[0],
+ flags_before[1]};
// now for what is done in each loop: we
// have to fulfill several tasks at the
{
// store highest level one of the cells
// adjacent to a vertex belongs to
- vector<int> vertex_level (vertices.size(), 0);
+ std::vector<int> vertex_level (vertices.size(), 0);
active_cell_iterator cell = begin_active(),
endc = end();
for (; cell!=endc; ++cell)
++vertex)
if (cell->refine_flag_set())
vertex_level[cell->vertex_index(vertex)]
- = max (vertex_level[cell->vertex_index(vertex)],
- cell->level()+1);
+ = std::max (vertex_level[cell->vertex_index(vertex)],
+ cell->level()+1);
else
vertex_level[cell->vertex_index(vertex)]
- = max (vertex_level[cell->vertex_index(vertex)],
- cell->level());
+ = std::max (vertex_level[cell->vertex_index(vertex)],
+ cell->level());
// loop over all cells in reverse
// order. do so because we can then
for (unsigned int v=0; v<GeometryInfo<dim>::vertices_per_cell;
++v)
vertex_level[cell->vertex_index(v)]
- = max (vertex_level[cell->vertex_index(v)],
- cell->level()+1);
+ = std::max (vertex_level[cell->vertex_index(v)],
+ cell->level()+1);
// now that we fixed this cell,
// we can safely leave this
// get the refinement and coarsening
// flags
- vector<bool> flags_after_loop[2];
+ std::vector<bool> flags_after_loop[2];
save_coarsen_flags (flags_after_loop[0]);
save_refine_flags (flags_after_loop[1]);
// used, is more severe and causes a memory
// leak which is probably impossible to
// find.
- const pair<line_iterator,bool> line_is_needed_pairs[12]
- = { make_pair(cell->line(0), false),
- make_pair(cell->line(1), false),
- make_pair(cell->line(2), false),
- make_pair(cell->line(3), false),
- make_pair(cell->line(4), false),
- make_pair(cell->line(5), false),
- make_pair(cell->line(6), false),
- make_pair(cell->line(7), false),
- make_pair(cell->line(8), false),
- make_pair(cell->line(9), false),
- make_pair(cell->line(10), false),
- make_pair(cell->line(11), false) };
+ const std::pair<line_iterator,bool> line_is_needed_pairs[12]
+ = { std::make_pair(cell->line(0), false),
+ std::make_pair(cell->line(1), false),
+ std::make_pair(cell->line(2), false),
+ std::make_pair(cell->line(3), false),
+ std::make_pair(cell->line(4), false),
+ std::make_pair(cell->line(5), false),
+ std::make_pair(cell->line(6), false),
+ std::make_pair(cell->line(7), false),
+ std::make_pair(cell->line(8), false),
+ std::make_pair(cell->line(9), false),
+ std::make_pair(cell->line(10), false),
+ std::make_pair(cell->line(11), false) };
// if in debug mode: make sure that
// none of the lines of this cell is
// twice refined; else, deleting this
// next make a map out of this for simpler
// access to the flag associated with a
// line
- map<line_iterator,bool> line_is_needed (&line_is_needed_pairs[0],
- &line_is_needed_pairs[12]);
+ std::map<line_iterator,bool> line_is_needed (&line_is_needed_pairs[0],
+ &line_is_needed_pairs[12]);
// then ask each neighbor and their neighbors
for (unsigned int nb=0; nb<GeometryInfo<dim>::faces_per_cell; ++nb)
{
const cell_iterator neighbor = cell->neighbor(nb);
- // do nothing if at boundary
+ // do nothing if at boundary
if (neighbor.state() != valid)
continue;
// now, if the lines are not marked as
// needed, we may delete their children
// and the midpoint
- map<line_iterator,bool>::iterator line_and_flag;
+ std::map<line_iterator,bool>::iterator line_and_flag;
for (line_and_flag=line_is_needed.begin();
line_and_flag!=line_is_needed.end(); ++line_and_flag)
if (line_and_flag->second == false)
template <int dim>
void Triangulation<dim>::write_bool_vector (const unsigned int magic_number1,
- const vector<bool> &v,
+ const std::vector<bool> &v,
const unsigned int magic_number2,
- ostream &out) {
+ std::ostream &out) {
const unsigned int N = v.size();
unsigned char *flags = new unsigned char[N/8+1];
for (unsigned int i=0; i<N/8+1; ++i) flags[i]=0;
// 1. number of flags
// 2. the flags
// 3. magic number
- out << magic_number1 << ' ' << N << endl;
+ out << magic_number1 << ' ' << N << std::endl;
for (unsigned int i=0; i<N/8+1; ++i)
out << static_cast<unsigned int>(flags[i]) << ' ';
- out << endl << magic_number2 << endl;
+ out << std::endl << magic_number2 << std::endl;
delete[] flags;
template <int dim>
void Triangulation<dim>::read_bool_vector (const unsigned int magic_number1,
- vector<bool> &v,
+ std::vector<bool> &v,
const unsigned int magic_number2,
- istream &in) {
+ std::istream &in) {
AssertThrow (in, ExcIO());
unsigned int magic_number;
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
template <int dim>
double TriaObjectAccessor<2, dim>::diameter () const
{
- return sqrt(max((vertex(2)-vertex(0)).square(),
- (vertex(3)-vertex(1)).square()));
+ return sqrt(std::max((vertex(2)-vertex(0)).square(),
+ (vertex(3)-vertex(1)).square()));
};
|K| = \int_K 1 dx dy = \int_{\hat K} |det J| d(xi) d(eta)
and that the barycenter is given by
\vec x_s = 1/|K| \int_K \vec x dx dy
- = 1/|K| \int_{\hat K} \vec x(xi,eta) |det J| d(xi) d(eta)
+ = 1/|K| \int_{\hat K} \vec x(xi,eta) |det J| d(xi) d(eta)
# x and y are arrays holding the x- and y-values of the four vertices
# of this cell in real space.
an area element in real space; this equals the Jacobian determinant
at this point, then. To do so, find out the points in real space
belonging to
- xi,eta
- xi+dxi, eta
- xi, eta+deta
+ xi,eta
+ xi+dxi, eta
+ xi, eta+deta
To this end, remember that the mapping is
- x(xi,eta) = \sum_i=0^3 x_i phi_i(xi,eta)
- y(xi,eta) = \sum_i=0^3 y_i phi_i(xi,eta)
- z(xi,eta) = \sum_i=0^3 z_i phi_i(xi,eta)
+ x(xi,eta) = \sum_i=0^3 x_i phi_i(xi,eta)
+ y(xi,eta) = \sum_i=0^3 y_i phi_i(xi,eta)
+ z(xi,eta) = \sum_i=0^3 z_i phi_i(xi,eta)
with x_i, y_i being the four vertices and the phi_i the shape functions
corresponding to these four vertices of this face. Now the real space
points belonging to the above points on the unit face are:
- x, y, z
- x+sum x_i \partial_xi phi_i(xi,eta) dxi,
- y+sum y_i \partial_xi phi_i(xi,eta) dxi,
- z+sum z_i \partial_xi phi_i(xi,eta) dxi
- x+sum x_i \partial_eta phi_i(xi,eta) deta,
- y+sum y_i \partial_eta phi_i(xi,eta) deta,
- z+sum z_i \partial_eta phi_i(xi,eta) deta
+ x, y, z
+ x+sum x_i \partial_xi phi_i(xi,eta) dxi,
+ y+sum y_i \partial_xi phi_i(xi,eta) dxi,
+ z+sum z_i \partial_xi phi_i(xi,eta) dxi
+ x+sum x_i \partial_eta phi_i(xi,eta) deta,
+ y+sum y_i \partial_eta phi_i(xi,eta) deta,
+ z+sum z_i \partial_eta phi_i(xi,eta) deta
The unit infinitesimal vectors at the point xi,eta have the direction
- dxi, 0
- 0, deta
+ dxi, 0
+ 0, deta
and are therefore in real space
- sum x_i \partial_xi phi_i(xi,eta) dxi,
- sum y_i \partial_xi phi_i(xi,eta) dxi,
- sum z_i \partial_xi phi_i(xi,eta) dxi
- sum x_i \partial_eta phi_i(xi,eta) deta,
- sum y_i \partial_eta phi_i(xi,eta) deta
- sum z_i \partial_eta phi_i(xi,eta) deta
+ sum x_i \partial_xi phi_i(xi,eta) dxi,
+ sum y_i \partial_xi phi_i(xi,eta) dxi,
+ sum z_i \partial_xi phi_i(xi,eta) dxi
+ sum x_i \partial_eta phi_i(xi,eta) deta,
+ sum y_i \partial_eta phi_i(xi,eta) deta
+ sum z_i \partial_eta phi_i(xi,eta) deta
or in other form:
- \partial_xi (x,y,z) dxi
- \partial_eta (x,y,z) deta
+ \partial_xi (x,y,z) dxi
+ \partial_eta (x,y,z) deta
Then the area element is the length of the cross-product of these two vectors and
the Jacobian determinant is this expression divided by dxi deta:
- |J| = |(\partial_xi (x,y,z) \times (\partial_eta (x,y,z)|
+ |J| = |(\partial_xi (x,y,z) \times (\partial_eta (x,y,z)|
There is a script in the deal.II/source/fe/scripts/3d directory, which does
these computations in Maple.
template <int dim>
double TriaObjectAccessor<3, dim>::diameter () const
{
- return sqrt(max( max((vertex(6)-vertex(0)).square(),
- (vertex(7)-vertex(1)).square()),
- max((vertex(4)-vertex(2)).square(),
- (vertex(5)-vertex(3)).square()) ));
+ return sqrt(std::max( std::max((vertex(6)-vertex(0)).square(),
+ (vertex(7)-vertex(1)).square()),
+ std::max((vertex(4)-vertex(2)).square(),
+ (vertex(5)-vertex(3)).square()) ));
};
|K| = \int_K 1 dx dy dz = \int_{\hat K} |det J| d(xi) d(eta) d(zeta)
and that the barycenter is given by
\vec x_s = 1/|K| \int_K \vec x dx dy dz
- = 1/|K| \int_{\hat K} \vec x(xi,eta,zeta) |det J| d(xi) d(eta) d(zeta)
+ = 1/|K| \int_{\hat K} \vec x(xi,eta,zeta) |det J| d(xi) d(eta) d(zeta)
# x, y and z are arrays holding the x-, y- and z-values of the four vertices
# of this cell in real space.
z_real := sum(z[s]*tphi[s], s=0..7):
with (linalg):
J := matrix(3,3, [[diff(x_real, xi), diff(x_real, eta), diff(x_real, zeta)],
- [diff(y_real, xi), diff(y_real, eta), diff(y_real, zeta)],
- [diff(z_real, xi), diff(z_real, eta), diff(z_real, zeta)]]):
+ [diff(y_real, xi), diff(y_real, eta), diff(y_real, zeta)],
+ [diff(z_real, xi), diff(z_real, eta), diff(z_real, zeta)]]):
detJ := det (J):
measure := simplify ( int ( int ( int (detJ, xi=0..1), eta=0..1), zeta=0..1)):
s1 = 1.0/6.0;
s8 = -x[2]*x[2]*y[0]*z[3]-2.0*z[6]*x[7]*x[7]*y[4]-z[5]*x[7]*x[7]*y[4]-z
-[6]*x[7]*x[7]*y[5]+2.0*y[6]*x[7]*x[7]*z[4]-z[5]*x[6]*x[6]*y[4]+x[6]*x[6]*y[4]*z
-[7]-z[1]*x[0]*x[0]*y[2]-x[6]*x[6]*y[7]*z[4]+2.0*x[6]*x[6]*y[5]*z[7]-2.0*x[6]*x
-[6]*y[7]*z[5]+y[5]*x[6]*x[6]*z[4]+2.0*x[5]*x[5]*y[4]*z[6]+x[0]*x[0]*y[7]*z[4]
--2.0*x[5]*x[5]*y[6]*z[4];
+ [6]*x[7]*x[7]*y[5]+2.0*y[6]*x[7]*x[7]*z[4]-z[5]*x[6]*x[6]*y[4]+x[6]*x[6]*y[4]*z
+ [7]-z[1]*x[0]*x[0]*y[2]-x[6]*x[6]*y[7]*z[4]+2.0*x[6]*x[6]*y[5]*z[7]-2.0*x[6]*x
+ [6]*y[7]*z[5]+y[5]*x[6]*x[6]*z[4]+2.0*x[5]*x[5]*y[4]*z[6]+x[0]*x[0]*y[7]*z[4]
+ -2.0*x[5]*x[5]*y[6]*z[4];
s7 = s8-y[6]*x[5]*x[5]*z[7]+z[6]*x[5]*x[5]*y[7]-y[1]*x[0]*x[0]*z[5]+x[7]*
-z[5]*x[4]*y[7]-x[7]*y[6]*x[5]*z[7]-2.0*x[7]*x[6]*y[7]*z[4]+2.0*x[7]*x[6]*y[4]*z
-[7]-x[7]*x[5]*y[7]*z[4]-2.0*x[7]*y[6]*x[4]*z[7]-x[7]*y[5]*x[4]*z[7]+x[2]*x[2]*y
-[3]*z[0]-x[7]*x[6]*y[7]*z[5]+x[7]*x[6]*y[5]*z[7]+2.0*x[1]*x[1]*y[0]*z[5]+x[7]*z
-[6]*x[5]*y[7];
+ z[5]*x[4]*y[7]-x[7]*y[6]*x[5]*z[7]-2.0*x[7]*x[6]*y[7]*z[4]+2.0*x[7]*x[6]*y[4]*z
+ [7]-x[7]*x[5]*y[7]*z[4]-2.0*x[7]*y[6]*x[4]*z[7]-x[7]*y[5]*x[4]*z[7]+x[2]*x[2]*y
+ [3]*z[0]-x[7]*x[6]*y[7]*z[5]+x[7]*x[6]*y[5]*z[7]+2.0*x[1]*x[1]*y[0]*z[5]+x[7]*z
+ [6]*x[5]*y[7];
s8 = -2.0*x[1]*x[1]*y[5]*z[0]+z[1]*x[0]*x[0]*y[5]+2.0*x[2]*x[2]*y[3]*z[1]
--z[5]*x[4]*x[4]*y[1]+y[5]*x[4]*x[4]*z[1]-2.0*x[5]*x[5]*y[4]*z[1]+2.0*x[5]*x[5]*
-y[1]*z[4]-2.0*x[2]*x[2]*y[1]*z[3]-y[1]*x[2]*x[2]*z[0]+x[7]*y[2]*x[3]*z[7]+x[7]*
-z[2]*x[6]*y[3]+2.0*x[7]*z[6]*x[4]*y[7]+z[5]*x[1]*x[1]*y[4]+z[1]*x[2]*x[2]*y[0]
--2.0*y[0]*x[3]*x[3]*z[7];
+ -z[5]*x[4]*x[4]*y[1]+y[5]*x[4]*x[4]*z[1]-2.0*x[5]*x[5]*y[4]*z[1]+2.0*x[5]*x[5]*
+ y[1]*z[4]-2.0*x[2]*x[2]*y[1]*z[3]-y[1]*x[2]*x[2]*z[0]+x[7]*y[2]*x[3]*z[7]+x[7]*
+ z[2]*x[6]*y[3]+2.0*x[7]*z[6]*x[4]*y[7]+z[5]*x[1]*x[1]*y[4]+z[1]*x[2]*x[2]*y[0]
+ -2.0*y[0]*x[3]*x[3]*z[7];
s6 = s8+2.0*z[0]*x[3]*x[3]*y[7]-x[7]*x[2]*y[3]*z[7]-x[7]*z[2]*x[3]*y[7]+x
-[7]*x[2]*y[7]*z[3]-x[7]*y[2]*x[6]*z[3]+x[4]*x[5]*y[1]*z[4]-x[4]*x[5]*y[4]*z[1]+
-x[4]*z[5]*x[1]*y[4]-x[4]*y[5]*x[1]*z[4]-2.0*x[5]*z[5]*x[4]*y[1]-2.0*x[5]*y[5]*x
-[1]*z[4]+2.0*x[5]*z[5]*x[1]*y[4]+2.0*x[5]*y[5]*x[4]*z[1]-x[6]*z[5]*x[7]*y[4]-z
-[2]*x[3]*x[3]*y[6]+s7;
+ [7]*x[2]*y[7]*z[3]-x[7]*y[2]*x[6]*z[3]+x[4]*x[5]*y[1]*z[4]-x[4]*x[5]*y[4]*z[1]+
+ x[4]*z[5]*x[1]*y[4]-x[4]*y[5]*x[1]*z[4]-2.0*x[5]*z[5]*x[4]*y[1]-2.0*x[5]*y[5]*x
+ [1]*z[4]+2.0*x[5]*z[5]*x[1]*y[4]+2.0*x[5]*y[5]*x[4]*z[1]-x[6]*z[5]*x[7]*y[4]-z
+ [2]*x[3]*x[3]*y[6]+s7;
s8 = -2.0*x[6]*z[6]*x[7]*y[5]-x[6]*y[6]*x[4]*z[7]+y[2]*x[3]*x[3]*z[6]+x
-[6]*y[6]*x[7]*z[4]+2.0*y[2]*x[3]*x[3]*z[7]+x[0]*x[1]*y[0]*z[5]+x[0]*y[1]*x[5]*z
-[0]-x[0]*z[1]*x[5]*y[0]-2.0*z[2]*x[3]*x[3]*y[7]+2.0*x[6]*z[6]*x[5]*y[7]-x[0]*x
-[1]*y[5]*z[0]-x[6]*y[5]*x[4]*z[6]-2.0*x[3]*z[0]*x[7]*y[3]-x[6]*z[6]*x[7]*y[4]
--2.0*x[1]*z[1]*x[5]*y[0];
+ [6]*y[6]*x[7]*z[4]+2.0*y[2]*x[3]*x[3]*z[7]+x[0]*x[1]*y[0]*z[5]+x[0]*y[1]*x[5]*z
+ [0]-x[0]*z[1]*x[5]*y[0]-2.0*z[2]*x[3]*x[3]*y[7]+2.0*x[6]*z[6]*x[5]*y[7]-x[0]*x
+ [1]*y[5]*z[0]-x[6]*y[5]*x[4]*z[6]-2.0*x[3]*z[0]*x[7]*y[3]-x[6]*z[6]*x[7]*y[4]
+ -2.0*x[1]*z[1]*x[5]*y[0];
s7 = s8+2.0*x[1]*y[1]*x[5]*z[0]+2.0*x[1]*z[1]*x[0]*y[5]+2.0*x[3]*y[0]*x
-[7]*z[3]+2.0*x[3]*x[0]*y[3]*z[7]-2.0*x[3]*x[0]*y[7]*z[3]-2.0*x[1]*y[1]*x[0]*z
-[5]-2.0*x[6]*y[6]*x[5]*z[7]+s6-y[5]*x[1]*x[1]*z[4]+x[6]*z[6]*x[4]*y[7]-2.0*x[2]
-*y[2]*x[3]*z[1]+x[6]*z[5]*x[4]*y[6]+x[6]*x[5]*y[4]*z[6]-y[6]*x[7]*x[7]*z[2]-x
-[6]*x[5]*y[6]*z[4];
+ [7]*z[3]+2.0*x[3]*x[0]*y[3]*z[7]-2.0*x[3]*x[0]*y[7]*z[3]-2.0*x[1]*y[1]*x[0]*z
+ [5]-2.0*x[6]*y[6]*x[5]*z[7]+s6-y[5]*x[1]*x[1]*z[4]+x[6]*z[6]*x[4]*y[7]-2.0*x[2]
+ *y[2]*x[3]*z[1]+x[6]*z[5]*x[4]*y[6]+x[6]*x[5]*y[4]*z[6]-y[6]*x[7]*x[7]*z[2]-x
+ [6]*x[5]*y[6]*z[4];
s8 = x[3]*x[3]*y[7]*z[4]-2.0*y[6]*x[7]*x[7]*z[3]+z[6]*x[7]*x[7]*y[2]+2.0*
-z[6]*x[7]*x[7]*y[3]+2.0*y[1]*x[0]*x[0]*z[3]+2.0*x[0]*x[1]*y[3]*z[0]-2.0*x[0]*y
-[0]*x[3]*z[4]-2.0*x[0]*z[1]*x[4]*y[0]-2.0*x[0]*y[1]*x[3]*z[0]+2.0*x[0]*y[0]*x
-[4]*z[3]-2.0*x[0]*z[0]*x[4]*y[3]+2.0*x[0]*x[1]*y[0]*z[4]+2.0*x[0]*z[1]*x[3]*y
-[0]-2.0*x[0]*x[1]*y[0]*z[3]-2.0*x[0]*x[1]*y[4]*z[0]+2.0*x[0]*y[1]*x[4]*z[0];
+ z[6]*x[7]*x[7]*y[3]+2.0*y[1]*x[0]*x[0]*z[3]+2.0*x[0]*x[1]*y[3]*z[0]-2.0*x[0]*y
+ [0]*x[3]*z[4]-2.0*x[0]*z[1]*x[4]*y[0]-2.0*x[0]*y[1]*x[3]*z[0]+2.0*x[0]*y[0]*x
+ [4]*z[3]-2.0*x[0]*z[0]*x[4]*y[3]+2.0*x[0]*x[1]*y[0]*z[4]+2.0*x[0]*z[1]*x[3]*y
+ [0]-2.0*x[0]*x[1]*y[0]*z[3]-2.0*x[0]*x[1]*y[4]*z[0]+2.0*x[0]*y[1]*x[4]*z[0];
s5 = s8+2.0*x[0]*z[0]*x[3]*y[4]+x[1]*y[1]*x[0]*z[3]-x[1]*z[1]*x[4]*y[0]-x
-[1]*y[1]*x[0]*z[4]+x[1]*z[1]*x[0]*y[4]-x[1]*y[1]*x[3]*z[0]-x[1]*z[1]*x[0]*y[3]-
-x[0]*z[5]*x[4]*y[1]+x[0]*y[5]*x[4]*z[1]-2.0*x[4]*x[0]*y[4]*z[7]-2.0*x[4]*y[5]*x
-[0]*z[4]+2.0*x[4]*z[5]*x[0]*y[4]-2.0*x[4]*x[5]*y[4]*z[0]-2.0*x[4]*y[0]*x[7]*z
-[4]-x[5]*y[5]*x[0]*z[4]+s7;
+ [1]*y[1]*x[0]*z[4]+x[1]*z[1]*x[0]*y[4]-x[1]*y[1]*x[3]*z[0]-x[1]*z[1]*x[0]*y[3]-
+ x[0]*z[5]*x[4]*y[1]+x[0]*y[5]*x[4]*z[1]-2.0*x[4]*x[0]*y[4]*z[7]-2.0*x[4]*y[5]*x
+ [0]*z[4]+2.0*x[4]*z[5]*x[0]*y[4]-2.0*x[4]*x[5]*y[4]*z[0]-2.0*x[4]*y[0]*x[7]*z
+ [4]-x[5]*y[5]*x[0]*z[4]+s7;
s8 = x[5]*z[5]*x[0]*y[4]-x[5]*z[5]*x[4]*y[0]+x[1]*z[5]*x[0]*y[4]+x[5]*y
-[5]*x[4]*z[0]-x[0]*y[0]*x[7]*z[4]-x[0]*z[5]*x[4]*y[0]-x[1]*y[5]*x[0]*z[4]+x[0]*
-z[0]*x[7]*y[4]+x[0]*y[5]*x[4]*z[0]-x[0]*z[0]*x[4]*y[7]+x[0]*x[5]*y[0]*z[4]+x[0]
-*y[0]*x[4]*z[7]-x[0]*x[5]*y[4]*z[0]-x[3]*x[3]*y[4]*z[7]+2.0*x[2]*z[2]*x[3]*y[1]
-;
+ [5]*x[4]*z[0]-x[0]*y[0]*x[7]*z[4]-x[0]*z[5]*x[4]*y[0]-x[1]*y[5]*x[0]*z[4]+x[0]*
+ z[0]*x[7]*y[4]+x[0]*y[5]*x[4]*z[0]-x[0]*z[0]*x[4]*y[7]+x[0]*x[5]*y[0]*z[4]+x[0]
+ *y[0]*x[4]*z[7]-x[0]*x[5]*y[4]*z[0]-x[3]*x[3]*y[4]*z[7]+2.0*x[2]*z[2]*x[3]*y[1]
+ ;
s7 = s8-x[5]*x[5]*y[4]*z[0]+2.0*y[5]*x[4]*x[4]*z[0]-2.0*z[0]*x[4]*x[4]*y
-[7]+2.0*y[0]*x[4]*x[4]*z[7]-2.0*z[5]*x[4]*x[4]*y[0]+x[5]*x[5]*y[4]*z[7]-x[5]*x
-[5]*y[7]*z[4]-2.0*y[5]*x[4]*x[4]*z[7]+2.0*z[5]*x[4]*x[4]*y[7]-x[0]*x[0]*y[7]*z
-[3]+y[2]*x[0]*x[0]*z[3]+x[0]*x[0]*y[3]*z[7]-x[5]*x[1]*y[4]*z[0]+x[5]*y[1]*x[4]*
-z[0]-x[4]*y[0]*x[3]*z[4];
+ [7]+2.0*y[0]*x[4]*x[4]*z[7]-2.0*z[5]*x[4]*x[4]*y[0]+x[5]*x[5]*y[4]*z[7]-x[5]*x
+ [5]*y[7]*z[4]-2.0*y[5]*x[4]*x[4]*z[7]+2.0*z[5]*x[4]*x[4]*y[7]-x[0]*x[0]*y[7]*z
+ [3]+y[2]*x[0]*x[0]*z[3]+x[0]*x[0]*y[3]*z[7]-x[5]*x[1]*y[4]*z[0]+x[5]*y[1]*x[4]*
+ z[0]-x[4]*y[0]*x[3]*z[4];
s8 = -x[4]*y[1]*x[0]*z[4]+x[4]*z[1]*x[0]*y[4]+x[4]*x[0]*y[3]*z[4]-x[4]*x
-[0]*y[4]*z[3]+x[4]*x[1]*y[0]*z[4]-x[4]*x[1]*y[4]*z[0]+x[4]*z[0]*x[3]*y[4]+x[5]*
-x[1]*y[0]*z[4]+x[1]*z[1]*x[3]*y[0]+x[1]*y[1]*x[4]*z[0]-x[5]*z[1]*x[4]*y[0]-2.0*
-y[1]*x[0]*x[0]*z[4]+2.0*z[1]*x[0]*x[0]*y[4]+2.0*x[0]*x[0]*y[3]*z[4]-2.0*z[1]*x
-[0]*x[0]*y[3];
+ [0]*y[4]*z[3]+x[4]*x[1]*y[0]*z[4]-x[4]*x[1]*y[4]*z[0]+x[4]*z[0]*x[3]*y[4]+x[5]*
+ x[1]*y[0]*z[4]+x[1]*z[1]*x[3]*y[0]+x[1]*y[1]*x[4]*z[0]-x[5]*z[1]*x[4]*y[0]-2.0*
+ y[1]*x[0]*x[0]*z[4]+2.0*z[1]*x[0]*x[0]*y[4]+2.0*x[0]*x[0]*y[3]*z[4]-2.0*z[1]*x
+ [0]*x[0]*y[3];
s6 = s8-2.0*x[0]*x[0]*y[4]*z[3]+x[1]*x[1]*y[3]*z[0]+x[1]*x[1]*y[0]*z[4]-x
-[1]*x[1]*y[0]*z[3]-x[1]*x[1]*y[4]*z[0]-z[1]*x[4]*x[4]*y[0]+y[0]*x[4]*x[4]*z[3]-
-z[0]*x[4]*x[4]*y[3]+y[1]*x[4]*x[4]*z[0]-x[0]*x[0]*y[4]*z[7]-y[5]*x[0]*x[0]*z[4]
-+z[5]*x[0]*x[0]*y[4]+x[5]*x[5]*y[0]*z[4]-x[0]*y[0]*x[3]*z[7]+x[0]*z[0]*x[3]*y
-[7]+s7;
+ [1]*x[1]*y[0]*z[3]-x[1]*x[1]*y[4]*z[0]-z[1]*x[4]*x[4]*y[0]+y[0]*x[4]*x[4]*z[3]-
+ z[0]*x[4]*x[4]*y[3]+y[1]*x[4]*x[4]*z[0]-x[0]*x[0]*y[4]*z[7]-y[5]*x[0]*x[0]*z[4]
+ +z[5]*x[0]*x[0]*y[4]+x[5]*x[5]*y[0]*z[4]-x[0]*y[0]*x[3]*z[7]+x[0]*z[0]*x[3]*y
+ [7]+s7;
s8 = s6+x[0]*x[2]*y[3]*z[0]-x[0]*x[2]*y[0]*z[3]+x[0]*y[0]*x[7]*z[3]-x[0]*
-y[2]*x[3]*z[0]+x[0]*z[2]*x[3]*y[0]-x[0]*z[0]*x[7]*y[3]+x[1]*x[2]*y[3]*z[0]-z[2]
-*x[0]*x[0]*y[3]+x[3]*z[2]*x[6]*y[3]-x[3]*x[2]*y[3]*z[6]+x[3]*x[2]*y[6]*z[3]-x
-[3]*y[2]*x[6]*z[3]-2.0*x[3]*y[2]*x[7]*z[3]+2.0*x[3]*z[2]*x[7]*y[3];
+ y[2]*x[3]*z[0]+x[0]*z[2]*x[3]*y[0]-x[0]*z[0]*x[7]*y[3]+x[1]*x[2]*y[3]*z[0]-z[2]
+ *x[0]*x[0]*y[3]+x[3]*z[2]*x[6]*y[3]-x[3]*x[2]*y[3]*z[6]+x[3]*x[2]*y[6]*z[3]-x
+ [3]*y[2]*x[6]*z[3]-2.0*x[3]*y[2]*x[7]*z[3]+2.0*x[3]*z[2]*x[7]*y[3];
s7 = s8+2.0*x[4]*y[5]*x[7]*z[4]+2.0*x[4]*x[5]*y[4]*z[7]-2.0*x[4]*z[5]*x
-[7]*y[4]-2.0*x[4]*x[5]*y[7]*z[4]+x[5]*y[5]*x[7]*z[4]-x[5]*z[5]*x[7]*y[4]-x[5]*y
-[5]*x[4]*z[7]+x[5]*z[5]*x[4]*y[7]+2.0*x[3]*x[2]*y[7]*z[3]-2.0*x[2]*z[2]*x[1]*y
-[3]+2.0*x[4]*z[0]*x[7]*y[4]+2.0*x[4]*x[0]*y[7]*z[4]+2.0*x[4]*x[5]*y[0]*z[4]-x
-[7]*x[6]*y[2]*z[7]-2.0*x[3]*x[2]*y[3]*z[7]-x[0]*x[4]*y[7]*z[3];
+ [7]*y[4]-2.0*x[4]*x[5]*y[7]*z[4]+x[5]*y[5]*x[7]*z[4]-x[5]*z[5]*x[7]*y[4]-x[5]*y
+ [5]*x[4]*z[7]+x[5]*z[5]*x[4]*y[7]+2.0*x[3]*x[2]*y[7]*z[3]-2.0*x[2]*z[2]*x[1]*y
+ [3]+2.0*x[4]*z[0]*x[7]*y[4]+2.0*x[4]*x[0]*y[7]*z[4]+2.0*x[4]*x[5]*y[0]*z[4]-x
+ [7]*x[6]*y[2]*z[7]-2.0*x[3]*x[2]*y[3]*z[7]-x[0]*x[4]*y[7]*z[3];
s8 = x[0]*x[3]*y[7]*z[4]-x[0]*x[3]*y[4]*z[7]+x[0]*x[4]*y[3]*z[7]-2.0*x[7]
-*z[6]*x[3]*y[7]+x[3]*x[7]*y[4]*z[3]-x[3]*x[4]*y[7]*z[3]-x[3]*x[7]*y[3]*z[4]+x
-[3]*x[4]*y[3]*z[7]+2.0*x[2]*y[2]*x[1]*z[3]+y[6]*x[3]*x[3]*z[7]-z[6]*x[3]*x[3]*y
-[7]-x[1]*z[5]*x[4]*y[1]-x[1]*x[5]*y[4]*z[1]-x[1]*z[2]*x[0]*y[3]-x[1]*x[2]*y[0]*
-z[3]+x[1]*y[2]*x[0]*z[3];
+ *z[6]*x[3]*y[7]+x[3]*x[7]*y[4]*z[3]-x[3]*x[4]*y[7]*z[3]-x[3]*x[7]*y[3]*z[4]+x
+ [3]*x[4]*y[3]*z[7]+2.0*x[2]*y[2]*x[1]*z[3]+y[6]*x[3]*x[3]*z[7]-z[6]*x[3]*x[3]*y
+ [7]-x[1]*z[5]*x[4]*y[1]-x[1]*x[5]*y[4]*z[1]-x[1]*z[2]*x[0]*y[3]-x[1]*x[2]*y[0]*
+ z[3]+x[1]*y[2]*x[0]*z[3];
s4 = s8+x[1]*x[5]*y[1]*z[4]+x[1]*y[5]*x[4]*z[1]+x[4]*y[0]*x[7]*z[3]-x[4]*
-z[0]*x[7]*y[3]-x[4]*x[4]*y[7]*z[3]+x[4]*x[4]*y[3]*z[7]+x[3]*z[6]*x[7]*y[3]-x[3]
-*x[6]*y[3]*z[7]+x[3]*x[6]*y[7]*z[3]-x[3]*z[6]*x[2]*y[7]-x[3]*y[6]*x[7]*z[3]+x
-[3]*z[6]*x[7]*y[2]+x[3]*y[6]*x[2]*z[7]+2.0*x[5]*z[5]*x[4]*y[6]+s5+s7;
+ z[0]*x[7]*y[3]-x[4]*x[4]*y[7]*z[3]+x[4]*x[4]*y[3]*z[7]+x[3]*z[6]*x[7]*y[3]-x[3]
+ *x[6]*y[3]*z[7]+x[3]*x[6]*y[7]*z[3]-x[3]*z[6]*x[2]*y[7]-x[3]*y[6]*x[7]*z[3]+x
+ [3]*z[6]*x[7]*y[2]+x[3]*y[6]*x[2]*z[7]+2.0*x[5]*z[5]*x[4]*y[6]+s5+s7;
s8 = s4-2.0*x[5]*z[5]*x[6]*y[4]-x[5]*z[6]*x[7]*y[5]+x[5]*x[6]*y[5]*z[7]-x
-[5]*x[6]*y[7]*z[5]-2.0*x[5]*y[5]*x[4]*z[6]+2.0*x[5]*y[5]*x[6]*z[4]-x[3]*y[6]*x
-[7]*z[2]+x[4]*x[7]*y[4]*z[3]+x[4]*x[3]*y[7]*z[4]-x[4]*x[7]*y[3]*z[4]-x[4]*x[3]*
-y[4]*z[7]-z[1]*x[5]*x[5]*y[0]+y[1]*x[5]*x[5]*z[0]+x[4]*y[6]*x[7]*z[4];
+ [5]*x[6]*y[7]*z[5]-2.0*x[5]*y[5]*x[4]*z[6]+2.0*x[5]*y[5]*x[6]*z[4]-x[3]*y[6]*x
+ [7]*z[2]+x[4]*x[7]*y[4]*z[3]+x[4]*x[3]*y[7]*z[4]-x[4]*x[7]*y[3]*z[4]-x[4]*x[3]*
+ y[4]*z[7]-z[1]*x[5]*x[5]*y[0]+y[1]*x[5]*x[5]*z[0]+x[4]*y[6]*x[7]*z[4];
s7 = s8-x[4]*x[6]*y[7]*z[4]+x[4]*x[6]*y[4]*z[7]-x[4]*z[6]*x[7]*y[4]-x[5]*
-y[6]*x[4]*z[7]-x[5]*x[6]*y[7]*z[4]+x[5]*x[6]*y[4]*z[7]+x[5]*z[6]*x[4]*y[7]-y[6]
-*x[4]*x[4]*z[7]+z[6]*x[4]*x[4]*y[7]+x[7]*x[5]*y[4]*z[7]-y[2]*x[7]*x[7]*z[3]+z
-[2]*x[7]*x[7]*y[3]-y[0]*x[3]*x[3]*z[4]-y[1]*x[3]*x[3]*z[0]+z[1]*x[3]*x[3]*y[0];
+ y[6]*x[4]*z[7]-x[5]*x[6]*y[7]*z[4]+x[5]*x[6]*y[4]*z[7]+x[5]*z[6]*x[4]*y[7]-y[6]
+ *x[4]*x[4]*z[7]+z[6]*x[4]*x[4]*y[7]+x[7]*x[5]*y[4]*z[7]-y[2]*x[7]*x[7]*z[3]+z
+ [2]*x[7]*x[7]*y[3]-y[0]*x[3]*x[3]*z[4]-y[1]*x[3]*x[3]*z[0]+z[1]*x[3]*x[3]*y[0];
s8 = z[0]*x[3]*x[3]*y[4]-x[2]*y[1]*x[3]*z[0]+x[2]*z[1]*x[3]*y[0]+x[3]*y
-[1]*x[0]*z[3]+x[3]*x[1]*y[3]*z[0]+x[3]*x[0]*y[3]*z[4]-x[3]*z[1]*x[0]*y[3]-x[3]*
-x[0]*y[4]*z[3]+x[3]*y[0]*x[4]*z[3]-x[3]*z[0]*x[4]*y[3]-x[3]*x[1]*y[0]*z[3]+x[3]
-*z[0]*x[7]*y[4]-x[3]*y[0]*x[7]*z[4]+z[0]*x[7]*x[7]*y[4]-y[0]*x[7]*x[7]*z[4];
+ [1]*x[0]*z[3]+x[3]*x[1]*y[3]*z[0]+x[3]*x[0]*y[3]*z[4]-x[3]*z[1]*x[0]*y[3]-x[3]*
+ x[0]*y[4]*z[3]+x[3]*y[0]*x[4]*z[3]-x[3]*z[0]*x[4]*y[3]-x[3]*x[1]*y[0]*z[3]+x[3]
+ *z[0]*x[7]*y[4]-x[3]*y[0]*x[7]*z[4]+z[0]*x[7]*x[7]*y[4]-y[0]*x[7]*x[7]*z[4];
s6 = s8+y[1]*x[0]*x[0]*z[2]-2.0*y[2]*x[3]*x[3]*z[0]+2.0*z[2]*x[3]*x[3]*y
-[0]-2.0*x[1]*x[1]*y[0]*z[2]+2.0*x[1]*x[1]*y[2]*z[0]-y[2]*x[3]*x[3]*z[1]+z[2]*x
-[3]*x[3]*y[1]-y[5]*x[4]*x[4]*z[6]+z[5]*x[4]*x[4]*y[6]+x[7]*x[0]*y[7]*z[4]-x[7]*
-z[0]*x[4]*y[7]-x[7]*x[0]*y[4]*z[7]+x[7]*y[0]*x[4]*z[7]-x[0]*x[1]*y[0]*z[2]+x[0]
-*z[1]*x[2]*y[0]+s7;
+ [0]-2.0*x[1]*x[1]*y[0]*z[2]+2.0*x[1]*x[1]*y[2]*z[0]-y[2]*x[3]*x[3]*z[1]+z[2]*x
+ [3]*x[3]*y[1]-y[5]*x[4]*x[4]*z[6]+z[5]*x[4]*x[4]*y[6]+x[7]*x[0]*y[7]*z[4]-x[7]*
+ z[0]*x[4]*y[7]-x[7]*x[0]*y[4]*z[7]+x[7]*y[0]*x[4]*z[7]-x[0]*x[1]*y[0]*z[2]+x[0]
+ *z[1]*x[2]*y[0]+s7;
s8 = s6+x[0]*x[1]*y[2]*z[0]-x[0]*y[1]*x[2]*z[0]-x[3]*z[1]*x[0]*y[2]+2.0*x
-[3]*x[2]*y[3]*z[0]+y[0]*x[7]*x[7]*z[3]-z[0]*x[7]*x[7]*y[3]-2.0*x[3]*z[2]*x[0]*y
-[3]-2.0*x[3]*x[2]*y[0]*z[3]+2.0*x[3]*y[2]*x[0]*z[3]+x[3]*x[2]*y[3]*z[1]-x[3]*x
-[2]*y[1]*z[3]-x[5]*y[1]*x[0]*z[5]+x[3]*y[1]*x[0]*z[2]+x[4]*y[6]*x[7]*z[5];
+ [3]*x[2]*y[3]*z[0]+y[0]*x[7]*x[7]*z[3]-z[0]*x[7]*x[7]*y[3]-2.0*x[3]*z[2]*x[0]*y
+ [3]-2.0*x[3]*x[2]*y[0]*z[3]+2.0*x[3]*y[2]*x[0]*z[3]+x[3]*x[2]*y[3]*z[1]-x[3]*x
+ [2]*y[1]*z[3]-x[5]*y[1]*x[0]*z[5]+x[3]*y[1]*x[0]*z[2]+x[4]*y[6]*x[7]*z[5];
s7 = s8-x[5]*x[1]*y[5]*z[0]+2.0*x[1]*z[1]*x[2]*y[0]-2.0*x[1]*z[1]*x[0]*y
-[2]+x[1]*x[2]*y[3]*z[1]-x[1]*x[2]*y[1]*z[3]+2.0*x[1]*y[1]*x[0]*z[2]-2.0*x[1]*y
-[1]*x[2]*z[0]-z[2]*x[1]*x[1]*y[3]+y[2]*x[1]*x[1]*z[3]+y[5]*x[7]*x[7]*z[4]+y[6]*
-x[7]*x[7]*z[5]+x[7]*x[6]*y[7]*z[2]+x[7]*y[6]*x[2]*z[7]-x[7]*z[6]*x[2]*y[7]-2.0*
-x[7]*x[6]*y[3]*z[7];
+ [2]+x[1]*x[2]*y[3]*z[1]-x[1]*x[2]*y[1]*z[3]+2.0*x[1]*y[1]*x[0]*z[2]-2.0*x[1]*y
+ [1]*x[2]*z[0]-z[2]*x[1]*x[1]*y[3]+y[2]*x[1]*x[1]*z[3]+y[5]*x[7]*x[7]*z[4]+y[6]*
+ x[7]*x[7]*z[5]+x[7]*x[6]*y[7]*z[2]+x[7]*y[6]*x[2]*z[7]-x[7]*z[6]*x[2]*y[7]-2.0*
+ x[7]*x[6]*y[3]*z[7];
s8 = s7+2.0*x[7]*x[6]*y[7]*z[3]+2.0*x[7]*y[6]*x[3]*z[7]-x[3]*z[2]*x[1]*y
-[3]+x[3]*y[2]*x[1]*z[3]+x[5]*x[1]*y[0]*z[5]+x[4]*y[5]*x[6]*z[4]+x[5]*z[1]*x[0]*
-y[5]-x[4]*z[6]*x[7]*y[5]-x[4]*x[5]*y[6]*z[4]+x[4]*x[5]*y[4]*z[6]-x[4]*z[5]*x[6]
-*y[4]-x[1]*y[2]*x[3]*z[1]+x[1]*z[2]*x[3]*y[1]-x[2]*x[1]*y[0]*z[2]-x[2]*z[1]*x
-[0]*y[2];
+ [3]+x[3]*y[2]*x[1]*z[3]+x[5]*x[1]*y[0]*z[5]+x[4]*y[5]*x[6]*z[4]+x[5]*z[1]*x[0]*
+ y[5]-x[4]*z[6]*x[7]*y[5]-x[4]*x[5]*y[6]*z[4]+x[4]*x[5]*y[4]*z[6]-x[4]*z[5]*x[6]
+ *y[4]-x[1]*y[2]*x[3]*z[1]+x[1]*z[2]*x[3]*y[1]-x[2]*x[1]*y[0]*z[2]-x[2]*z[1]*x
+ [0]*y[2];
s5 = s8+x[2]*x[1]*y[2]*z[0]-x[2]*z[2]*x[0]*y[3]+x[2]*y[2]*x[0]*z[3]-x[2]*
-y[2]*x[3]*z[0]+x[2]*z[2]*x[3]*y[0]+x[2]*y[1]*x[0]*z[2]+x[5]*y[6]*x[7]*z[5]+x[6]
-*y[5]*x[7]*z[4]+2.0*x[6]*y[6]*x[7]*z[5]-x[7]*y[0]*x[3]*z[7]+x[7]*z[0]*x[3]*y[7]
--x[7]*x[0]*y[7]*z[3]+x[7]*x[0]*y[3]*z[7]+2.0*x[7]*x[7]*y[4]*z[3]-2.0*x[7]*x[7]*
-y[3]*z[4]-2.0*x[1]*x[1]*y[2]*z[5];
+ y[2]*x[3]*z[0]+x[2]*z[2]*x[3]*y[0]+x[2]*y[1]*x[0]*z[2]+x[5]*y[6]*x[7]*z[5]+x[6]
+ *y[5]*x[7]*z[4]+2.0*x[6]*y[6]*x[7]*z[5]-x[7]*y[0]*x[3]*z[7]+x[7]*z[0]*x[3]*y[7]
+ -x[7]*x[0]*y[7]*z[3]+x[7]*x[0]*y[3]*z[7]+2.0*x[7]*x[7]*y[4]*z[3]-2.0*x[7]*x[7]*
+ y[3]*z[4]-2.0*x[1]*x[1]*y[2]*z[5];
s8 = s5-2.0*x[7]*x[4]*y[7]*z[3]+2.0*x[7]*x[3]*y[7]*z[4]-2.0*x[7]*x[3]*y
-[4]*z[7]+2.0*x[7]*x[4]*y[3]*z[7]+2.0*x[1]*x[1]*y[5]*z[2]-x[1]*x[1]*y[2]*z[6]+x
-[1]*x[1]*y[6]*z[2]+z[1]*x[5]*x[5]*y[2]-y[1]*x[5]*x[5]*z[2]-x[1]*x[1]*y[6]*z[5]+
-x[1]*x[1]*y[5]*z[6]+x[5]*x[5]*y[6]*z[2]-x[5]*x[5]*y[2]*z[6]-2.0*y[1]*x[5]*x[5]*
-z[6];
+ [4]*z[7]+2.0*x[7]*x[4]*y[3]*z[7]+2.0*x[1]*x[1]*y[5]*z[2]-x[1]*x[1]*y[2]*z[6]+x
+ [1]*x[1]*y[6]*z[2]+z[1]*x[5]*x[5]*y[2]-y[1]*x[5]*x[5]*z[2]-x[1]*x[1]*y[6]*z[5]+
+ x[1]*x[1]*y[5]*z[6]+x[5]*x[5]*y[6]*z[2]-x[5]*x[5]*y[2]*z[6]-2.0*y[1]*x[5]*x[5]*
+ z[6];
s7 = s8+2.0*z[1]*x[5]*x[5]*y[6]+2.0*x[1]*z[1]*x[5]*y[2]+2.0*x[1]*y[1]*x
-[2]*z[5]-2.0*x[1]*z[1]*x[2]*y[5]-2.0*x[1]*y[1]*x[5]*z[2]-x[1]*y[1]*x[6]*z[2]-x
-[1]*z[1]*x[2]*y[6]+x[1]*z[1]*x[6]*y[2]+x[1]*y[1]*x[2]*z[6]-x[5]*x[1]*y[2]*z[5]+
-x[5]*y[1]*x[2]*z[5]-x[5]*z[1]*x[2]*y[5]+x[5]*x[1]*y[5]*z[2]-x[5]*y[1]*x[6]*z[2]
--x[5]*x[1]*y[2]*z[6];
+ [2]*z[5]-2.0*x[1]*z[1]*x[2]*y[5]-2.0*x[1]*y[1]*x[5]*z[2]-x[1]*y[1]*x[6]*z[2]-x
+ [1]*z[1]*x[2]*y[6]+x[1]*z[1]*x[6]*y[2]+x[1]*y[1]*x[2]*z[6]-x[5]*x[1]*y[2]*z[5]+
+ x[5]*y[1]*x[2]*z[5]-x[5]*z[1]*x[2]*y[5]+x[5]*x[1]*y[5]*z[2]-x[5]*y[1]*x[6]*z[2]
+ -x[5]*x[1]*y[2]*z[6];
s8 = s7+x[5]*x[1]*y[6]*z[2]+x[5]*z[1]*x[6]*y[2]+x[1]*x[2]*y[5]*z[6]-x[1]*
-x[2]*y[6]*z[5]-x[1]*z[1]*x[6]*y[5]-x[1]*y[1]*x[5]*z[6]+x[1]*z[1]*x[5]*y[6]+x[1]
-*y[1]*x[6]*z[5]-x[5]*x[6]*y[5]*z[2]+x[5]*x[2]*y[5]*z[6]-x[5]*x[2]*y[6]*z[5]+x
-[5]*x[6]*y[2]*z[5]-2.0*x[5]*z[1]*x[6]*y[5]-2.0*x[5]*x[1]*y[6]*z[5]+2.0*x[5]*x
-[1]*y[5]*z[6];
+ x[2]*y[6]*z[5]-x[1]*z[1]*x[6]*y[5]-x[1]*y[1]*x[5]*z[6]+x[1]*z[1]*x[5]*y[6]+x[1]
+ *y[1]*x[6]*z[5]-x[5]*x[6]*y[5]*z[2]+x[5]*x[2]*y[5]*z[6]-x[5]*x[2]*y[6]*z[5]+x
+ [5]*x[6]*y[2]*z[5]-2.0*x[5]*z[1]*x[6]*y[5]-2.0*x[5]*x[1]*y[6]*z[5]+2.0*x[5]*x
+ [1]*y[5]*z[6];
s6 = s8+2.0*x[5]*y[1]*x[6]*z[5]+2.0*x[2]*x[1]*y[6]*z[2]+2.0*x[2]*z[1]*x
-[6]*y[2]-2.0*x[2]*x[1]*y[2]*z[6]+x[2]*x[5]*y[6]*z[2]+x[2]*x[6]*y[2]*z[5]-x[2]*x
-[5]*y[2]*z[6]+y[1]*x[2]*x[2]*z[5]-z[1]*x[2]*x[2]*y[5]-2.0*x[2]*y[1]*x[6]*z[2]-x
-[2]*x[6]*y[5]*z[2]-2.0*z[1]*x[2]*x[2]*y[6]+x[2]*x[2]*y[5]*z[6]-x[2]*x[2]*y[6]*z
-[5]+2.0*y[1]*x[2]*x[2]*z[6]+x[2]*z[1]*x[5]*y[2];
+ [6]*y[2]-2.0*x[2]*x[1]*y[2]*z[6]+x[2]*x[5]*y[6]*z[2]+x[2]*x[6]*y[2]*z[5]-x[2]*x
+ [5]*y[2]*z[6]+y[1]*x[2]*x[2]*z[5]-z[1]*x[2]*x[2]*y[5]-2.0*x[2]*y[1]*x[6]*z[2]-x
+ [2]*x[6]*y[5]*z[2]-2.0*z[1]*x[2]*x[2]*y[6]+x[2]*x[2]*y[5]*z[6]-x[2]*x[2]*y[6]*z
+ [5]+2.0*y[1]*x[2]*x[2]*z[6]+x[2]*z[1]*x[5]*y[2];
s8 = s6-x[2]*x[1]*y[2]*z[5]+x[2]*x[1]*y[5]*z[2]-x[2]*y[1]*x[5]*z[2]+x[6]*
-y[1]*x[2]*z[5]-x[6]*z[1]*x[2]*y[5]-z[1]*x[6]*x[6]*y[5]+y[1]*x[6]*x[6]*z[5]-y[1]
-*x[6]*x[6]*z[2]-2.0*x[6]*x[6]*y[5]*z[2]+2.0*x[6]*x[6]*y[2]*z[5]+z[1]*x[6]*x[6]*
-y[2]-x[6]*x[1]*y[6]*z[5]-x[6]*y[1]*x[5]*z[6]+x[6]*x[1]*y[5]*z[6];
+ y[1]*x[2]*z[5]-x[6]*z[1]*x[2]*y[5]-z[1]*x[6]*x[6]*y[5]+y[1]*x[6]*x[6]*z[5]-y[1]
+ *x[6]*x[6]*z[2]-2.0*x[6]*x[6]*y[5]*z[2]+2.0*x[6]*x[6]*y[2]*z[5]+z[1]*x[6]*x[6]*
+ y[2]-x[6]*x[1]*y[6]*z[5]-x[6]*y[1]*x[5]*z[6]+x[6]*x[1]*y[5]*z[6];
s7 = s8+x[6]*z[1]*x[5]*y[6]-x[6]*z[1]*x[2]*y[6]-x[6]*x[1]*y[2]*z[6]+2.0*x
-[6]*x[5]*y[6]*z[2]+2.0*x[6]*x[2]*y[5]*z[6]-2.0*x[6]*x[2]*y[6]*z[5]-2.0*x[6]*x
-[5]*y[2]*z[6]+x[6]*x[1]*y[6]*z[2]+x[6]*y[1]*x[2]*z[6]-x[2]*x[2]*y[3]*z[7]+x[2]*
-x[2]*y[7]*z[3]-x[2]*z[2]*x[3]*y[7]-x[2]*y[2]*x[7]*z[3]+x[2]*z[2]*x[7]*y[3]+x[2]
-*y[2]*x[3]*z[7]-x[6]*x[6]*y[3]*z[7];
+ [6]*x[5]*y[6]*z[2]+2.0*x[6]*x[2]*y[5]*z[6]-2.0*x[6]*x[2]*y[6]*z[5]-2.0*x[6]*x
+ [5]*y[2]*z[6]+x[6]*x[1]*y[6]*z[2]+x[6]*y[1]*x[2]*z[6]-x[2]*x[2]*y[3]*z[7]+x[2]*
+ x[2]*y[7]*z[3]-x[2]*z[2]*x[3]*y[7]-x[2]*y[2]*x[7]*z[3]+x[2]*z[2]*x[7]*y[3]+x[2]
+ *y[2]*x[3]*z[7]-x[6]*x[6]*y[3]*z[7];
s8 = s7+x[6]*x[6]*y[7]*z[3]-x[6]*x[2]*y[3]*z[7]+x[6]*x[2]*y[7]*z[3]-x[6]*
-y[6]*x[7]*z[3]+x[6]*y[6]*x[3]*z[7]-x[6]*z[6]*x[3]*y[7]+x[6]*z[6]*x[7]*y[3]+y[6]
-*x[2]*x[2]*z[7]-z[6]*x[2]*x[2]*y[7]+2.0*x[2]*x[2]*y[6]*z[3]-x[2]*y[6]*x[7]*z[2]
--2.0*x[2]*y[2]*x[6]*z[3]-2.0*x[2]*x[2]*y[3]*z[6]+2.0*x[2]*y[2]*x[3]*z[6]-x[2]*x
-[6]*y[2]*z[7];
+ y[6]*x[7]*z[3]+x[6]*y[6]*x[3]*z[7]-x[6]*z[6]*x[3]*y[7]+x[6]*z[6]*x[7]*y[3]+y[6]
+ *x[2]*x[2]*z[7]-z[6]*x[2]*x[2]*y[7]+2.0*x[2]*x[2]*y[6]*z[3]-x[2]*y[6]*x[7]*z[2]
+ -2.0*x[2]*y[2]*x[6]*z[3]-2.0*x[2]*x[2]*y[3]*z[6]+2.0*x[2]*y[2]*x[3]*z[6]-x[2]*x
+ [6]*y[2]*z[7];
s3 = s8+x[2]*x[6]*y[7]*z[2]+x[2]*z[6]*x[7]*y[2]+2.0*x[2]*z[2]*x[6]*y[3]
--2.0*x[2]*z[2]*x[3]*y[6]-y[2]*x[6]*x[6]*z[3]-2.0*x[6]*x[6]*y[2]*z[7]+2.0*x[6]*x
-[6]*y[7]*z[2]+z[2]*x[6]*x[6]*y[3]-2.0*x[6]*y[6]*x[7]*z[2]+x[6]*y[2]*x[3]*z[6]-x
-[6]*x[2]*y[3]*z[6]+2.0*x[6]*z[6]*x[7]*y[2]+2.0*x[6]*y[6]*x[2]*z[7]-2.0*x[6]*z
-[6]*x[2]*y[7]+x[6]*x[2]*y[6]*z[3]-x[6]*z[2]*x[3]*y[6];
+ -2.0*x[2]*z[2]*x[3]*y[6]-y[2]*x[6]*x[6]*z[3]-2.0*x[6]*x[6]*y[2]*z[7]+2.0*x[6]*x
+ [6]*y[7]*z[2]+z[2]*x[6]*x[6]*y[3]-2.0*x[6]*y[6]*x[7]*z[2]+x[6]*y[2]*x[3]*z[6]-x
+ [6]*x[2]*y[3]*z[6]+2.0*x[6]*z[6]*x[7]*y[2]+2.0*x[6]*y[6]*x[2]*z[7]-2.0*x[6]*z
+ [6]*x[2]*y[7]+x[6]*x[2]*y[6]*z[3]-x[6]*z[2]*x[3]*y[6];
s8 = y[1]*x[0]*z[3]+x[1]*y[3]*z[0]-y[0]*x[3]*z[7]-x[1]*y[5]*z[0]-y[0]*x
-[3]*z[4]-x[1]*y[0]*z[2]+z[1]*x[2]*y[0]-y[1]*x[0]*z[5]-z[1]*x[0]*y[2]-y[1]*x[0]*
-z[4]+z[1]*x[5]*y[2]+z[0]*x[7]*y[4]+z[0]*x[3]*y[7]+z[1]*x[0]*y[4]-x[1]*y[2]*z[5]
-+x[2]*y[3]*z[0]+y[1]*x[2]*z[5]-x[2]*y[3]*z[7];
+ [3]*z[4]-x[1]*y[0]*z[2]+z[1]*x[2]*y[0]-y[1]*x[0]*z[5]-z[1]*x[0]*y[2]-y[1]*x[0]*
+ z[4]+z[1]*x[5]*y[2]+z[0]*x[7]*y[4]+z[0]*x[3]*y[7]+z[1]*x[0]*y[4]-x[1]*y[2]*z[5]
+ +x[2]*y[3]*z[0]+y[1]*x[2]*z[5]-x[2]*y[3]*z[7];
s7 = s8-z[1]*x[2]*y[5]-y[1]*x[3]*z[0]-x[0]*y[7]*z[3]-z[1]*x[0]*y[3]+y[5]*
-x[4]*z[0]-x[0]*y[4]*z[3]+y[5]*x[7]*z[4]-z[0]*x[4]*y[3]+x[1]*y[0]*z[4]-z[2]*x[3]
-*y[7]-y[6]*x[7]*z[2]+x[1]*y[5]*z[2]+y[6]*x[7]*z[5]+x[0]*y[7]*z[4]+x[1]*y[2]*z
-[0]-z[1]*x[4]*y[0]-z[0]*x[4]*y[7]-z[2]*x[0]*y[3];
+ x[4]*z[0]-x[0]*y[4]*z[3]+y[5]*x[7]*z[4]-z[0]*x[4]*y[3]+x[1]*y[0]*z[4]-z[2]*x[3]
+ *y[7]-y[6]*x[7]*z[2]+x[1]*y[5]*z[2]+y[6]*x[7]*z[5]+x[0]*y[7]*z[4]+x[1]*y[2]*z
+ [0]-z[1]*x[4]*y[0]-z[0]*x[4]*y[7]-z[2]*x[0]*y[3];
s8 = x[5]*y[0]*z[4]+z[1]*x[0]*y[5]-x[2]*y[0]*z[3]-z[1]*x[5]*y[0]+y[1]*x
-[5]*z[0]-x[1]*y[0]*z[3]-x[1]*y[4]*z[0]-y[1]*x[5]*z[2]+x[2]*y[7]*z[3]+y[0]*x[4]*
-z[3]-x[0]*y[4]*z[7]+x[1]*y[0]*z[5]-y[1]*x[6]*z[2]-y[2]*x[6]*z[3]+y[0]*x[7]*z[3]
--y[2]*x[7]*z[3]+z[2]*x[7]*y[3]+y[2]*x[0]*z[3];
+ [5]*z[0]-x[1]*y[0]*z[3]-x[1]*y[4]*z[0]-y[1]*x[5]*z[2]+x[2]*y[7]*z[3]+y[0]*x[4]*
+ z[3]-x[0]*y[4]*z[7]+x[1]*y[0]*z[5]-y[1]*x[6]*z[2]-y[2]*x[6]*z[3]+y[0]*x[7]*z[3]
+ -y[2]*x[7]*z[3]+z[2]*x[7]*y[3]+y[2]*x[0]*z[3];
s6 = s8+y[2]*x[3]*z[7]-y[2]*x[3]*z[0]-x[6]*y[5]*z[2]-y[5]*x[0]*z[4]+z[2]*
-x[3]*y[0]+x[2]*y[3]*z[1]+x[0]*y[3]*z[7]-x[2]*y[1]*z[3]+y[1]*x[4]*z[0]+y[1]*x[0]
-*z[2]-z[1]*x[2]*y[6]+y[2]*x[3]*z[6]-y[1]*x[2]*z[0]+z[1]*x[3]*y[0]-x[1]*y[2]*z
-[6]-x[2]*y[3]*z[6]+x[0]*y[3]*z[4]+z[0]*x[3]*y[4]+s7;
+ x[3]*y[0]+x[2]*y[3]*z[1]+x[0]*y[3]*z[7]-x[2]*y[1]*z[3]+y[1]*x[4]*z[0]+y[1]*x[0]
+ *z[2]-z[1]*x[2]*y[6]+y[2]*x[3]*z[6]-y[1]*x[2]*z[0]+z[1]*x[3]*y[0]-x[1]*y[2]*z
+ [6]-x[2]*y[3]*z[6]+x[0]*y[3]*z[4]+z[0]*x[3]*y[4]+s7;
s8 = x[5]*y[4]*z[7]+s6+y[5]*x[6]*z[4]-y[5]*x[4]*z[6]+z[6]*x[5]*y[7]-x[6]*
-y[2]*z[7]-x[6]*y[7]*z[5]+x[5]*y[6]*z[2]+x[6]*y[5]*z[7]+x[6]*y[7]*z[2]+y[6]*x[7]
-*z[4]-y[6]*x[4]*z[7]-y[6]*x[7]*z[3]+z[6]*x[7]*y[2]+x[2]*y[5]*z[6]-x[2]*y[6]*z
-[5]+y[6]*x[2]*z[7]+x[6]*y[2]*z[5];
+ y[2]*z[7]-x[6]*y[7]*z[5]+x[5]*y[6]*z[2]+x[6]*y[5]*z[7]+x[6]*y[7]*z[2]+y[6]*x[7]
+ *z[4]-y[6]*x[4]*z[7]-y[6]*x[7]*z[3]+z[6]*x[7]*y[2]+x[2]*y[5]*z[6]-x[2]*y[6]*z
+ [5]+y[6]*x[2]*z[7]+x[6]*y[2]*z[5];
s7 = s8-x[5]*y[2]*z[6]-z[6]*x[7]*y[5]-z[5]*x[7]*y[4]+z[5]*x[0]*y[4]-y[5]*
-x[4]*z[7]+y[0]*x[4]*z[7]-z[6]*x[2]*y[7]-x[5]*y[4]*z[0]-x[5]*y[7]*z[4]-y[0]*x[7]
-*z[4]+y[5]*x[4]*z[1]-x[6]*y[7]*z[4]+x[7]*y[4]*z[3]-x[4]*y[7]*z[3]+x[3]*y[7]*z
-[4]-x[7]*y[3]*z[4]-x[6]*y[3]*z[7]+x[6]*y[4]*z[7];
+ x[4]*z[7]+y[0]*x[4]*z[7]-z[6]*x[2]*y[7]-x[5]*y[4]*z[0]-x[5]*y[7]*z[4]-y[0]*x[7]
+ *z[4]+y[5]*x[4]*z[1]-x[6]*y[7]*z[4]+x[7]*y[4]*z[3]-x[4]*y[7]*z[3]+x[3]*y[7]*z
+ [4]-x[7]*y[3]*z[4]-x[6]*y[3]*z[7]+x[6]*y[4]*z[7];
s8 = -x[3]*y[4]*z[7]+x[4]*y[3]*z[7]-z[6]*x[7]*y[4]-z[1]*x[6]*y[5]+x[6]*y
-[7]*z[3]-x[1]*y[6]*z[5]-y[1]*x[5]*z[6]+z[5]*x[4]*y[7]-z[5]*x[4]*y[0]+x[1]*y[5]*
-z[6]-y[6]*x[5]*z[7]-y[2]*x[3]*z[1]+z[1]*x[5]*y[6]-y[5]*x[1]*z[4]+z[6]*x[4]*y[7]
-+x[5]*y[1]*z[4]-x[5]*y[6]*z[4]+y[6]*x[3]*z[7]-x[5]*y[4]*z[1];
+ [7]*z[3]-x[1]*y[6]*z[5]-y[1]*x[5]*z[6]+z[5]*x[4]*y[7]-z[5]*x[4]*y[0]+x[1]*y[5]*
+ z[6]-y[6]*x[5]*z[7]-y[2]*x[3]*z[1]+z[1]*x[5]*y[6]-y[5]*x[1]*z[4]+z[6]*x[4]*y[7]
+ +x[5]*y[1]*z[4]-x[5]*y[6]*z[4]+y[6]*x[3]*z[7]-x[5]*y[4]*z[1];
s5 = s8+x[5]*y[4]*z[6]+z[5]*x[1]*y[4]+y[1]*x[6]*z[5]-z[6]*x[3]*y[7]+z[6]*
-x[7]*y[3]-z[5]*x[6]*y[4]-z[5]*x[4]*y[1]+z[5]*x[4]*y[6]+x[1]*y[6]*z[2]+x[2]*y[6]
-*z[3]+z[2]*x[6]*y[3]+z[1]*x[6]*y[2]+z[2]*x[3]*y[1]-z[2]*x[1]*y[3]-z[2]*x[3]*y
-[6]+y[2]*x[1]*z[3]+y[1]*x[2]*z[6]-z[0]*x[7]*y[3]+s7;
+ x[7]*y[3]-z[5]*x[6]*y[4]-z[5]*x[4]*y[1]+z[5]*x[4]*y[6]+x[1]*y[6]*z[2]+x[2]*y[6]
+ *z[3]+z[2]*x[6]*y[3]+z[1]*x[6]*y[2]+z[2]*x[3]*y[1]-z[2]*x[1]*y[3]-z[2]*x[3]*y
+ [6]+y[2]*x[1]*z[3]+y[1]*x[2]*z[6]-z[0]*x[7]*y[3]+s7;
s4 = 1/s5;
s2 = s3*s4;
const double unknown0 = s1*s2;
s1 = 1.0/6.0;
s8 = 2.0*x[1]*y[0]*y[0]*z[4]+x[5]*y[0]*y[0]*z[4]-x[1]*y[4]*y[4]*z[0]+z[1]
-*x[0]*y[4]*y[4]+x[1]*y[0]*y[0]*z[5]-z[1]*x[5]*y[0]*y[0]-2.0*z[1]*x[4]*y[0]*y[0]
-+2.0*z[1]*x[3]*y[0]*y[0]+z[2]*x[3]*y[0]*y[0]+y[0]*y[0]*x[7]*z[3]+2.0*y[0]*y[0]*
-x[4]*z[3]-2.0*x[1]*y[0]*y[0]*z[3]-2.0*x[5]*y[4]*y[4]*z[0]+2.0*z[5]*x[0]*y[4]*y
-[4]+2.0*y[4]*y[5]*x[7]*z[4];
+ *x[0]*y[4]*y[4]+x[1]*y[0]*y[0]*z[5]-z[1]*x[5]*y[0]*y[0]-2.0*z[1]*x[4]*y[0]*y[0]
+ +2.0*z[1]*x[3]*y[0]*y[0]+z[2]*x[3]*y[0]*y[0]+y[0]*y[0]*x[7]*z[3]+2.0*y[0]*y[0]*
+ x[4]*z[3]-2.0*x[1]*y[0]*y[0]*z[3]-2.0*x[5]*y[4]*y[4]*z[0]+2.0*z[5]*x[0]*y[4]*y
+ [4]+2.0*y[4]*y[5]*x[7]*z[4];
s7 = s8-x[3]*y[4]*y[4]*z[7]+x[7]*y[4]*y[4]*z[3]+z[0]*x[3]*y[4]*y[4]-2.0*x
-[0]*y[4]*y[4]*z[7]-y[1]*x[1]*y[4]*z[0]-x[0]*y[4]*y[4]*z[3]+2.0*z[0]*x[7]*y[4]*y
-[4]+y[4]*z[6]*x[4]*y[7]-y[0]*y[0]*x[7]*z[4]+y[0]*y[0]*x[4]*z[7]+2.0*y[4]*z[5]*x
-[4]*y[7]-2.0*y[4]*x[5]*y[7]*z[4]-y[4]*x[6]*y[7]*z[4]-y[4]*y[6]*x[4]*z[7]-2.0*y
-[4]*y[5]*x[4]*z[7];
+ [0]*y[4]*y[4]*z[7]-y[1]*x[1]*y[4]*z[0]-x[0]*y[4]*y[4]*z[3]+2.0*z[0]*x[7]*y[4]*y
+ [4]+y[4]*z[6]*x[4]*y[7]-y[0]*y[0]*x[7]*z[4]+y[0]*y[0]*x[4]*z[7]+2.0*y[4]*z[5]*x
+ [4]*y[7]-2.0*y[4]*x[5]*y[7]*z[4]-y[4]*x[6]*y[7]*z[4]-y[4]*y[6]*x[4]*z[7]-2.0*y
+ [4]*y[5]*x[4]*z[7];
s8 = y[4]*y[6]*x[7]*z[4]-y[7]*y[2]*x[7]*z[3]+y[7]*z[2]*x[7]*y[3]+y[7]*y
-[2]*x[3]*z[7]+2.0*x[5]*y[4]*y[4]*z[7]-y[7]*x[2]*y[3]*z[7]-y[0]*z[0]*x[4]*y[7]+z
-[6]*x[7]*y[3]*y[3]-y[0]*x[0]*y[4]*z[7]+y[0]*x[0]*y[7]*z[4]-2.0*x[2]*y[3]*y[3]*z
-[7]-z[5]*x[4]*y[0]*y[0]+y[0]*z[0]*x[7]*y[4]-2.0*z[6]*x[3]*y[7]*y[7]+z[1]*x[2]*y
-[0]*y[0];
+ [2]*x[3]*z[7]+2.0*x[5]*y[4]*y[4]*z[7]-y[7]*x[2]*y[3]*z[7]-y[0]*z[0]*x[4]*y[7]+z
+ [6]*x[7]*y[3]*y[3]-y[0]*x[0]*y[4]*z[7]+y[0]*x[0]*y[7]*z[4]-2.0*x[2]*y[3]*y[3]*z
+ [7]-z[5]*x[4]*y[0]*y[0]+y[0]*z[0]*x[7]*y[4]-2.0*z[6]*x[3]*y[7]*y[7]+z[1]*x[2]*y
+ [0]*y[0];
s6 = s8+y[4]*y[0]*x[4]*z[3]-2.0*y[4]*z[0]*x[4]*y[7]+2.0*y[4]*x[0]*y[7]*z
-[4]-y[4]*z[0]*x[4]*y[3]-y[4]*x[0]*y[7]*z[3]+y[4]*z[0]*x[3]*y[7]-y[4]*y[0]*x[3]*
-z[4]+y[0]*x[4]*y[3]*z[7]-y[0]*x[7]*y[3]*z[4]-y[0]*x[3]*y[4]*z[7]+y[0]*x[7]*y[4]
-*z[3]+x[2]*y[7]*y[7]*z[3]-z[2]*x[3]*y[7]*y[7]-2.0*z[2]*x[0]*y[3]*y[3]+2.0*y[0]*
-z[1]*x[0]*y[4]+s7;
+ [4]-y[4]*z[0]*x[4]*y[3]-y[4]*x[0]*y[7]*z[3]+y[4]*z[0]*x[3]*y[7]-y[4]*y[0]*x[3]*
+ z[4]+y[0]*x[4]*y[3]*z[7]-y[0]*x[7]*y[3]*z[4]-y[0]*x[3]*y[4]*z[7]+y[0]*x[7]*y[4]
+ *z[3]+x[2]*y[7]*y[7]*z[3]-z[2]*x[3]*y[7]*y[7]-2.0*z[2]*x[0]*y[3]*y[3]+2.0*y[0]*
+ z[1]*x[0]*y[4]+s7;
s8 = -2.0*y[0]*y[1]*x[0]*z[4]-y[0]*y[1]*x[0]*z[5]-y[0]*y[0]*x[3]*z[7]-z
-[1]*x[0]*y[3]*y[3]-y[0]*x[1]*y[5]*z[0]-2.0*z[0]*x[7]*y[3]*y[3]+x[0]*y[3]*y[3]*z
-[4]+2.0*x[0]*y[3]*y[3]*z[7]-z[0]*x[4]*y[3]*y[3]+2.0*x[2]*y[3]*y[3]*z[0]+x[1]*y
-[3]*y[3]*z[0]+2.0*y[7]*z[6]*x[7]*y[3]+2.0*y[7]*y[6]*x[3]*z[7]-2.0*y[7]*y[6]*x
-[7]*z[3]-2.0*y[7]*x[6]*y[3]*z[7];
+ [1]*x[0]*y[3]*y[3]-y[0]*x[1]*y[5]*z[0]-2.0*z[0]*x[7]*y[3]*y[3]+x[0]*y[3]*y[3]*z
+ [4]+2.0*x[0]*y[3]*y[3]*z[7]-z[0]*x[4]*y[3]*y[3]+2.0*x[2]*y[3]*y[3]*z[0]+x[1]*y
+ [3]*y[3]*z[0]+2.0*y[7]*z[6]*x[7]*y[3]+2.0*y[7]*y[6]*x[3]*z[7]-2.0*y[7]*y[6]*x
+ [7]*z[3]-2.0*y[7]*x[6]*y[3]*z[7];
s7 = s8+y[4]*x[4]*y[3]*z[7]-y[4]*x[4]*y[7]*z[3]+y[4]*x[3]*y[7]*z[4]-y[4]*
-x[7]*y[3]*z[4]+2.0*y[4]*y[0]*x[4]*z[7]-2.0*y[4]*y[0]*x[7]*z[4]+2.0*x[6]*y[7]*y
-[7]*z[3]+y[4]*x[0]*y[3]*z[4]+y[0]*y[1]*x[5]*z[0]+y[0]*z[1]*x[0]*y[5]-x[2]*y[0]*
-y[0]*z[3]+x[4]*y[3]*y[3]*z[7]-x[7]*y[3]*y[3]*z[4]-x[5]*y[4]*y[4]*z[1]+y[3]*z[0]
-*x[3]*y[4];
+ x[7]*y[3]*z[4]+2.0*y[4]*y[0]*x[4]*z[7]-2.0*y[4]*y[0]*x[7]*z[4]+2.0*x[6]*y[7]*y
+ [7]*z[3]+y[4]*x[0]*y[3]*z[4]+y[0]*y[1]*x[5]*z[0]+y[0]*z[1]*x[0]*y[5]-x[2]*y[0]*
+ y[0]*z[3]+x[4]*y[3]*y[3]*z[7]-x[7]*y[3]*y[3]*z[4]-x[5]*y[4]*y[4]*z[1]+y[3]*z[0]
+ *x[3]*y[4];
s8 = y[3]*y[0]*x[4]*z[3]+2.0*y[3]*y[0]*x[7]*z[3]+2.0*y[3]*y[2]*x[0]*z[3]
--2.0*y[3]*y[2]*x[3]*z[0]+2.0*y[3]*z[2]*x[3]*y[0]+y[3]*z[1]*x[3]*y[0]-2.0*y[3]*x
-[2]*y[0]*z[3]-y[3]*x[1]*y[0]*z[3]-y[3]*y[1]*x[3]*z[0]-2.0*y[3]*x[0]*y[7]*z[3]-y
-[3]*x[0]*y[4]*z[3]-2.0*y[3]*y[0]*x[3]*z[7]-y[3]*y[0]*x[3]*z[4]+2.0*y[3]*z[0]*x
-[3]*y[7]+y[3]*y[1]*x[0]*z[3]+z[5]*x[1]*y[4]*y[4];
+ -2.0*y[3]*y[2]*x[3]*z[0]+2.0*y[3]*z[2]*x[3]*y[0]+y[3]*z[1]*x[3]*y[0]-2.0*y[3]*x
+ [2]*y[0]*z[3]-y[3]*x[1]*y[0]*z[3]-y[3]*y[1]*x[3]*z[0]-2.0*y[3]*x[0]*y[7]*z[3]-y
+ [3]*x[0]*y[4]*z[3]-2.0*y[3]*y[0]*x[3]*z[7]-y[3]*y[0]*x[3]*z[4]+2.0*y[3]*z[0]*x
+ [3]*y[7]+y[3]*y[1]*x[0]*z[3]+z[5]*x[1]*y[4]*y[4];
s5 = s8-2.0*y[0]*y[0]*x[3]*z[4]-2.0*y[0]*x[1]*y[4]*z[0]+y[3]*x[7]*y[4]*z
-[3]-y[3]*x[4]*y[7]*z[3]+y[3]*x[3]*y[7]*z[4]-y[3]*x[3]*y[4]*z[7]+y[3]*x[0]*y[7]*
-z[4]-y[3]*z[0]*x[4]*y[7]-2.0*y[4]*y[5]*x[0]*z[4]+s6+y[7]*x[0]*y[3]*z[7]-y[7]*z
-[0]*x[7]*y[3]+y[7]*y[0]*x[7]*z[3]-y[7]*y[0]*x[3]*z[7]+2.0*y[0]*y[1]*x[4]*z[0]+
-s7;
+ [3]-y[3]*x[4]*y[7]*z[3]+y[3]*x[3]*y[7]*z[4]-y[3]*x[3]*y[4]*z[7]+y[3]*x[0]*y[7]*
+ z[4]-y[3]*z[0]*x[4]*y[7]-2.0*y[4]*y[5]*x[0]*z[4]+s6+y[7]*x[0]*y[3]*z[7]-y[7]*z
+ [0]*x[7]*y[3]+y[7]*y[0]*x[7]*z[3]-y[7]*y[0]*x[3]*z[7]+2.0*y[0]*y[1]*x[4]*z[0]+
+ s7;
s8 = -2.0*y[7]*x[7]*y[3]*z[4]-2.0*y[7]*x[3]*y[4]*z[7]+2.0*y[7]*x[4]*y[3]*
-z[7]+y[7]*y[0]*x[4]*z[7]-y[7]*y[0]*x[7]*z[4]+2.0*y[7]*x[7]*y[4]*z[3]-y[7]*x[0]*
-y[4]*z[7]+y[7]*z[0]*x[7]*y[4]+z[5]*x[4]*y[7]*y[7]+2.0*z[6]*x[4]*y[7]*y[7]-x[5]*
-y[7]*y[7]*z[4]-2.0*x[6]*y[7]*y[7]*z[4]+2.0*y[7]*x[6]*y[4]*z[7]-2.0*y[7]*z[6]*x
-[7]*y[4]+2.0*y[7]*y[6]*x[7]*z[4];
+ z[7]+y[7]*y[0]*x[4]*z[7]-y[7]*y[0]*x[7]*z[4]+2.0*y[7]*x[7]*y[4]*z[3]-y[7]*x[0]*
+ y[4]*z[7]+y[7]*z[0]*x[7]*y[4]+z[5]*x[4]*y[7]*y[7]+2.0*z[6]*x[4]*y[7]*y[7]-x[5]*
+ y[7]*y[7]*z[4]-2.0*x[6]*y[7]*y[7]*z[4]+2.0*y[7]*x[6]*y[4]*z[7]-2.0*y[7]*z[6]*x
+ [7]*y[4]+2.0*y[7]*y[6]*x[7]*z[4];
s7 = s8-2.0*y[7]*y[6]*x[4]*z[7]-y[7]*z[5]*x[7]*y[4]-y[7]*y[5]*x[4]*z[7]-x
-[0]*y[7]*y[7]*z[3]+z[0]*x[3]*y[7]*y[7]+y[7]*x[5]*y[4]*z[7]+y[7]*y[5]*x[7]*z[4]-
-y[4]*x[1]*y[5]*z[0]-x[1]*y[0]*y[0]*z[2]-y[4]*y[5]*x[1]*z[4]-2.0*y[4]*z[5]*x[4]*
-y[0]-y[4]*y[1]*x[0]*z[4]+y[4]*y[5]*x[4]*z[1]+y[0]*z[0]*x[3]*y[7]-y[0]*z[1]*x[0]
-*y[2];
+ [0]*y[7]*y[7]*z[3]+z[0]*x[3]*y[7]*y[7]+y[7]*x[5]*y[4]*z[7]+y[7]*y[5]*x[7]*z[4]-
+ y[4]*x[1]*y[5]*z[0]-x[1]*y[0]*y[0]*z[2]-y[4]*y[5]*x[1]*z[4]-2.0*y[4]*z[5]*x[4]*
+ y[0]-y[4]*y[1]*x[0]*z[4]+y[4]*y[5]*x[4]*z[1]+y[0]*z[0]*x[3]*y[7]-y[0]*z[1]*x[0]
+ *y[2];
s8 = 2.0*y[0]*x[1]*y[3]*z[0]+y[4]*y[1]*x[4]*z[0]+2.0*y[0]*y[1]*x[0]*z[3]+
-y[4]*x[1]*y[0]*z[5]-y[4]*z[1]*x[5]*y[0]+y[4]*z[1]*x[0]*y[5]-y[4]*z[1]*x[4]*y[0]
-+y[4]*x[1]*y[0]*z[4]-y[4]*z[5]*x[4]*y[1]+x[5]*y[4]*y[4]*z[6]-z[5]*x[6]*y[4]*y
-[4]+y[4]*x[5]*y[1]*z[4]-y[0]*z[2]*x[0]*y[3]+y[0]*y[5]*x[4]*z[0]+y[0]*x[1]*y[2]*
-z[0];
+ y[4]*x[1]*y[0]*z[5]-y[4]*z[1]*x[5]*y[0]+y[4]*z[1]*x[0]*y[5]-y[4]*z[1]*x[4]*y[0]
+ +y[4]*x[1]*y[0]*z[4]-y[4]*z[5]*x[4]*y[1]+x[5]*y[4]*y[4]*z[6]-z[5]*x[6]*y[4]*y
+ [4]+y[4]*x[5]*y[1]*z[4]-y[0]*z[2]*x[0]*y[3]+y[0]*y[5]*x[4]*z[0]+y[0]*x[1]*y[2]*
+ z[0];
s6 = s8-2.0*y[0]*z[0]*x[4]*y[3]-2.0*y[0]*x[0]*y[4]*z[3]-2.0*y[0]*z[1]*x
-[0]*y[3]-y[0]*x[0]*y[7]*z[3]-2.0*y[0]*y[1]*x[3]*z[0]+y[0]*x[2]*y[3]*z[0]-y[0]*y
-[1]*x[2]*z[0]+y[0]*y[1]*x[0]*z[2]-y[0]*x[2]*y[1]*z[3]+y[0]*x[0]*y[3]*z[7]+y[0]*
-x[2]*y[3]*z[1]-y[0]*y[2]*x[3]*z[0]+y[0]*y[2]*x[0]*z[3]-y[0]*y[5]*x[0]*z[4]-y[4]
-*y[5]*x[4]*z[6]+s7;
+ [0]*y[3]-y[0]*x[0]*y[7]*z[3]-2.0*y[0]*y[1]*x[3]*z[0]+y[0]*x[2]*y[3]*z[0]-y[0]*y
+ [1]*x[2]*z[0]+y[0]*y[1]*x[0]*z[2]-y[0]*x[2]*y[1]*z[3]+y[0]*x[0]*y[3]*z[7]+y[0]*
+ x[2]*y[3]*z[1]-y[0]*y[2]*x[3]*z[0]+y[0]*y[2]*x[0]*z[3]-y[0]*y[5]*x[0]*z[4]-y[4]
+ *y[5]*x[4]*z[6]+s7;
s8 = s6+y[4]*z[6]*x[5]*y[7]-y[4]*x[6]*y[7]*z[5]+y[4]*x[6]*y[5]*z[7]-y[4]*
-z[6]*x[7]*y[5]-y[4]*x[5]*y[6]*z[4]+y[4]*z[5]*x[4]*y[6]+y[4]*y[5]*x[6]*z[4]-2.0*
-y[1]*y[1]*x[0]*z[5]+2.0*y[1]*y[1]*x[5]*z[0]-2.0*y[2]*y[2]*x[6]*z[3]+x[5]*y[1]*y
-[1]*z[4]-z[5]*x[4]*y[1]*y[1]-x[6]*y[2]*y[2]*z[7]+z[6]*x[7]*y[2]*y[2];
+ z[6]*x[7]*y[5]-y[4]*x[5]*y[6]*z[4]+y[4]*z[5]*x[4]*y[6]+y[4]*y[5]*x[6]*z[4]-2.0*
+ y[1]*y[1]*x[0]*z[5]+2.0*y[1]*y[1]*x[5]*z[0]-2.0*y[2]*y[2]*x[6]*z[3]+x[5]*y[1]*y
+ [1]*z[4]-z[5]*x[4]*y[1]*y[1]-x[6]*y[2]*y[2]*z[7]+z[6]*x[7]*y[2]*y[2];
s7 = s8-x[1]*y[5]*y[5]*z[0]+z[1]*x[0]*y[5]*y[5]+y[1]*y[5]*x[4]*z[1]-y[1]*
-y[5]*x[1]*z[4]-2.0*y[2]*z[2]*x[3]*y[6]+2.0*y[1]*z[1]*x[0]*y[5]-2.0*y[1]*z[1]*x
-[5]*y[0]+2.0*y[1]*x[1]*y[0]*z[5]-y[2]*x[2]*y[3]*z[7]-y[2]*z[2]*x[3]*y[7]+y[2]*x
-[2]*y[7]*z[3]+y[2]*z[2]*x[7]*y[3]-2.0*y[2]*x[2]*y[3]*z[6]+2.0*y[2]*x[2]*y[6]*z
-[3]+2.0*y[2]*z[2]*x[6]*y[3]-y[3]*y[2]*x[6]*z[3];
+ y[5]*x[1]*z[4]-2.0*y[2]*z[2]*x[3]*y[6]+2.0*y[1]*z[1]*x[0]*y[5]-2.0*y[1]*z[1]*x
+ [5]*y[0]+2.0*y[1]*x[1]*y[0]*z[5]-y[2]*x[2]*y[3]*z[7]-y[2]*z[2]*x[3]*y[7]+y[2]*x
+ [2]*y[7]*z[3]+y[2]*z[2]*x[7]*y[3]-2.0*y[2]*x[2]*y[3]*z[6]+2.0*y[2]*x[2]*y[6]*z
+ [3]+2.0*y[2]*z[2]*x[6]*y[3]-y[3]*y[2]*x[6]*z[3];
s8 = y[3]*y[2]*x[3]*z[6]+y[3]*x[2]*y[6]*z[3]-y[3]*z[2]*x[3]*y[6]-y[2]*y
-[2]*x[7]*z[3]+2.0*y[2]*y[2]*x[3]*z[6]+y[2]*y[2]*x[3]*z[7]-2.0*y[1]*x[1]*y[5]*z
-[0]-x[2]*y[3]*y[3]*z[6]+z[2]*x[6]*y[3]*y[3]+2.0*y[6]*x[2]*y[5]*z[6]+2.0*y[6]*x
-[6]*y[2]*z[5]-2.0*y[6]*x[5]*y[2]*z[6]+2.0*y[3]*x[2]*y[7]*z[3]-2.0*y[3]*z[2]*x
-[3]*y[7]-y[0]*z[0]*x[7]*y[3]-y[0]*z[2]*x[1]*y[3];
+ [2]*x[7]*z[3]+2.0*y[2]*y[2]*x[3]*z[6]+y[2]*y[2]*x[3]*z[7]-2.0*y[1]*x[1]*y[5]*z
+ [0]-x[2]*y[3]*y[3]*z[6]+z[2]*x[6]*y[3]*y[3]+2.0*y[6]*x[2]*y[5]*z[6]+2.0*y[6]*x
+ [6]*y[2]*z[5]-2.0*y[6]*x[5]*y[2]*z[6]+2.0*y[3]*x[2]*y[7]*z[3]-2.0*y[3]*z[2]*x
+ [3]*y[7]-y[0]*z[0]*x[7]*y[3]-y[0]*z[2]*x[1]*y[3];
s4 = s8-y[2]*y[6]*x[7]*z[2]+y[0]*z[2]*x[3]*y[1]+y[1]*z[5]*x[1]*y[4]-y[1]*
-x[5]*y[4]*z[1]+2.0*y[0]*z[0]*x[3]*y[4]+2.0*y[0]*x[0]*y[3]*z[4]+2.0*z[2]*x[7]*y
-[3]*y[3]-2.0*z[5]*x[7]*y[4]*y[4]+x[6]*y[4]*y[4]*z[7]-z[6]*x[7]*y[4]*y[4]+y[1]*y
-[1]*x[0]*z[3]+y[3]*x[6]*y[7]*z[2]-y[3]*z[6]*x[2]*y[7]+2.0*y[3]*y[2]*x[3]*z[7]+
-s5+s7;
+ x[5]*y[4]*z[1]+2.0*y[0]*z[0]*x[3]*y[4]+2.0*y[0]*x[0]*y[3]*z[4]+2.0*z[2]*x[7]*y
+ [3]*y[3]-2.0*z[5]*x[7]*y[4]*y[4]+x[6]*y[4]*y[4]*z[7]-z[6]*x[7]*y[4]*y[4]+y[1]*y
+ [1]*x[0]*z[3]+y[3]*x[6]*y[7]*z[2]-y[3]*z[6]*x[2]*y[7]+2.0*y[3]*y[2]*x[3]*z[7]+
+ s5+s7;
s8 = s4+y[2]*x[6]*y[7]*z[2]-y[2]*y[6]*x[7]*z[3]+y[2]*y[6]*x[2]*z[7]-y[2]*
-z[6]*x[2]*y[7]-y[2]*x[6]*y[3]*z[7]+y[2]*y[6]*x[3]*z[7]+y[2]*z[6]*x[7]*y[3]-2.0*
-y[3]*y[2]*x[7]*z[3]-x[6]*y[3]*y[3]*z[7]+y[1]*y[1]*x[4]*z[0]-y[1]*y[1]*x[3]*z[0]
-+x[2]*y[6]*y[6]*z[3]-z[2]*x[3]*y[6]*y[6]-y[1]*y[1]*x[0]*z[4];
+ z[6]*x[2]*y[7]-y[2]*x[6]*y[3]*z[7]+y[2]*y[6]*x[3]*z[7]+y[2]*z[6]*x[7]*y[3]-2.0*
+ y[3]*y[2]*x[7]*z[3]-x[6]*y[3]*y[3]*z[7]+y[1]*y[1]*x[4]*z[0]-y[1]*y[1]*x[3]*z[0]
+ +x[2]*y[6]*y[6]*z[3]-z[2]*x[3]*y[6]*y[6]-y[1]*y[1]*x[0]*z[4];
s7 = s8+y[5]*x[1]*y[0]*z[5]+y[6]*x[2]*y[7]*z[3]-y[6]*y[2]*x[6]*z[3]+y[6]*
-y[2]*x[3]*z[6]-y[6]*x[2]*y[3]*z[6]+y[6]*z[2]*x[6]*y[3]-y[5]*y[1]*x[0]*z[5]-y[5]
-*z[1]*x[5]*y[0]+y[5]*y[1]*x[5]*z[0]-y[6]*z[2]*x[3]*y[7]-y[7]*y[6]*x[7]*z[2]+2.0
-*y[6]*y[6]*x[2]*z[7]+y[6]*y[6]*x[3]*z[7]+x[6]*y[7]*y[7]*z[2]-z[6]*x[2]*y[7]*y
-[7];
+ y[2]*x[3]*z[6]-y[6]*x[2]*y[3]*z[6]+y[6]*z[2]*x[6]*y[3]-y[5]*y[1]*x[0]*z[5]-y[5]
+ *z[1]*x[5]*y[0]+y[5]*y[1]*x[5]*z[0]-y[6]*z[2]*x[3]*y[7]-y[7]*y[6]*x[7]*z[2]+2.0
+ *y[6]*y[6]*x[2]*z[7]+y[6]*y[6]*x[3]*z[7]+x[6]*y[7]*y[7]*z[2]-z[6]*x[2]*y[7]*y
+ [7];
s8 = -x[2]*y[1]*y[1]*z[3]+2.0*y[1]*y[1]*x[0]*z[2]-2.0*y[1]*y[1]*x[2]*z[0]
-+z[2]*x[3]*y[1]*y[1]-z[1]*x[0]*y[2]*y[2]+x[1]*y[2]*y[2]*z[0]+y[2]*y[2]*x[0]*z
-[3]-y[2]*y[2]*x[3]*z[0]-2.0*y[2]*y[2]*x[3]*z[1]+y[1]*x[1]*y[3]*z[0]-2.0*y[6]*y
-[6]*x[7]*z[2]+2.0*y[5]*y[5]*x[4]*z[1]-2.0*y[5]*y[5]*x[1]*z[4]-y[6]*y[6]*x[7]*z
-[3]-2.0*y[1]*x[1]*y[0]*z[2];
+ +z[2]*x[3]*y[1]*y[1]-z[1]*x[0]*y[2]*y[2]+x[1]*y[2]*y[2]*z[0]+y[2]*y[2]*x[0]*z
+ [3]-y[2]*y[2]*x[3]*z[0]-2.0*y[2]*y[2]*x[3]*z[1]+y[1]*x[1]*y[3]*z[0]-2.0*y[6]*y
+ [6]*x[7]*z[2]+2.0*y[5]*y[5]*x[4]*z[1]-2.0*y[5]*y[5]*x[1]*z[4]-y[6]*y[6]*x[7]*z
+ [3]-2.0*y[1]*x[1]*y[0]*z[2];
s6 = s8+2.0*y[1]*z[1]*x[2]*y[0]-2.0*y[1]*z[1]*x[0]*y[2]+2.0*y[1]*x[1]*y
-[2]*z[0]+y[1]*x[2]*y[3]*z[1]-y[1]*y[2]*x[3]*z[1]-y[1]*z[2]*x[1]*y[3]+y[1]*y[2]*
-x[1]*z[3]-y[2]*x[1]*y[0]*z[2]+y[2]*z[1]*x[2]*y[0]+y[2]*x[2]*y[3]*z[0]-y[7]*x[6]
-*y[2]*z[7]+y[7]*z[6]*x[7]*y[2]+y[7]*y[6]*x[2]*z[7]-y[6]*x[6]*y[3]*z[7]+y[6]*x
-[6]*y[7]*z[3]+s7;
+ [2]*z[0]+y[1]*x[2]*y[3]*z[1]-y[1]*y[2]*x[3]*z[1]-y[1]*z[2]*x[1]*y[3]+y[1]*y[2]*
+ x[1]*z[3]-y[2]*x[1]*y[0]*z[2]+y[2]*z[1]*x[2]*y[0]+y[2]*x[2]*y[3]*z[0]-y[7]*x[6]
+ *y[2]*z[7]+y[7]*z[6]*x[7]*y[2]+y[7]*y[6]*x[2]*z[7]-y[6]*x[6]*y[3]*z[7]+y[6]*x
+ [6]*y[7]*z[3]+s7;
s8 = s6-y[6]*z[6]*x[3]*y[7]+y[6]*z[6]*x[7]*y[3]+2.0*y[2]*y[2]*x[1]*z[3]+x
-[2]*y[3]*y[3]*z[1]-z[2]*x[1]*y[3]*y[3]+y[1]*x[1]*y[0]*z[4]+y[1]*z[1]*x[3]*y[0]-
-y[1]*x[1]*y[0]*z[3]+2.0*y[5]*x[5]*y[1]*z[4]-2.0*y[5]*x[5]*y[4]*z[1]+2.0*y[5]*z
-[5]*x[1]*y[4]-2.0*y[5]*z[5]*x[4]*y[1]-2.0*y[6]*x[6]*y[2]*z[7]+2.0*y[6]*x[6]*y
-[7]*z[2];
+ [2]*y[3]*y[3]*z[1]-z[2]*x[1]*y[3]*y[3]+y[1]*x[1]*y[0]*z[4]+y[1]*z[1]*x[3]*y[0]-
+ y[1]*x[1]*y[0]*z[3]+2.0*y[5]*x[5]*y[1]*z[4]-2.0*y[5]*x[5]*y[4]*z[1]+2.0*y[5]*z
+ [5]*x[1]*y[4]-2.0*y[5]*z[5]*x[4]*y[1]-2.0*y[6]*x[6]*y[2]*z[7]+2.0*y[6]*x[6]*y
+ [7]*z[2];
s7 = s8+2.0*y[6]*z[6]*x[7]*y[2]-2.0*y[6]*z[6]*x[2]*y[7]-y[1]*z[1]*x[4]*y
-[0]+y[1]*z[1]*x[0]*y[4]-y[1]*z[1]*x[0]*y[3]+2.0*y[6]*y[6]*x[7]*z[5]+2.0*y[5]*y
-[5]*x[6]*z[4]-2.0*y[5]*y[5]*x[4]*z[6]+x[6]*y[5]*y[5]*z[7]-y[3]*x[2]*y[1]*z[3]-y
-[3]*y[2]*x[3]*z[1]+y[3]*z[2]*x[3]*y[1]+y[3]*y[2]*x[1]*z[3]-y[2]*x[2]*y[0]*z[3]+
-y[2]*z[2]*x[3]*y[0];
+ [0]+y[1]*z[1]*x[0]*y[4]-y[1]*z[1]*x[0]*y[3]+2.0*y[6]*y[6]*x[7]*z[5]+2.0*y[5]*y
+ [5]*x[6]*z[4]-2.0*y[5]*y[5]*x[4]*z[6]+x[6]*y[5]*y[5]*z[7]-y[3]*x[2]*y[1]*z[3]-y
+ [3]*y[2]*x[3]*z[1]+y[3]*z[2]*x[3]*y[1]+y[3]*y[2]*x[1]*z[3]-y[2]*x[2]*y[0]*z[3]+
+ y[2]*z[2]*x[3]*y[0];
s8 = s7+2.0*y[2]*x[2]*y[3]*z[1]-2.0*y[2]*x[2]*y[1]*z[3]+y[2]*y[1]*x[0]*z
-[2]-y[2]*y[1]*x[2]*z[0]+2.0*y[2]*z[2]*x[3]*y[1]-2.0*y[2]*z[2]*x[1]*y[3]-y[2]*z
-[2]*x[0]*y[3]+y[5]*z[6]*x[5]*y[7]-y[5]*x[6]*y[7]*z[5]-y[5]*y[6]*x[4]*z[7]-y[5]*
-y[6]*x[5]*z[7]-2.0*y[5]*x[5]*y[6]*z[4]+2.0*y[5]*x[5]*y[4]*z[6]-2.0*y[5]*z[5]*x
-[6]*y[4]+2.0*y[5]*z[5]*x[4]*y[6];
+ [2]-y[2]*y[1]*x[2]*z[0]+2.0*y[2]*z[2]*x[3]*y[1]-2.0*y[2]*z[2]*x[1]*y[3]-y[2]*z
+ [2]*x[0]*y[3]+y[5]*z[6]*x[5]*y[7]-y[5]*x[6]*y[7]*z[5]-y[5]*y[6]*x[4]*z[7]-y[5]*
+ y[6]*x[5]*z[7]-2.0*y[5]*x[5]*y[6]*z[4]+2.0*y[5]*x[5]*y[4]*z[6]-2.0*y[5]*z[5]*x
+ [6]*y[4]+2.0*y[5]*z[5]*x[4]*y[6];
s5 = s8-y[1]*y[5]*x[0]*z[4]-z[6]*x[7]*y[5]*y[5]+y[6]*y[6]*x[7]*z[4]-y[6]*
-y[6]*x[4]*z[7]-2.0*y[6]*y[6]*x[5]*z[7]-x[5]*y[6]*y[6]*z[4]+z[5]*x[4]*y[6]*y[6]+
-z[6]*x[5]*y[7]*y[7]-x[6]*y[7]*y[7]*z[5]+y[1]*y[5]*x[4]*z[0]+y[7]*y[6]*x[7]*z[5]
-+y[6]*y[5]*x[7]*z[4]+y[5]*y[6]*x[7]*z[5]+y[6]*y[5]*x[6]*z[4]-y[6]*y[5]*x[4]*z
-[6]+2.0*y[6]*z[6]*x[5]*y[7];
+ y[6]*x[4]*z[7]-2.0*y[6]*y[6]*x[5]*z[7]-x[5]*y[6]*y[6]*z[4]+z[5]*x[4]*y[6]*y[6]+
+ z[6]*x[5]*y[7]*y[7]-x[6]*y[7]*y[7]*z[5]+y[1]*y[5]*x[4]*z[0]+y[7]*y[6]*x[7]*z[5]
+ +y[6]*y[5]*x[7]*z[4]+y[5]*y[6]*x[7]*z[5]+y[6]*y[5]*x[6]*z[4]-y[6]*y[5]*x[4]*z
+ [6]+2.0*y[6]*z[6]*x[5]*y[7];
s8 = s5-2.0*y[6]*x[6]*y[7]*z[5]+2.0*y[6]*x[6]*y[5]*z[7]-2.0*y[6]*z[6]*x
-[7]*y[5]-y[6]*x[5]*y[7]*z[4]-y[6]*x[6]*y[7]*z[4]+y[6]*x[6]*y[4]*z[7]-y[6]*z[6]*
-x[7]*y[4]+y[6]*z[5]*x[4]*y[7]+y[6]*z[6]*x[4]*y[7]+y[6]*x[5]*y[4]*z[6]-y[6]*z[5]
-*x[6]*y[4]+y[7]*x[6]*y[5]*z[7]-y[7]*z[6]*x[7]*y[5]-2.0*y[6]*x[6]*y[5]*z[2];
+ [7]*y[5]-y[6]*x[5]*y[7]*z[4]-y[6]*x[6]*y[7]*z[4]+y[6]*x[6]*y[4]*z[7]-y[6]*z[6]*
+ x[7]*y[4]+y[6]*z[5]*x[4]*y[7]+y[6]*z[6]*x[4]*y[7]+y[6]*x[5]*y[4]*z[6]-y[6]*z[5]
+ *x[6]*y[4]+y[7]*x[6]*y[5]*z[7]-y[7]*z[6]*x[7]*y[5]-2.0*y[6]*x[6]*y[5]*z[2];
s7 = s8-y[7]*y[6]*x[5]*z[7]+2.0*y[4]*y[5]*x[4]*z[0]+2.0*x[3]*y[7]*y[7]*z
-[4]-2.0*x[4]*y[7]*y[7]*z[3]-z[0]*x[4]*y[7]*y[7]+x[0]*y[7]*y[7]*z[4]-y[0]*z[5]*x
-[4]*y[1]+y[0]*x[5]*y[1]*z[4]-y[0]*x[5]*y[4]*z[0]+y[0]*z[5]*x[0]*y[4]-y[5]*y[5]*
-x[0]*z[4]+y[5]*y[5]*x[4]*z[0]+2.0*y[1]*y[1]*x[2]*z[5]-2.0*y[1]*y[1]*x[5]*z[2]+z
-[1]*x[5]*y[2]*y[2];
+ [4]-2.0*x[4]*y[7]*y[7]*z[3]-z[0]*x[4]*y[7]*y[7]+x[0]*y[7]*y[7]*z[4]-y[0]*z[5]*x
+ [4]*y[1]+y[0]*x[5]*y[1]*z[4]-y[0]*x[5]*y[4]*z[0]+y[0]*z[5]*x[0]*y[4]-y[5]*y[5]*
+ x[0]*z[4]+y[5]*y[5]*x[4]*z[0]+2.0*y[1]*y[1]*x[2]*z[5]-2.0*y[1]*y[1]*x[5]*z[2]+z
+ [1]*x[5]*y[2]*y[2];
s8 = s7-x[1]*y[2]*y[2]*z[5]-y[5]*z[5]*x[4]*y[0]+y[5]*z[5]*x[0]*y[4]-y[5]*
-x[5]*y[4]*z[0]-y[2]*x[1]*y[6]*z[5]-y[2]*y[1]*x[5]*z[6]+y[2]*z[1]*x[5]*y[6]+y[2]
-*y[1]*x[6]*z[5]-y[1]*z[1]*x[6]*y[5]-y[1]*x[1]*y[6]*z[5]+y[1]*x[1]*y[5]*z[6]+y
-[1]*z[1]*x[5]*y[6]+y[5]*x[5]*y[0]*z[4]+y[2]*y[1]*x[2]*z[5]-y[2]*z[1]*x[2]*y[5];
+ x[5]*y[4]*z[0]-y[2]*x[1]*y[6]*z[5]-y[2]*y[1]*x[5]*z[6]+y[2]*z[1]*x[5]*y[6]+y[2]
+ *y[1]*x[6]*z[5]-y[1]*z[1]*x[6]*y[5]-y[1]*x[1]*y[6]*z[5]+y[1]*x[1]*y[5]*z[6]+y
+ [1]*z[1]*x[5]*y[6]+y[5]*x[5]*y[0]*z[4]+y[2]*y[1]*x[2]*z[5]-y[2]*z[1]*x[2]*y[5];
s6 = s8+y[2]*x[1]*y[5]*z[2]-y[2]*y[1]*x[5]*z[2]-y[1]*y[1]*x[5]*z[6]+y[1]*
-y[1]*x[6]*z[5]-z[1]*x[2]*y[5]*y[5]+x[1]*y[5]*y[5]*z[2]+2.0*y[1]*z[1]*x[5]*y[2]
--2.0*y[1]*x[1]*y[2]*z[5]-2.0*y[1]*z[1]*x[2]*y[5]+2.0*y[1]*x[1]*y[5]*z[2]-y[1]*y
-[1]*x[6]*z[2]+y[1]*y[1]*x[2]*z[6]-2.0*y[5]*x[1]*y[6]*z[5]-2.0*y[5]*y[1]*x[5]*z
-[6]+2.0*y[5]*z[1]*x[5]*y[6]+2.0*y[5]*y[1]*x[6]*z[5];
+ y[1]*x[6]*z[5]-z[1]*x[2]*y[5]*y[5]+x[1]*y[5]*y[5]*z[2]+2.0*y[1]*z[1]*x[5]*y[2]
+ -2.0*y[1]*x[1]*y[2]*z[5]-2.0*y[1]*z[1]*x[2]*y[5]+2.0*y[1]*x[1]*y[5]*z[2]-y[1]*y
+ [1]*x[6]*z[2]+y[1]*y[1]*x[2]*z[6]-2.0*y[5]*x[1]*y[6]*z[5]-2.0*y[5]*y[1]*x[5]*z
+ [6]+2.0*y[5]*z[1]*x[5]*y[6]+2.0*y[5]*y[1]*x[6]*z[5];
s8 = s6-y[6]*z[1]*x[6]*y[5]-y[6]*y[1]*x[5]*z[6]+y[6]*x[1]*y[5]*z[6]+y[6]*
-y[1]*x[6]*z[5]-2.0*z[1]*x[6]*y[5]*y[5]+2.0*x[1]*y[5]*y[5]*z[6]-x[1]*y[6]*y[6]*z
-[5]+z[1]*x[5]*y[6]*y[6]+y[5]*z[1]*x[5]*y[2]-y[5]*x[1]*y[2]*z[5]+y[5]*y[1]*x[2]*
-z[5]-y[5]*y[1]*x[5]*z[2]-y[6]*z[1]*x[2]*y[5]+y[6]*x[1]*y[5]*z[2];
+ y[1]*x[6]*z[5]-2.0*z[1]*x[6]*y[5]*y[5]+2.0*x[1]*y[5]*y[5]*z[6]-x[1]*y[6]*y[6]*z
+ [5]+z[1]*x[5]*y[6]*y[6]+y[5]*z[1]*x[5]*y[2]-y[5]*x[1]*y[2]*z[5]+y[5]*y[1]*x[2]*
+ z[5]-y[5]*y[1]*x[5]*z[2]-y[6]*z[1]*x[2]*y[5]+y[6]*x[1]*y[5]*z[2];
s7 = s8-y[1]*z[1]*x[2]*y[6]-y[1]*x[1]*y[2]*z[6]+y[1]*x[1]*y[6]*z[2]+y[1]*
-z[1]*x[6]*y[2]+y[5]*x[5]*y[6]*z[2]-y[5]*x[2]*y[6]*z[5]+y[5]*x[6]*y[2]*z[5]-y[5]
-*x[5]*y[2]*z[6]-x[6]*y[5]*y[5]*z[2]+x[2]*y[5]*y[5]*z[6]-y[5]*y[5]*x[4]*z[7]+y
-[5]*y[5]*x[7]*z[4]-y[1]*x[6]*y[5]*z[2]+y[1]*x[2]*y[5]*z[6]-y[2]*x[6]*y[5]*z[2]
--2.0*y[2]*y[1]*x[6]*z[2];
+ z[1]*x[6]*y[2]+y[5]*x[5]*y[6]*z[2]-y[5]*x[2]*y[6]*z[5]+y[5]*x[6]*y[2]*z[5]-y[5]
+ *x[5]*y[2]*z[6]-x[6]*y[5]*y[5]*z[2]+x[2]*y[5]*y[5]*z[6]-y[5]*y[5]*x[4]*z[7]+y
+ [5]*y[5]*x[7]*z[4]-y[1]*x[6]*y[5]*z[2]+y[1]*x[2]*y[5]*z[6]-y[2]*x[6]*y[5]*z[2]
+ -2.0*y[2]*y[1]*x[6]*z[2];
s8 = s7-2.0*y[2]*z[1]*x[2]*y[6]+2.0*y[2]*x[1]*y[6]*z[2]+2.0*y[2]*y[1]*x
-[2]*z[6]-2.0*x[1]*y[2]*y[2]*z[6]+2.0*z[1]*x[6]*y[2]*y[2]+x[6]*y[2]*y[2]*z[5]-x
-[5]*y[2]*y[2]*z[6]+2.0*x[5]*y[6]*y[6]*z[2]-2.0*x[2]*y[6]*y[6]*z[5]-z[1]*x[2]*y
-[6]*y[6]-y[6]*y[1]*x[6]*z[2]-y[6]*x[1]*y[2]*z[6]+y[6]*z[1]*x[6]*y[2]+y[6]*y[1]*
-x[2]*z[6]+x[1]*y[6]*y[6]*z[2];
+ [2]*z[6]-2.0*x[1]*y[2]*y[2]*z[6]+2.0*z[1]*x[6]*y[2]*y[2]+x[6]*y[2]*y[2]*z[5]-x
+ [5]*y[2]*y[2]*z[6]+2.0*x[5]*y[6]*y[6]*z[2]-2.0*x[2]*y[6]*y[6]*z[5]-z[1]*x[2]*y
+ [6]*y[6]-y[6]*y[1]*x[6]*z[2]-y[6]*x[1]*y[2]*z[6]+y[6]*z[1]*x[6]*y[2]+y[6]*y[1]*
+ x[2]*z[6]+x[1]*y[6]*y[6]*z[2];
s3 = s8+y[2]*x[5]*y[6]*z[2]+y[2]*x[2]*y[5]*z[6]-y[2]*x[2]*y[6]*z[5]+y[5]*
-z[5]*x[4]*y[7]+y[5]*x[5]*y[4]*z[7]-y[5]*z[5]*x[7]*y[4]-y[5]*x[5]*y[7]*z[4]+2.0*
-y[4]*x[5]*y[0]*z[4]-y[3]*z[6]*x[3]*y[7]+y[3]*y[6]*x[3]*z[7]+y[3]*x[6]*y[7]*z[3]
--y[3]*y[6]*x[7]*z[3]-y[2]*y[1]*x[3]*z[0]-y[2]*z[1]*x[0]*y[3]+y[2]*y[1]*x[0]*z
-[3]+y[2]*x[1]*y[3]*z[0];
+ z[5]*x[4]*y[7]+y[5]*x[5]*y[4]*z[7]-y[5]*z[5]*x[7]*y[4]-y[5]*x[5]*y[7]*z[4]+2.0*
+ y[4]*x[5]*y[0]*z[4]-y[3]*z[6]*x[3]*y[7]+y[3]*y[6]*x[3]*z[7]+y[3]*x[6]*y[7]*z[3]
+ -y[3]*y[6]*x[7]*z[3]-y[2]*y[1]*x[3]*z[0]-y[2]*z[1]*x[0]*y[3]+y[2]*y[1]*x[0]*z
+ [3]+y[2]*x[1]*y[3]*z[0];
s8 = y[1]*x[0]*z[3]+x[1]*y[3]*z[0]-y[0]*x[3]*z[7]-x[1]*y[5]*z[0]-y[0]*x
-[3]*z[4]-x[1]*y[0]*z[2]+z[1]*x[2]*y[0]-y[1]*x[0]*z[5]-z[1]*x[0]*y[2]-y[1]*x[0]*
-z[4]+z[1]*x[5]*y[2]+z[0]*x[7]*y[4]+z[0]*x[3]*y[7]+z[1]*x[0]*y[4]-x[1]*y[2]*z[5]
-+x[2]*y[3]*z[0]+y[1]*x[2]*z[5]-x[2]*y[3]*z[7];
+ [3]*z[4]-x[1]*y[0]*z[2]+z[1]*x[2]*y[0]-y[1]*x[0]*z[5]-z[1]*x[0]*y[2]-y[1]*x[0]*
+ z[4]+z[1]*x[5]*y[2]+z[0]*x[7]*y[4]+z[0]*x[3]*y[7]+z[1]*x[0]*y[4]-x[1]*y[2]*z[5]
+ +x[2]*y[3]*z[0]+y[1]*x[2]*z[5]-x[2]*y[3]*z[7];
s7 = s8-z[1]*x[2]*y[5]-y[1]*x[3]*z[0]-x[0]*y[7]*z[3]-z[1]*x[0]*y[3]+y[5]*
-x[4]*z[0]-x[0]*y[4]*z[3]+y[5]*x[7]*z[4]-z[0]*x[4]*y[3]+x[1]*y[0]*z[4]-z[2]*x[3]
-*y[7]-y[6]*x[7]*z[2]+x[1]*y[5]*z[2]+y[6]*x[7]*z[5]+x[0]*y[7]*z[4]+x[1]*y[2]*z
-[0]-z[1]*x[4]*y[0]-z[0]*x[4]*y[7]-z[2]*x[0]*y[3];
+ x[4]*z[0]-x[0]*y[4]*z[3]+y[5]*x[7]*z[4]-z[0]*x[4]*y[3]+x[1]*y[0]*z[4]-z[2]*x[3]
+ *y[7]-y[6]*x[7]*z[2]+x[1]*y[5]*z[2]+y[6]*x[7]*z[5]+x[0]*y[7]*z[4]+x[1]*y[2]*z
+ [0]-z[1]*x[4]*y[0]-z[0]*x[4]*y[7]-z[2]*x[0]*y[3];
s8 = x[5]*y[0]*z[4]+z[1]*x[0]*y[5]-x[2]*y[0]*z[3]-z[1]*x[5]*y[0]+y[1]*x
-[5]*z[0]-x[1]*y[0]*z[3]-x[1]*y[4]*z[0]-y[1]*x[5]*z[2]+x[2]*y[7]*z[3]+y[0]*x[4]*
-z[3]-x[0]*y[4]*z[7]+x[1]*y[0]*z[5]-y[1]*x[6]*z[2]-y[2]*x[6]*z[3]+y[0]*x[7]*z[3]
--y[2]*x[7]*z[3]+z[2]*x[7]*y[3]+y[2]*x[0]*z[3];
+ [5]*z[0]-x[1]*y[0]*z[3]-x[1]*y[4]*z[0]-y[1]*x[5]*z[2]+x[2]*y[7]*z[3]+y[0]*x[4]*
+ z[3]-x[0]*y[4]*z[7]+x[1]*y[0]*z[5]-y[1]*x[6]*z[2]-y[2]*x[6]*z[3]+y[0]*x[7]*z[3]
+ -y[2]*x[7]*z[3]+z[2]*x[7]*y[3]+y[2]*x[0]*z[3];
s6 = s8+y[2]*x[3]*z[7]-y[2]*x[3]*z[0]-x[6]*y[5]*z[2]-y[5]*x[0]*z[4]+z[2]*
-x[3]*y[0]+x[2]*y[3]*z[1]+x[0]*y[3]*z[7]-x[2]*y[1]*z[3]+y[1]*x[4]*z[0]+y[1]*x[0]
-*z[2]-z[1]*x[2]*y[6]+y[2]*x[3]*z[6]-y[1]*x[2]*z[0]+z[1]*x[3]*y[0]-x[1]*y[2]*z
-[6]-x[2]*y[3]*z[6]+x[0]*y[3]*z[4]+z[0]*x[3]*y[4]+s7;
+ x[3]*y[0]+x[2]*y[3]*z[1]+x[0]*y[3]*z[7]-x[2]*y[1]*z[3]+y[1]*x[4]*z[0]+y[1]*x[0]
+ *z[2]-z[1]*x[2]*y[6]+y[2]*x[3]*z[6]-y[1]*x[2]*z[0]+z[1]*x[3]*y[0]-x[1]*y[2]*z
+ [6]-x[2]*y[3]*z[6]+x[0]*y[3]*z[4]+z[0]*x[3]*y[4]+s7;
s8 = x[5]*y[4]*z[7]+s6+y[5]*x[6]*z[4]-y[5]*x[4]*z[6]+z[6]*x[5]*y[7]-x[6]*
-y[2]*z[7]-x[6]*y[7]*z[5]+x[5]*y[6]*z[2]+x[6]*y[5]*z[7]+x[6]*y[7]*z[2]+y[6]*x[7]
-*z[4]-y[6]*x[4]*z[7]-y[6]*x[7]*z[3]+z[6]*x[7]*y[2]+x[2]*y[5]*z[6]-x[2]*y[6]*z
-[5]+y[6]*x[2]*z[7]+x[6]*y[2]*z[5];
+ y[2]*z[7]-x[6]*y[7]*z[5]+x[5]*y[6]*z[2]+x[6]*y[5]*z[7]+x[6]*y[7]*z[2]+y[6]*x[7]
+ *z[4]-y[6]*x[4]*z[7]-y[6]*x[7]*z[3]+z[6]*x[7]*y[2]+x[2]*y[5]*z[6]-x[2]*y[6]*z
+ [5]+y[6]*x[2]*z[7]+x[6]*y[2]*z[5];
s7 = s8-x[5]*y[2]*z[6]-z[6]*x[7]*y[5]-z[5]*x[7]*y[4]+z[5]*x[0]*y[4]-y[5]*
-x[4]*z[7]+y[0]*x[4]*z[7]-z[6]*x[2]*y[7]-x[5]*y[4]*z[0]-x[5]*y[7]*z[4]-y[0]*x[7]
-*z[4]+y[5]*x[4]*z[1]-x[6]*y[7]*z[4]+x[7]*y[4]*z[3]-x[4]*y[7]*z[3]+x[3]*y[7]*z
-[4]-x[7]*y[3]*z[4]-x[6]*y[3]*z[7]+x[6]*y[4]*z[7];
+ x[4]*z[7]+y[0]*x[4]*z[7]-z[6]*x[2]*y[7]-x[5]*y[4]*z[0]-x[5]*y[7]*z[4]-y[0]*x[7]
+ *z[4]+y[5]*x[4]*z[1]-x[6]*y[7]*z[4]+x[7]*y[4]*z[3]-x[4]*y[7]*z[3]+x[3]*y[7]*z
+ [4]-x[7]*y[3]*z[4]-x[6]*y[3]*z[7]+x[6]*y[4]*z[7];
s8 = -x[3]*y[4]*z[7]+x[4]*y[3]*z[7]-z[6]*x[7]*y[4]-z[1]*x[6]*y[5]+x[6]*y
-[7]*z[3]-x[1]*y[6]*z[5]-y[1]*x[5]*z[6]+z[5]*x[4]*y[7]-z[5]*x[4]*y[0]+x[1]*y[5]*
-z[6]-y[6]*x[5]*z[7]-y[2]*x[3]*z[1]+z[1]*x[5]*y[6]-y[5]*x[1]*z[4]+z[6]*x[4]*y[7]
-+x[5]*y[1]*z[4]-x[5]*y[6]*z[4]+y[6]*x[3]*z[7]-x[5]*y[4]*z[1];
+ [7]*z[3]-x[1]*y[6]*z[5]-y[1]*x[5]*z[6]+z[5]*x[4]*y[7]-z[5]*x[4]*y[0]+x[1]*y[5]*
+ z[6]-y[6]*x[5]*z[7]-y[2]*x[3]*z[1]+z[1]*x[5]*y[6]-y[5]*x[1]*z[4]+z[6]*x[4]*y[7]
+ +x[5]*y[1]*z[4]-x[5]*y[6]*z[4]+y[6]*x[3]*z[7]-x[5]*y[4]*z[1];
s5 = s8+x[5]*y[4]*z[6]+z[5]*x[1]*y[4]+y[1]*x[6]*z[5]-z[6]*x[3]*y[7]+z[6]*
-x[7]*y[3]-z[5]*x[6]*y[4]-z[5]*x[4]*y[1]+z[5]*x[4]*y[6]+x[1]*y[6]*z[2]+x[2]*y[6]
-*z[3]+z[2]*x[6]*y[3]+z[1]*x[6]*y[2]+z[2]*x[3]*y[1]-z[2]*x[1]*y[3]-z[2]*x[3]*y
-[6]+y[2]*x[1]*z[3]+y[1]*x[2]*z[6]-z[0]*x[7]*y[3]+s7;
+ x[7]*y[3]-z[5]*x[6]*y[4]-z[5]*x[4]*y[1]+z[5]*x[4]*y[6]+x[1]*y[6]*z[2]+x[2]*y[6]
+ *z[3]+z[2]*x[6]*y[3]+z[1]*x[6]*y[2]+z[2]*x[3]*y[1]-z[2]*x[1]*y[3]-z[2]*x[3]*y
+ [6]+y[2]*x[1]*z[3]+y[1]*x[2]*z[6]-z[0]*x[7]*y[3]+s7;
s4 = 1/s5;
s2 = s3*s4;
const double unknown1 = s1*s2;
s1 = 1.0/6.0;
s8 = -z[2]*x[1]*y[2]*z[5]+z[2]*y[1]*x[2]*z[5]-z[2]*z[1]*x[2]*y[5]+z[2]*z
-[1]*x[5]*y[2]+2.0*y[5]*x[7]*z[4]*z[4]-y[1]*x[2]*z[0]*z[0]+x[0]*y[3]*z[7]*z[7]
--2.0*z[5]*z[5]*x[4]*y[1]+2.0*z[5]*z[5]*x[1]*y[4]+z[5]*z[5]*x[0]*y[4]-2.0*z[2]*z
-[2]*x[1]*y[3]+2.0*z[2]*z[2]*x[3]*y[1]-x[0]*y[4]*z[7]*z[7]-y[0]*x[3]*z[7]*z[7]+x
-[1]*y[0]*z[5]*z[5];
+ [1]*x[5]*y[2]+2.0*y[5]*x[7]*z[4]*z[4]-y[1]*x[2]*z[0]*z[0]+x[0]*y[3]*z[7]*z[7]
+ -2.0*z[5]*z[5]*x[4]*y[1]+2.0*z[5]*z[5]*x[1]*y[4]+z[5]*z[5]*x[0]*y[4]-2.0*z[2]*z
+ [2]*x[1]*y[3]+2.0*z[2]*z[2]*x[3]*y[1]-x[0]*y[4]*z[7]*z[7]-y[0]*x[3]*z[7]*z[7]+x
+ [1]*y[0]*z[5]*z[5];
s7 = s8-y[1]*x[0]*z[5]*z[5]+z[1]*y[1]*x[2]*z[6]+y[1]*x[0]*z[2]*z[2]+z[2]*
-z[2]*x[3]*y[0]-z[2]*z[2]*x[0]*y[3]-x[1]*y[0]*z[2]*z[2]+2.0*z[5]*z[5]*x[4]*y[6]
--2.0*z[5]*z[5]*x[6]*y[4]-z[5]*z[5]*x[7]*y[4]-x[6]*y[7]*z[5]*z[5]+2.0*z[2]*y[1]*
-x[2]*z[6]-2.0*z[2]*x[1]*y[2]*z[6]+2.0*z[2]*z[1]*x[6]*y[2]-y[6]*x[5]*z[7]*z[7]+
-2.0*x[6]*y[4]*z[7]*z[7];
+ z[2]*x[3]*y[0]-z[2]*z[2]*x[0]*y[3]-x[1]*y[0]*z[2]*z[2]+2.0*z[5]*z[5]*x[4]*y[6]
+ -2.0*z[5]*z[5]*x[6]*y[4]-z[5]*z[5]*x[7]*y[4]-x[6]*y[7]*z[5]*z[5]+2.0*z[2]*y[1]*
+ x[2]*z[6]-2.0*z[2]*x[1]*y[2]*z[6]+2.0*z[2]*z[1]*x[6]*y[2]-y[6]*x[5]*z[7]*z[7]+
+ 2.0*x[6]*y[4]*z[7]*z[7];
s8 = -2.0*y[6]*x[4]*z[7]*z[7]+x[6]*y[5]*z[7]*z[7]-2.0*z[2]*z[1]*x[2]*y[6]
-+z[4]*y[6]*x[7]*z[5]+x[5]*y[4]*z[6]*z[6]+z[6]*z[6]*x[4]*y[7]-z[6]*z[6]*x[7]*y
-[4]-2.0*z[6]*z[6]*x[7]*y[5]+2.0*z[6]*z[6]*x[5]*y[7]-y[5]*x[4]*z[6]*z[6]+2.0*z
-[0]*z[0]*x[3]*y[4]-x[6]*y[5]*z[2]*z[2]+z[1]*z[1]*x[5]*y[6]-z[1]*z[1]*x[6]*y[5]-
-z[5]*z[5]*x[4]*y[0];
+ +z[4]*y[6]*x[7]*z[5]+x[5]*y[4]*z[6]*z[6]+z[6]*z[6]*x[4]*y[7]-z[6]*z[6]*x[7]*y
+ [4]-2.0*z[6]*z[6]*x[7]*y[5]+2.0*z[6]*z[6]*x[5]*y[7]-y[5]*x[4]*z[6]*z[6]+2.0*z
+ [0]*z[0]*x[3]*y[4]-x[6]*y[5]*z[2]*z[2]+z[1]*z[1]*x[5]*y[6]-z[1]*z[1]*x[6]*y[5]-
+ z[5]*z[5]*x[4]*y[0];
s6 = s8+2.0*x[1]*y[3]*z[0]*z[0]+2.0*x[1]*y[6]*z[2]*z[2]-2.0*y[1]*x[6]*z
-[2]*z[2]-y[1]*x[5]*z[2]*z[2]-z[1]*z[1]*x[2]*y[6]-2.0*z[1]*z[1]*x[2]*y[5]+2.0*z
-[1]*z[1]*x[5]*y[2]+z[1]*y[1]*x[6]*z[5]+y[1]*x[2]*z[5]*z[5]+z[2]*z[1]*x[2]*y[0]+
-z[1]*x[1]*y[5]*z[6]-z[1]*x[1]*y[6]*z[5]-z[1]*y[1]*x[5]*z[6]-z[1]*x[2]*y[6]*z[5]
-+z[1]*x[6]*y[2]*z[5]+s7;
+ [2]*z[2]-y[1]*x[5]*z[2]*z[2]-z[1]*z[1]*x[2]*y[6]-2.0*z[1]*z[1]*x[2]*y[5]+2.0*z
+ [1]*z[1]*x[5]*y[2]+z[1]*y[1]*x[6]*z[5]+y[1]*x[2]*z[5]*z[5]+z[2]*z[1]*x[2]*y[0]+
+ z[1]*x[1]*y[5]*z[6]-z[1]*x[1]*y[6]*z[5]-z[1]*y[1]*x[5]*z[6]-z[1]*x[2]*y[6]*z[5]
+ +z[1]*x[6]*y[2]*z[5]+s7;
s8 = -x[1]*y[2]*z[5]*z[5]+z[1]*x[5]*y[6]*z[2]-2.0*z[2]*z[2]*x[3]*y[6]+2.0
-*z[2]*z[2]*x[6]*y[3]+z[2]*z[2]*x[7]*y[3]-z[2]*z[2]*x[3]*y[7]-z[1]*x[6]*y[5]*z
-[2]+2.0*z[1]*x[1]*y[5]*z[2]-2.0*x[3]*y[4]*z[7]*z[7]+2.0*x[4]*y[3]*z[7]*z[7]+x
-[5]*y[6]*z[2]*z[2]+y[1]*x[2]*z[6]*z[6]+y[0]*x[4]*z[7]*z[7]+z[2]*x[2]*y[3]*z[0]-
-x[1]*y[2]*z[6]*z[6];
+ *z[2]*z[2]*x[6]*y[3]+z[2]*z[2]*x[7]*y[3]-z[2]*z[2]*x[3]*y[7]-z[1]*x[6]*y[5]*z
+ [2]+2.0*z[1]*x[1]*y[5]*z[2]-2.0*x[3]*y[4]*z[7]*z[7]+2.0*x[4]*y[3]*z[7]*z[7]+x
+ [5]*y[6]*z[2]*z[2]+y[1]*x[2]*z[6]*z[6]+y[0]*x[4]*z[7]*z[7]+z[2]*x[2]*y[3]*z[0]-
+ x[1]*y[2]*z[6]*z[6];
s7 = s8-z[7]*z[2]*x[3]*y[7]+x[2]*y[6]*z[3]*z[3]-y[2]*x[6]*z[3]*z[3]-z[6]*
-x[2]*y[3]*z[7]-z[2]*z[1]*x[0]*y[2]+z[6]*z[2]*x[6]*y[3]-z[6]*z[2]*x[3]*y[6]+z[6]
-*x[2]*y[6]*z[3]+z[2]*x[1]*y[2]*z[0]+z[6]*y[2]*x[3]*z[7]-z[4]*z[5]*x[6]*y[4]+z
-[4]*z[5]*x[4]*y[6]-z[4]*y[6]*x[5]*z[7]+z[4]*z[6]*x[4]*y[7]+z[4]*x[5]*y[4]*z[6];
+ x[2]*y[3]*z[7]-z[2]*z[1]*x[0]*y[2]+z[6]*z[2]*x[6]*y[3]-z[6]*z[2]*x[3]*y[6]+z[6]
+ *x[2]*y[6]*z[3]+z[2]*x[1]*y[2]*z[0]+z[6]*y[2]*x[3]*z[7]-z[4]*z[5]*x[6]*y[4]+z
+ [4]*z[5]*x[4]*y[6]-z[4]*y[6]*x[5]*z[7]+z[4]*z[6]*x[4]*y[7]+z[4]*x[5]*y[4]*z[6];
s8 = -z[6]*y[2]*x[6]*z[3]-z[4]*y[5]*x[4]*z[6]-z[2]*y[1]*x[5]*z[6]+z[2]*x
-[1]*y[5]*z[6]+z[4]*x[6]*y[4]*z[7]+2.0*z[4]*z[5]*x[4]*y[7]-z[4]*z[6]*x[7]*y[4]+x
-[6]*y[7]*z[3]*z[3]-2.0*z[4]*z[5]*x[7]*y[4]-2.0*z[4]*y[5]*x[4]*z[7]-z[4]*y[6]*x
-[4]*z[7]+z[4]*x[6]*y[5]*z[7]-z[4]*x[6]*y[7]*z[5]+2.0*z[4]*x[5]*y[4]*z[7]+z[2]*x
-[2]*y[5]*z[6]-z[2]*x[2]*y[6]*z[5];
+ [1]*y[5]*z[6]+z[4]*x[6]*y[4]*z[7]+2.0*z[4]*z[5]*x[4]*y[7]-z[4]*z[6]*x[7]*y[4]+x
+ [6]*y[7]*z[3]*z[3]-2.0*z[4]*z[5]*x[7]*y[4]-2.0*z[4]*y[5]*x[4]*z[7]-z[4]*y[6]*x
+ [4]*z[7]+z[4]*x[6]*y[5]*z[7]-z[4]*x[6]*y[7]*z[5]+2.0*z[4]*x[5]*y[4]*z[7]+z[2]*x
+ [2]*y[5]*z[6]-z[2]*x[2]*y[6]*z[5];
s5 = s8+z[2]*x[6]*y[2]*z[5]-z[2]*x[5]*y[2]*z[6]-z[2]*x[2]*y[3]*z[7]-x[2]*
-y[3]*z[7]*z[7]+2.0*z[2]*x[2]*y[3]*z[1]-z[2]*y[2]*x[3]*z[0]+z[2]*y[2]*x[0]*z[3]-
-z[2]*x[2]*y[0]*z[3]-z[7]*y[2]*x[7]*z[3]+z[7]*z[2]*x[7]*y[3]+z[7]*x[2]*y[7]*z[3]
-+z[6]*y[1]*x[2]*z[5]-z[6]*x[1]*y[2]*z[5]+z[5]*x[1]*y[5]*z[2]+s6+s7;
+ y[3]*z[7]*z[7]+2.0*z[2]*x[2]*y[3]*z[1]-z[2]*y[2]*x[3]*z[0]+z[2]*y[2]*x[0]*z[3]-
+ z[2]*x[2]*y[0]*z[3]-z[7]*y[2]*x[7]*z[3]+z[7]*z[2]*x[7]*y[3]+z[7]*x[2]*y[7]*z[3]
+ +z[6]*y[1]*x[2]*z[5]-z[6]*x[1]*y[2]*z[5]+z[5]*x[1]*y[5]*z[2]+s6+s7;
s8 = z[5]*z[1]*x[5]*y[2]-z[5]*z[1]*x[2]*y[5]-y[6]*x[7]*z[2]*z[2]+2.0*z[2]
-*x[2]*y[6]*z[3]-2.0*z[2]*x[2]*y[3]*z[6]+2.0*z[2]*y[2]*x[3]*z[6]+y[2]*x[3]*z[6]*
-z[6]+y[6]*x[7]*z[5]*z[5]+z[2]*y[2]*x[3]*z[7]-z[2]*y[2]*x[7]*z[3]-2.0*z[2]*y[2]*
-x[6]*z[3]+z[2]*x[2]*y[7]*z[3]+x[6]*y[2]*z[5]*z[5]-2.0*z[2]*x[2]*y[1]*z[3]-x[2]*
-y[6]*z[5]*z[5];
+ *x[2]*y[6]*z[3]-2.0*z[2]*x[2]*y[3]*z[6]+2.0*z[2]*y[2]*x[3]*z[6]+y[2]*x[3]*z[6]*
+ z[6]+y[6]*x[7]*z[5]*z[5]+z[2]*y[2]*x[3]*z[7]-z[2]*y[2]*x[7]*z[3]-2.0*z[2]*y[2]*
+ x[6]*z[3]+z[2]*x[2]*y[7]*z[3]+x[6]*y[2]*z[5]*z[5]-2.0*z[2]*x[2]*y[1]*z[3]-x[2]*
+ y[6]*z[5]*z[5];
s7 = s8-y[1]*x[5]*z[6]*z[6]+z[6]*x[1]*y[6]*z[2]-z[3]*z[2]*x[3]*y[6]+z[6]*
-z[1]*x[6]*y[2]-z[6]*z[1]*x[2]*y[6]-z[6]*y[1]*x[6]*z[2]-2.0*x[5]*y[2]*z[6]*z[6]+
-z[4]*z[1]*x[0]*y[4]-z[3]*x[2]*y[3]*z[6]-z[5]*y[1]*x[5]*z[2]+z[3]*y[2]*x[3]*z[6]
-+2.0*x[2]*y[5]*z[6]*z[6]-z[5]*x[1]*y[5]*z[0]+y[2]*x[3]*z[7]*z[7]-x[2]*y[3]*z[6]
-*z[6];
+ z[1]*x[6]*y[2]-z[6]*z[1]*x[2]*y[6]-z[6]*y[1]*x[6]*z[2]-2.0*x[5]*y[2]*z[6]*z[6]+
+ z[4]*z[1]*x[0]*y[4]-z[3]*x[2]*y[3]*z[6]-z[5]*y[1]*x[5]*z[2]+z[3]*y[2]*x[3]*z[6]
+ +2.0*x[2]*y[5]*z[6]*z[6]-z[5]*x[1]*y[5]*z[0]+y[2]*x[3]*z[7]*z[7]-x[2]*y[3]*z[6]
+ *z[6];
s8 = z[5]*y[5]*x[4]*z[0]+z[3]*z[2]*x[6]*y[3]+x[1]*y[5]*z[6]*z[6]+z[5]*y
-[5]*x[7]*z[4]-z[1]*x[1]*y[2]*z[6]+z[1]*x[1]*y[6]*z[2]+2.0*z[6]*y[6]*x[7]*z[5]-z
-[7]*y[6]*x[7]*z[2]-z[3]*y[6]*x[7]*z[2]+x[6]*y[7]*z[2]*z[2]-2.0*z[6]*y[6]*x[7]*z
-[2]-2.0*x[6]*y[3]*z[7]*z[7]-x[6]*y[2]*z[7]*z[7]-z[5]*x[6]*y[5]*z[2]+y[6]*x[2]*z
-[7]*z[7];
+ [5]*x[7]*z[4]-z[1]*x[1]*y[2]*z[6]+z[1]*x[1]*y[6]*z[2]+2.0*z[6]*y[6]*x[7]*z[5]-z
+ [7]*y[6]*x[7]*z[2]-z[3]*y[6]*x[7]*z[2]+x[6]*y[7]*z[2]*z[2]-2.0*z[6]*y[6]*x[7]*z
+ [2]-2.0*x[6]*y[3]*z[7]*z[7]-x[6]*y[2]*z[7]*z[7]-z[5]*x[6]*y[5]*z[2]+y[6]*x[2]*z
+ [7]*z[7];
s6 = s8+2.0*y[6]*x[3]*z[7]*z[7]+z[6]*z[6]*x[7]*y[3]-y[6]*x[7]*z[3]*z[3]+z
-[5]*x[5]*y[0]*z[4]+2.0*z[6]*z[6]*x[7]*y[2]-2.0*z[6]*z[6]*x[2]*y[7]-z[6]*z[6]*x
-[3]*y[7]+z[7]*y[6]*x[7]*z[5]+z[7]*y[5]*x[7]*z[4]-2.0*z[7]*x[7]*y[3]*z[4]+2.0*z
-[7]*x[3]*y[7]*z[4]-2.0*z[7]*x[4]*y[7]*z[3]+2.0*z[7]*x[7]*y[4]*z[3]-z[7]*y[0]*x
-[7]*z[4]-2.0*z[7]*z[6]*x[3]*y[7]+s7;
+ [5]*x[5]*y[0]*z[4]+2.0*z[6]*z[6]*x[7]*y[2]-2.0*z[6]*z[6]*x[2]*y[7]-z[6]*z[6]*x
+ [3]*y[7]+z[7]*y[6]*x[7]*z[5]+z[7]*y[5]*x[7]*z[4]-2.0*z[7]*x[7]*y[3]*z[4]+2.0*z
+ [7]*x[3]*y[7]*z[4]-2.0*z[7]*x[4]*y[7]*z[3]+2.0*z[7]*x[7]*y[4]*z[3]-z[7]*y[0]*x
+ [7]*z[4]-2.0*z[7]*z[6]*x[3]*y[7]+s7;
s8 = s6+2.0*z[7]*z[6]*x[7]*y[3]+2.0*z[7]*x[6]*y[7]*z[3]+z[7]*x[6]*y[7]*z
-[2]-2.0*z[7]*y[6]*x[7]*z[3]+z[7]*z[6]*x[7]*y[2]-z[7]*z[6]*x[2]*y[7]+z[5]*y[1]*x
-[5]*z[0]-z[5]*z[1]*x[5]*y[0]+2.0*y[1]*x[6]*z[5]*z[5]-2.0*x[1]*y[6]*z[5]*z[5]+z
-[5]*z[1]*x[0]*y[5]+z[6]*y[6]*x[3]*z[7]+2.0*z[6]*x[6]*y[7]*z[2]-z[6]*y[6]*x[7]*z
-[3];
+ [2]-2.0*z[7]*y[6]*x[7]*z[3]+z[7]*z[6]*x[7]*y[2]-z[7]*z[6]*x[2]*y[7]+z[5]*y[1]*x
+ [5]*z[0]-z[5]*z[1]*x[5]*y[0]+2.0*y[1]*x[6]*z[5]*z[5]-2.0*x[1]*y[6]*z[5]*z[5]+z
+ [5]*z[1]*x[0]*y[5]+z[6]*y[6]*x[3]*z[7]+2.0*z[6]*x[6]*y[7]*z[2]-z[6]*y[6]*x[7]*z
+ [3];
s7 = s8+2.0*z[6]*y[6]*x[2]*z[7]-z[6]*x[6]*y[3]*z[7]+z[6]*x[6]*y[7]*z[3]
--2.0*z[6]*x[6]*y[2]*z[7]-2.0*z[1]*y[1]*x[5]*z[2]-z[1]*y[1]*x[6]*z[2]-z[7]*z[0]*
-x[7]*y[3]-2.0*z[6]*x[6]*y[5]*z[2]-z[2]*z[6]*x[3]*y[7]+z[2]*x[6]*y[7]*z[3]-z[2]*
-z[6]*x[2]*y[7]+y[5]*x[6]*z[4]*z[4]+z[2]*y[6]*x[2]*z[7]+y[6]*x[7]*z[4]*z[4]+z[2]
-*z[6]*x[7]*y[2]-2.0*x[5]*y[7]*z[4]*z[4];
+ -2.0*z[6]*x[6]*y[2]*z[7]-2.0*z[1]*y[1]*x[5]*z[2]-z[1]*y[1]*x[6]*z[2]-z[7]*z[0]*
+ x[7]*y[3]-2.0*z[6]*x[6]*y[5]*z[2]-z[2]*z[6]*x[3]*y[7]+z[2]*x[6]*y[7]*z[3]-z[2]*
+ z[6]*x[2]*y[7]+y[5]*x[6]*z[4]*z[4]+z[2]*y[6]*x[2]*z[7]+y[6]*x[7]*z[4]*z[4]+z[2]
+ *z[6]*x[7]*y[2]-2.0*x[5]*y[7]*z[4]*z[4];
s8 = -x[6]*y[7]*z[4]*z[4]-z[5]*y[5]*x[0]*z[4]-z[2]*x[6]*y[2]*z[7]-x[5]*y
-[6]*z[4]*z[4]-2.0*z[5]*y[1]*x[5]*z[6]+2.0*z[5]*z[1]*x[5]*y[6]+2.0*z[5]*x[1]*y
-[5]*z[6]-2.0*z[5]*z[1]*x[6]*y[5]-z[5]*x[5]*y[2]*z[6]+z[5]*x[5]*y[6]*z[2]+z[5]*x
-[2]*y[5]*z[6]+z[5]*z[5]*x[4]*y[7]-y[5]*x[4]*z[7]*z[7]+x[5]*y[4]*z[7]*z[7]+z[6]*
-z[1]*x[5]*y[6]+z[6]*y[1]*x[6]*z[5];
+ [6]*z[4]*z[4]-2.0*z[5]*y[1]*x[5]*z[6]+2.0*z[5]*z[1]*x[5]*y[6]+2.0*z[5]*x[1]*y
+ [5]*z[6]-2.0*z[5]*z[1]*x[6]*y[5]-z[5]*x[5]*y[2]*z[6]+z[5]*x[5]*y[6]*z[2]+z[5]*x
+ [2]*y[5]*z[6]+z[5]*z[5]*x[4]*y[7]-y[5]*x[4]*z[7]*z[7]+x[5]*y[4]*z[7]*z[7]+z[6]*
+ z[1]*x[5]*y[6]+z[6]*y[1]*x[6]*z[5];
s4 = s8-z[6]*z[1]*x[6]*y[5]-z[6]*x[1]*y[6]*z[5]+z[2]*z[6]*x[7]*y[3]+2.0*z
-[6]*x[6]*y[2]*z[5]+2.0*z[6]*x[5]*y[6]*z[2]-2.0*z[6]*x[2]*y[6]*z[5]+z[7]*z[0]*x
-[3]*y[7]+z[7]*z[0]*x[7]*y[4]+z[3]*z[6]*x[7]*y[3]-z[3]*z[6]*x[3]*y[7]-z[3]*x[6]*
-y[3]*z[7]+z[3]*y[6]*x[2]*z[7]-z[3]*x[6]*y[2]*z[7]+z[5]*x[5]*y[4]*z[7]+s5+s7;
+ [6]*x[6]*y[2]*z[5]+2.0*z[6]*x[5]*y[6]*z[2]-2.0*z[6]*x[2]*y[6]*z[5]+z[7]*z[0]*x
+ [3]*y[7]+z[7]*z[0]*x[7]*y[4]+z[3]*z[6]*x[7]*y[3]-z[3]*z[6]*x[3]*y[7]-z[3]*x[6]*
+ y[3]*z[7]+z[3]*y[6]*x[2]*z[7]-z[3]*x[6]*y[2]*z[7]+z[5]*x[5]*y[4]*z[7]+s5+s7;
s8 = s4+z[3]*y[6]*x[3]*z[7]-z[7]*x[0]*y[7]*z[3]+z[6]*x[5]*y[4]*z[7]+z[7]*
-y[0]*x[7]*z[3]+z[5]*z[6]*x[4]*y[7]-2.0*z[5]*x[5]*y[6]*z[4]+2.0*z[5]*x[5]*y[4]*z
-[6]-z[5]*x[5]*y[7]*z[4]-z[5]*y[6]*x[5]*z[7]-z[5]*z[6]*x[7]*y[4]-z[7]*z[0]*x[4]*
-y[7]-z[5]*z[6]*x[7]*y[5]-z[5]*y[5]*x[4]*z[7]+z[7]*x[0]*y[7]*z[4];
+ y[0]*x[7]*z[3]+z[5]*z[6]*x[4]*y[7]-2.0*z[5]*x[5]*y[6]*z[4]+2.0*z[5]*x[5]*y[4]*z
+ [6]-z[5]*x[5]*y[7]*z[4]-z[5]*y[6]*x[5]*z[7]-z[5]*z[6]*x[7]*y[4]-z[7]*z[0]*x[4]*
+ y[7]-z[5]*z[6]*x[7]*y[5]-z[5]*y[5]*x[4]*z[7]+z[7]*x[0]*y[7]*z[4];
s7 = s8-2.0*z[5]*y[5]*x[4]*z[6]+z[5]*z[6]*x[5]*y[7]+z[5]*x[6]*y[5]*z[7]+
-2.0*z[5]*y[5]*x[6]*z[4]+z[6]*z[5]*x[4]*y[6]-z[6]*x[5]*y[6]*z[4]-z[6]*z[5]*x[6]*
-y[4]-z[6]*x[6]*y[7]*z[4]-2.0*z[6]*y[6]*x[5]*z[7]+z[6]*x[6]*y[4]*z[7]-z[6]*y[5]*
-x[4]*z[7]-z[6]*y[6]*x[4]*z[7]+z[6]*y[6]*x[7]*z[4]+z[6]*y[5]*x[6]*z[4]+2.0*z[6]*
-x[6]*y[5]*z[7];
+ 2.0*z[5]*y[5]*x[6]*z[4]+z[6]*z[5]*x[4]*y[6]-z[6]*x[5]*y[6]*z[4]-z[6]*z[5]*x[6]*
+ y[4]-z[6]*x[6]*y[7]*z[4]-2.0*z[6]*y[6]*x[5]*z[7]+z[6]*x[6]*y[4]*z[7]-z[6]*y[5]*
+ x[4]*z[7]-z[6]*y[6]*x[4]*z[7]+z[6]*y[6]*x[7]*z[4]+z[6]*y[5]*x[6]*z[4]+2.0*z[6]*
+ x[6]*y[5]*z[7];
s8 = -2.0*z[6]*x[6]*y[7]*z[5]-z[2]*y[1]*x[2]*z[0]+2.0*z[7]*z[6]*x[4]*y[7]
--2.0*z[7]*x[6]*y[7]*z[4]-2.0*z[7]*z[6]*x[7]*y[4]+z[7]*z[5]*x[4]*y[7]-z[7]*z[5]*
-x[7]*y[4]-z[7]*x[5]*y[7]*z[4]+2.0*z[7]*y[6]*x[7]*z[4]-z[7]*z[6]*x[7]*y[5]+z[7]*
-z[6]*x[5]*y[7]-z[7]*x[6]*y[7]*z[5]+z[1]*z[1]*x[6]*y[2]+s7+x[1]*y[5]*z[2]*z[2];
+ -2.0*z[7]*x[6]*y[7]*z[4]-2.0*z[7]*z[6]*x[7]*y[4]+z[7]*z[5]*x[4]*y[7]-z[7]*z[5]*
+ x[7]*y[4]-z[7]*x[5]*y[7]*z[4]+2.0*z[7]*y[6]*x[7]*z[4]-z[7]*z[6]*x[7]*y[5]+z[7]*
+ z[6]*x[5]*y[7]-z[7]*x[6]*y[7]*z[5]+z[1]*z[1]*x[6]*y[2]+s7+x[1]*y[5]*z[2]*z[2];
s6 = s8+2.0*z[2]*y[2]*x[1]*z[3]-2.0*z[2]*y[2]*x[3]*z[1]-2.0*x[1]*y[4]*z
-[0]*z[0]+2.0*y[1]*x[4]*z[0]*z[0]+2.0*x[2]*y[7]*z[3]*z[3]-2.0*y[2]*x[7]*z[3]*z
-[3]-x[1]*y[5]*z[0]*z[0]+z[0]*z[0]*x[7]*y[4]+z[0]*z[0]*x[3]*y[7]+x[2]*y[3]*z[0]*
-z[0]-2.0*y[1]*x[3]*z[0]*z[0]+y[5]*x[4]*z[0]*z[0]-2.0*z[0]*z[0]*x[4]*y[3]+x[1]*y
-[2]*z[0]*z[0]-z[0]*z[0]*x[4]*y[7]+y[1]*x[5]*z[0]*z[0];
+ [0]*z[0]+2.0*y[1]*x[4]*z[0]*z[0]+2.0*x[2]*y[7]*z[3]*z[3]-2.0*y[2]*x[7]*z[3]*z
+ [3]-x[1]*y[5]*z[0]*z[0]+z[0]*z[0]*x[7]*y[4]+z[0]*z[0]*x[3]*y[7]+x[2]*y[3]*z[0]*
+ z[0]-2.0*y[1]*x[3]*z[0]*z[0]+y[5]*x[4]*z[0]*z[0]-2.0*z[0]*z[0]*x[4]*y[3]+x[1]*y
+ [2]*z[0]*z[0]-z[0]*z[0]*x[4]*y[7]+y[1]*x[5]*z[0]*z[0];
s8 = s6-y[2]*x[3]*z[0]*z[0]+y[1]*x[0]*z[3]*z[3]-2.0*x[0]*y[7]*z[3]*z[3]-x
-[0]*y[4]*z[3]*z[3]-2.0*x[2]*y[0]*z[3]*z[3]-x[1]*y[0]*z[3]*z[3]+y[0]*x[4]*z[3]*z
-[3]-2.0*z[0]*y[1]*x[0]*z[4]+2.0*z[0]*z[1]*x[0]*y[4]+2.0*z[0]*x[1]*y[0]*z[4]-2.0
-*z[0]*z[1]*x[4]*y[0]-2.0*z[3]*x[2]*y[3]*z[7]-2.0*z[3]*z[2]*x[3]*y[7]+2.0*z[3]*z
-[2]*x[7]*y[3];
+ [0]*y[4]*z[3]*z[3]-2.0*x[2]*y[0]*z[3]*z[3]-x[1]*y[0]*z[3]*z[3]+y[0]*x[4]*z[3]*z
+ [3]-2.0*z[0]*y[1]*x[0]*z[4]+2.0*z[0]*z[1]*x[0]*y[4]+2.0*z[0]*x[1]*y[0]*z[4]-2.0
+ *z[0]*z[1]*x[4]*y[0]-2.0*z[3]*x[2]*y[3]*z[7]-2.0*z[3]*z[2]*x[3]*y[7]+2.0*z[3]*z
+ [2]*x[7]*y[3];
s7 = s8+2.0*z[3]*y[2]*x[3]*z[7]+2.0*z[5]*y[5]*x[4]*z[1]+2.0*z[0]*y[1]*x
-[0]*z[3]-z[0]*y[0]*x[3]*z[7]-2.0*z[0]*y[0]*x[3]*z[4]-z[0]*x[1]*y[0]*z[2]+z[0]*z
-[1]*x[2]*y[0]-z[0]*y[1]*x[0]*z[5]-z[0]*z[1]*x[0]*y[2]-z[0]*x[0]*y[7]*z[3]-2.0*z
-[0]*z[1]*x[0]*y[3]-z[5]*x[5]*y[4]*z[0]-2.0*z[0]*x[0]*y[4]*z[3]+z[0]*x[0]*y[7]*z
-[4]-z[0]*z[2]*x[0]*y[3];
+ [0]*z[3]-z[0]*y[0]*x[3]*z[7]-2.0*z[0]*y[0]*x[3]*z[4]-z[0]*x[1]*y[0]*z[2]+z[0]*z
+ [1]*x[2]*y[0]-z[0]*y[1]*x[0]*z[5]-z[0]*z[1]*x[0]*y[2]-z[0]*x[0]*y[7]*z[3]-2.0*z
+ [0]*z[1]*x[0]*y[3]-z[5]*x[5]*y[4]*z[0]-2.0*z[0]*x[0]*y[4]*z[3]+z[0]*x[0]*y[7]*z
+ [4]-z[0]*z[2]*x[0]*y[3];
s8 = s7+z[0]*x[5]*y[0]*z[4]+z[0]*z[1]*x[0]*y[5]-z[0]*x[2]*y[0]*z[3]-z[0]*
-z[1]*x[5]*y[0]-2.0*z[0]*x[1]*y[0]*z[3]+2.0*z[0]*y[0]*x[4]*z[3]-z[0]*x[0]*y[4]*z
-[7]+z[0]*x[1]*y[0]*z[5]+z[0]*y[0]*x[7]*z[3]+z[0]*y[2]*x[0]*z[3]-z[0]*y[5]*x[0]*
-z[4]+z[0]*z[2]*x[3]*y[0]+z[0]*x[2]*y[3]*z[1]+z[0]*x[0]*y[3]*z[7]-z[0]*x[2]*y[1]
-*z[3];
+ z[1]*x[5]*y[0]-2.0*z[0]*x[1]*y[0]*z[3]+2.0*z[0]*y[0]*x[4]*z[3]-z[0]*x[0]*y[4]*z
+ [7]+z[0]*x[1]*y[0]*z[5]+z[0]*y[0]*x[7]*z[3]+z[0]*y[2]*x[0]*z[3]-z[0]*y[5]*x[0]*
+ z[4]+z[0]*z[2]*x[3]*y[0]+z[0]*x[2]*y[3]*z[1]+z[0]*x[0]*y[3]*z[7]-z[0]*x[2]*y[1]
+ *z[3];
s5 = s8+z[0]*y[1]*x[0]*z[2]+z[3]*x[1]*y[3]*z[0]-2.0*z[3]*y[0]*x[3]*z[7]-z
-[3]*y[0]*x[3]*z[4]-z[3]*x[1]*y[0]*z[2]+z[3]*z[0]*x[7]*y[4]+2.0*z[3]*z[0]*x[3]*y
-[7]+2.0*z[3]*x[2]*y[3]*z[0]-z[3]*y[1]*x[3]*z[0]-z[3]*z[1]*x[0]*y[3]-z[3]*z[0]*x
-[4]*y[3]+z[3]*x[1]*y[2]*z[0]-z[3]*z[0]*x[4]*y[7]-2.0*z[3]*z[2]*x[0]*y[3]-z[3]*x
-[0]*y[4]*z[7]-2.0*z[3]*y[2]*x[3]*z[0];
+ [3]*y[0]*x[3]*z[4]-z[3]*x[1]*y[0]*z[2]+z[3]*z[0]*x[7]*y[4]+2.0*z[3]*z[0]*x[3]*y
+ [7]+2.0*z[3]*x[2]*y[3]*z[0]-z[3]*y[1]*x[3]*z[0]-z[3]*z[1]*x[0]*y[3]-z[3]*z[0]*x
+ [4]*y[3]+z[3]*x[1]*y[2]*z[0]-z[3]*z[0]*x[4]*y[7]-2.0*z[3]*z[2]*x[0]*y[3]-z[3]*x
+ [0]*y[4]*z[7]-2.0*z[3]*y[2]*x[3]*z[0];
s8 = s5+2.0*z[3]*z[2]*x[3]*y[0]+z[3]*x[2]*y[3]*z[1]+2.0*z[3]*x[0]*y[3]*z
-[7]+z[3]*y[1]*x[0]*z[2]-z[4]*y[0]*x[3]*z[7]-z[4]*x[1]*y[5]*z[0]-z[4]*y[1]*x[0]*
-z[5]+2.0*z[4]*z[0]*x[7]*y[4]+z[4]*z[0]*x[3]*y[7]+2.0*z[4]*y[5]*x[4]*z[0]+2.0*y
-[0]*x[7]*z[3]*z[3]+2.0*y[2]*x[0]*z[3]*z[3]-x[2]*y[1]*z[3]*z[3]-y[0]*x[3]*z[4]*z
-[4];
+ [7]+z[3]*y[1]*x[0]*z[2]-z[4]*y[0]*x[3]*z[7]-z[4]*x[1]*y[5]*z[0]-z[4]*y[1]*x[0]*
+ z[5]+2.0*z[4]*z[0]*x[7]*y[4]+z[4]*z[0]*x[3]*y[7]+2.0*z[4]*y[5]*x[4]*z[0]+2.0*y
+ [0]*x[7]*z[3]*z[3]+2.0*y[2]*x[0]*z[3]*z[3]-x[2]*y[1]*z[3]*z[3]-y[0]*x[3]*z[4]*z
+ [4];
s7 = s8-y[1]*x[0]*z[4]*z[4]+x[1]*y[0]*z[4]*z[4]+2.0*x[0]*y[7]*z[4]*z[4]+
-2.0*x[5]*y[0]*z[4]*z[4]-2.0*y[5]*x[0]*z[4]*z[4]+2.0*z[1]*z[1]*x[2]*y[0]-2.0*z
-[1]*z[1]*x[0]*y[2]+z[1]*z[1]*x[0]*y[4]-z[1]*z[1]*x[0]*y[3]-z[1]*z[1]*x[4]*y[0]+
-2.0*z[1]*z[1]*x[0]*y[5]-2.0*z[1]*z[1]*x[5]*y[0]+x[2]*y[3]*z[1]*z[1]-x[5]*y[4]*z
-[0]*z[0]-z[0]*z[0]*x[7]*y[3];
+ 2.0*x[5]*y[0]*z[4]*z[4]-2.0*y[5]*x[0]*z[4]*z[4]+2.0*z[1]*z[1]*x[2]*y[0]-2.0*z
+ [1]*z[1]*x[0]*y[2]+z[1]*z[1]*x[0]*y[4]-z[1]*z[1]*x[0]*y[3]-z[1]*z[1]*x[4]*y[0]+
+ 2.0*z[1]*z[1]*x[0]*y[5]-2.0*z[1]*z[1]*x[5]*y[0]+x[2]*y[3]*z[1]*z[1]-x[5]*y[4]*z
+ [0]*z[0]-z[0]*z[0]*x[7]*y[3];
s8 = s7+x[7]*y[4]*z[3]*z[3]-x[4]*y[7]*z[3]*z[3]+y[2]*x[1]*z[3]*z[3]+x[0]*
-y[3]*z[4]*z[4]-2.0*y[0]*x[7]*z[4]*z[4]+x[3]*y[7]*z[4]*z[4]-x[7]*y[3]*z[4]*z[4]-
-y[5]*x[1]*z[4]*z[4]+x[5]*y[1]*z[4]*z[4]+z[1]*z[1]*x[3]*y[0]+y[5]*x[4]*z[1]*z[1]
--y[2]*x[3]*z[1]*z[1]-x[5]*y[4]*z[1]*z[1]-z[4]*x[0]*y[4]*z[3]-z[4]*z[0]*x[4]*y
-[3];
+ y[3]*z[4]*z[4]-2.0*y[0]*x[7]*z[4]*z[4]+x[3]*y[7]*z[4]*z[4]-x[7]*y[3]*z[4]*z[4]-
+ y[5]*x[1]*z[4]*z[4]+x[5]*y[1]*z[4]*z[4]+z[1]*z[1]*x[3]*y[0]+y[5]*x[4]*z[1]*z[1]
+ -y[2]*x[3]*z[1]*z[1]-x[5]*y[4]*z[1]*z[1]-z[4]*x[0]*y[4]*z[3]-z[4]*z[0]*x[4]*y
+ [3];
s6 = s8-z[4]*z[1]*x[4]*y[0]-2.0*z[4]*z[0]*x[4]*y[7]+z[4]*y[1]*x[5]*z[0]
--2.0*z[5]*x[5]*y[4]*z[1]-z[4]*x[1]*y[4]*z[0]+z[4]*y[0]*x[4]*z[3]-2.0*z[4]*x[0]*
-y[4]*z[7]+z[4]*x[1]*y[0]*z[5]-2.0*z[1]*x[1]*y[2]*z[5]+z[4]*x[0]*y[3]*z[7]+2.0*z
-[5]*x[5]*y[1]*z[4]+z[4]*y[1]*x[4]*z[0]+z[1]*y[1]*x[0]*z[3]+z[1]*x[1]*y[3]*z[0]
--2.0*z[1]*x[1]*y[5]*z[0]-2.0*z[1]*x[1]*y[0]*z[2];
+ -2.0*z[5]*x[5]*y[4]*z[1]-z[4]*x[1]*y[4]*z[0]+z[4]*y[0]*x[4]*z[3]-2.0*z[4]*x[0]*
+ y[4]*z[7]+z[4]*x[1]*y[0]*z[5]-2.0*z[1]*x[1]*y[2]*z[5]+z[4]*x[0]*y[3]*z[7]+2.0*z
+ [5]*x[5]*y[1]*z[4]+z[4]*y[1]*x[4]*z[0]+z[1]*y[1]*x[0]*z[3]+z[1]*x[1]*y[3]*z[0]
+ -2.0*z[1]*x[1]*y[5]*z[0]-2.0*z[1]*x[1]*y[0]*z[2];
s8 = s6-2.0*z[1]*y[1]*x[0]*z[5]-z[1]*y[1]*x[0]*z[4]+2.0*z[1]*y[1]*x[2]*z
-[5]-z[1]*y[1]*x[3]*z[0]-2.0*z[5]*y[5]*x[1]*z[4]+z[1]*y[5]*x[4]*z[0]+z[1]*x[1]*y
-[0]*z[4]+2.0*z[1]*x[1]*y[2]*z[0]-z[1]*z[2]*x[0]*y[3]+2.0*z[1]*y[1]*x[5]*z[0]-z
-[1]*x[1]*y[0]*z[3]-z[1]*x[1]*y[4]*z[0]+2.0*z[1]*x[1]*y[0]*z[5]-z[1]*y[2]*x[3]*z
-[0];
+ [5]-z[1]*y[1]*x[3]*z[0]-2.0*z[5]*y[5]*x[1]*z[4]+z[1]*y[5]*x[4]*z[0]+z[1]*x[1]*y
+ [0]*z[4]+2.0*z[1]*x[1]*y[2]*z[0]-z[1]*z[2]*x[0]*y[3]+2.0*z[1]*y[1]*x[5]*z[0]-z
+ [1]*x[1]*y[0]*z[3]-z[1]*x[1]*y[4]*z[0]+2.0*z[1]*x[1]*y[0]*z[5]-z[1]*y[2]*x[3]*z
+ [0];
s7 = s8+z[1]*z[2]*x[3]*y[0]-z[1]*x[2]*y[1]*z[3]+z[1]*y[1]*x[4]*z[0]+2.0*z
-[1]*y[1]*x[0]*z[2]+2.0*z[0]*z[1]*x[3]*y[0]+2.0*z[0]*x[0]*y[3]*z[4]+z[0]*z[5]*x
-[0]*y[4]+z[0]*y[0]*x[4]*z[7]-z[0]*y[0]*x[7]*z[4]-z[0]*x[7]*y[3]*z[4]-z[0]*z[5]*
-x[4]*y[0]-z[0]*x[5]*y[4]*z[1]+z[3]*z[1]*x[3]*y[0]+z[3]*x[0]*y[3]*z[4]+z[3]*z[0]
-*x[3]*y[4]+z[3]*y[0]*x[4]*z[7];
+ [1]*y[1]*x[0]*z[2]+2.0*z[0]*z[1]*x[3]*y[0]+2.0*z[0]*x[0]*y[3]*z[4]+z[0]*z[5]*x
+ [0]*y[4]+z[0]*y[0]*x[4]*z[7]-z[0]*y[0]*x[7]*z[4]-z[0]*x[7]*y[3]*z[4]-z[0]*z[5]*
+ x[4]*y[0]-z[0]*x[5]*y[4]*z[1]+z[3]*z[1]*x[3]*y[0]+z[3]*x[0]*y[3]*z[4]+z[3]*z[0]
+ *x[3]*y[4]+z[3]*y[0]*x[4]*z[7];
s8 = s7+z[3]*x[3]*y[7]*z[4]-z[3]*x[7]*y[3]*z[4]-z[3]*x[3]*y[4]*z[7]+z[3]*
-x[4]*y[3]*z[7]-z[3]*y[2]*x[3]*z[1]+z[3]*z[2]*x[3]*y[1]-z[3]*z[2]*x[1]*y[3]-2.0*
-z[3]*z[0]*x[7]*y[3]+z[4]*z[0]*x[3]*y[4]+2.0*z[4]*z[5]*x[0]*y[4]+2.0*z[4]*y[0]*x
-[4]*z[7]-2.0*z[4]*x[5]*y[4]*z[0]+z[4]*y[5]*x[4]*z[1]+z[4]*x[7]*y[4]*z[3]-z[4]*x
-[4]*y[7]*z[3];
+ x[4]*y[3]*z[7]-z[3]*y[2]*x[3]*z[1]+z[3]*z[2]*x[3]*y[1]-z[3]*z[2]*x[1]*y[3]-2.0*
+ z[3]*z[0]*x[7]*y[3]+z[4]*z[0]*x[3]*y[4]+2.0*z[4]*z[5]*x[0]*y[4]+2.0*z[4]*y[0]*x
+ [4]*z[7]-2.0*z[4]*x[5]*y[4]*z[0]+z[4]*y[5]*x[4]*z[1]+z[4]*x[7]*y[4]*z[3]-z[4]*x
+ [4]*y[7]*z[3];
s3 = s8-z[4]*x[3]*y[4]*z[7]+z[4]*x[4]*y[3]*z[7]-2.0*z[4]*z[5]*x[4]*y[0]-z
-[4]*x[5]*y[4]*z[1]+z[4]*z[5]*x[1]*y[4]-z[4]*z[5]*x[4]*y[1]-2.0*z[1]*y[1]*x[2]*z
-[0]+z[1]*z[5]*x[0]*y[4]-z[1]*z[5]*x[4]*y[0]-z[1]*y[5]*x[1]*z[4]+z[1]*x[5]*y[1]*
-z[4]+z[1]*z[5]*x[1]*y[4]-z[1]*z[5]*x[4]*y[1]+z[1]*z[2]*x[3]*y[1]-z[1]*z[2]*x[1]
-*y[3]+z[1]*y[2]*x[1]*z[3];
+ [4]*x[5]*y[4]*z[1]+z[4]*z[5]*x[1]*y[4]-z[4]*z[5]*x[4]*y[1]-2.0*z[1]*y[1]*x[2]*z
+ [0]+z[1]*z[5]*x[0]*y[4]-z[1]*z[5]*x[4]*y[0]-z[1]*y[5]*x[1]*z[4]+z[1]*x[5]*y[1]*
+ z[4]+z[1]*z[5]*x[1]*y[4]-z[1]*z[5]*x[4]*y[1]+z[1]*z[2]*x[3]*y[1]-z[1]*z[2]*x[1]
+ *y[3]+z[1]*y[2]*x[1]*z[3];
s8 = y[1]*x[0]*z[3]+x[1]*y[3]*z[0]-y[0]*x[3]*z[7]-x[1]*y[5]*z[0]-y[0]*x
-[3]*z[4]-x[1]*y[0]*z[2]+z[1]*x[2]*y[0]-y[1]*x[0]*z[5]-z[1]*x[0]*y[2]-y[1]*x[0]*
-z[4]+z[1]*x[5]*y[2]+z[0]*x[7]*y[4]+z[0]*x[3]*y[7]+z[1]*x[0]*y[4]-x[1]*y[2]*z[5]
-+x[2]*y[3]*z[0]+y[1]*x[2]*z[5]-x[2]*y[3]*z[7];
+ [3]*z[4]-x[1]*y[0]*z[2]+z[1]*x[2]*y[0]-y[1]*x[0]*z[5]-z[1]*x[0]*y[2]-y[1]*x[0]*
+ z[4]+z[1]*x[5]*y[2]+z[0]*x[7]*y[4]+z[0]*x[3]*y[7]+z[1]*x[0]*y[4]-x[1]*y[2]*z[5]
+ +x[2]*y[3]*z[0]+y[1]*x[2]*z[5]-x[2]*y[3]*z[7];
s7 = s8-z[1]*x[2]*y[5]-y[1]*x[3]*z[0]-x[0]*y[7]*z[3]-z[1]*x[0]*y[3]+y[5]*
-x[4]*z[0]-x[0]*y[4]*z[3]+y[5]*x[7]*z[4]-z[0]*x[4]*y[3]+x[1]*y[0]*z[4]-z[2]*x[3]
-*y[7]-y[6]*x[7]*z[2]+x[1]*y[5]*z[2]+y[6]*x[7]*z[5]+x[0]*y[7]*z[4]+x[1]*y[2]*z
-[0]-z[1]*x[4]*y[0]-z[0]*x[4]*y[7]-z[2]*x[0]*y[3];
+ x[4]*z[0]-x[0]*y[4]*z[3]+y[5]*x[7]*z[4]-z[0]*x[4]*y[3]+x[1]*y[0]*z[4]-z[2]*x[3]
+ *y[7]-y[6]*x[7]*z[2]+x[1]*y[5]*z[2]+y[6]*x[7]*z[5]+x[0]*y[7]*z[4]+x[1]*y[2]*z
+ [0]-z[1]*x[4]*y[0]-z[0]*x[4]*y[7]-z[2]*x[0]*y[3];
s8 = x[5]*y[0]*z[4]+z[1]*x[0]*y[5]-x[2]*y[0]*z[3]-z[1]*x[5]*y[0]+y[1]*x
-[5]*z[0]-x[1]*y[0]*z[3]-x[1]*y[4]*z[0]-y[1]*x[5]*z[2]+x[2]*y[7]*z[3]+y[0]*x[4]*
-z[3]-x[0]*y[4]*z[7]+x[1]*y[0]*z[5]-y[1]*x[6]*z[2]-y[2]*x[6]*z[3]+y[0]*x[7]*z[3]
--y[2]*x[7]*z[3]+z[2]*x[7]*y[3]+y[2]*x[0]*z[3];
+ [5]*z[0]-x[1]*y[0]*z[3]-x[1]*y[4]*z[0]-y[1]*x[5]*z[2]+x[2]*y[7]*z[3]+y[0]*x[4]*
+ z[3]-x[0]*y[4]*z[7]+x[1]*y[0]*z[5]-y[1]*x[6]*z[2]-y[2]*x[6]*z[3]+y[0]*x[7]*z[3]
+ -y[2]*x[7]*z[3]+z[2]*x[7]*y[3]+y[2]*x[0]*z[3];
s6 = s8+y[2]*x[3]*z[7]-y[2]*x[3]*z[0]-x[6]*y[5]*z[2]-y[5]*x[0]*z[4]+z[2]*
-x[3]*y[0]+x[2]*y[3]*z[1]+x[0]*y[3]*z[7]-x[2]*y[1]*z[3]+y[1]*x[4]*z[0]+y[1]*x[0]
-*z[2]-z[1]*x[2]*y[6]+y[2]*x[3]*z[6]-y[1]*x[2]*z[0]+z[1]*x[3]*y[0]-x[1]*y[2]*z
-[6]-x[2]*y[3]*z[6]+x[0]*y[3]*z[4]+z[0]*x[3]*y[4]+s7;
+ x[3]*y[0]+x[2]*y[3]*z[1]+x[0]*y[3]*z[7]-x[2]*y[1]*z[3]+y[1]*x[4]*z[0]+y[1]*x[0]
+ *z[2]-z[1]*x[2]*y[6]+y[2]*x[3]*z[6]-y[1]*x[2]*z[0]+z[1]*x[3]*y[0]-x[1]*y[2]*z
+ [6]-x[2]*y[3]*z[6]+x[0]*y[3]*z[4]+z[0]*x[3]*y[4]+s7;
s8 = x[5]*y[4]*z[7]+s6+y[5]*x[6]*z[4]-y[5]*x[4]*z[6]+z[6]*x[5]*y[7]-x[6]*
-y[2]*z[7]-x[6]*y[7]*z[5]+x[5]*y[6]*z[2]+x[6]*y[5]*z[7]+x[6]*y[7]*z[2]+y[6]*x[7]
-*z[4]-y[6]*x[4]*z[7]-y[6]*x[7]*z[3]+z[6]*x[7]*y[2]+x[2]*y[5]*z[6]-x[2]*y[6]*z
-[5]+y[6]*x[2]*z[7]+x[6]*y[2]*z[5];
+ y[2]*z[7]-x[6]*y[7]*z[5]+x[5]*y[6]*z[2]+x[6]*y[5]*z[7]+x[6]*y[7]*z[2]+y[6]*x[7]
+ *z[4]-y[6]*x[4]*z[7]-y[6]*x[7]*z[3]+z[6]*x[7]*y[2]+x[2]*y[5]*z[6]-x[2]*y[6]*z
+ [5]+y[6]*x[2]*z[7]+x[6]*y[2]*z[5];
s7 = s8-x[5]*y[2]*z[6]-z[6]*x[7]*y[5]-z[5]*x[7]*y[4]+z[5]*x[0]*y[4]-y[5]*
-x[4]*z[7]+y[0]*x[4]*z[7]-z[6]*x[2]*y[7]-x[5]*y[4]*z[0]-x[5]*y[7]*z[4]-y[0]*x[7]
-*z[4]+y[5]*x[4]*z[1]-x[6]*y[7]*z[4]+x[7]*y[4]*z[3]-x[4]*y[7]*z[3]+x[3]*y[7]*z
-[4]-x[7]*y[3]*z[4]-x[6]*y[3]*z[7]+x[6]*y[4]*z[7];
+ x[4]*z[7]+y[0]*x[4]*z[7]-z[6]*x[2]*y[7]-x[5]*y[4]*z[0]-x[5]*y[7]*z[4]-y[0]*x[7]
+ *z[4]+y[5]*x[4]*z[1]-x[6]*y[7]*z[4]+x[7]*y[4]*z[3]-x[4]*y[7]*z[3]+x[3]*y[7]*z
+ [4]-x[7]*y[3]*z[4]-x[6]*y[3]*z[7]+x[6]*y[4]*z[7];
s8 = -x[3]*y[4]*z[7]+x[4]*y[3]*z[7]-z[6]*x[7]*y[4]-z[1]*x[6]*y[5]+x[6]*y
-[7]*z[3]-x[1]*y[6]*z[5]-y[1]*x[5]*z[6]+z[5]*x[4]*y[7]-z[5]*x[4]*y[0]+x[1]*y[5]*
-z[6]-y[6]*x[5]*z[7]-y[2]*x[3]*z[1]+z[1]*x[5]*y[6]-y[5]*x[1]*z[4]+z[6]*x[4]*y[7]
-+x[5]*y[1]*z[4]-x[5]*y[6]*z[4]+y[6]*x[3]*z[7]-x[5]*y[4]*z[1];
+ [7]*z[3]-x[1]*y[6]*z[5]-y[1]*x[5]*z[6]+z[5]*x[4]*y[7]-z[5]*x[4]*y[0]+x[1]*y[5]*
+ z[6]-y[6]*x[5]*z[7]-y[2]*x[3]*z[1]+z[1]*x[5]*y[6]-y[5]*x[1]*z[4]+z[6]*x[4]*y[7]
+ +x[5]*y[1]*z[4]-x[5]*y[6]*z[4]+y[6]*x[3]*z[7]-x[5]*y[4]*z[1];
s5 = s8+x[5]*y[4]*z[6]+z[5]*x[1]*y[4]+y[1]*x[6]*z[5]-z[6]*x[3]*y[7]+z[6]*
-x[7]*y[3]-z[5]*x[6]*y[4]-z[5]*x[4]*y[1]+z[5]*x[4]*y[6]+x[1]*y[6]*z[2]+x[2]*y[6]
-*z[3]+z[2]*x[6]*y[3]+z[1]*x[6]*y[2]+z[2]*x[3]*y[1]-z[2]*x[1]*y[3]-z[2]*x[3]*y
-[6]+y[2]*x[1]*z[3]+y[1]*x[2]*z[6]-z[0]*x[7]*y[3]+s7;
+ x[7]*y[3]-z[5]*x[6]*y[4]-z[5]*x[4]*y[1]+z[5]*x[4]*y[6]+x[1]*y[6]*z[2]+x[2]*y[6]
+ *z[3]+z[2]*x[6]*y[3]+z[1]*x[6]*y[2]+z[2]*x[3]*y[1]-z[2]*x[1]*y[3]-z[2]*x[3]*y
+ [6]+y[2]*x[1]*z[3]+y[1]*x[2]*z[6]-z[0]*x[7]*y[3]+s7;
s4 = 1/s5;
s2 = s3*s4;
const double unknown2 = s1*s2;
double s1, s2, s3;
s3 = -x[2]*y[7]*z[3]/12.0+x[1]*y[4]*z[0]/12.0-x[0]*y[3]*z[7]/12.0-z[1]*x
-[2]*y[0]/12.0+x[5]*y[4]*z[0]/12.0+x[1]*y[5]*z[0]/12.0-x[1]*y[2]*z[0]/12.0-y[2]*
-x[3]*z[7]/12.0-x[1]*y[0]*z[4]/12.0-y[1]*x[0]*z[2]/12.0-y[0]*x[7]*z[3]/12.0+y[5]
-*x[4]*z[7]/12.0-x[0]*y[3]*z[4]/12.0-y[1]*x[0]*z[3]/12.0-z[0]*x[7]*y[4]/12.0+x
-[1]*y[0]*z[3]/12.0-x[2]*y[3]*z[0]/12.0-y[1]*x[2]*z[5]/12.0;
+ [2]*y[0]/12.0+x[5]*y[4]*z[0]/12.0+x[1]*y[5]*z[0]/12.0-x[1]*y[2]*z[0]/12.0-y[2]*
+ x[3]*z[7]/12.0-x[1]*y[0]*z[4]/12.0-y[1]*x[0]*z[2]/12.0-y[0]*x[7]*z[3]/12.0+y[5]
+ *x[4]*z[7]/12.0-x[0]*y[3]*z[4]/12.0-y[1]*x[0]*z[3]/12.0-z[0]*x[7]*y[4]/12.0+x
+ [1]*y[0]*z[3]/12.0-x[2]*y[3]*z[0]/12.0-y[1]*x[2]*z[5]/12.0;
s2 = s3+y[0]*x[3]*z[4]/12.0+y[1]*x[2]*z[0]/12.0+y[2]*x[7]*z[3]/12.0+z[1]*
-x[4]*y[0]/12.0-y[5]*x[4]*z[0]/12.0-y[1]*x[5]*z[0]/12.0+x[5]*y[7]*z[4]/12.0+y[1]
-*x[3]*z[0]/12.0+x[0]*y[4]*z[7]/12.0+z[0]*x[7]*y[3]/12.0-z[2]*x[3]*y[0]/12.0+y
-[1]*x[0]*z[5]/12.0-x[1]*y[5]*z[2]/12.0+y[1]*x[0]*z[4]/12.0+z[1]*x[2]*y[5]/12.0-
-x[5]*y[0]*z[4]/12.0+y[2]*x[3]*z[1]/12.0+x[1]*y[0]*z[2]/12.0;
+ x[4]*y[0]/12.0-y[5]*x[4]*z[0]/12.0-y[1]*x[5]*z[0]/12.0+x[5]*y[7]*z[4]/12.0+y[1]
+ *x[3]*z[0]/12.0+x[0]*y[4]*z[7]/12.0+z[0]*x[7]*y[3]/12.0-z[2]*x[3]*y[0]/12.0+y
+ [1]*x[0]*z[5]/12.0-x[1]*y[5]*z[2]/12.0+y[1]*x[0]*z[4]/12.0+z[1]*x[2]*y[5]/12.0-
+ x[5]*y[0]*z[4]/12.0+y[2]*x[3]*z[1]/12.0+x[1]*y[0]*z[2]/12.0;
s3 = -z[1]*x[0]*y[4]/12.0+z[1]*x[0]*y[2]/12.0-x[0]*y[7]*z[4]/12.0+z[0]*x
-[4]*y[7]/12.0+x[2]*y[3]*z[7]/12.0+y[2]*x[6]*z[3]/12.0+y[1]*x[6]*z[2]/12.0-y[2]*
-x[1]*z[3]/12.0+x[1]*y[2]*z[5]/12.0+y[0]*x[3]*z[7]/12.0+y[2]*x[3]*z[0]/12.0-y[0]
-*x[4]*z[3]/12.0-y[2]*x[0]*z[3]/12.0-y[1]*x[4]*z[0]/12.0+z[1]*x[5]*y[0]/12.0+x
-[1]*y[2]*z[6]/12.0-x[1]*y[0]*z[5]/12.0-x[2]*y[3]*z[1]/12.0;
+ [4]*y[7]/12.0+x[2]*y[3]*z[7]/12.0+y[2]*x[6]*z[3]/12.0+y[1]*x[6]*z[2]/12.0-y[2]*
+ x[1]*z[3]/12.0+x[1]*y[2]*z[5]/12.0+y[0]*x[3]*z[7]/12.0+y[2]*x[3]*z[0]/12.0-y[0]
+ *x[4]*z[3]/12.0-y[2]*x[0]*z[3]/12.0-y[1]*x[4]*z[0]/12.0+z[1]*x[5]*y[0]/12.0+x
+ [1]*y[2]*z[6]/12.0-x[1]*y[0]*z[5]/12.0-x[2]*y[3]*z[1]/12.0;
s1 = s3-z[0]*x[3]*y[4]/12.0+z[1]*x[0]*y[3]/12.0-z[1]*x[5]*y[2]/12.0+z[1]*
-x[2]*y[6]/12.0-z[2]*x[3]*y[1]/12.0+z[2]*x[3]*y[6]/12.0+x[2]*y[1]*z[3]/12.0-z[1]
-*x[3]*y[0]/12.0+x[2]*y[3]*z[6]/12.0-z[0]*x[3]*y[7]/12.0+y[5]*x[0]*z[4]/12.0-z
-[1]*x[6]*y[2]/12.0-z[2]*x[6]*y[3]/12.0+z[2]*x[0]*y[3]/12.0+z[2]*x[3]*y[7]/12.0+
-z[2]*x[1]*y[3]/12.0+y[1]*x[5]*z[2]/12.0-z[2]*x[7]*y[3]/12.0+s2;
+ x[2]*y[6]/12.0-z[2]*x[3]*y[1]/12.0+z[2]*x[3]*y[6]/12.0+x[2]*y[1]*z[3]/12.0-z[1]
+ *x[3]*y[0]/12.0+x[2]*y[3]*z[6]/12.0-z[0]*x[3]*y[7]/12.0+y[5]*x[0]*z[4]/12.0-z
+ [1]*x[6]*y[2]/12.0-z[2]*x[6]*y[3]/12.0+z[2]*x[0]*y[3]/12.0+z[2]*x[3]*y[7]/12.0+
+ z[2]*x[1]*y[3]/12.0+y[1]*x[5]*z[2]/12.0-z[2]*x[7]*y[3]/12.0+s2;
s3 = x[0]*y[7]*z[3]/12.0-z[1]*x[0]*y[5]/12.0-x[1]*y[3]*z[0]/12.0-x[1]*y
-[6]*z[2]/12.0-x[2]*y[6]*z[3]/12.0-x[5]*y[4]*z[7]/12.0+z[0]*x[4]*y[3]/12.0+x[0]*
-y[4]*z[3]/12.0-x[6]*y[5]*z[7]/12.0-x[6]*y[7]*z[2]/12.0+z[1]*x[6]*y[5]/12.0+y[6]
-*x[4]*z[7]/12.0+y[1]*x[5]*z[6]/12.0+x[1]*y[6]*z[5]/12.0-y[5]*x[7]*z[4]/12.0+y
-[0]*x[7]*z[4]/12.0-y[0]*x[4]*z[7]/12.0-z[5]*x[0]*y[4]/12.0;
+ [6]*z[2]/12.0-x[2]*y[6]*z[3]/12.0-x[5]*y[4]*z[7]/12.0+z[0]*x[4]*y[3]/12.0+x[0]*
+ y[4]*z[3]/12.0-x[6]*y[5]*z[7]/12.0-x[6]*y[7]*z[2]/12.0+z[1]*x[6]*y[5]/12.0+y[6]
+ *x[4]*z[7]/12.0+y[1]*x[5]*z[6]/12.0+x[1]*y[6]*z[5]/12.0-y[5]*x[7]*z[4]/12.0+y
+ [0]*x[7]*z[4]/12.0-y[0]*x[4]*z[7]/12.0-z[5]*x[0]*y[4]/12.0;
s2 = s3+z[6]*x[3]*y[7]/12.0+z[6]*x[7]*y[4]/12.0-z[6]*x[4]*y[7]/12.0-z[6]*
-x[7]*y[3]/12.0+y[6]*x[5]*z[7]/12.0-y[6]*x[7]*z[5]/12.0-x[2]*y[5]*z[6]/12.0+z[6]
-*x[2]*y[7]/12.0+z[6]*x[7]*y[5]/12.0-z[6]*x[5]*y[7]/12.0-z[6]*x[7]*y[2]/12.0+x
-[6]*y[7]*z[5]/12.0+z[5]*x[7]*y[4]/12.0-z[5]*x[4]*y[7]/12.0+y[5]*x[1]*z[4]/12.0-
-y[5]*x[6]*z[4]/12.0-y[5]*x[4]*z[1]/12.0+y[5]*x[4]*z[6]/12.0;
+ x[7]*y[3]/12.0+y[6]*x[5]*z[7]/12.0-y[6]*x[7]*z[5]/12.0-x[2]*y[5]*z[6]/12.0+z[6]
+ *x[2]*y[7]/12.0+z[6]*x[7]*y[5]/12.0-z[6]*x[5]*y[7]/12.0-z[6]*x[7]*y[2]/12.0+x
+ [6]*y[7]*z[5]/12.0+z[5]*x[7]*y[4]/12.0-z[5]*x[4]*y[7]/12.0+y[5]*x[1]*z[4]/12.0-
+ y[5]*x[6]*z[4]/12.0-y[5]*x[4]*z[1]/12.0+y[5]*x[4]*z[6]/12.0;
s3 = y[6]*x[7]*z[3]/12.0+x[6]*y[5]*z[2]/12.0-x[5]*y[6]*z[2]/12.0-x[6]*y
-[2]*z[5]/12.0+x[5]*y[2]*z[6]/12.0+x[6]*y[2]*z[7]/12.0+z[5]*x[4]*y[0]/12.0-y[6]*
-x[2]*z[7]/12.0+x[2]*y[6]*z[5]/12.0+y[6]*x[7]*z[2]/12.0-y[6]*x[3]*z[7]/12.0-x[7]
-*y[4]*z[3]/12.0-x[6]*y[4]*z[7]/12.0-x[5]*y[1]*z[4]/12.0+x[6]*y[7]*z[4]/12.0+x
-[7]*y[3]*z[4]/12.0-z[1]*x[5]*y[6]/12.0+x[3]*y[4]*z[7]/12.0+x[5]*y[6]*z[4]/12.0;
+ [2]*z[5]/12.0+x[5]*y[2]*z[6]/12.0+x[6]*y[2]*z[7]/12.0+z[5]*x[4]*y[0]/12.0-y[6]*
+ x[2]*z[7]/12.0+x[2]*y[6]*z[5]/12.0+y[6]*x[7]*z[2]/12.0-y[6]*x[3]*z[7]/12.0-x[7]
+ *y[4]*z[3]/12.0-x[6]*y[4]*z[7]/12.0-x[5]*y[1]*z[4]/12.0+x[6]*y[7]*z[4]/12.0+x
+ [7]*y[3]*z[4]/12.0-z[1]*x[5]*y[6]/12.0+x[3]*y[4]*z[7]/12.0+x[5]*y[6]*z[4]/12.0;
return s3+x[5]*y[4]*z[1]/12.0-x[5]*y[4]*z[6]/12.0-x[3]*y[7]*z[4]/12.0+x[6]*
-y[3]*z[7]/12.0-y[1]*x[6]*z[5]/12.0-z[5]*x[1]*y[4]/12.0+z[5]*x[6]*y[4]/12.0+z[5]
-*x[4]*y[1]/12.0-z[5]*x[4]*y[6]/12.0-x[6]*y[7]*z[3]/12.0-x[4]*y[3]*z[7]/12.0+x
-[4]*y[7]*z[3]/12.0-x[1]*y[5]*z[6]/12.0-y[6]*x[7]*z[4]/12.0-y[1]*x[2]*z[6]/12.0-
-y[2]*x[3]*z[6]/12.0+s2+s1+x[2]*y[0]*z[3]/12.0;
+ y[3]*z[7]/12.0-y[1]*x[6]*z[5]/12.0-z[5]*x[1]*y[4]/12.0+z[5]*x[6]*y[4]/12.0+z[5]
+ *x[4]*y[1]/12.0-z[5]*x[4]*y[6]/12.0-x[6]*y[7]*z[3]/12.0-x[4]*y[3]*z[7]/12.0+x
+ [4]*y[7]*z[3]/12.0-x[1]*y[5]*z[6]/12.0-y[6]*x[7]*z[4]/12.0-y[1]*x[2]*z[6]/12.0-
+ y[2]*x[3]*z[6]/12.0+s2+s1+x[2]*y[0]*z[3]/12.0;
};
#endif
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
template <int dim>
void
-MGDoFObjectAccessor<1, dim>::get_mg_dof_indices (vector<unsigned int> &dof_indices) const
+MGDoFObjectAccessor<1, dim>::get_mg_dof_indices (std::vector<unsigned int> &dof_indices) const
{
Assert (dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
Assert (mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
const unsigned int dofs_per_vertex = dof_handler->get_fe().dofs_per_vertex,
dofs_per_line = dof_handler->get_fe().dofs_per_line;
- vector<unsigned int>::iterator next = dof_indices.begin();
+ std::vector<unsigned int>::iterator next = dof_indices.begin();
for (unsigned int vertex=0; vertex<2; ++vertex)
for (unsigned int d=0; d<dofs_per_vertex; ++d)
*next++ = mg_vertex_dof_index(vertex,d);
const unsigned int dofs_per_vertex = dof_handler->get_fe().dofs_per_vertex,
dofs_per_line = dof_handler->get_fe().dofs_per_line;
- typename vector<number>::iterator next_dof_value=dof_values.begin();
+ typename Vector<number>::iterator next_dof_value=dof_values.begin();
for (unsigned int vertex=0; vertex<2; ++vertex)
for (unsigned int d=0; d<dofs_per_vertex; ++d)
*next_dof_value++ = values(mg_vertex_dof_index(vertex,d));
template <int dim>
void
-MGDoFObjectAccessor<2, dim>::get_mg_dof_indices (vector<unsigned int> &dof_indices) const
+MGDoFObjectAccessor<2, dim>::get_mg_dof_indices (std::vector<unsigned int> &dof_indices) const
{
Assert (dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
Assert (mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
const unsigned int dofs_per_vertex = dof_handler->get_fe().dofs_per_vertex,
dofs_per_line = dof_handler->get_fe().dofs_per_line,
dofs_per_quad = dof_handler->get_fe().dofs_per_quad;
- vector<unsigned int>::iterator next = dof_indices.begin();
+ std::vector<unsigned int>::iterator next = dof_indices.begin();
for (unsigned int vertex=0; vertex<4; ++vertex)
for (unsigned int d=0; d<dofs_per_vertex; ++d)
*next++ = mg_vertex_dof_index(vertex,d);
const unsigned int dofs_per_vertex = dof_handler->get_fe().dofs_per_vertex,
dofs_per_line = dof_handler->get_fe().dofs_per_line,
dofs_per_quad = dof_handler->get_fe().dofs_per_quad;
- typename vector<number>::iterator next_dof_value=dof_values.begin();
+ typename Vector<number>::iterator next_dof_value=dof_values.begin();
for (unsigned int vertex=0; vertex<4; ++vertex)
for (unsigned int d=0; d<dofs_per_vertex; ++d)
*next_dof_value++ = values(mg_vertex_dof_index(vertex,d));
template <int dim>
void
-MGDoFObjectAccessor<3, dim>::get_mg_dof_indices (vector<unsigned int> &dof_indices) const
+MGDoFObjectAccessor<3, dim>::get_mg_dof_indices (std::vector<unsigned int> &dof_indices) const
{
Assert (dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
Assert (mg_dof_handler != 0, DoFAccessor<dim>::ExcInvalidObject());
dofs_per_line = dof_handler->get_fe().dofs_per_line,
dofs_per_quad = dof_handler->get_fe().dofs_per_quad,
dofs_per_hex = dof_handler->get_fe().dofs_per_hex;
- vector<unsigned int>::iterator next = dof_indices.begin();
+ std::vector<unsigned int>::iterator next = dof_indices.begin();
for (unsigned int vertex=0; vertex<8; ++vertex)
for (unsigned int d=0; d<dofs_per_vertex; ++d)
*next++ = mg_vertex_dof_index(vertex,d);
dofs_per_line = dof_handler->get_fe().dofs_per_line,
dofs_per_quad = dof_handler->get_fe().dofs_per_quad,
dofs_per_hex = dof_handler->get_fe().dofs_per_hex;
- typename vector<number>::iterator next_dof_value=dof_values.begin();
+ typename Vector<number>::iterator next_dof_value=dof_values.begin();
for (unsigned int vertex=0; vertex<8; ++vertex)
for (unsigned int d=0; d<dofs_per_vertex; ++d)
*next_dof_value++ = values(mg_vertex_dof_index(vertex,d));
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
template <>
void MGDoFHandler<1>::renumber_dofs (const unsigned int level,
- const vector<unsigned int> &new_numbers) {
+ const std::vector<unsigned int> &new_numbers) {
Assert (new_numbers.size() == n_dofs(level), ExcRenumberingIncomplete());
// note that we can not use cell iterators
// two cells more than once. Anyway, this
// ways it's not only more correct but also
// faster
- for (vector<MGVertexDoFs>::iterator i=mg_vertex_dofs.begin();
+ for (std::vector<MGVertexDoFs>::iterator i=mg_vertex_dofs.begin();
i!=mg_vertex_dofs.end(); ++i)
// if the present vertex lives on
// the present level
new_numbers[i->get_index (level, d,
selected_fe->dofs_per_vertex)]);
- for (vector<unsigned int>::iterator i=mg_levels[level]->line_dofs.begin();
+ for (std::vector<unsigned int>::iterator i=mg_levels[level]->line_dofs.begin();
i!=mg_levels[level]->line_dofs.end(); ++i)
{
Assert (*i != DoFHandler<1>::invalid_dof_index, ExcInternalError());
template <>
void MGDoFHandler<2>::renumber_dofs (const unsigned int level,
- const vector<unsigned int> &new_numbers) {
+ const std::vector<unsigned int> &new_numbers) {
Assert (new_numbers.size() == n_dofs(level), ExcRenumberingIncomplete());
- for (vector<MGVertexDoFs>::iterator i=mg_vertex_dofs.begin();
+ for (std::vector<MGVertexDoFs>::iterator i=mg_vertex_dofs.begin();
i!=mg_vertex_dofs.end(); ++i)
// if the present vertex lives on
// the present level
new_numbers[i->get_index (level, d,
selected_fe->dofs_per_vertex)]);
- for (vector<unsigned int>::iterator i=mg_levels[level]->line_dofs.begin();
+ for (std::vector<unsigned int>::iterator i=mg_levels[level]->line_dofs.begin();
i!=mg_levels[level]->line_dofs.end(); ++i)
{
Assert (*i != DoFHandler<2>::invalid_dof_index, ExcInternalError());
*i = new_numbers[*i];
};
- for (vector<unsigned int>::iterator i=mg_levels[level]->quad_dofs.begin();
+ for (std::vector<unsigned int>::iterator i=mg_levels[level]->quad_dofs.begin();
i!=mg_levels[level]->quad_dofs.end(); ++i)
{
Assert (*i != DoFHandler<2>::invalid_dof_index, ExcInternalError());
template <>
void MGDoFHandler<3>::renumber_dofs (const unsigned int level,
- const vector<unsigned int> &new_numbers) {
+ const std::vector<unsigned int> &new_numbers) {
Assert (new_numbers.size() == n_dofs(level), ExcRenumberingIncomplete());
- for (vector<MGVertexDoFs>::iterator i=mg_vertex_dofs.begin();
+ for (std::vector<MGVertexDoFs>::iterator i=mg_vertex_dofs.begin();
i!=mg_vertex_dofs.end(); ++i)
// if the present vertex lives on
// the present level
new_numbers[i->get_index (level, d,
selected_fe->dofs_per_vertex)]);
- for (vector<unsigned int>::iterator i=mg_levels[level]->line_dofs.begin();
+ for (std::vector<unsigned int>::iterator i=mg_levels[level]->line_dofs.begin();
i!=mg_levels[level]->line_dofs.end(); ++i)
{
Assert (*i != DoFHandler<3>::invalid_dof_index, ExcInternalError());
*i = new_numbers[*i];
};
- for (vector<unsigned int>::iterator i=mg_levels[level]->quad_dofs.begin();
+ for (std::vector<unsigned int>::iterator i=mg_levels[level]->quad_dofs.begin();
i!=mg_levels[level]->quad_dofs.end(); ++i)
{
Assert (*i != DoFHandler<3>::invalid_dof_index, ExcInternalError());
*i = new_numbers[*i];
};
- for (vector<unsigned int>::iterator i=mg_levels[level]->hex_dofs.begin();
+ for (std::vector<unsigned int>::iterator i=mg_levels[level]->hex_dofs.begin();
i!=mg_levels[level]->hex_dofs.end(); ++i)
{
Assert (*i != DoFHandler<3>::invalid_dof_index, ExcInternalError());
{
mg_levels.push_back (new DoFLevel<1>);
- mg_levels.back()->line_dofs = vector<unsigned int>(tria->levels[i]->lines.lines.size() *
+ mg_levels.back()->line_dofs = std::vector<unsigned int>(tria->levels[i]->lines.lines.size() *
selected_fe->dofs_per_line,
DoFHandler<1>::invalid_dof_index);
};
// vertex we pass by belongs to
mg_vertex_dofs.resize (tria->vertices.size());
- vector<unsigned int> min_level (tria->vertices.size(), tria->n_levels());
- vector<unsigned int> max_level (tria->vertices.size(), 0);
+ std::vector<unsigned int> min_level (tria->vertices.size(), tria->n_levels());
+ std::vector<unsigned int> max_level (tria->vertices.size(), 0);
Triangulation<dim>::cell_iterator cell = tria->begin(),
endc = tria->end();
{
mg_levels.push_back (new DoFLevel<2>);
- mg_levels.back()->line_dofs = vector<unsigned int> (tria->levels[i]->lines.lines.size() *
+ mg_levels.back()->line_dofs = std::vector<unsigned int> (tria->levels[i]->lines.lines.size() *
selected_fe->dofs_per_line,
DoFHandler<2>::invalid_dof_index);
- mg_levels.back()->quad_dofs = vector<unsigned int> (tria->levels[i]->quads.quads.size() *
+ mg_levels.back()->quad_dofs = std::vector<unsigned int> (tria->levels[i]->quads.quads.size() *
selected_fe->dofs_per_quad,
DoFHandler<2>::invalid_dof_index);
};
// vertex we pass by belongs to
mg_vertex_dofs.resize (tria->vertices.size());
- vector<unsigned int> min_level (tria->vertices.size(), tria->n_levels());
- vector<unsigned int> max_level (tria->vertices.size(), 0);
+ std::vector<unsigned int> min_level (tria->vertices.size(), tria->n_levels());
+ std::vector<unsigned int> max_level (tria->vertices.size(), 0);
Triangulation<dim>::cell_iterator cell = tria->begin(),
endc = tria->end();
{
mg_levels.push_back (new DoFLevel<3>);
- mg_levels.back()->line_dofs = vector<unsigned int> (tria->levels[i]->lines.lines.size() *
+ mg_levels.back()->line_dofs = std::vector<unsigned int> (tria->levels[i]->lines.lines.size() *
selected_fe->dofs_per_line,
DoFHandler<3>::invalid_dof_index);
- mg_levels.back()->quad_dofs = vector<unsigned int> (tria->levels[i]->quads.quads.size() *
+ mg_levels.back()->quad_dofs = std::vector<unsigned int> (tria->levels[i]->quads.quads.size() *
selected_fe->dofs_per_quad,
DoFHandler<3>::invalid_dof_index);
- mg_levels.back()->hex_dofs = vector<unsigned int> (tria->levels[i]->hexes.hexes.size() *
+ mg_levels.back()->hex_dofs = std::vector<unsigned int> (tria->levels[i]->hexes.hexes.size() *
selected_fe->dofs_per_hex,
DoFHandler<3>::invalid_dof_index);
};
// vertex we pass by belongs to
mg_vertex_dofs.resize (tria->vertices.size());
- vector<unsigned int> min_level (tria->vertices.size(), tria->n_levels());
- vector<unsigned int> max_level (tria->vertices.size(), 0);
+ std::vector<unsigned int> min_level (tria->vertices.size(), tria->n_levels());
+ std::vector<unsigned int> max_level (tria->vertices.size(), 0);
Triangulation<dim>::cell_iterator cell = tria->begin(),
endc = tria->end();
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
ExcDimensionMismatch (sparsity.n_cols(), n_dofs));
const unsigned int dofs_per_cell = dof.get_fe().dofs_per_cell;
- vector<unsigned int> dofs_on_this_cell(dofs_per_cell);
+ std::vector<unsigned int> dofs_on_this_cell(dofs_per_cell);
MGDoFHandler<dim>::cell_iterator cell = dof.begin(level),
endc = dof.end(level);
for (; cell!=endc; ++cell)
ExcDimensionMismatch (sparsity.n_cols(), n_dofs));
const unsigned int dofs_per_cell = dof.get_fe().dofs_per_cell;
- vector<unsigned int> dofs_on_this_cell(dofs_per_cell);
- vector<unsigned int> dofs_on_other_cell(dofs_per_cell);
+ std::vector<unsigned int> dofs_on_this_cell(dofs_per_cell);
+ std::vector<unsigned int> dofs_on_other_cell(dofs_per_cell);
MGDoFHandler<dim>::cell_iterator cell = dof.begin(level),
endc = dof.end(level);
for (; cell!=endc; ++cell)
ExcDimensionMismatch (sparsity.n_cols(), fine_dofs));
const unsigned int dofs_per_cell = dof.get_fe().dofs_per_cell;
- vector<unsigned int> dofs_on_this_cell(dofs_per_cell);
- vector<unsigned int> dofs_on_other_cell(dofs_per_cell);
+ std::vector<unsigned int> dofs_on_this_cell(dofs_per_cell);
+ std::vector<unsigned int> dofs_on_other_cell(dofs_per_cell);
MGDoFHandler<dim>::cell_iterator cell = dof.begin(level),
endc = dof.end(level);
for (; cell!=endc; ++cell)
ExcDimensionMismatch (flux_mask.n(), n_comp));
const unsigned int total_dofs = dof.get_fe().dofs_per_cell;
- vector<unsigned int> dofs_on_this_cell(total_dofs);
- vector<unsigned int> dofs_on_other_cell(total_dofs);
+ std::vector<unsigned int> dofs_on_this_cell(total_dofs);
+ std::vector<unsigned int> dofs_on_other_cell(total_dofs);
MGDoFHandler<dim>::cell_iterator cell = dof.begin(level),
endc = dof.end(level);
- vector<vector<bool> > int_dof_mask(total_dofs,
- vector<bool>(total_dofs, false));
- vector<vector<bool> > flux_dof_mask(total_dofs,
- vector<bool>(total_dofs, false));
+ std::vector<std::vector<bool> > int_dof_mask(total_dofs,
+ std::vector<bool>(total_dofs, false));
+ std::vector<std::vector<bool> > flux_dof_mask(total_dofs,
+ std::vector<bool>(total_dofs, false));
for (unsigned int i=0; i<total_dofs; ++i)
for (unsigned int j=0; j<total_dofs; ++j)
{
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// to much memory by later copying the
// content of this vector to its final
// destination
- vector<unsigned int> boundary_dofs;
+ std::vector<unsigned int> boundary_dofs;
// temporary to hold the dof indices
// on a face between to levels
- vector<unsigned int> dofs_on_face (mg_dof.get_fe().dofs_per_face);
+ std::vector<unsigned int> dofs_on_face (mg_dof.get_fe().dofs_per_face);
for (unsigned int level=1; level<n_levels; ++level)
{
if (level==0)
return;
else
- for (vector<unsigned int>::const_iterator p=interior_boundary_dofs[level-1].begin();
+ for (std::vector<unsigned int>::const_iterator p=interior_boundary_dofs[level-1].begin();
p!=interior_boundary_dofs[level-1].end(); ++p)
u(*p) = 0;
};
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
const unsigned int maxlevel)
:
MGBase(transfer, minlevel,
- min(mg_dof_handler.get_tria().n_levels()-1,
+ std::min(mg_dof_handler.get_tria().n_levels()-1,
maxlevel)),
mg_dof_handler(&mg_dof_handler),
level_sparsities(&level_sparsities),
// two fields which will store the
// indices of the multigrid dofs
// for a cell and one of its children
- vector<unsigned int> dof_indices_mother (dofs_per_cell);
- vector<unsigned int> dof_indices_child (dofs_per_cell);
+ std::vector<unsigned int> dof_indices_mother (dofs_per_cell);
+ std::vector<unsigned int> dof_indices_child (dofs_per_cell);
// for each level: first build the sparsity
// pattern of the matrices and then build the
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// get indices of dofs
- vector<unsigned int> dofs (n_dofs);
+ std::vector<unsigned int> dofs (n_dofs);
get_dof_indices (dofs);
// one could use the
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// apply Dirichlet bc as described
// in the docs
- map<unsigned int, double> boundary_value_list;
+ std::map<unsigned int, double> boundary_value_list;
for (typename FunctionMap::const_iterator dirichlet = dirichlet_bc.begin() ;
dirichlet != dirichlet_bc.end() ; ++dirichlet)
template <int dim>
-string ProblemBase<dim>::get_solution_name () const {
+std::string ProblemBase<dim>::get_solution_name () const {
return "solution";
};
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
template <int dof_handler_dim, int patch_dim, int patch_space_dim>
DataOut_DoFData<dof_handler_dim,patch_dim,patch_space_dim>::DataEntry::
DataEntry (const Vector<double> *data,
- const vector<string> &names) :
+ const std::vector<std::string> &names) :
data(data),
names(names)
{};
template <int dof_handler_dim, int patch_dim, int patch_space_dim>
void
DataOut_DoFData<dof_handler_dim,patch_dim,patch_space_dim>::add_data_vector (const Vector<double> &vec,
- const vector<string> &names)
+ const std::vector<std::string> &names)
{
Assert (dofs != 0, ExcNoDoFHandlerSelected ());
for (unsigned int i=0; i<names.size(); ++i)
Assert (names[i].find_first_not_of("abcdefghijklmnopqrstuvwxyz"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
- "0123456789_<>()") == string::npos,
+ "0123456789_<>()") == std::string::npos,
ExcInvalidCharacter (names[i]));
DataEntry new_entry (&vec, names);
template <int dof_handler_dim, int patch_dim, int patch_space_dim>
void
DataOut_DoFData<dof_handler_dim,patch_dim,patch_space_dim>::add_data_vector (const Vector<double> &vec,
- const string &name)
+ const std::string &name)
{
unsigned int n_components = dofs->get_fe().n_components ();
- vector<string> names;
+ std::vector<std::string> names;
// if only one component or vector
// is cell vector: we only need one
// name
names.resize (n_components);
for (unsigned int i=0; i<n_components; ++i)
{
- ostrstream namebuf;
- namebuf << name << '_' << i << ends;
+ std::ostrstream namebuf;
+ namebuf << name << '_' << i << std::ends;
names[i] = namebuf.str();
};
};
cell_data.erase (cell_data.begin(), cell_data.end());
// delete patches
- vector<DataOutBase::Patch<patch_dim,patch_space_dim> > dummy;
+
std::vector<DataOutBase::Patch<patch_dim,patch_space_dim> > dummy;
patches.swap (dummy);
}
};
// delete patches
- vector<DataOutBase::Patch<patch_dim,patch_space_dim> > dummy;
+
std::vector<DataOutBase::Patch<patch_dim,patch_space_dim> > dummy;
patches.swap (dummy);
}
template <int dof_handler_dim, int patch_dim, int patch_space_dim>
-vector<string>
+std::vector<std::string>
DataOut_DoFData<dof_handler_dim,patch_dim,patch_space_dim>::get_dataset_names () const
{
- vector<string> names;
+ std::vector<std::string> names;
// collect the names of dof
// and cell data
- for (typename vector<DataEntry>::const_iterator d=dof_data.begin();
+ for (typename std::vector<DataEntry>::const_iterator d=dof_data.begin();
d!=dof_data.end(); ++d)
for (unsigned int i=0; i<d->names.size(); ++i)
names.push_back (d->names[i]);
- for (typename vector<DataEntry>::const_iterator d=cell_data.begin();
+ for (typename std::vector<DataEntry>::const_iterator d=cell_data.begin();
d!=cell_data.end(); ++d)
{
Assert (d->names.size() == 1, ExcInternalError());
template <int dof_handler_dim, int patch_dim, int patch_space_dim>
-const vector<typename DataOutBase::Patch<patch_dim, patch_space_dim> > &
+const
std::vector<typename DataOutBase::Patch<patch_dim, patch_space_dim> > &
DataOut_DoFData<dof_handler_dim,patch_dim,patch_space_dim>::get_patches () const
{
return patches;
const unsigned int n_q_points = patch_points.n_quadrature_points;
unsigned int cell_number = 0;
- typename vector<DataOutBase::Patch<dim> >::iterator patch = patches.begin();
+ typename std::vector<DataOutBase::Patch<dim> >::iterator patch = patches.begin();
DoFHandler<dim>::cell_iterator cell=first_cell();
// get first cell in this thread
// clear the patches array
if (true)
{
- vector<DataOutBase::Patch<dim> > dummy;
+ std::vector<DataOutBase::Patch<dim> > dummy;
patches.swap (dummy);
};
cell = next_cell(cell))
++n_patches;
- vector<Data> thread_data(n_threads);
+ std::vector<Data> thread_data(n_threads);
// init data for the threads
for (unsigned int i=0;i<n_threads;++i)
// $Id$
// Version: $Name$
//
-// Copyright (C) 2000 by the deal.II authors
+// Copyright (C) 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
const unsigned int n_q_points = patch_points.n_quadrature_points;
unsigned int face_number = 0;
- typename vector<DataOutBase::Patch<dim-1,dim> >::iterator patch = patches.begin();
+ typename std::vector<DataOutBase::Patch<dim-1,dim> >::iterator patch = patches.begin();
FaceDescriptor face=first_face();
// get first face in this thread
// clear the patches array
if (true)
{
- vector<DataOutBase::Patch<dim-1,dim> > dummy;
+ std::vector<DataOutBase::Patch<dim-1,dim> > dummy;
patches.swap (dummy);
};
face = next_face(face))
++n_patches;
- vector<Data> thread_data(n_threads);
+ std::vector<Data> thread_data(n_threads);
// init data for the threads
for (unsigned int i=0;i<n_threads;++i)
// $Id$
// Version: $Name$
//
-// Copyright (C) 2000 by the deal.II authors
+// Copyright (C) 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// initial direction at the end
// again
const double pi = 3.14159265358979323846;
- vector<Point<dim+1> > angle_directions (n_patches_per_circle+1);
+
std::vector<Point<dim+1> > angle_directions (n_patches_per_circle+1);
for (unsigned int i=0; i<=n_patches_per_circle; ++i)
{
angle_directions[i][0] = cos(2*pi*i/n_patches_per_circle);
unsigned int cell_number = 0;
- typename vector<DataOutBase::Patch<dim+1> >::iterator patch = patches.begin();
+ typename std::vector<DataOutBase::Patch<dim+1> >::iterator patch = patches.begin();
typename DoFHandler<dim>::cell_iterator cell=first_cell();
// get first cell in this thread
// clear the patches array
if (true)
{
- vector<DataOutBase::Patch<dim+1> > dummy;
+ std::vector<DataOutBase::Patch<dim+1> > dummy;
patches.swap (dummy);
};
// rotation
n_patches *= n_patches_per_circle;
- vector<Data> thread_data(n_threads);
+ std::vector<Data> thread_data(n_threads);
// init data for the threads
for (unsigned int i=0;i<n_threads;++i)
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
//
// this is to prevent serious waste of
// memory
- for (typename vector<DataVector>::const_iterator i=dof_data.begin();
+ for (typename std::vector<DataVector>::const_iterator i=dof_data.begin();
i!=dof_data.end(); ++i)
Assert (i->data.size() == 0,
ExcDataNotCleared ());
- for (typename vector<DataVector>::const_iterator i=cell_data.begin();
+ for (typename std::vector<DataVector>::const_iterator i=cell_data.begin();
i!=cell_data.end(); ++i)
Assert (i->data.size() == 0,
ExcDataNotCleared ());
template <int dim>
-void DataOutStack<dim>::declare_data_vector (const string &name,
+void DataOutStack<dim>::declare_data_vector (const std::string &name,
const VectorType vector_type)
{
- vector<string> names;
+ std::vector<std::string> names;
names.push_back (name);
declare_data_vector (names, vector_type);
};
template <int dim>
-void DataOutStack<dim>::declare_data_vector (const vector<string> &names,
+void DataOutStack<dim>::declare_data_vector (const std::vector<std::string> &names,
const VectorType vector_type)
{
// make sure this function is
// also make sure that no name is
// used twice
- for (vector<string>::const_iterator name=names.begin(); name!=names.end(); ++name)
+ for (std::vector<std::string>::const_iterator name=names.begin(); name!=names.end(); ++name)
{
- for (typename vector<DataVector>::const_iterator data_set=dof_data.begin();
+ for (typename std::vector<DataVector>::const_iterator data_set=dof_data.begin();
data_set!=dof_data.end(); ++data_set)
for (unsigned int i=0; i<data_set->names.size(); ++i)
Assert (*name != data_set->names[i], ExcNameAlreadyUsed(*name));
- for (typename vector<DataVector>::const_iterator data_set=cell_data.begin();
+ for (typename std::vector<DataVector>::const_iterator data_set=cell_data.begin();
data_set!=cell_data.end(); ++data_set)
for (unsigned int i=0; i<data_set->names.size(); ++i)
Assert (*name != data_set->names[i], ExcNameAlreadyUsed(*name));
template <int dim>
template <typename number>
void DataOutStack<dim>::add_data_vector (const Vector<number> &vec,
- const string &name)
+ const std::string &name)
{
- vector<string> names;
+ std::vector<std::string> names;
names.push_back (name);
add_data_vector (vec, names);
};
template <int dim>
template <typename number>
void DataOutStack<dim>::add_data_vector (const Vector<number> &vec,
- const vector<string> &names)
+ const std::vector<std::string> &names)
{
Assert (dof_handler != 0, ExcNoDoFHandlerSelected ());
// either cell data and one name,
for (unsigned int i=0; i<names.size(); ++i)
Assert (names[i].find_first_not_of("abcdefghijklmnopqrstuvwxyz"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
- "0123456789_<>()") == string::npos,
+ "0123456789_<>()") == std::string::npos,
ExcInvalidCharacter (names[i]));
if (vec.size() == dof_handler->n_dofs())
{
- typename vector<DataVector>::iterator data_vector=dof_data.begin();
+ typename std::vector<DataVector>::iterator data_vector=dof_data.begin();
for (; data_vector!=dof_data.end(); ++data_vector)
if (data_vector->names == names)
{
data_vector->data.reinit (vec.size());
- copy (vec.begin(), vec.end(),
+ std::copy (vec.begin(), vec.end(),
data_vector->data.begin());
break;
};
}
else
{
- typename vector<DataVector>::iterator data_vector=cell_data.begin();
+ typename std::vector<DataVector>::iterator data_vector=cell_data.begin();
for (; data_vector!=cell_data.end(); ++data_vector)
if (data_vector->names == names)
{
data_vector->data.reinit (vec.size());
- copy (vec.begin(), vec.end(),
- data_vector->data.begin());
+ std::copy (vec.begin(), vec.end(),
+ data_vector->data.begin());
break;
};
Assert (data_vector != cell_data.end(),
patch_points,
update_values);
const unsigned int n_q_points = patch_points.n_quadrature_points;
- vector<double> patch_values (n_q_points);
- vector<Vector<double> > patch_values_system (n_q_points,
+ std::vector<double> patch_values (n_q_points);
+ std::vector<Vector<double> > patch_values_system (n_q_points,
Vector<double>(n_components));
// add the required number of patches
// now loop over all cells and
// actually create the patches
- typename vector<DataOutBase::Patch<dim+1> >::iterator patch = &patches[patches.size()-n_patches];
- unsigned int cell_number = 0;
+ typename std::vector<DataOutBase::Patch<dim+1> >::iterator
+ patch = patches.begin() + (patches.size()-n_patches);
+ unsigned int cell_number = 0;
for (typename DoFHandler<dim>::active_cell_iterator cell=dof_handler->begin_active();
cell != dof_handler->end(); ++cell, ++patch, ++cell_number)
{
{
// release lock on dof handler
dof_handler = 0;
- for (typename vector<DataVector>::iterator i=dof_data.begin();
+ for (typename std::vector<DataVector>::iterator i=dof_data.begin();
i!=dof_data.end(); ++i)
i->data.reinit (0);
- for (typename vector<DataVector>::iterator i=cell_data.begin();
+ for (typename std::vector<DataVector>::iterator i=cell_data.begin();
i!=cell_data.end(); ++i)
i->data.reinit (0);
};
template <int dim>
-const vector<DataOutBase::Patch<dim+1> > &
+const std::vector<DataOutBase::Patch<dim+1> > &
DataOutStack<dim>::get_patches () const
{
return patches;
template <int dim>
-vector<string> DataOutStack<dim>::get_dataset_names () const
+std::vector<std::string> DataOutStack<dim>::get_dataset_names () const
{
- vector<string> names;
- for (typename vector<DataVector>::const_iterator dataset=dof_data.begin();
+ std::vector<std::string> names;
+ for (typename std::vector<DataVector>::const_iterator dataset=dof_data.begin();
dataset!=dof_data.end(); ++dataset)
names.insert (names.end(), dataset->names.begin(), dataset->names.end());
- for (typename vector<DataVector>::const_iterator dataset=cell_data.begin();
+ for (typename std::vector<DataVector>::const_iterator dataset=cell_data.begin();
dataset!=cell_data.end(); ++dataset)
names.insert (names.end(), dataset->names.begin(), dataset->names.end());
// explicit instantiations
template class DataOutStack<deal_II_dimension>;
template void DataOutStack<deal_II_dimension>::add_data_vector (const Vector<double> &vec,
- const string &name);
+ const std::string &name);
template void DataOutStack<deal_II_dimension>::add_data_vector (const Vector<float> &vec,
- const string &name);
+ const std::string &name);
// $Id$
// Version: $Name$
//
-// Copyright (C) 2000 by the deal.II authors
+// Copyright (C) 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
{
if (fe_values.get_fe().n_components() == 1)
{
- vector<ProjectedDerivative> values (1);
+
std::vector<ProjectedDerivative> values (1);
fe_values.get_function_values (solution, values);
return values[0];
}
else
{
- vector<Vector<double> > values
+ std::vector<Vector<double> > values
(1, Vector<double>(fe_values.get_fe().n_components()));
fe_values.get_function_values (solution, values);
return values[0](component);
{
if (fe_values.get_fe().n_components() == 1)
{
- vector<ProjectedDerivative> values (1);
+
std::vector<ProjectedDerivative> values (1);
fe_values.get_function_grads (solution, values);
return values[0];
}
else
{
-
vector<vector<ProjectedDerivative> > values
- (1, vector<ProjectedDerivative>(fe_values.get_fe().n_components()));
+
std::vector<std::vector<ProjectedDerivative> > values
+ (1,
std::vector<ProjectedDerivative>(fe_values.get_fe().n_components()));
fe_values.get_function_grads (solution, values);
return values[0][component];
};
= { 0.5*(d[0][0] + d[1][1] + sqrt(radicand)),
0.5*(d[0][0] + d[1][1] - sqrt(radicand)) };
- return max (fabs (eigenvalues[0]),
- fabs (eigenvalues[1]));
+ return std::max (std::fabs (eigenvalues[0]),
+ std::fabs (eigenvalues[1]));
};
dof_handler.get_tria().n_active_cells()));
const unsigned int n_threads = multithread_info.n_default_threads;
- vector<IndexInterval> index_intervals
+ std::vector<IndexInterval> index_intervals
= Threads::split_interval (0, dof_handler.get_tria().n_active_cells(),
n_threads);
Threads::ThreadManager thread_manager;
// active neighbors of a cell
// reserve the maximal number of
// active neighbors
- vector<typename DoFHandler<dim>::active_cell_iterator> active_neighbors;
+ std::vector<typename DoFHandler<dim>::active_cell_iterator> active_neighbors;
active_neighbors.reserve (GeometryInfo<dim>::faces_per_cell *
GeometryInfo<dim>::subfaces_per_face);
// now loop over all active
// neighbors and collect the
// data we need
- typename vector<typename DoFHandler<dim>::active_cell_iterator>::const_iterator
+ typename std::vector<typename DoFHandler<dim>::active_cell_iterator>::const_iterator
neighbor_ptr = active_neighbors.begin();
for (; neighbor_ptr!=active_neighbors.end(); ++neighbor_ptr)
{
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
KellyErrorEstimator<1>::Data::Data(const DoFHandler<1> &,
const Quadrature<0> &,
const FunctionMap &,
- const vector<const Vector<double>*> &,
- const vector<bool> &,
+ const std::vector<const Vector<double>*> &,
+ const std::vector<bool> &,
const Function<1> *,
const unsigned int ,
FaceIntegrals &):
dof_handler(* static_cast <const DoFHandler<1> *> (0)),
quadrature(* static_cast <const Quadrature<0> *> (0)),
neumann_bc(* static_cast <const FunctionMap *> (0)),
- solutions(* static_cast <const vector<const Vector<double>*> *> (0)),
+ solutions(* static_cast <const std::vector<const Vector<double>*> *> (0)),
face_integrals (* static_cast<FaceIntegrals*> (0))
{
Assert (false, ExcInternalError());
KellyErrorEstimator<dim>::Data::Data(const DoFHandler<dim> &dof_handler,
const Quadrature<dim-1> &quadrature,
const FunctionMap &neumann_bc,
- const vector<const Vector<double>*> &solutions,
- const vector<bool> &component_mask,
+ const std::vector<const Vector<double>*> &solutions,
+ const std::vector<bool> &component_mask,
const Function<dim> *coefficients,
const unsigned int n_threads,
FaceIntegrals &face_integrals):
const FunctionMap &neumann_bc,
const Vector<double> &solution,
Vector<float> &error,
- const vector<bool> &component_mask,
+ const std::vector<bool> &component_mask,
const Function<dim> *coefficients,
unsigned int n_threads)
{
// just pass on to the other function
- const vector<const Vector<double>*> solutions (1, &solution);
- vector<Vector<float>*> errors (1, &error);
+ const std::vector<const Vector<double>*> solutions (1, &solution);
+ std::vector<Vector<float>*> errors (1, &error);
estimate (dof_handler, quadrature, neumann_bc, solutions, errors,
component_mask, coefficients, n_threads);
};
void KellyErrorEstimator<1>::estimate (const DoFHandler<1> &dof_handler,
const Quadrature<0> &,
const FunctionMap &neumann_bc,
- const vector<const Vector<double>*> &solutions,
- vector<Vector<float>*> &errors,
- const vector<bool> &component_mask_,
+ const std::vector<const Vector<double>*> &solutions,
+ std::vector<Vector<float>*> &errors,
+ const std::vector<bool> &component_mask_,
const Function<1> *coefficient,
const unsigned int)
{
ExcInvalidSolutionVector());
// if no mask given: treat all components
- vector<bool> component_mask ((component_mask_.size() == 0) ?
- vector<bool>(n_components, true) :
+ std::vector<bool> component_mask ((component_mask_.size() == 0) ?
+ std::vector<bool>(n_components, true) :
component_mask_);
Assert (component_mask.size() == n_components, ExcInvalidComponentMask());
Assert (count(component_mask.begin(), component_mask.end(), true) > 0,
// need several auxiliary fields,
// depending on the way we get it
// (see below)
- vector<vector<vector<Tensor<1,1> > > >
+ std::vector<std::vector<std::vector<Tensor<1,1> > > >
gradients_here (n_solution_vectors,
- vector<vector<Tensor<1,1> > >(2, vector<Tensor<1,1> >(n_components)));
- vector<vector<vector<Tensor<1,1> > > >
+ std::vector<std::vector<Tensor<1,1> > >(2, std::vector<Tensor<1,1> >(n_components)));
+ std::vector<std::vector<std::vector<Tensor<1,1> > > >
gradients_neighbor (gradients_here);
- vector<Vector<double> >
+ std::vector<Vector<double> >
grad_neighbor (n_solution_vectors, Vector<double>(n_components));
// reserve some space for
void KellyErrorEstimator<dim>::estimate (const DoFHandler<dim> &dof_handler,
const Quadrature<dim-1> &quadrature,
const FunctionMap &neumann_bc,
- const vector<const Vector<double>*> &solutions,
- vector<Vector<float>*> &errors,
- const vector<bool> &component_mask,
+ const std::vector<const Vector<double>*> &solutions,
+ std::vector<Vector<float>*> &errors,
+ const std::vector<bool> &component_mask,
const Function<dim> *coefficients,
unsigned int n_threads)
{
// in multithreaded mode. Negative
// value indicates that the face
// has not yet been processed.
- vector<double> default_face_integrals (n_solution_vectors, -10e20);
+ std::vector<double> default_face_integrals (n_solution_vectors, -10e20);
FaceIntegrals face_integrals;
for (active_cell_iterator cell=dof_handler.begin_active(); cell!=dof_handler.end(); ++cell)
for (unsigned int face_no=0; face_no<GeometryInfo<dim>::faces_per_cell; ++face_no)
// note that if no component mask
// was given, then treat all
// components
- vector<Data*> data_structures (n_threads);
+ std::vector<Data*> data_structures (n_threads);
for (unsigned int i=0; i<n_threads; ++i)
data_structures[i] = new Data (dof_handler,
quadrature,
neumann_bc,
solutions,
((component_mask.size() == 0) ?
- vector<bool>(dof_handler.get_fe().n_components(),
+ std::vector<bool>(dof_handler.get_fe().n_components(),
true) :
component_mask),
coefficients,
// function at the quadrature
// points
- vector<Vector<double> > g(n_q_points, Vector<double>(n_components));
+ std::vector<Vector<double> > g(n_q_points, Vector<double>(n_components));
data.neumann_bc.find(boundary_indicator)->second
->vector_value_list (fe_face_values_cell.get_quadrature_points(),
g);
// take the square of the phi[i]
// for integration, and sum up
- vector<double> face_integral (n_solution_vectors, 0);
+ std::vector<double> face_integral (n_solution_vectors, 0);
for (unsigned int n=0; n<n_solution_vectors; ++n)
for (unsigned int component=0; component<n_components; ++component)
if (data.component_mask[component] == true)
// take the square of the phi[i]
// for integration, and sum up
- vector<double> face_integral (n_solution_vectors, 0);
+ std::vector<double> face_integral (n_solution_vectors, 0);
for (unsigned int n=0; n<n_solution_vectors; ++n)
for (unsigned int component=0; component<n_components; ++component)
if (data.component_mask[component] == true)
// collect the contributions of the
// subfaces and store them with the
// mother face
- vector<double> sum (n_solution_vectors, 0);
+ std::vector<double> sum (n_solution_vectors, 0);
typename DoFHandler<dim>::face_iterator face = cell->face(face_no);
for (unsigned int subface_no=0; subface_no<GeometryInfo<dim>::subfaces_per_face;
++subface_no)
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
template <typename number>
-void Histogram::evaluate (const vector<Vector<number> > &values,
- const vector<double> &_y_values,
+void Histogram::evaluate (const std::vector<Vector<number> > &values,
+ const std::vector<double> &_y_values,
const unsigned int n_intervals,
const IntervalSpacing interval_spacing)
{
switch (interval_spacing)
{
case linear:
- min_value = *min_element(values[0].begin(),
+ min_value = *std::min_element(values[0].begin(),
values[0].end());
- max_value = *max_element(values[0].begin(),
+ max_value = *std::max_element(values[0].begin(),
values[0].end());
for (unsigned int i=1; i<values.size(); ++i)
{
- min_value = min (min_value,
- *min_element(values[i].begin(),
+ min_value = std::min (min_value,
+ *std::min_element(values[i].begin(),
values[i].end()));
- max_value = max (max_value,
- *max_element(values[i].begin(),
+ max_value = std::max (max_value,
+ *std::max_element(values[i].begin(),
values[i].end()));
};
break;
case logarithmic:
- min_value = *min_element(values[0].begin(),
+ min_value = *std::min_element(values[0].begin(),
values[0].end(),
#if (__GNUC__==2) && (__GNUC_MINOR__ < 95)
&logarithmic_less<number>
#endif
);
- max_value = *max_element(values[0].begin(),
+ max_value = *std::max_element(values[0].begin(),
values[0].end(),
#if (__GNUC__==2) && (__GNUC_MINOR__ < 95)
&logarithmic_less<number>
for (unsigned int i=1; i<values.size(); ++i)
{
- min_value = min (min_value,
- *min_element(values[i].begin(),
+ min_value = std::min (min_value,
+ *std::min_element(values[i].begin(),
values[i].end(),
#if (__GNUC__==2) && (__GNUC_MINOR__ < 95)
&logarithmic_less<number>
#endif
);
- max_value = max (max_value,
- *max_element(values[i].begin(),
+ max_value = std::max (max_value,
+ *std::max_element(values[i].begin(),
values[i].end(),
#if (__GNUC__==2) && (__GNUC_MINOR__ < 95)
&logarithmic_less<number>
// then produce all the other lists
// for the other data vectors by
// copying
- intervals.push_back (vector<Interval>());
+ intervals.push_back (std::vector<Interval>());
switch (interval_spacing)
{
const unsigned int n_intervals,
const IntervalSpacing interval_spacing)
{
- vector<Vector<number> > values_list (1,
+ std::vector<Vector<number> > values_list (1,
values);
- evaluate (values_list, vector<double>(1,0.), n_intervals, interval_spacing);
+ evaluate (values_list, std::vector<double>(1,0.), n_intervals, interval_spacing);
};
-void Histogram::write_gnuplot (ostream &out) const
+void Histogram::write_gnuplot (std::ostream &out) const
{
AssertThrow (out, ExcIO());
Assert (intervals.size() > 0, ExcEmptyData());
out << intervals[0][n].left_point
<< ' '
<< intervals[0][n].content
- << endl
+ << std::endl
<< intervals[0][n].right_point
<< ' '
<< intervals[0][n].content
- << endl;
+ << std::endl;
}
else
// otherwise create a whole 3d plot
y_values[i] + (y_values[i]-y_values[i-1]))
<< ' '
<< intervals[i][n].content
- << endl
+ << std::endl
<< intervals[i][n].right_point
<< ' '
<< (i<static_cast<int>(intervals.size())-1 ?
y_values[i] + (y_values[i]-y_values[i-1]))
<< ' '
<< intervals[i][n].content
- << endl;
+ << std::endl;
- out << endl;
+ out << std::endl;
for (unsigned int n=0; n<intervals[i].size(); ++n)
out << intervals[i][n].left_point
<< ' '
<< y_values[i]
<< ' '
<< intervals[i][n].content
- << endl
+ << std::endl
<< intervals[i][n].right_point
<< ' '
<< y_values[i]
<< ' '
<< intervals[i][n].content
- << endl;
+ << std::endl;
- out << endl;
+ out << std::endl;
};
-string Histogram::get_interval_spacing_names ()
+std::string Histogram::get_interval_spacing_names ()
{
return "linear|logarithmic";
};
Histogram::IntervalSpacing
-Histogram::parse_interval_spacing (const string &name)
+Histogram::parse_interval_spacing (const std::string &name)
{
if (name=="linear")
return linear;
// explicit instantiations for float
template
-void Histogram::evaluate (const vector<Vector<float> > &values,
- const vector<double> &y_values,
+void Histogram::evaluate (const std::vector<Vector<float> > &values,
+ const std::vector<double> &y_values,
const unsigned int n_intervals,
const IntervalSpacing interval_spacing);
template
// explicit instantiations for double
template
-void Histogram::evaluate (const vector<Vector<double> > &values,
- const vector<double> &y_values,
+void Histogram::evaluate (const std::vector<Vector<double> > &values,
+ const std::vector<double> &y_values,
const unsigned int n_intervals,
const IntervalSpacing interval_spacing);
template
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
const unsigned int dofs_per_cell = fe.dofs_per_cell;
FullMatrix<double> local_mass_matrix (dofs_per_cell, dofs_per_cell);
- vector<unsigned int> dofs_on_this_cell (dofs_per_cell);
+ std::vector<unsigned int> dofs_on_this_cell (dofs_per_cell);
DoFHandler<dim>::active_cell_iterator cell = dof.begin_active(),
endc = dof.end();
SparseMatrix<double> &,
const FunctionMap &,
Vector<double> &,
- vector<unsigned int> &,
+ std::vector<unsigned int> &,
const Function<1> *)
{
Assert (false, ExcNotImplemented());
SparseMatrix<double> &matrix,
const FunctionMap &rhs,
Vector<double> &rhs_vector,
- vector<unsigned int> &dof_to_boundary_mapping,
+ std::vector<unsigned int> &dof_to_boundary_mapping,
const Function<dim> *a)
{
const FiniteElement<dim> &fe = dof.get_fe();
if (true)
{
unsigned int max_element = 0;
- for (vector<unsigned int>::const_iterator i=dof_to_boundary_mapping.begin();
+ for (std::vector<unsigned int>::const_iterator i=dof_to_boundary_mapping.begin();
i!=dof_to_boundary_mapping.end(); ++i)
if ((*i != DoFHandler<dim>::invalid_dof_index) &&
(*i > max_element))
// two variables for the coefficient,
// one for the two cases indicated in
// the name
- vector<double> coefficient_values_scalar (fe_values.n_quadrature_points);
- vector<Vector<double> > coefficient_values_system (fe_values.n_quadrature_points,
+ std::vector<double> coefficient_values_scalar (fe_values.n_quadrature_points);
+ std::vector<Vector<double> > coefficient_values_system (fe_values.n_quadrature_points,
Vector<double>(n_components));
- vector<double> rhs_values_scalar (fe_values.n_quadrature_points);
- vector<Vector<double> > rhs_values_system (fe_values.n_quadrature_points,
+ std::vector<double> rhs_values_scalar (fe_values.n_quadrature_points);
+ std::vector<Vector<double> > rhs_values_system (fe_values.n_quadrature_points,
Vector<double>(n_components));
- vector<unsigned int> dofs (dofs_per_cell);
- vector<unsigned int> dofs_on_face_vector (dofs_per_face);
- set<int> dofs_on_face;
+ std::vector<unsigned int> dofs (dofs_per_cell);
+ std::vector<unsigned int> dofs_on_face_vector (dofs_per_face);
+ std::set<int> dofs_on_face;
DoFHandler<dim>::active_cell_iterator cell = dof.begin_active (),
endc = dof.end ();
fe_values.reinit (cell, face);
const FullMatrix<double> &values = fe_values.get_shape_values ();
- const vector<double> &weights = fe_values.get_JxW_values ();
+ const std::vector<double> &weights = fe_values.get_JxW_values ();
if (fe_is_system)
// FE has several components
template <int dim>
template <typename number>
void
-MatrixTools<dim>::apply_boundary_values (const map<unsigned int,double> &boundary_values,
+MatrixTools<dim>::apply_boundary_values (const std::map<unsigned int,double> &boundary_values,
SparseMatrix<number> &matrix,
Vector<number> &solution,
Vector<number> &right_hand_side,
return;
- map<unsigned int,double>::const_iterator dof = boundary_values.begin(),
+ std::map<unsigned int,double>::const_iterator dof = boundary_values.begin(),
endd = boundary_values.end();
const unsigned int n_dofs = matrix.m();
const SparsityPattern &sparsity = matrix.get_sparsity_pattern();
// element
// (row,dof_number)
const unsigned int *
- p = lower_bound(&sparsity_colnums[sparsity_rowstart[row]+1],
+ p = std::lower_bound(&sparsity_colnums[sparsity_rowstart[row]+1],
&sparsity_colnums[sparsity_rowstart[row+1]],
dof_number);
template <int dim>
void
-MatrixTools<dim>::apply_boundary_values (const map<unsigned int,double> &boundary_values,
+MatrixTools<dim>::apply_boundary_values (const std::map<unsigned int,double> &boundary_values,
BlockSparseMatrix<double> &matrix,
BlockVector<double> &solution,
BlockVector<double> &right_hand_side,
return;
- map<unsigned int,double>::const_iterator dof = boundary_values.begin(),
+ std::map<unsigned int,double>::const_iterator dof = boundary_values.begin(),
endd = boundary_values.end();
const unsigned int n_dofs = matrix.m();
const BlockSparsityPattern &
// in the block in which this
// dof is located
const unsigned int dof_number = dof->first;
- const pair<unsigned int,unsigned int>
+ const std::pair<unsigned int,unsigned int>
block_index = index_mapping.global_to_local (dof_number);
// for each boundary dof:
p = &this_sparsity.get_column_numbers()
[this_sparsity.get_rowstart_indices()[row]];
else
- p = lower_bound(&this_sparsity.get_column_numbers()
+ p = std::lower_bound(&this_sparsity.get_column_numbers()
[this_sparsity.get_rowstart_indices()[row]+1],
&this_sparsity.get_column_numbers()
[this_sparsity.get_rowstart_indices()[row+1]],
block_index.second);
}
else
- p = lower_bound(&this_sparsity.get_column_numbers()
+ p = std::lower_bound(&this_sparsity.get_column_numbers()
[this_sparsity.get_rowstart_indices()[row]],
&this_sparsity.get_column_numbers()
[this_sparsity.get_rowstart_indices()[row+1]],
Equation<dim>::ExcObjectNotEmpty());
const FullMatrix<double> &values = fe_values.get_shape_values ();
- const vector<double> &weights = fe_values.get_JxW_values ();
+ const std::vector<double> &weights = fe_values.get_JxW_values ();
if (coefficient != 0)
if (coefficient->n_components == 1)
// scalar coefficient given
{
- vector<double> coefficient_values (fe_values.n_quadrature_points);
+ std::vector<double> coefficient_values (fe_values.n_quadrature_points);
coefficient->value_list (fe_values.get_quadrature_points(),
coefficient_values);
for (unsigned int i=0; i<dofs_per_cell; ++i)
// vectorial coefficient
// given
{
- vector<Vector<double> > coefficient_values (fe_values.n_quadrature_points,
+ std::vector<Vector<double> > coefficient_values (fe_values.n_quadrature_points,
Vector<double>(n_components));
coefficient->vector_value_list (fe_values.get_quadrature_points(),
coefficient_values);
Equation<dim>::ExcObjectNotEmpty());
const FullMatrix<double> &values = fe_values.get_shape_values ();
- const vector<double> &weights = fe_values.get_JxW_values ();
- vector<double> rhs_values (fe_values.n_quadrature_points);
+ const std::vector<double> &weights = fe_values.get_JxW_values ();
+ std::vector<double> rhs_values (fe_values.n_quadrature_points);
right_hand_side->value_list (fe_values.get_quadrature_points(), rhs_values);
if (coefficient != 0)
{
- vector<double> coefficient_values (n_q_points);
+ std::vector<double> coefficient_values (n_q_points);
coefficient->value_list (fe_values.get_quadrature_points(),
coefficient_values);
for (unsigned int point=0; point<n_q_points; ++point)
Equation<dim>::ExcObjectNotEmpty());
const FullMatrix<double> &values = fe_values.get_shape_values ();
- const vector<double> &weights = fe_values.get_JxW_values ();
- vector<double> rhs_values(fe_values.n_quadrature_points);
+ const std::vector<double> &weights = fe_values.get_JxW_values ();
+ std::vector<double> rhs_values(fe_values.n_quadrature_points);
right_hand_side->value_list (fe_values.get_quadrature_points(), rhs_values);
for (unsigned int point=0; point<n_q_points; ++point)
Assert (rhs.all_zero(),
Equation<dim>::ExcObjectNotEmpty());
- const vector<vector<Tensor<1,dim> > >&gradients = fe_values.get_shape_grads ();
+ const std::vector<std::vector<Tensor<1,dim> > >&gradients = fe_values.get_shape_grads ();
const FullMatrix<double> &values = fe_values.get_shape_values ();
- vector<double> rhs_values(fe_values.n_quadrature_points);
- const vector<double> &weights = fe_values.get_JxW_values ();
+ std::vector<double> rhs_values(fe_values.n_quadrature_points);
+ const std::vector<double> &weights = fe_values.get_JxW_values ();
right_hand_side->value_list (fe_values.get_quadrature_points(), rhs_values);
if (coefficient != 0)
{
- vector<double> coefficient_values(n_q_points);
+ std::vector<double> coefficient_values(n_q_points);
coefficient->value_list (fe_values.get_quadrature_points(),
coefficient_values);
for (unsigned int point=0; point<n_q_points; ++point)
Assert (cell_matrix.all_zero(),
Equation<dim>::ExcObjectNotEmpty());
- const vector<vector<Tensor<1,dim> > >&gradients = fe_values.get_shape_grads ();
- const vector<double> &weights = fe_values.get_JxW_values ();
+ const std::vector<std::vector<Tensor<1,dim> > >&gradients = fe_values.get_shape_grads ();
+ const std::vector<double> &weights = fe_values.get_JxW_values ();
if (coefficient != 0)
{
- vector<double> coefficient_values(n_q_points);
+ std::vector<double> coefficient_values(n_q_points);
coefficient->value_list (fe_values.get_quadrature_points(),
coefficient_values);
for (unsigned int point=0; point<n_q_points; ++point)
Equation<dim>::ExcObjectNotEmpty());
const FullMatrix<double> &values = fe_values.get_shape_values ();
- const vector<double> &weights = fe_values.get_JxW_values ();
- vector<double> rhs_values(fe_values.n_quadrature_points);
+ const std::vector<double> &weights = fe_values.get_JxW_values ();
+ std::vector<double> rhs_values(fe_values.n_quadrature_points);
right_hand_side->value_list (fe_values.get_quadrature_points(), rhs_values);
for (unsigned int point=0; point<n_q_points; ++point)
template
void
MatrixTools<deal_II_dimension>::
-apply_boundary_values (const map<unsigned int,double> &boundary_values,
+apply_boundary_values (const std::map<unsigned int,double> &boundary_values,
SparseMatrix<double> &matrix,
Vector<double> &solution,
Vector<double> &right_hand_side,
template
void
MatrixTools<deal_II_dimension>::
-apply_boundary_values (const map<unsigned int,double> &boundary_values,
+apply_boundary_values (const std::map<unsigned int,double> &boundary_values,
SparseMatrix<float> &matrix,
Vector<float> &solution,
Vector<float> &right_hand_side,
template
void
MatrixTools<deal_II_dimension>::
-apply_boundary_values (const map<unsigned int,double> &,
+apply_boundary_values (const std::map<unsigned int,double> &,
BlockSparseMatrix<double> &,
BlockVector<double> &,
BlockVector<double> &,
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
const unsigned int dofs_per_cell = dof_handler->get_fe().dofs_per_cell;
n_dofs_old=dof_handler->n_dofs();
- indices_on_cell=vector<vector<unsigned int> > (n_active_cells,
- vector<unsigned int> (dofs_per_cell));
+ indices_on_cell=std::vector<std::vector<unsigned int> > (n_active_cells,
+ std::vector<unsigned int> (dofs_per_cell));
DoFHandler<dim>::cell_iterator cell = dof_handler->begin(),
endc = dof_handler->end();
DoFHandler<dim>::cell_iterator cell = dof_handler->begin(),
endc = dof_handler->end();
- vector<unsigned int> *indexptr;
+ std::vector<unsigned int> *indexptr;
for (; cell!=endc; ++cell)
{
// which is both done by one
// function
{
- indexptr=static_cast<vector<unsigned int> *>(cell->user_pointer());
+ indexptr=static_cast<std::vector<unsigned int> *>(cell->user_pointer());
for (unsigned int i=0; i<dofs_per_cell; ++i)
local_values(i)=in(indexptr->operator[](i));
cell->set_dof_values_by_interpolation(local_values, out);
template<int dim, typename number>
void
SolutionTransfer<dim, number>::
-prepare_for_coarsening_and_refinement(const vector<Vector<number> > &all_in)
+prepare_for_coarsening_and_refinement(const std::vector<Vector<number> > &all_in)
{
Assert(prepared_for!=pure_refinement, ExcAlreadyPrepForRef());
Assert(!prepared_for!=coarsening_and_refinement,
GeometryInfo<dim>::children_per_cell;
// allocate the needed memory
- indices_on_cell = vector<vector<unsigned int> > (n_cells_to_stay_or_refine,
- vector<unsigned int> (dofs_per_cell));
+ indices_on_cell = std::vector<std::vector<unsigned int> > (n_cells_to_stay_or_refine,
+ std::vector<unsigned int> (dofs_per_cell));
dof_values_on_cell
- = vector<vector<Vector<number> > > (n_coarsen_fathers,
- vector<Vector<number> > (in_size,
+ = std::vector<std::vector<Vector<number> > > (n_coarsen_fathers,
+ std::vector<Vector<number> > (in_size,
Vector<number> (dofs_per_cell)));
- all_pointerstructs = vector<Pointerstruct> (n_cells_to_stay_or_refine +
+ all_pointerstructs =
std::vector<Pointerstruct> (n_cells_to_stay_or_refine +
n_coarsen_fathers);
void
SolutionTransfer<dim, number>::prepare_for_coarsening_and_refinement(const Vector<number> &in)
{
- vector<Vector<number> > all_in=vector<Vector<number> >(1, in);
+ std::vector<Vector<number> > all_in=std::vector<Vector<number> >(1, in);
prepare_for_coarsening_and_refinement(all_in);
}
template<int dim, typename number>
void SolutionTransfer<dim, number>::
-interpolate (const vector<Vector<number> > &all_in,
- vector<Vector<number> > &all_out) const
+interpolate (const std::vector<Vector<number> > &all_in,
+ std::vector<Vector<number> > &all_out) const
{
Assert(prepared_for==coarsening_and_refinement, ExcNotPrepared());
for (unsigned int i=0; i<all_in.size(); ++i)
// resize the output vector
if (all_out.size() != all_in.size())
- all_out = vector<Vector<number> >(all_in.size(),
+ all_out = std::vector<Vector<number> >(all_in.size(),
Vector<number>(dof_handler->n_dofs()));
else
{
const unsigned int dofs_per_cell=dof_handler->get_fe().dofs_per_cell;
Vector<number> local_values(dofs_per_cell);
- vector<unsigned int> *indexptr;
+ std::vector<unsigned int> *indexptr;
Pointerstruct *structptr;
- vector<Vector<number> > *valuesptr;
- vector<unsigned int> dofs(dofs_per_cell);
+ std::vector<Vector<number> > *valuesptr;
+ std::vector<unsigned int> dofs(dofs_per_cell);
DoFHandler<dim>::cell_iterator cell = dof_handler->begin(),
endc = dof_handler->end();
void SolutionTransfer<dim, number>::interpolate(const Vector<number> &in,
Vector<number> &out) const
{
- vector<Vector<number> > all_in(1);
+ std::vector<Vector<number> > all_in(1);
all_in[0] = in;
- vector<Vector<number> > all_out(1);
+ std::vector<Vector<number> > all_out(1);
all_out[0] = out;
interpolate(all_in,
all_out);
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
else
{
// inner time step
- vector<TimeStepBase*>::iterator insert_position
+ std::vector<TimeStepBase*>::iterator insert_position
= find(timesteps.begin(), timesteps.end(), position);
(*(insert_position-1))->set_next_timestep (new_timestep);
timesteps[position]->unsubscribe();
delete timesteps[position];
- timesteps.erase (×teps[position]);
+ timesteps.erase (timesteps.begin() + position);
// reset "next" pointer of previous
// time step if possible
void
TimeDependent::solve_primal_problem ()
{
- do_loop (mem_fun(&TimeStepBase::init_for_primal_problem),
- mem_fun(&TimeStepBase::solve_primal_problem),
+ do_loop (std::mem_fun(&TimeStepBase::init_for_primal_problem),
+ std::mem_fun(&TimeStepBase::solve_primal_problem),
timestepping_data_primal,
forward);
};
void
TimeDependent::solve_dual_problem ()
{
- do_loop (mem_fun(&TimeStepBase::init_for_dual_problem),
- mem_fun(&TimeStepBase::solve_dual_problem),
+ do_loop (std::mem_fun(&TimeStepBase::init_for_dual_problem),
+ std::mem_fun(&TimeStepBase::solve_dual_problem),
timestepping_data_dual,
backward);
};
void
TimeDependent::postprocess ()
{
- do_loop (mem_fun(&TimeStepBase::init_for_postprocessing),
- mem_fun(&TimeStepBase::postprocess_timestep),
+ do_loop (std::mem_fun(&TimeStepBase::init_for_postprocessing),
+ std::mem_fun(&TimeStepBase::postprocess_timestep),
timestepping_data_postprocess,
forward);
};
{
// for any of the non-initial grids
// store the refinement flags
- refine_flags.push_back (vector<bool>());
- coarsen_flags.push_back (vector<bool>());
+ refine_flags.push_back (std::vector<bool>());
+ coarsen_flags.push_back (std::vector<bool>());
tria->save_refine_flags (refine_flags.back());
tria->save_coarsen_flags (coarsen_flags.back());
};
(refinement_flags.cell_number_correction_steps > 0))
{
sorted_criteria = criteria;
- sort (sorted_criteria.begin(),
+ std::sort (sorted_criteria.begin(),
sorted_criteria.end());
- p_refinement_threshold = lower_bound (sorted_criteria.begin(),
- sorted_criteria.end(),
- refinement_threshold);
- p_coarsening_threshold = upper_bound (sorted_criteria.begin(),
- sorted_criteria.end(),
- coarsening_threshold);
+ p_refinement_threshold = std::lower_bound (sorted_criteria.begin(),
+ sorted_criteria.end(),
+ static_cast<float>(refinement_threshold));
+ p_coarsening_threshold = std::upper_bound (sorted_criteria.begin(),
+ sorted_criteria.end(),
+ static_cast<float>(coarsening_threshold));
};
double delta_up = refinement_flags.cell_number_corridor_top,
delta_down = refinement_flags.cell_number_corridor_bottom;
- const vector<pair<unsigned int,double> > &relaxations
+ const std::vector<std::pair<unsigned int,double> > &relaxations
= (sweep_no >= refinement_flags.correction_relaxations.size() ?
refinement_flags.correction_relaxations.back() :
refinement_flags.correction_relaxations[sweep_no]);
TimeStepBase_Tria<dim>::RefinementFlags::CorrectionRelaxations
TimeStepBase_Tria<dim>::RefinementFlags::default_correction_relaxations
(1, // one element, denoting the first and all subsequent sweeps
- vector<pair<unsigned int,double> >(1, // one element, denoting the upper bound
- // for the following
- // relaxation
- make_pair (0, 0.)));
+ std::vector<std::pair<unsigned int,double> >(1, // one element, denoting the upper bound
+ // for the following
+ // relaxation
+ std::make_pair (0, 0.)));
template <int dim>
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
void
VectorTools::subtract_mean_value(Vector<double> &v,
- const vector<bool> &p_select)
+ const std::vector<bool> &p_select)
{
unsigned int n = v.size();
Assert(n == p_select.size(), ExcDimensionMismatch(n, p_select.size()));
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <numeric>
#include <algorithm>
-#include <bvector.h>
+#include <vector.h>
#include <cmath>
// avoided to evaluate
// the vectorfunction multiply at
// the same point on a cell.
- vector<Point<dim> > unit_support_points (fe.dofs_per_cell);
+
std::vector<Point<dim> > unit_support_points (fe.dofs_per_cell);
fe.get_unit_support_points(unit_support_points);
// The following works well
// the following vector collects all rep dofs.
// the position of a rep dof within this vector
// is called rep index.
- vector<unsigned int> dofs_of_rep_points;
+ std::vector<unsigned int> dofs_of_rep_points;
// the following table converts a dof i
// to the rep index.
- vector<unsigned int> dof_to_rep_index_table;
+ std::vector<unsigned int> dof_to_rep_index_table;
unsigned int n_rep_points=0;
for (unsigned int i=0; i<fe.dofs_per_cell; ++i)
{
Assert(dofs_of_rep_points.size()==n_rep_points, ExcInternalError());
Assert(dof_to_rep_index_table.size()==fe.dofs_per_cell, ExcInternalError());
- vector<unsigned int> dofs_on_cell (fe.dofs_per_cell);
- vector<Point<dim> > support_points (fe.dofs_per_cell);
+ std::vector<unsigned int> dofs_on_cell (fe.dofs_per_cell);
+
std::vector<Point<dim> > support_points (fe.dofs_per_cell);
- vector<Point<dim> > rep_points (n_rep_points);
+
std::vector<Point<dim> > rep_points (n_rep_points);
// get space for the values of the
// function at the rep support points.
// have two versions, one for system fe
// and one for scalar ones, to take the
// more efficient one respectively
- vector<double> function_values_scalar (n_rep_points);
- vector<Vector<double> > function_values_system (n_rep_points,
+ std::vector<double> function_values_scalar (n_rep_points);
+ std::vector<Vector<double> > function_values_system (n_rep_points,
Vector<double>(fe.n_components()));
for (; cell!=endc; ++cell)
Vector<double> cell_data_1(dof_1.get_fe().dofs_per_cell);
Vector<double> cell_data_2(dof_2.get_fe().dofs_per_cell);
- vector<short unsigned int> touch_count (dof_2.n_dofs(), 0);
- vector<unsigned int> local_dof_indices (dof_2.get_fe().dofs_per_cell);
+ std::vector<short unsigned int> touch_count (dof_2.n_dofs(), 0);
+ std::vector<unsigned int> local_dof_indices (dof_2.get_fe().dofs_per_cell);
DoFHandler<dim>::active_cell_iterator h = dof_1.begin_active();
DoFHandler<dim>::active_cell_iterator l = dof_2.begin_active();
const FiniteElement<dim> &fe = dof.get_fe();
// make up boundary values
- map<unsigned int,double> boundary_values;
+ std::map<unsigned int,double> boundary_values;
if (enforce_zero_boundary == true)
// no need to project boundary values, but
{
DoFHandler<dim>::active_face_iterator face = dof.begin_active_face(),
endf = dof.end_face();
- vector<unsigned int> face_dof_indices (fe.dofs_per_face);
+ std::vector<unsigned int> face_dof_indices (fe.dofs_per_face);
for (; face!=endf; ++face)
if (face->at_boundary())
{
// the different boundary parts. We want the
// @p{function} to hold on all parts of the
// boundary
- map<unsigned char,const Function<dim>*> boundary_functions;
+ std::map<unsigned char,const Function<dim>*> boundary_functions;
for (unsigned char c=0; c<255; ++c)
boundary_functions[c] = &function;
project_boundary_values (dof, boundary_functions, q_boundary,
n_q_points = fe_values.n_quadrature_points,
n_components = fe.n_components();
- vector<unsigned int> dofs (dofs_per_cell);
+ std::vector<unsigned int> dofs (dofs_per_cell);
Vector<double> cell_vector (dofs_per_cell);
DoFHandler<dim>::active_cell_iterator cell = dof_handler.begin_active(),
if (n_components==1)
{
- vector<double> rhs_values(n_q_points);
+ std::vector<double> rhs_values(n_q_points);
for (; cell!=endc; ++cell)
{
fe_values.reinit(cell);
const FullMatrix<double> &values = fe_values.get_shape_values ();
- const vector<double> &weights = fe_values.get_JxW_values ();
+ const std::vector<double> &weights = fe_values.get_JxW_values ();
rhs_function.value_list (fe_values.get_quadrature_points(), rhs_values);
cell_vector.clear();
}
else
{
- vector<Vector<double> > rhs_values(n_q_points, Vector<double>(n_components));
+ std::vector<Vector<double> > rhs_values(n_q_points, Vector<double>(n_components));
for (; cell!=endc; ++cell)
{
fe_values.reinit(cell);
const FullMatrix<double> &values = fe_values.get_shape_values ();
- const vector<double> &weights = fe_values.get_JxW_values ();
+ const std::vector<double> &weights = fe_values.get_JxW_values ();
rhs_function.vector_value_list (fe_values.get_quadrature_points(), rhs_values);
cell_vector.clear();
VectorTools::interpolate_boundary_values (const DoFHandler<1> &dof,
const unsigned char boundary_component,
const Function<1> &boundary_function,
- map<unsigned int,double> &boundary_values,
- const vector<bool> &component_mask_)
+ std::map<unsigned int,double> &boundary_values,
+ const std::vector<bool> &component_mask_)
{
Assert (boundary_component != 255,
ExcInvalidBoundaryIndicator());
// set the component mask to either
// the original value or a vector
// of @p{true}s
- const vector<bool> component_mask ((component_mask_.size() == 0) ?
- vector<bool> (fe.n_components(), true) :
+ const std::vector<bool> component_mask ((component_mask_.size() == 0) ?
+ std::vector<bool> (fe.n_components(), true) :
component_mask_);
Assert (count(component_mask.begin(), component_mask.end(), true) > 0,
ExcComponentMismatch());
VectorTools::interpolate_boundary_values (const DoFHandler<dim> &dof,
const unsigned char boundary_component,
const Function<dim> &boundary_function,
- map<unsigned int,double> &boundary_values,
- const vector<bool> &component_mask_)
+ std::map<unsigned int,double> &boundary_values,
+ const std::vector<bool> &component_mask_)
{
Assert (boundary_component != 255,
ExcInvalidBoundaryIndicator());
// set the component mask to either
// the original value or a vector
// of @p{true}s
- const vector<bool> component_mask ((component_mask_.size() == 0) ?
- vector<bool> (fe.n_components(), true) :
+ const std::vector<bool> component_mask ((component_mask_.size() == 0) ?
+ std::vector<bool> (fe.n_components(), true) :
component_mask_);
Assert (count(component_mask.begin(), component_mask.end(), true) > 0,
ExcComponentMismatch());
// field to store the indices of dofs
- vector<unsigned int> face_dofs (fe.dofs_per_face, -1);
- vector<Point<dim> > dof_locations (face_dofs.size(), Point<dim>());
+ std::vector<unsigned int> face_dofs (fe.dofs_per_face, -1);
+
std::vector<Point<dim> > dof_locations (face_dofs.size(), Point<dim>());
// array to store the values of
// the boundary function at the
// boundary points. have to arrays
// for scalar and vector functions
// to use the more efficient one
// respectively
- vector<double> dof_values_scalar (fe.dofs_per_face);
- vector<Vector<double> > dof_values_system (fe.dofs_per_face,
+ std::vector<double> dof_values_scalar (fe.dofs_per_face);
+ std::vector<Vector<double> > dof_values_system (fe.dofs_per_face,
Vector<double>(fe.n_components()));
DoFHandler<dim>::active_face_iterator face = dof.begin_active_face(),
template <int dim>
void
VectorTools::project_boundary_values (const DoFHandler<dim> &dof,
- const map<unsigned char,const Function<dim>*> &boundary_functions,
+ const std::map<unsigned char,const Function<dim>*> &boundary_functions,
const Quadrature<dim-1> &q,
- map<unsigned int,double> &boundary_values)
+ std::map<unsigned int,double> &boundary_values)
{
Assert (dof.get_fe().n_components() == boundary_functions.begin()->second->n_components,
ExcComponentMismatch());
- vector<unsigned int> dof_to_boundary_mapping;
- set<unsigned char> selected_boundary_components;
- for (typename map<unsigned char,const Function<dim>*>::const_iterator
+ std::vector<unsigned int> dof_to_boundary_mapping;
+ std::set<unsigned char> selected_boundary_components;
+ for (typename std::map<unsigned char,const Function<dim>*>::const_iterator
i=boundary_functions.begin();
i!=boundary_functions.end(); ++i)
selected_boundary_components.insert (i->first);
FEValues<dim> fe_values(fe, q, update_flags);
- vector< Vector<double> > function_values (n_q_points,
+ std::vector< Vector<double> > function_values (n_q_points,
Vector<double>(n_components));
- vector<vector<Tensor<1,dim> > > function_grads (n_q_points,
- vector<Tensor<1,dim> >(n_components));
- vector<double> weight_values (n_q_points);
- vector<Vector<double> > weight_vectors (n_q_points, n_components);
+ std::vector<std::vector<Tensor<1,dim> > > function_grads (n_q_points,
+ std::vector<Tensor<1,dim> >(n_components));
+ std::vector<double> weight_values (n_q_points);
+ std::vector<Vector<double> > weight_vectors (n_q_points, n_components);
- vector<Vector<double> > psi_values (n_q_points,
+ std::vector<Vector<double> > psi_values (n_q_points,
Vector<double>(n_components));
- vector<vector<Tensor<1,dim> > > psi_grads (n_q_points,
- vector<Tensor<1,dim> >(n_components));
- vector<double> psi_scalar (n_q_points);
+ std::vector<std::vector<Tensor<1,dim> > > psi_grads (n_q_points,
+ std::vector<Tensor<1,dim> >(n_components));
+ std::vector<double> psi_scalar (n_q_points);
// tmp vector when we use the
// Function<dim> functions for
// scalar functions
- vector<double> tmp_values (fe_values.n_quadrature_points);
- vector<Tensor<1,dim> > tmp_gradients (fe_values.n_quadrature_points);
+ std::vector<double> tmp_values (fe_values.n_quadrature_points);
+ std::vector<Tensor<1,dim> > tmp_gradients (fe_values.n_quadrature_points);
// loop over all cells
DoFHandler<dim>::active_cell_iterator cell = dof.begin_active(),
}
// Integration on one cell
- diff = inner_product (psi_scalar.begin(), psi_scalar.end(),
- fe_values.get_JxW_values().begin(),
- 0.0);
+ diff = std::inner_product (psi_scalar.begin(), psi_scalar.end(),
+ fe_values.get_JxW_values().begin(),
+ 0.0);
break;
// Compute (weighted) squares
// in each quadrature point
psi_scalar[q] = psi_values[q].linfty_norm();
// Maximum on one cell
- diff = *max_element (psi_scalar.begin(), psi_scalar.end());
+ diff = *std::max_element (psi_scalar.begin(), psi_scalar.end());
break;
default:
Assert (false, ExcNotImplemented());
| update_values));
DoFHandler<dim>::active_cell_iterator c;
- vector<Vector<double> > values(quadrature.n_quadrature_points,
+ std::vector<Vector<double> > values(quadrature.n_quadrature_points,
Vector<double> (dof.get_fe().n_components()));
double mean = 0.;
const Function<deal_II_dimension> *);
template
void VectorTools::project_boundary_values (const DoFHandler<deal_II_dimension> &,
- const map<unsigned char,const Function<deal_II_dimension>*>&,
+ const std::map<unsigned char,const Function<deal_II_dimension>*>&,
const Quadrature<deal_II_dimension-1>&,
- map<unsigned int,double> &);
+ std::map<unsigned int,double> &);
template
void VectorTools::create_right_hand_side (const DoFHandler<deal_II_dimension> &,
void VectorTools::interpolate_boundary_values (const DoFHandler<deal_II_dimension> &,
const unsigned char,
const Function<deal_II_dimension> &,
- map<unsigned int,double> &,
- const vector<bool> &);
+ std::map<unsigned int,double> &,
+ const std::vector<bool> &);
template
void VectorTools::project (const DoFHandler<deal_II_dimension> &,
const ConstraintMatrix &,
// Now we want to write it to some
// output, here in postscript
// format
- ofstream out ("grid-1.eps");
+ std::ofstream out ("grid-1.eps");
GridOut grid_out;
grid_out.write_eps (triangulation, out);
};
// Now we want to write it to some
// output, here in postscript
// format
- ofstream out ("grid-2.eps");
+ std::ofstream out ("grid-2.eps");
GridOut grid_out;
grid_out.write_eps (triangulation, out);
sparsity_pattern.compress ();
// Now write the results to a file
- ofstream out ("sparsity_pattern.1");
+ std::ofstream out ("sparsity_pattern.1");
sparsity_pattern.print_gnuplot (out);
// The result is in GNUPLOT format,
// where in each line of the output
DoFTools::make_sparsity_pattern (dof_handler, sparsity_pattern);
sparsity_pattern.compress ();
// ...and output the result:
- ofstream out ("sparsity_pattern.2");
+ std::ofstream out ("sparsity_pattern.2");
sparsity_pattern.print_gnuplot (out);
// Again, the output is shown
// below. Note that the nonzero
// of terminal cells. By terminal
// we mean the cells on the finest
// grid.
- cout << "Number of active cells: "
- << triangulation.n_active_cells()
- << endl;
+ std::cout << "Number of active cells: "
+ << triangulation.n_active_cells()
+ << std::endl;
// We stress the adjective
// `terminal' or `active', since
// there are more cells, namely the
// i.e. 256, then 64, 16, 4, and
// 1. We can get the total number
// of cells like this:
- cout << "Total number of cells: "
- << triangulation.n_cells()
- << endl;
+ std::cout << "Total number of cells: "
+ << triangulation.n_cells()
+ << std::endl;
// Note the distinction between
// n_active_cells() and n_cells().
// Now that we have the degrees of
// freedom, we can take a look at
// how many there are:
- cout << "Number of degrees of freedom: "
- << dof_handler.n_dofs()
- << endl;
+ std::cout << "Number of degrees of freedom: "
+ << dof_handler.n_dofs()
+ << std::endl;
// There should be one DoF for each
// vertex. Since we have a 32 times
// 32 grid, the number of DoFs
// them, we need a scratch
// (temporary) array for these
// numbers:
- vector<unsigned int> local_dof_indices (dofs_per_cell);
+ std::vector<unsigned int> local_dof_indices (dofs_per_cell);
// Now for the loop over all
// cells. You have seen before how
// mapping of DoF numbers to
// boundary values is done by the
// `map' class.
- map<unsigned int,double> boundary_values;
+ std::map<unsigned int,double> boundary_values;
VectorTools::interpolate_boundary_values (dof_handler,
0,
ZeroFunction<2>(),
// are other functions which write
// their data in postscript, AVS,
// GMV, or some other format):
- ofstream output ("solution.gpl");
+ std::ofstream output ("solution.gpl");
data_out.write_gnuplot (output);
};
GridGenerator::hyper_cube (triangulation, -1, 1);
triangulation.refine_global (4);
- cout << " Number of active cells: "
- << triangulation.n_active_cells()
- << endl
- << " Total number of cells: "
- << triangulation.n_cells()
- << endl;
+ std::cout << " Number of active cells: "
+ << triangulation.n_active_cells()
+ << std::endl
+ << " Total number of cells: "
+ << triangulation.n_cells()
+ << std::endl;
dof_handler.distribute_dofs (fe);
- cout << " Number of degrees of freedom: "
- << dof_handler.n_dofs()
- << endl;
+ std::cout << " Number of degrees of freedom: "
+ << dof_handler.n_dofs()
+ << std::endl;
sparsity_pattern.reinit (dof_handler.n_dofs(),
dof_handler.n_dofs(),
FullMatrix<double> cell_matrix (dofs_per_cell, dofs_per_cell);
Vector<double> cell_rhs (dofs_per_cell);
- vector<unsigned int> local_dof_indices (dofs_per_cell);
+ std::vector<unsigned int> local_dof_indices (dofs_per_cell);
// Note here, that a cell is a
// quadrilateral in two space
// would like to use (i.e. the
// BoundaryValues class declared
// above):
- map<unsigned int,double> boundary_values;
+ std::map<unsigned int,double> boundary_values;
VectorTools::interpolate_boundary_values (dof_handler,
0,
BoundaryValues<dim>(),
// from the linear solvers, we have
// to print the number of
// iterations by hand.
- cout << " " << solver_control.last_step()
- << " CG iterations needed to obtain convergence."
- << endl;
+ std::cout << " " << solver_control.last_step()
+ << " CG iterations needed to obtain convergence."
+ << std::endl;
};
// other values than 2 or 3, but we
// neglect this here for the sake
// of brevity).
- ofstream output (dim == 2 ?
- "solution-2d.gmv" :
- "solution-3d.gmv");
+ std::ofstream output (dim == 2 ?
+ "solution-2d.gmv" :
+ "solution-3d.gmv");
data_out.write_gmv (output);
};
template <int dim>
void LaplaceProblem<dim>::run ()
{
- cout << "Solving problem in " << dim << " space dimensions." << endl;
+ std::cout << "Solving problem in " << dim << " space dimensions." << std::endl;
make_grid_and_dofs();
assemble_system ();
virtual double value (const Point<dim> &p,
const unsigned int component = 0) const;
- virtual void value_list (const vector<Point<dim> > &points,
- vector<double> &values,
- const unsigned int component = 0) const;
+ virtual void value_list (const
std::vector<Point<dim> > &points,
+ std::vector<double> &values,
+ const unsigned int component = 0) const;
};
// values are the same as if we would
// ask the ``value'' function.
template <int dim>
-void Coefficient<dim>::value_list (const vector<Point<dim> > &points,
- vector<double> &values,
- const unsigned int component) const
+void Coefficient<dim>::value_list (const
std::vector<Point<dim> > &points,
+ std::vector<double> &values,
+ const unsigned int component) const
{
// Use n_q_points as an
// abbreviation for the number of
{
dof_handler.distribute_dofs (fe);
- cout << " Number of degrees of freedom: "
- << dof_handler.n_dofs()
- << endl;
+ std::cout << " Number of degrees of freedom: "
+ << dof_handler.n_dofs()
+ << std::endl;
sparsity_pattern.reinit (dof_handler.n_dofs(),
dof_handler.n_dofs(),
FullMatrix<double> cell_matrix (dofs_per_cell, dofs_per_cell);
Vector<double> cell_rhs (dofs_per_cell);
- vector<unsigned int> local_dof_indices (dofs_per_cell);
+ std::vector<unsigned int> local_dof_indices (dofs_per_cell);
// Below, we will ask the
// Coefficient class to compute the
// space to store the values in,
// which we use the following
// variable for:
- vector<double> coefficient_values (n_q_points);
+ std::vector<double> coefficient_values (n_q_points);
DoFHandler<dim>::active_cell_iterator cell = dof_handler.begin_active(),
endc = dof_handler.end();
// in the FEValues class. The
// gradient are accessed as
// follows:
- const vector<vector<Tensor<1,dim> > >
+ const std::vector<std::vector<Tensor<1,dim> > >
& shape_grads = fe_values.get_shape_grads();
// The data type looks a bit
// unwieldy, since each entry
// respective quadrature points
// are stored, can be obtained
// like this:
- const vector<double>
+ const std::vector<double>
& JxW_values = fe_values.get_JxW_values();
- const vector<Point<dim> >
+ const
std::vector<Point<dim> >
& q_points = fe_values.get_quadrature_points();
// Admittedly, the declarations
// above are not easily
};
// Again use zero boundary values:
- map<unsigned int,double> boundary_values;
+ std::map<unsigned int,double> boundary_values;
VectorTools::interpolate_boundary_values (dof_handler,
0,
ZeroFunction<dim>(),
cg.solve (system_matrix, solution, system_rhs,
preconditioner);
- cout << " " << solver_control.last_step()
- << " CG iterations needed to obtain convergence."
- << endl;
+ std::cout << " " << solver_control.last_step()
+ << " CG iterations needed to obtain convergence."
+ << std::endl;
};
// could as well give stream
// modifiers such as ``setf'',
// ``setprecision'', and so on.
- ostrstream filename;
+ std::ostrstream filename;
filename << "solution-"
<< cycle
<< ".eps";
// In order to append the final
// '\0', we have to put an ``ends''
// to the end of the string:
- filename << ends;
+ filename << std::ends;
// We can get whatever we wrote to
// the stream using the ``str()''
// function. Use that as filename
// for the output stream:
- ofstream output (filename.str());
+ std::ofstream output (filename.str());
// And then write the data to the
// file.
data_out.write_eps (output);
{
for (unsigned int cycle=0; cycle<6; ++cycle)
{
- cout << "Cycle " << cycle << ':' << endl;
+ std::cout << "Cycle " << cycle << ':' << std::endl;
// If this is the first round,
// then we have no grid yet,
{
GridIn<dim> grid_in;
grid_in.attach_triangulation (triangulation);
- ifstream input_file("circle-grid.inp");
+ std::ifstream input_file("circle-grid.inp");
// We would now like to
// read the file. However,
// the input file is only
// the things that we have
// already seen in the previous
// examples.
- cout << " Number of active cells: "
- << triangulation.n_active_cells()
- << endl
- << " Total number of cells: "
- << triangulation.n_cells()
- << endl;
+ std::cout << " Number of active cells: "
+ << triangulation.n_active_cells()
+ << std::endl
+ << " Total number of cells: "
+ << triangulation.n_cells()
+ << std::endl;
setup_system ();
assemble_system ();
// lines.
/*
Coefficient<2> coefficient;
- vector<Point<2> > points (2);
- vector<double> coefficient_values (1);
+
std::vector<Point<2> > points (2);
+ std::vector<double> coefficient_values (1);
coefficient.value_list (points, coefficient_values);
*/
virtual double value (const Point<dim> &p,
const unsigned int component = 0) const;
- virtual void value_list (const vector<Point<dim> > &points,
- vector<double> &values,
- const unsigned int component = 0) const;
+ virtual void value_list (const
std::vector<Point<dim> > &points,
+ std::vector<double> &values,
+ const unsigned int component = 0) const;
};
template <int dim>
-void Coefficient<dim>::value_list (const vector<Point<dim> > &points,
- vector<double> &values,
- const unsigned int component) const
+void Coefficient<dim>::value_list (const
std::vector<Point<dim> > &points,
+ std::vector<double> &values,
+ const unsigned int component) const
{
const unsigned int n_points = points.size();
FullMatrix<double> cell_matrix (dofs_per_cell, dofs_per_cell);
Vector<double> cell_rhs (dofs_per_cell);
- vector<unsigned int> local_dof_indices (dofs_per_cell);
+ std::vector<unsigned int> local_dof_indices (dofs_per_cell);
- vector<double> coefficient_values (n_q_points);
+ std::vector<double> coefficient_values (n_q_points);
// We can now go on with assembling
// the matrix and right hand
fe_values.reinit (cell);
const FullMatrix<double>
& shape_values = fe_values.get_shape_values();
- const vector<vector<Tensor<1,dim> > >
+ const std::vector<std::vector<Tensor<1,dim> > >
& shape_grads = fe_values.get_shape_grads();
- const vector<double>
+ const std::vector<double>
& JxW_values = fe_values.get_JxW_values();
- const vector<Point<dim> >
+ const
std::vector<Point<dim> >
& q_points = fe_values.get_quadrature_points();
coefficient.value_list (q_points, coefficient_values);
// from the system of equations
// happens *after* the elimination
// of hanging nodes.
- map<unsigned int,double> boundary_values;
+ std::map<unsigned int,double> boundary_values;
VectorTools::interpolate_boundary_values (dof_handler,
0,
ZeroFunction<dim>(),
// this will only work if the cycle
// number is less than ten, which
// we check by an assertion.
- string filename = "grid-";
+ std::string filename = "grid-";
filename += ('0' + cycle);
Assert (cycle < 10, ExcInternalError());
filename += ".eps";
- ofstream output (filename.c_str());
+ std::ofstream output (filename.c_str());
// Using this filename, we write
// each grid as a postscript file.
{
for (unsigned int cycle=0; cycle<8; ++cycle)
{
- cout << "Cycle " << cycle << ':' << endl;
+ std::cout << "Cycle " << cycle << ':' << std::endl;
if (cycle == 0)
{
};
- cout << " Number of active cells: "
- << triangulation.n_active_cells()
- << endl;
+ std::cout << " Number of active cells: "
+ << triangulation.n_active_cells()
+ << std::endl;
setup_system ();
- cout << " Number of degrees of freedom: "
- << dof_handler.n_dofs()
- << endl;
+ std::cout << " Number of degrees of freedom: "
+ << dof_handler.n_dofs()
+ << std::endl;
assemble_system ();
solve ();
data_out.add_data_vector (solution, "solution");
data_out.build_patches ();
- ofstream output ("final-solution.eps");
+ std::ofstream output ("final-solution.eps");
data_out.write_eps (output);
};
// other information. This is also
// what would be printed in the
// following.
- catch (exception &exc)
+ catch (std::exception &exc)
{
- cerr << endl << endl
- << "----------------------------------------------------"
- << endl;
- cerr << "Exception on processing: " << endl
- << exc.what() << endl
- << "Aborting!" << endl
- << "----------------------------------------------------"
- << endl;
+ std::cerr << std::endl << std::endl
+ << "----------------------------------------------------"
+ << std::endl;
+ std::cerr << "Exception on processing: " << std::endl
+ << exc.what() << std::endl
+ << "Aborting!" << std::endl
+ << "----------------------------------------------------"
+ << std::endl;
// We can't do much more than
// printing as much information
// as we can get to, so abort
// message and exit.
catch (...)
{
- cerr << endl << endl
- << "----------------------------------------------------"
- << endl;
- cerr << "Unknown exception!" << endl
- << "Aborting!" << endl
- << "----------------------------------------------------"
- << endl;
+ std::cerr << std::endl << std::endl
+ << "----------------------------------------------------"
+ << std::endl;
+ std::cerr << "Unknown exception!" << std::endl
+ << "Aborting!" << std::endl
+ << "----------------------------------------------------"
+ << std::endl;
return 1;
};
// of the degrees of freedom on a
// cell.
RightHandSide<dim> right_hand_side;
- vector<double> rhs_values (n_q_points);
+ std::vector<double> rhs_values (n_q_points);
FullMatrix<double> cell_matrix (dofs_per_cell, dofs_per_cell);
Vector<double> cell_rhs (dofs_per_cell);
- vector<unsigned int> local_dof_indices (dofs_per_cell);
+ std::vector<unsigned int> local_dof_indices (dofs_per_cell);
// Then we define an object
// denoting the exact solution
fe_values.reinit (cell);
const FullMatrix<double>
& shape_values = fe_values.get_shape_values();
- const vector<vector<Tensor<1,dim> > >
+ const std::vector<std::vector<Tensor<1,dim> > >
& shape_grads = fe_values.get_shape_grads();
- const vector<double>
+ const std::vector<double>
& JxW_values = fe_values.get_JxW_values();
- const vector<Point<dim> >
+ const
std::vector<Point<dim> >
& q_points = fe_values.get_quadrature_points();
right_hand_side.value_list (q_points, rhs_values);
// local variables:
const FullMatrix<double>
& face_shape_values = fe_face_values.get_shape_values();
- const vector<double>
+ const std::vector<double>
& face_JxW_values = fe_face_values.get_JxW_values();
- const vector<Point<dim> >
+ const
std::vector<Point<dim> >
& face_q_points = fe_face_values.get_quadrature_points();
- const vector<Point<dim> >
+ const
std::vector<Point<dim> >
& face_normal_vectors = fe_face_values.get_normal_vectors ();
// And we can then
// belong to Gamma1 are therefore
// excluded from the interpolation
// of boundary values.
- map<unsigned int,double> boundary_values;
+ std::map<unsigned int,double> boundary_values;
VectorTools::interpolate_boundary_values (dof_handler,
0,
Solution<dim>(),
const unsigned int n_active_cells=triangulation.n_active_cells();
const unsigned int n_dofs=dof_handler.n_dofs();
- cout << "Cycle " << cycle << ':'
- << endl
- << " Number of active cells: "
- << n_active_cells
- << endl
- << " Number of degrees of freedom: "
- << n_dofs
- << endl;
+ std::cout << "Cycle " << cycle << ':'
+ << std::endl
+ << " Number of active cells: "
+ << n_active_cells
+ << std::endl
+ << " Number of degrees of freedom: "
+ << n_dofs
+ << std::endl;
// Add the important data to the
// ``TableHandler'' by giving the key
// statements which you have
// already seen in previous
// examples:
- string filename;
+ std::string filename;
switch (refinement_mode)
{
case global_refinement:
filename += ".gmv";
- ofstream output (filename.c_str());
+ std::ofstream output (filename.c_str());
DataOut<dim> data_out;
// In each cycle values were added
// to the TableHandler. Now write
// the table to the standard output
- // stream cout. Note, that the
+ // stream `std::cout'. Note, that the
// output in text format is a quite
// simple one and the captions may
// not be printed directly above
// the specific columns.
- convergence_table.write_text(cout);
+ convergence_table.write_text(std::cout);
// The table can also be written
// into a Tex file. The (nicely)
// formatted table can be viewed at
// refinement mode, as above
if (true)
{
- string filename = "error";
+ std::string filename = "error";
switch (refinement_mode)
{
case global_refinement:
Assert (false, ExcInternalError());
filename += ".tex";
- ofstream table_file(filename.c_str());
+ std::ofstream table_file(filename.c_str());
convergence_table.write_tex(table_file);
table_file.close();
}
// by adding the columns or the
// supercolumns to a new string
// vector.
- vector<string> new_order;
+ std::vector<std::string> new_order;
new_order.push_back("n cells");
new_order.push_back("H1");
new_order.push_back("L2");
// Finally, the convergence chart
// is written. The filename is
// again constructed as above.
- convergence_table.write_text(cout);
+ convergence_table.write_text(std::cout);
if (true)
{
- string filename = "convergence";
+ std::string filename = "convergence";
switch (refinement_mode)
{
case global_refinement:
Assert (false, ExcInternalError());
filename += ".tex";
- ofstream table_file(filename.c_str());
+ std::ofstream table_file(filename.c_str());
convergence_table.write_tex(table_file);
table_file.close();
}
// before we go to the next
// run.
{
- cout << "Solving with Q1 elements, adaptive refinement" << endl
- << "=============================================" << endl
- << endl;
+ std::cout << "Solving with Q1 elements, adaptive refinement" << std::endl
+ << "=============================================" << std::endl
+ << std::endl;
FEQ1<2> fe;
LaplaceProblem<2> laplace_problem_2d (fe, LaplaceProblem<2>::adaptive_refinement);
laplace_problem_2d.run ();
- cout << endl;
+ std::cout << std::endl;
};
{
- cout << "Solving with Q1 elements, global refinement" << endl
- << "===========================================" << endl
- << endl;
+ std::cout << "Solving with Q1 elements, global refinement" << std::endl
+ << "===========================================" << std::endl
+ << std::endl;
FEQ1<2> fe;
LaplaceProblem<2> laplace_problem_2d (fe, LaplaceProblem<2>::global_refinement);
laplace_problem_2d.run ();
- cout << endl;
+ std::cout << std::endl;
};
{
- cout << "Solving with Q2 elements, global refinement" << endl
- << "===========================================" << endl
- << endl;
+ std::cout << "Solving with Q2 elements, global refinement" << std::endl
+ << "===========================================" << std::endl
+ << std::endl;
FEQ2<2> fe;
LaplaceProblem<2> laplace_problem_2d (fe, LaplaceProblem<2>::global_refinement);
laplace_problem_2d.run ();
- cout << endl;
+ std::cout << std::endl;
};
}
- catch (exception &exc)
+ catch (std::exception &exc)
{
- cerr << endl << endl
- << "----------------------------------------------------"
- << endl;
- cerr << "Exception on processing: " << endl
- << exc.what() << endl
- << "Aborting!" << endl
- << "----------------------------------------------------"
- << endl;
+ std::cerr << std::endl << std::endl
+ << "----------------------------------------------------"
+ << std::endl;
+ std::cerr << "Exception on processing: " << std::endl
+ << exc.what() << std::endl
+ << "Aborting!" << std::endl
+ << "----------------------------------------------------"
+ << std::endl;
return 1;
}
catch (...)
{
- cerr << endl << endl
- << "----------------------------------------------------"
- << endl;
- cerr << "Unknown exception!" << endl
- << "Aborting!" << endl
- << "----------------------------------------------------"
- << endl;
+ std::cerr << std::endl << std::endl
+ << "----------------------------------------------------"
+ << std::endl;
+ std::cerr << "Unknown exception!" << std::endl
+ << "Aborting!" << std::endl
+ << "----------------------------------------------------"
+ << std::endl;
return 1;
};
// returns the values of the
// vector-valued function at
// several points at once:
- virtual void vector_value_list (const vector<Point<dim> > &points,
- vector<Vector<double> > &value_list) const;
+ virtual void vector_value_list (const
std::vector<Point<dim> > &points,
+ std::vector<Vector<double> > &value_list) const;
};
// the values at several points at
// once.
template <int dim>
-void RightHandSide<dim>::vector_value_list (const vector<Point<dim> > &points,
- vector<Vector<double> > &value_list) const
+void RightHandSide<dim>::vector_value_list (const
std::vector<Point<dim> > &points,
+ std::vector<Vector<double> > &value_list) const
{
// First we define an abbreviation
// for the number of points which
FullMatrix<double> cell_matrix (dofs_per_cell, dofs_per_cell);
Vector<double> cell_rhs (dofs_per_cell);
- vector<unsigned int> local_dof_indices (dofs_per_cell);
+ std::vector<unsigned int> local_dof_indices (dofs_per_cell);
// As was shown in previous
// examples as well, we need a
// quadrature points on a cell. In
// the present situation, we have
// two coefficients, lambda and mu.
- vector<double> lambda_values (n_q_points);
- vector<double> mu_values (n_q_points);
+ std::vector<double> lambda_values (n_q_points);
+ std::vector<double> mu_values (n_q_points);
// Well, we could as well have
// omitted the above two arrays
// which is a ``Vector<double>''
// with ``dim'' elements.
RightHandSide<dim> right_hand_side;
- vector<Vector<double> > rhs_values (n_q_points,
- Vector<double>(dim));
+ std::vector<Vector<double> > rhs_values (n_q_points,
+ Vector<double>(dim));
// Now we can begin with the loop
// offers:
const FullMatrix<double>
& shape_values = fe_values.get_shape_values();
- const vector<vector<Tensor<1,dim> > >
+ const std::vector<std::vector<Tensor<1,dim> > >
& shape_grads = fe_values.get_shape_grads();
- const vector<double>
+ const std::vector<double>
& JxW_values = fe_values.get_JxW_values();
- const vector<Point<dim> >
+ const
std::vector<Point<dim> >
& q_points = fe_values.get_quadrature_points();
// Next we get the values of
// that there is more in
// it. In fact, the
// function returns a
- // ``pair<unsigned int,
+ // ``std::pair<unsigned int,
// unsigned int>'', of
// which the first element
// is ``comp(i)'' and the
// we need to pass ``dim'' as
// number of components to the zero
// function as well.
- map<unsigned int,double> boundary_values;
+ std::map<unsigned int,double> boundary_values;
VectorTools::interpolate_boundary_values (dof_handler,
0,
ZeroFunction<dim>(dim),
// been shown in previous examples
// already. The only difference is
// not that the solution function is
- // vector values. The ``DataOut''
+ // std::vector values. The ``DataOut''
// class takes care of this
// automatically, but we have to give
// each component of the solution
- // vector a different name.
+ // std::vector a different name.
template <int dim>
void ElasticProblem<dim>::output_results (const unsigned int cycle) const
{
- string filename = "solution-";
+ std::string filename = "solution-";
filename += ('0' + cycle);
Assert (cycle < 10, ExcInternalError());
filename += ".gmv";
- ofstream output (filename.c_str());
+ std::ofstream output (filename.c_str());
DataOut<dim> data_out;
data_out.attach_dof_handler (dof_handler);
// library will throw an exception
// otherwise, at least if in debug
// mode.
- vector<string> solution_names;
+ std::vector<std::string> solution_names;
switch (dim)
{
case 1:
{
for (unsigned int cycle=0; cycle<8; ++cycle)
{
- cout << "Cycle " << cycle << ':' << endl;
+ std::cout << "Cycle " << cycle << ':' << std::endl;
if (cycle == 0)
{
else
refine_grid ();
- cout << " Number of active cells: "
- << triangulation.n_active_cells()
- << endl;
+ std::cout << " Number of active cells: "
+ << triangulation.n_active_cells()
+ << std::endl;
setup_system ();
- cout << " Number of degrees of freedom: "
- << dof_handler.n_dofs()
- << endl;
+ std::cout << " Number of degrees of freedom: "
+ << dof_handler.n_dofs()
+ << std::endl;
assemble_system ();
solve ();
ElasticProblem<2> elastic_problem_2d;
elastic_problem_2d.run ();
}
- catch (exception &exc)
+ catch (std::exception &exc)
{
- cerr << endl << endl
- << "----------------------------------------------------"
- << endl;
- cerr << "Exception on processing: " << endl
- << exc.what() << endl
- << "Aborting!" << endl
- << "----------------------------------------------------"
- << endl;
-
+ std::cerr << std::endl << std::endl
+ << "----------------------------------------------------"
+ << std::endl;
+ std::cerr << "Exception on processing: " << std::endl
+ << exc.what() << std::endl
+ << "Aborting!" << std::endl
+ << "----------------------------------------------------"
+ << std::endl;
+
return 1;
}
catch (...)
{
- cerr << endl << endl
- << "----------------------------------------------------"
- << endl;
- cerr << "Unknown exception!" << endl
- << "Aborting!" << endl
- << "----------------------------------------------------"
- << endl;
+ std::cerr << std::endl << std::endl
+ << "----------------------------------------------------"
+ << std::endl;
+ std::cerr << "Unknown exception!" << std::endl
+ << "Aborting!" << std::endl
+ << "----------------------------------------------------"
+ << std::endl;
return 1;
};
public:
virtual Tensor<1,dim> value (const Point<dim> &p) const;
- virtual void value_list (const vector<Point<dim> > &points,
- vector<Tensor<1,dim> > &values) const;
+ virtual void value_list (const
std::vector<Point<dim> > &points,
+ std::vector<Tensor<1,dim> > &values) const;
// In previous examples, we have
// used assertions that throw
// follows:
DeclException2 (ExcDimensionMismatch,
unsigned int, unsigned int,
- << "The vector has size " << arg1 << " but should have "
+ << "The std::vector has size " << arg1 << " but should have "
<< arg2 << " elements.");
// The syntax may look a little
// strange, but is
// types of the parameters. The
// last argument is a sequence of
// output directives that will be
- // piped into the ``cerr''
+ // piped into the ``std::cerr''
// object, thus the strange
// format with the leading ``<<''
// operator and the like. Note
template <int dim>
void
-AdvectionField<dim>::value_list (const vector<Point<dim> > &points,
- vector<Tensor<1,dim> > &values) const
+AdvectionField<dim>::value_list (const
std::vector<Point<dim> > &points,
+ std::vector<Tensor<1,dim> > &values) const
{
Assert (values.size() == points.size(),
ExcDimensionMismatch (values.size(), points.size()));
virtual double value (const Point<dim> &p,
const unsigned int component = 0) const;
- virtual void value_list (const vector<Point<dim> > &points,
- vector<double> &values,
- const unsigned int component = 0) const;
+ virtual void value_list (const
std::vector<Point<dim> > &points,
+ std::vector<double> &values,
+ const unsigned int component = 0) const;
private:
static const Point<dim> center_point;
template <int dim>
void
-RightHandSide<dim>::value_list (const vector<Point<dim> > &points,
- vector<double> &values,
- const unsigned int component) const
+RightHandSide<dim>::value_list (const
std::vector<Point<dim> > &points,
+ std::vector<double> &values,
+ const unsigned int component) const
{
Assert (values.size() == points.size(),
ExcDimensionMismatch (values.size(), points.size()));
virtual double value (const Point<dim> &p,
const unsigned int component = 0) const;
- virtual void value_list (const vector<Point<dim> > &points,
- vector<double> &values,
- const unsigned int component = 0) const;
+ virtual void value_list (const
std::vector<Point<dim> > &points,
+ std::vector<double> &values,
+ const unsigned int component = 0) const;
};
template <int dim>
void
-BoundaryValues<dim>::value_list (const vector<Point<dim> > &points,
- vector<double> &values,
- const unsigned int component) const
+BoundaryValues<dim>::value_list (const
std::vector<Point<dim> > &points,
+ std::vector<double> &values,
+ const unsigned int component) const
{
Assert (values.size() == points.size(),
ExcDimensionMismatch (values.size(), points.size()));
DeclException0 (ExcInsufficientDirections);
private:
- typedef pair<unsigned int,unsigned int> IndexInterval;
+ typedef std::pair<unsigned int,unsigned int> IndexInterval;
template <int dim>
static void estimate_interval (const DoFHandler<dim> &dof,
// only for a range of cell
// iterators, but for iterators in
// general, so you could use for
- // ``vector<T>::iterator'' or usual
+ // ``std::vector<T>::iterator'' or usual
// pointers as well.
//
// The function returns a vector of
// first typedef this data type to
// an alias.
typedef typename DoFHandler<dim>::active_cell_iterator active_cell_iterator;
-
vector<pair<active_cell_iterator,active_cell_iterator> >
+
std::vector<std::pair<active_cell_iterator,active_cell_iterator> >
thread_ranges
= Threads::split_range<active_cell_iterator> (dof_handler.begin_active (),
dof_handler.end (),
// indices of the degrees of
// freedom of the cell on which we
// are presently working...
- vector<unsigned int> local_dof_indices (dofs_per_cell);
+ std::vector<unsigned int> local_dof_indices (dofs_per_cell);
// ... and array in which the
// values of right hand side,
// boundary values will be stored,
// for cell and face integrals
// respectively:
- vector<double> rhs_values (n_q_points);
- vector<Tensor<1,dim> > advection_directions (n_q_points);
- vector<double> face_boundary_values (n_face_q_points);
- vector<Tensor<1,dim> > face_advection_directions (n_face_q_points);
+ std::vector<double> rhs_values (n_q_points);
+ std::vector<Tensor<1,dim> > advection_directions (n_q_points);
+ std::vector<double> face_boundary_values (n_face_q_points);
+ std::vector<Tensor<1,dim> > face_advection_directions (n_face_q_points);
// Then we start the main loop over
// the cells:
fe_values.reinit (cell);
const FullMatrix<double>
& shape_values = fe_values.get_shape_values();
- const vector<vector<Tensor<1,dim> > >
+ const std::vector<std::vector<Tensor<1,dim> > >
& shape_grads = fe_values.get_shape_grads();
- const vector<double>
+ const std::vector<double>
& JxW_values = fe_values.get_JxW_values();
- const vector<Point<dim> >
+ const
std::vector<Point<dim> >
& q_points = fe_values.get_quadrature_points();
// ... obtain the values of
const FullMatrix<double>
& face_shape_values = fe_face_values.get_shape_values();
- const vector<double>
+ const std::vector<double>
& face_JxW_values = fe_face_values.get_JxW_values();
- const vector<Point<dim> >
+ const
std::vector<Point<dim> >
& face_q_points = fe_face_values.get_quadrature_points();
- const vector<Point<dim> >
+ const
std::vector<Point<dim> >
& normal_vectors = fe_face_values.get_normal_vectors();
// For the quadrature
template <int dim>
void AdvectionProblem<dim>::output_results (const unsigned int cycle) const
{
- string filename = "grid-";
+ std::string filename = "grid-";
filename += ('0' + cycle);
Assert (cycle < 10, ExcInternalError());
filename += ".eps";
- ofstream output (filename.c_str());
+ std::ofstream output (filename.c_str());
GridOut grid_out;
grid_out.write_eps (triangulation, output);
{
for (unsigned int cycle=0; cycle<6; ++cycle)
{
- cout << "Cycle " << cycle << ':' << endl;
+ std::cout << "Cycle " << cycle << ':' << std::endl;
if (cycle == 0)
{
};
- cout << " Number of active cells: "
- << triangulation.n_active_cells()
- << endl;
+ std::cout << " Number of active cells: "
+ << triangulation.n_active_cells()
+ << std::endl;
setup_system ();
- cout << " Number of degrees of freedom: "
- << dof_handler.n_dofs()
- << endl;
+ std::cout << " Number of degrees of freedom: "
+ << dof_handler.n_dofs()
+ << std::endl;
assemble_system ();
solve ();
data_out.add_data_vector (solution, "solution");
data_out.build_patches ();
- ofstream output ("final-solution.gmv");
+ std::ofstream output ("final-solution.gmv");
data_out.write_gmv (output);
};
// larger interval. This is used
// here:
const unsigned int n_threads = multithread_info.n_default_threads;
- vector<IndexInterval> index_intervals
+ std::vector<IndexInterval> index_intervals
= Threads::split_interval (0, dof_handler.get_tria().n_active_cells(),
n_threads);
// later reallocations. Note how
// this maximal number of active
// neighbors is computed here.
- vector<typename DoFHandler<dim>::active_cell_iterator> active_neighbors;
+ std::vector<typename DoFHandler<dim>::active_cell_iterator> active_neighbors;
active_neighbors.reserve (GeometryInfo<dim>::faces_per_cell *
GeometryInfo<dim>::subfaces_per_face);
// in real space.
const Point<dim> this_center = fe_midpoint_value.quadrature_point(0);
- vector<double> this_midpoint_value(1);
+ std::vector<double> this_midpoint_value(1);
fe_midpoint_value.get_function_values (solution, this_midpoint_value);
// Now loop over all active
// neighbors and collect the
// data we need.
- typename vector<DoFHandler<dim>::active_cell_iterator>::const_iterator
+ typename std::vector<DoFHandler<dim>::active_cell_iterator>::const_iterator
neighbor_ptr = active_neighbors.begin();
for (; neighbor_ptr!=active_neighbors.end(); ++neighbor_ptr)
{
fe_midpoint_value.reinit (neighbor);
const Point<dim> neighbor_center = fe_midpoint_value.quadrature_point(0);
- vector<double> neighbor_midpoint_value(1);
+ std::vector<double> neighbor_midpoint_value(1);
fe_midpoint_value.get_function_values (solution, this_midpoint_value);
// Compute the vector ``y''
AdvectionProblem<2> advection_problem_2d;
advection_problem_2d.run ();
}
- catch (exception &exc)
+ catch (std::exception &exc)
{
- cerr << endl << endl
- << "----------------------------------------------------"
- << endl;
- cerr << "Exception on processing: " << endl
- << exc.what() << endl
- << "Aborting!" << endl
- << "----------------------------------------------------"
- << endl;
+ std::cerr << std::endl << std::endl
+ << "----------------------------------------------------"
+ << std::endl;
+ std::cerr << "Exception on processing: " << std::endl
+ << exc.what() << std::endl
+ << "Aborting!" << std::endl
+ << "----------------------------------------------------"
+ << std::endl;
return 1;
}
catch (...)
{
- cerr << endl << endl
- << "----------------------------------------------------"
- << endl;
- cerr << "Unknown exception!" << endl
- << "Aborting!" << endl
- << "----------------------------------------------------"
- << endl;
+ std::cerr << std::endl << std::endl
+ << "----------------------------------------------------"
+ << std::endl;
+ std::cerr << "Unknown exception!" << std::endl
+ << "Aborting!" << std::endl
+ << "----------------------------------------------------"
+ << std::endl;
return 1;
};
// $Id$
// Version: $Name$
//
-// Copyright (C) 2000 by the deal.II authors
+// Copyright (C) 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* number of blocks will be the
* size of the vector
*/
- BlockIndices (const vector<unsigned int> &n);
+ BlockIndices (const std::vector<unsigned int> &n);
/**
* Reinitialize the number of
* of block @p{i} is set to
* @p{n[i]}.
*/
- void reinit (const vector<unsigned int> &n);
+ void reinit (const std::vector<unsigned int> &n);
/**
* Return the block and the
* the block, the second the
* index within it.
*/
- pair<unsigned int,unsigned int>
+ std::pair<unsigned int,unsigned int>
global_to_local (const unsigned int i) const;
/**
* value is the total number of
* entries.
*/
- vector<unsigned int> start_indices;
+ std::vector<unsigned int> start_indices;
};
inline
-BlockIndices::BlockIndices (const vector<unsigned int> &n)
+BlockIndices::BlockIndices (const std::vector<unsigned int> &n)
: n_blocks(n.size()),
start_indices(n.size()+1)
{
BlockIndices::reinit (const unsigned int n_blocks,
const unsigned int n_elements_per_block)
{
- const vector<unsigned int> v(n_blocks, n_elements_per_block);
+ const std::vector<unsigned int> v(n_blocks, n_elements_per_block);
reinit (v);
};
inline
void
-BlockIndices::reinit (const vector<unsigned int> &n)
+BlockIndices::reinit (const std::vector<unsigned int> &n)
{
if (start_indices.size() != n.size()+1)
{
inline
-pair<unsigned int,unsigned int>
+std::pair<unsigned int,unsigned int>
BlockIndices::global_to_local (const unsigned int i) const
{
Assert (i<total_size(), ExcIndexRange(i, 0, total_size()));
while (i < start_indices[block])
--block;
- return make_pair<unsigned int>(block, i-start_indices[block]);
+ return std::make_pair<unsigned int>(block, i-start_indices[block]);
};
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// $Id$
// Version: $Name$
//
-// Copyright (C) 2000 by the deal.II authors
+// Copyright (C) 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
/**
* Array of sub-matrices.
*/
- vector<vector<SmartPointer<SparseMatrix<number> > > > sub_objects;
+ std::vector<std::vector<SmartPointer<SparseMatrix<number> > > > sub_objects;
};
const unsigned int j,
const number value)
{
- const pair<unsigned int,unsigned int>
+ const std::pair<unsigned int,unsigned int>
row_index = sparsity_pattern->row_indices.global_to_local (i),
col_index = sparsity_pattern->column_indices.global_to_local (j);
block(row_index.first,col_index.first).set (row_index.second,
const unsigned int j,
const number value)
{
- const pair<unsigned int,unsigned int>
+ const std::pair<unsigned int,unsigned int>
row_index = sparsity_pattern->row_indices.global_to_local (i),
col_index = sparsity_pattern->column_indices.global_to_local (j);
block(row_index.first,col_index.first).add (row_index.second,
BlockSparseMatrix<number>::operator () (const unsigned int i,
const unsigned int j) const
{
- const pair<unsigned int,unsigned int>
+ const std::pair<unsigned int,unsigned int>
row_index = sparsity_pattern->row_indices.global_to_local (i),
col_index = sparsity_pattern->column_indices.global_to_local (j);
return block(row_index.first,col_index.first) (row_index.second,
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
sparsity_pattern = &sparsity;
rows = sparsity.n_block_rows();
columns = sparsity.n_block_cols();
- sub_objects = vector<vector<SmartPointer<SparseMatrix<number> > > >
- (rows, vector<SmartPointer<SparseMatrix<number> > > (columns, 0));
+ sub_objects = std::vector<std::vector<SmartPointer<SparseMatrix<number> > > >
+ (rows, std::vector<SmartPointer<SparseMatrix<number> > > (columns, 0));
// and reinitialize the blocks
for (unsigned int r=0; r<rows; ++r)
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
/**
* Array of sparsity patterns.
*/
- vector<vector<SmartPointer<SparsityPattern> > > sub_objects;
+ std::vector<std::vector<SmartPointer<SparsityPattern> > > sub_objects;
/**
* Object storing and managing
// if you get an error here, are
// you sure you called
// @p{collect_sizes()} before?
- const pair<unsigned int,unsigned int>
+ const std::pair<unsigned int,unsigned int>
row_index = row_indices.global_to_local (i),
col_index = column_indices.global_to_local (j);
sub_objects[row_index.first][col_index.first]->add (row_index.second,
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* initialize each block with
* @p{n[i]} zero elements.
*/
- BlockVector (const vector<unsigned int> &n);
+ BlockVector (const std::vector<unsigned int> &n);
/**
* Destructor. Clears memory
* If @p{fast==false}, the vector
* is filled with zeros.
*/
- void reinit (const vector<unsigned int> &N,
- const bool fast=false);
+ void reinit (const std::vector<unsigned int> &N,
+ const bool fast=false);
/**
* Change the dimension to that of the
* @p{reinit (V.size(), fast)}.
*/
void reinit (const BlockVector<Number> &V,
- const bool fast=false);
+ const bool fast=false);
/**
* Set all entries to zero. Equivalent to
/**
* Print to a stream.
- *
*/
- void print (ostream &, unsigned int precision = 3,
- bool scientific = true,
- bool across = true) const;
+ void print (std::ostream &out,
+ const unsigned int precision = 3,
+ const bool scientific = true,
+ const bool across = true) const;
/**
* Write the vector en bloc to a file. This
* a different operating system of number
* format.
*/
- void block_write (ostream &out) const;
+ void block_write (std::ostream &out) const;
/**
* Read a vector en block from a file. This
* data as a vector stored bitwise to a
* file, but not more.
*/
- void block_read (istream &in);
+ void block_read (std::istream &in);
/**
* Determine an estimate for the
/**
* Pointer to the array of components.
*/
- vector<Vector<Number> > components;
+ std::vector<Vector<Number> > components;
/**
* Object managing the
inline
Number BlockVector<Number>::operator() (const unsigned int i) const
{
- const pair<unsigned int,unsigned int> local_index
+ const std::pair<unsigned int,unsigned int> local_index
= block_indices.global_to_local (i);
return components[local_index.first](local_index.second);
}
inline
Number& BlockVector<Number>::operator() (const unsigned int i)
{
- const pair<unsigned int,unsigned int> local_index
+ const std::pair<unsigned int,unsigned int> local_index
= block_indices.global_to_local (i);
return components[local_index.first](local_index.second);
}
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
template <typename Number>
-BlockVector<Number>::BlockVector (const vector<unsigned int> &n)
+BlockVector<Number>::BlockVector (const std::vector<unsigned int> &n)
{
reinit (n, false);
}
const unsigned int bl_sz,
const bool fast)
{
- vector<unsigned int> n(n_bl, bl_sz);
+ std::vector<unsigned int> n(n_bl, bl_sz);
reinit(n, fast);
}
template <typename Number>
-void BlockVector<Number>::reinit (const vector<unsigned int> &n,
- const bool fast)
+void BlockVector<Number>::reinit (const std::vector<unsigned int> &n,
+ const bool fast)
{
block_indices.reinit (n);
num_blocks = n.size();
template <typename Number>
-void BlockVector<Number>::print (ostream &out,
- unsigned int precision,
- bool scientific,
- bool across) const
+void BlockVector<Number>::print (std::ostream &out,
+ const unsigned int precision,
+ const bool scientific,
+ const bool across) const
{
for (unsigned int i=0;i<num_blocks;++i)
{
if (across)
out << 'C' << i << ':';
else
- out << "Component " << i << endl;
+ out << "Component " << i << std::endl;
components[i].print(out, precision, scientific, across);
}
}
template <typename Number>
-void BlockVector<Number>::block_write (ostream &out) const
+void BlockVector<Number>::block_write (std::ostream &out) const
{
for (unsigned int i=0;i<num_blocks;++i)
{
template <typename Number>
-void BlockVector<Number>::block_read (istream &in)
+void BlockVector<Number>::block_read (std::istream &in)
{
for (unsigned int i=0;i<num_blocks;++i)
{
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
/**
* Output of the matrix in user-defined format.
*/
- void print (ostream& s, int width=5, int precision=2) const;
+ void print (std::ostream &s,
+ const unsigned int width=5,
+ const unsigned int precision=2) const;
/**
* Print the matrix in the usual format,
* output if applied to a large matrix!
* Be careful with it.
*/
- void print_formatted (ostream &out,
+ void print_formatted (std::ostream &out,
const unsigned int presicion=3) const;
/**
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
{
reinit (m.dim_image, m.dim_range);
if (dim_range*dim_image != 0)
- copy (&m.val[0], &m.val[dim_image*dim_range],
- &val[0]);
+ std::copy (&m.val[0], &m.val[dim_image*dim_range],
+ &val[0]);
};
{
reinit (m);
if (dim_range*dim_image != 0)
- copy (&m.val[0], &m.val[dim_image*dim_range],
- &val[0]);
+ std::copy (&m.val[0], &m.val[dim_image*dim_range],
+ &val[0]);
return *this;
}
template <typename number>
void
-FullMatrix<number>::print (ostream& s, int w, int p) const
+FullMatrix<number>::print (std::ostream &s,
+ const unsigned int w,
+ const unsigned int p) const
{
Assert (val != 0, ExcEmptyMatrix());
- unsigned int i,j;
- for (i=0;i<m();i++)
+ for (unsigned int i=0; i<m(); ++i)
{
- for (j=0;j<n();j++) s << setw(w) << setprecision(p) << el(i,j);
- s << endl;
+ for (unsigned int j=0; j<n(); ++j)
+ s << std::setw(w) << std::setprecision(p) << el(i,j);
+ s << std::endl;
}
}
return ( ((val==0) && (m.val==0)) ||
((dim_range==m.dim_range) &&
(dim_image==m.dim_image) &&
- equal (&val[0], &val[dim_range*dim_image],
- &m.val[0])));
+ std::equal (&val[0], &val[dim_range*dim_image],
+ &m.val[0])));
};
void FullMatrix<number>::clear ()
{
if (val != 0)
- fill_n (&val[0], n()*m(), 0);
+ std::fill_n (&val[0], n()*m(), 0);
};
template <typename number>
void
-FullMatrix<number>::print_formatted (ostream &out, const unsigned int precision) const
+FullMatrix<number>::print_formatted (std::ostream &out,
+ const unsigned int precision) const
{
Assert (val != 0, ExcEmptyMatrix());
-
+
+ // set output format, but store old
+ // state
+ std::ios::fmtflags old_flags = out.flags();
out.precision (precision);
- out.setf (ios::scientific, ios::floatfield); // set output format
+ out.setf (std::ios::scientific, std::ios::floatfield);
for (unsigned int i=0; i<m(); ++i)
{
for (unsigned int j=0; j<n(); ++j)
if (el(i,j) != 0)
- out << setw(precision+7)
+ out << std::setw(precision+7)
<< el(i,j) << ' ';
else
- out << setw(precision+8) << " ";
- out << endl;
+ out << std::setw(precision+8) << " ";
+ out << std::endl;
};
AssertThrow (out, ExcIO());
- out.setf (0, ios::floatfield); // reset output format
+ // reset output format
+ out.flags (old_flags);
};
-// Gauss-Jordan-Algorithmus
-// cf. Stoer I (4th Edition) p. 153
-
template <typename number>
void
FullMatrix<number>::gauss_jordan()
Assert (val != 0, ExcEmptyMatrix());
Assert (dim_range == dim_image, ExcNotQuadratic());
- vector<unsigned int> p(n());
+ // Gauss-Jordan-Algorithmus
+ // cf. Stoer I (4th Edition) p. 153
+ std::vector<unsigned int> p(n());
for (unsigned int i=0; i<n(); ++i)
p[i] = i;
if (r>j)
{
for (unsigned int k=0; k<n(); ++k)
- swap (el(j,k), el(r,k));
+ std::swap (el(j,k), el(r,k));
- swap (p[j], p[r]);
+ std::swap (p[j], p[r]);
}
// transformation
el(j,j) = hr;
}
// columninterchange
- vector<number> hv(n());
+ std::vector<number> hv(n());
for (unsigned int i=0; i<n(); ++i)
{
for (unsigned int k=0; k<n(); ++k)
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* memory in comparison with
* @p{inverse_type=double}.
*/
- vector<FullMatrix<inverse_type> > var_inverse;
+ std::vector<FullMatrix<inverse_type> > var_inverse;
/**
* Storage of the original diagonal blocks.
*
* Used by the blocked SSOR method.
*/
- vector<FullMatrix<inverse_type> > var_diagonal;
+ std::vector<FullMatrix<inverse_type> > var_diagonal;
/**
* Flag for diagonal compression.
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// avoids copying
if (store_diagonals)
{
- vector<FullMatrix<inverse_type> > tmp(n_cells,
- FullMatrix<inverse_type>(blocksize));
+ std::vector<FullMatrix<inverse_type> >
+ tmp(n_cells, FullMatrix<inverse_type>(blocksize));
var_diagonal.swap (tmp);
}
-
- vector<FullMatrix<inverse_type> > tmp(n_cells,
- FullMatrix<inverse_type>(blocksize));
- var_inverse.swap (tmp);
+
+ if (true)
+ {
+ std::vector<FullMatrix<inverse_type> >
+ tmp(n_cells, FullMatrix<inverse_type>(blocksize));
+ var_inverse.swap (tmp);
+ // make sure the tmp object
+ // goes out of scope as
+ // soon as possible
+ };
M_cell.clear ();
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* the damping parameter of
* the preconditioning.
*/
- PreconditionSelector(const string preconditioning,
+ PreconditionSelector(const std::string &preconditioning,
const typename Vector::value_type &omega=1.);
/**
* Get the names of all implemented
* preconditionings.
*/
- static string get_precondition_names();
+ static std::string get_precondition_names();
/**
* Exception.
* Stores the name of the
* preconditioning.
*/
- string preconditioning;
+ std::string preconditioning;
private:
/**
template <class Matrix, class Vector>
PreconditionSelector<Matrix,Vector>
-::PreconditionSelector(string preconditioning,
+::PreconditionSelector(std::string &preconditioning,
const typename Vector::value_type &omega) :
preconditioning(preconditioning),
omega(omega) {}
template <class Matrix, class Vector>
-string PreconditionSelector<Matrix,Vector>::get_precondition_names()
+std::string PreconditionSelector<Matrix,Vector>::get_precondition_names()
{
return "none|jacobi|sor|ssor";
}
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// This is really bad since vectors
// should only be allocated if
// really needed. (GK)
- vector<VECTOR*> tmp_vectors (n_tmp_vectors, 0);
+ std::vector<VECTOR*> tmp_vectors (n_tmp_vectors, 0);
for (unsigned int tmp=0; tmp<n_tmp_vectors; ++tmp)
{
tmp_vectors[tmp] = memory.alloc();
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
do
{
if (step)
- deallog << "Restart step " << step << endl;
+ deallog << "Restart step " << step << std::endl;
state = iterate(A, precondition);
}
while (state == breakdown);
precondition.vmult(q,p);
tau = v.norm_sqr();
- //deallog << "tau:" << tau << endl;
+ //deallog << "tau:" << tau << std::endl;
rho = q*v;
- //deallog << "rho:" << rho << endl;
+ //deallog << "rho:" << rho << std::endl;
while (state == SolverControl::iterate)
return breakdown;
// Step 3
alpha = rho/sigma;
- //deallog << "alpha:" << alpha << endl;
+ //deallog << "alpha:" << alpha << std::endl;
v.add(-alpha,t);
// Step 4
psi = 1./(1.+theta);
tau *= theta*psi;
- //deallog << "psi:" << psi << endl;
- //deallog << "theta:" << theta << endl;
- //deallog << "tau:" << tau << endl;
+ //deallog << "psi:" << psi << std::endl;
+ //deallog << "theta:" << theta << std::endl;
+ //deallog << "tau:" << tau << std::endl;
d.sadd(psi*theta_old, psi*alpha, p);
x.add(d);
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* the @p{SolverControl} and the
* @p{VectorMemory} as argument.
*/
- SolverSelector(const string solvername,
- SolverControl &control,
- VectorMemory<Vector> &vectorm);
+ SolverSelector (const std::string &solvername,
+ SolverControl &control,
+ VectorMemory<Vector> &vectorm);
/**
* Destructor
* Get the names of all implemented
* solvers.
*/
- static string get_solver_names ();
+ static std::string get_solver_names ();
/**
* Exception.
*/
DeclException1 (ExcSolverDoesNotExist,
- string, << "Solver " << arg1 << " does not exist. Use one of "
- << endl << get_solver_names());
+ std::string, << "Solver " << arg1 << " does not exist. Use one of "
+ << std::endl << get_solver_names());
protected:
/**
* Stores the Name of the solver.
*/
- string solver_name;
+ std::string solver_name;
/**
* Stores the @p{SolverControl} that
template <class Vector>
-SolverSelector<Vector>::SolverSelector(string solver_name,
- SolverControl &control,
+SolverSelector<Vector>::SolverSelector(const std::string &solver_name,
+ SolverControl &control,
VectorMemory<Vector> &vector_memory) :
solver_name(solver_name),
control(&control),
template <class Vector>
-string SolverSelector<Vector>::get_solver_names()
+std::string SolverSelector<Vector>::get_solver_names()
{
return "richardson|cg|bicgstab|gmres";
};
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
if (true)
{
// preset the elements
- fill_n (&global_entry(0),
- n_nonzero_elements(),
- 0);
+ std::fill_n (&global_entry(0),
+ n_nonzero_elements(),
+ 0);
// note: pointers to the sparsity
// pattern of the old matrix!
const unsigned int * first_of_row
= &column_numbers[rowstart_indices[row]+1];
const unsigned int * first_after_diagonal
- = lower_bound (&column_numbers[rowstart_indices[row]+1],
- &column_numbers[rowstart_indices[row+1]],
- row);
+ = std::lower_bound (&column_numbers[rowstart_indices[row]+1],
+ &column_numbers[rowstart_indices[row+1]],
+ row);
// k := *col_ptr
for (const unsigned int * col_ptr = first_of_row; col_ptr!=first_after_diagonal; ++col_ptr)
// find the position where the part
// right of the diagonal starts
const unsigned int * const first_after_diagonal
- = lower_bound (rowstart,
- &column_numbers[rowstart_indices[row+1]],
- row);
+ = std::lower_bound (rowstart,
+ &column_numbers[rowstart_indices[row+1]],
+ row);
for (const unsigned int * col=rowstart; col!=first_after_diagonal; ++col)
dst(row) -= global_entry (col-column_numbers) * dst(*col);
// find the position where the part
// right of the diagonal starts
const unsigned int * const first_after_diagonal
- = lower_bound (&column_numbers[rowstart_indices[row]+1],
- &column_numbers[rowstart_indices[row+1]],
- static_cast<unsigned int>(row));
+ = std::lower_bound (&column_numbers[rowstart_indices[row]+1],
+ &column_numbers[rowstart_indices[row+1]],
+ static_cast<unsigned int>(row));
for (const unsigned int * col=first_after_diagonal; col!=rowend; ++col)
dst(row) -= global_entry (col-column_numbers) * dst(*col);
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* nonzero entry of the matrix
* per line.
*/
- void print (ostream &out) const;
+ void print (std::ostream &out) const;
/**
* Print the matrix in the usual
* output if applied to a large matrix!
* Be careful with it.
*/
- void print_formatted (ostream &out,
+ void print_formatted (std::ostream &out,
const unsigned int precision = 3,
const bool scientific = true,
const unsigned int width = 0,
void threaded_residual (Vector<somenumber> &dst,
const Vector<somenumber> &u,
const Vector<somenumber> &b,
- const pair<unsigned int,unsigned int> interval,
+ const std::pair<unsigned int,unsigned int> interval,
somenumber *partial_norm) const;
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
};
if (val)
- fill_n (&val[0], N, 0);
+ std::fill_n (&val[0], N, 0);
}
SparseMatrix<number>::n_actually_nonzero_elements () const
{
Assert (cols != 0, ExcMatrixNotInitialized());
- return count_if(&val[0], &val[n_nonzero_elements ()],
- bind2nd(not_equal_to<double>(), 0));
+ return std::count_if(&val[0], &val[n_nonzero_elements ()],
+ std::bind2nd(std::not_equal_to<double>(), 0));
};
Assert (val != 0, ExcMatrixNotInitialized());
Assert (cols == matrix.cols, ExcDifferentSparsityPatterns());
- copy (&matrix.val[0], &matrix.val[cols->n_nonzero_elements()],
- &val[0]);
+ std::copy (&matrix.val[0], &matrix.val[cols->n_nonzero_elements()],
+ &val[0]);
return *this;
};
// space for the norms of
// the different parts
- vector<somenumber> partial_sums (n_threads, 0);
+ std::vector<somenumber> partial_sums (n_threads, 0);
Threads::ThreadManager thread_manager;
// spawn some jobs...
for (unsigned int i=0; i<n_threads; ++i)
// space for the norms of
// the different parts
- vector<somenumber> partial_sums (n_threads, 0);
+ std::vector<somenumber> partial_sums (n_threads, 0);
Threads::ThreadManager thread_manager;
// spawn some jobs...
for (unsigned int i=0; i<n_threads; ++i)
// space for the square norms of
// the different parts
- vector<somenumber> partial_norms (n_threads, 0);
+ std::vector<somenumber> partial_norms (n_threads, 0);
Threads::ThreadManager thread_manager;
for (unsigned int i=0; i<n_threads; ++i)
Threads::spawn (thread_manager,
SparseMatrix<number>::threaded_residual (Vector<somenumber> &dst,
const Vector<somenumber> &u,
const Vector<somenumber> &b,
- const pair<unsigned int, unsigned int> interval,
+ const std::pair<unsigned int, unsigned int> interval,
somenumber *partial_norm) const
{
const unsigned int begin_row = interval.first,
// line denotes the diagonal element,
// which we need not check.
const unsigned int first_right_of_diagonal_index
- = (lower_bound (&cols->colnums[*rowstart_ptr+1],
- &cols->colnums[*(rowstart_ptr+1)],
- row) -
+ = (std::lower_bound (&cols->colnums[*rowstart_ptr+1],
+ &cols->colnums[*(rowstart_ptr+1)],
+ row)
+ -
&cols->colnums[0]);
for (unsigned int j=(*rowstart_ptr)+1; j<first_right_of_diagonal_index; ++j)
for (int row=n-1; row>=0; --row, --rowstart_ptr, --dst_ptr)
{
const unsigned int first_right_of_diagonal_index
- = (lower_bound (&cols->colnums[*rowstart_ptr+1],
- &cols->colnums[*(rowstart_ptr+1)],
- static_cast<unsigned int>(row)) -
+ = (std::lower_bound (&cols->colnums[*rowstart_ptr+1],
+ &cols->colnums[*(rowstart_ptr+1)],
+ static_cast<unsigned int>(row)) -
&cols->colnums[0]);
for (unsigned int j=first_right_of_diagonal_index; j<*(rowstart_ptr+1); ++j)
if (cols->colnums[j] > static_cast<unsigned int>(row))
}
+
template <typename number>
const SparsityPattern &
SparseMatrix<number>::get_sparsity_pattern () const
};
+
template <typename number>
-void SparseMatrix<number>::print (ostream &out) const {
+void SparseMatrix<number>::print (std::ostream &out) const
+{
Assert (cols != 0, ExcMatrixNotInitialized());
Assert (val != 0, ExcMatrixNotInitialized());
for (unsigned int i=0; i<cols->rows; ++i)
for (unsigned int j=cols->rowstart[i]; j<cols->rowstart[i+1]; ++j)
- out << "(" << i << "," << cols->colnums[j] << ") " << val[j] << endl;
+ out << "(" << i << "," << cols->colnums[j] << ") " << val[j] << std::endl;
AssertThrow (out, ExcIO());
};
template <typename number>
-void SparseMatrix<number>::print_formatted (ostream &out,
+void SparseMatrix<number>::print_formatted (std::ostream &out,
const unsigned int precision,
bool scientific,
unsigned int width,
out.precision (precision);
if (scientific)
{
- out.setf (ios::scientific, ios::floatfield);
+ out.setf (std::ios::scientific, std::ios::floatfield);
if (!width)
width = precision+7;
} else {
- out.setf (ios::fixed, ios::floatfield);
+ out.setf (std::ios::fixed, std::ios::floatfield);
if (!width)
width = precision+2;
}
{
for (unsigned int j=0; j<n(); ++j)
if ((*cols)(i,j) != SparsityPattern::invalid_entry)
- out << setw(width)
+ out << std::setw(width)
<< val[cols->operator()(i,j)] * denominator << ' ';
else
- out << setw(width) << zero_string << ' ';
- out << endl;
+ out << std::setw(width) << zero_string << ' ';
+ out << std::endl;
};
AssertThrow (out, ExcIO());
// see above
-// out.setf (0, ios::floatfield); // reset output format
+// out.setf (0, std::ios::floatfield); // reset output format
};
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#define __deal2__sparse_vanka_h
-/* Copyright Guido Kanschat, Wolfgang Bangerth 1999, 2000 */
#include <base/smartpointer.h>
* @p{multithread_info.n_default_threads}.
*/
SparseVanka(const SparseMatrix<number> &M,
- const vector<bool> &selected,
+ const std::vector<bool> &selected,
const bool conserve_memory = false,
const unsigned int n_threads = multithread_info.n_default_threads);
* with a null pointer
*/
template<typename number2>
- void apply_preconditioner (Vector<number2> &dst,
- const Vector<number2> &src,
- const vector<bool> *dof_mask = 0) const;
+ void apply_preconditioner (Vector<number2> &dst,
+ const Vector<number2> &src,
+ const std::vector<bool> *dof_mask = 0) const;
/**
* Determine an estimate for the
* Indices of those degrees of
* freedom that we shall work on.
*/
- const vector<bool> &selected;
+ const std::vector<bool> &selected;
/**
* Number of threads to be used
* Only those elements will be used
* that are tagged in @p{selected}.
*/
- mutable vector<SmartPointer<FullMatrix<float> > > inverses;
+ mutable std::vector<SmartPointer<FullMatrix<float> > > inverses;
/**
* Compute the inverses of all
* the case where this function
* re-creates it each time.
*/
- void compute_inverse (const unsigned int row,
- vector<unsigned int> &local_indices);
+ void compute_inverse (const unsigned int row,
+ std::vector<unsigned int> &local_indices);
};
* @p{n_blocks} to the base class.
*/
SparseBlockVanka (const SparseMatrix<number> &M,
- const vector<bool> &selected,
+ const std::vector<bool> &selected,
const unsigned int n_blocks,
const BlockingStrategy blocking_strategy,
const bool conserve_memory = false,
* recomputing each time the
* preconditioner is called.
*/
- vector<vector<bool> > dof_masks;
+ std::vector<std::vector<bool> > dof_masks;
/**
* Compute the contents of the
* constructor.
*/
void compute_dof_masks (const SparseMatrix<number> &M,
- const vector<bool> &selected,
+ const std::vector<bool> &selected,
const BlockingStrategy blocking_strategy);
};
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
template<typename number>
SparseVanka<number>::SparseVanka(const SparseMatrix<number> &M,
- const vector<bool> &selected,
+ const std::vector<bool> &selected,
const bool conserve_mem,
const unsigned int n_threads)
:
template<typename number>
SparseVanka<number>::~SparseVanka()
{
- vector<SmartPointer<FullMatrix<float> > >::iterator i;
+ std::vector<SmartPointer<FullMatrix<float> > >::iterator i;
for(i=inverses.begin(); i!=inverses.end(); ++i)
{
FullMatrix<float> *p = *i;
// consecutive, with other
// consecutive regions where we do
// not have to do something
- vector<pair<unsigned int, unsigned int> > blocking (n_threads);
+ std::vector<std::pair<unsigned int, unsigned int> > blocking (n_threads);
unsigned int c = 0;
unsigned int thread = 0;
// set-up the vector that will be used
// by the functions which we call
// below.
- vector<unsigned int> local_indices;
+ std::vector<unsigned int> local_indices;
// traverse all rows of the matrix
// which are selected
template <typename number>
void
-SparseVanka<number>::compute_inverse (const unsigned int row,
- vector<unsigned int> &local_indices)
+SparseVanka<number>::compute_inverse (const unsigned int row,
+ std::vector<unsigned int> &local_indices)
{
// first define an alias to the sparsity
// pattern of the matrix, since this
template<typename number>
template<typename number2>
void
-SparseVanka<number>::apply_preconditioner (Vector<number2> &dst,
- const Vector<number2> &src,
- const vector<bool> *const dof_mask) const
+SparseVanka<number>::apply_preconditioner (Vector<number2> &dst,
+ const Vector<number2> &src,
+ const std::vector<bool> *const dof_mask) const
{
Assert (dst.size() == src.size(),
ExcInvalidVectorSize(dst.size(), src.size()));
Vector<float> b (structure.max_entries_per_row());
Vector<float> x (structure.max_entries_per_row());
- map<unsigned int, unsigned int> local_index;
+ std::map<unsigned int, unsigned int> local_index;
// traverse all rows of the matrix
// which are selected
// couple with @p{row}.
local_index.clear ();
for (unsigned int i=0; i<row_length; ++i)
- local_index.insert(pair<unsigned int, unsigned int>
+ local_index.insert(std::pair<unsigned int, unsigned int>
(structure.column_number(row, i), i));
// Build local matrix and rhs
- for (map<unsigned int, unsigned int>::const_iterator is=local_index.begin();
+ for (std::map<unsigned int, unsigned int>::const_iterator is=local_index.begin();
is!=local_index.end(); ++is)
{
// irow loops over all DoFs that
// which itself couples with
// @p{row}) also couples with
// @p{row}.
- const map<unsigned int, unsigned int>::const_iterator js
+ const std::map<unsigned int, unsigned int>::const_iterator js
= local_index.find(col);
// if not, then still use
// this dof to modify the rhs
inverses[row]->vmult(x,b);
// Distribute new values
- for (map<unsigned int, unsigned int>::const_iterator is=local_index.begin();
+ for (std::map<unsigned int, unsigned int>::const_iterator is=local_index.begin();
is!=local_index.end(); ++is)
{
const unsigned int irow = is->first;
template <typename number>
SparseBlockVanka<number>::SparseBlockVanka (const SparseMatrix<number> &M,
- const vector<bool> &selected,
+ const std::vector<bool> &selected,
const unsigned int n_blocks,
const BlockingStrategy blocking_strategy,
const bool conserve_memory,
SparseVanka<number> (M, selected, conserve_memory, n_threads),
n_blocks (n_blocks),
dof_masks (n_blocks,
- vector<bool>(M.m(), false))
+ std::vector<bool>(M.m(), false))
{
compute_dof_masks (M, selected, blocking_strategy);
};
template <typename number>
void
SparseBlockVanka<number>::compute_dof_masks (const SparseMatrix<number> &M,
- const vector<bool> &selected,
+ const std::vector<bool> &selected,
const BlockingStrategy blocking_strategy)
{
Assert (n_blocks > 0, ExcInternalError());
selected.end(),
true);
- const unsigned int n_inverses_per_block = max(n_inverses / n_blocks,
- 1U);
+ const unsigned int n_inverses_per_block = std::max(n_inverses / n_blocks, 1U);
// precompute the splitting points
- vector<pair<unsigned int, unsigned int> > intervals (n_blocks);
+ std::vector<std::pair<unsigned int, unsigned int> > intervals (n_blocks);
// set up start and end index for
// each of the blocks. note that
// Lagrange dofs of each
// block access the different
// dofs
- vector<vector<unsigned int> > access_count (n_blocks,
- vector<unsigned int>(M.m(), 0));
+ std::vector<std::vector<unsigned int> >
+ access_count (n_blocks, std::vector<unsigned int>(M.m(), 0));
// set-up the map that will
// be used to store the
// indices each Lagrange dof
// accesses
- map<unsigned int, unsigned int> local_index;
+ std::map<unsigned int, unsigned int> local_index;
const SparsityPattern &structure = M.get_sparsity_pattern();
for (unsigned int row=0; row<M.m(); ++row)
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* row is given by the
* @p{row_lengths} array.
*/
- SparsityPattern (const unsigned int m,
- const unsigned int n,
- const vector<unsigned int> &row_lengths);
+ SparsityPattern (const unsigned int m,
+ const unsigned int n,
+ const std::vector<unsigned int> &row_lengths);
/**
* Initialize a square matrix of dimension
* row is given by the
* @p{row_lengths} array.
*/
- SparsityPattern (const unsigned int m,
- const vector<unsigned int> &row_lengths);
+ SparsityPattern (const unsigned int m,
+ const std::vector<unsigned int> &row_lengths);
/**
* Copy operator. For this the same holds
* to save time and to avoid fragmentation
* of the heap.
*/
- void reinit (const unsigned int m,
- const unsigned int n,
- const vector<unsigned int> &row_lengths);
+ void reinit (const unsigned int m,
+ const unsigned int n,
+ const std::vector<unsigned int> &row_lengths);
/**
* This function compresses the sparsity
* to dots or points and use the
* @p{plot} command.
*/
- void print_gnuplot (ostream &out) const;
+ void print_gnuplot (std::ostream &out) const;
/**
* Return number of rows of this
DeclException2 (ExcNotEnoughSpace,
int, int,
<< "Upon entering a new entry to row " << arg1
- << ": there was no free entry any more. " << endl
+ << ": there was no free entry any more. " << std::endl
<< "(Maximum number of entries for this row: "
<< arg2 << "; maybe the matrix is already compressed?)");
/**
// $Id$
// Version: $Name$
//
-// Copyright (C) 1999, 2000 by the deal.II authors
+// Copyright (C) 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* has previously been called,
* then that is deleted first.
*/
- void swap_out (const string &filename);
+ void swap_out (const std::string &filename);
/**
* Reload the data of this vector
* the filename is an empty
* string.
*/
- const string & get_filename () const;
+ const std::string & get_filename () const;
/**
* Determine an estimate for the
* Exception.
*/
DeclException1 (ExcInvalidFilename,
- string,
+ std::string,
<< "The filename <" << arg1
<< "> is not a valid one here.");
/**
* empty, indicating no ownership
* of files.
*/
- string filename;
+ std::string filename;
/**
* If in multithread mode, then
// $Id$
// Version: $Name$
//
-// Copyright (C) 1999, 2000 by the deal.II authors
+// Copyright (C) 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
template <typename number>
-void SwappableVector<number>::swap_out (const string &name)
+void SwappableVector<number>::swap_out (const std::string &name)
{
// if the vector was stored in
// another file previously, and
// @p{reload} function
Assert (data_is_preloaded == false, ExcInternalError());
- ofstream tmp_out(filename.c_str());
+ std::ofstream tmp_out(filename.c_str());
block_write (tmp_out);
tmp_out.close ();
Assert (filename != "", ExcInvalidFilename (filename));
Assert (size() == 0, ExcSizeNonzero());
- ifstream tmp_in(filename.c_str());
+ std::ifstream tmp_in(filename.c_str());
block_read (tmp_in);
tmp_in.close ();
template <typename number>
-const string &
+const std::string &
SwappableVector<number>::get_filename () const
{
return filename;
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* @author Guido Kanschat, Franz-Theo Suttmeier, Wolfgang Bangerth
*/
template <typename Number>
-class Vector {
+class Vector
+{
public:
/**
* Declare standard types used in all
* Print to a stream.
*
*/
- void print (ostream &, unsigned int precision = 3,
- bool scientific = true,
- bool across = true) const;
+ void print (std::ostream &out,
+ const unsigned int precision = 3,
+ const bool scientific = true,
+ const bool across = true) const;
/**
* Write the vector en bloc to a file. This
* a different operating system of number
* format.
*/
- void block_write (ostream &out) const;
+ void block_write (std::ostream &out) const;
/**
* Read a vector en block from a file. This
* data as a vector stored bitwise to a
* file, but not more.
*/
- void block_read (istream &in);
+ void block_read (std::istream &in);
/**
* Determine an estimate for the
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
template <typename Number>
-static inline Number sqr (const Number x) {
+static inline Number sqr (const Number x)
+{
return x*x;
};
{
val = new Number[maxdim];
Assert (val != 0, ExcOutOfMemory());
- copy (v.begin(), v.end(), begin());
+ std::copy (v.begin(), v.end(), begin());
}
}
void Vector<Number>::clear ()
{
if (dim>0)
- fill (begin(), end(), 0.);
+ std::fill (begin(), end(), 0.);
}
if (max0<fabs(val[i]))
max0 = fabs(val[i]);
- return max (max(max0, max1),
- max(max2, max3));
+ return std::max (std::max(max0, max1),
+ std::max(max2, max3));
};
Vector<Number>& Vector<Number>::operator = (const Number s)
{
Assert (dim!=0, ExcEmptyVector());
- fill (begin(), end(), s);
+ std::fill (begin(), end(), s);
return *this;
}
if (v.dim != dim)
reinit (v.dim, true);
if (dim!=0)
- copy (v.begin(), v.end(), begin());
+ std::copy (v.begin(), v.end(), begin());
return *this;
}
if (v.size() != dim)
reinit (v.size(), true);
if (dim!=0)
- copy (v.begin(), v.end(), begin());
+ std::copy (v.begin(), v.end(), begin());
return *this;
}
template <typename Number>
-void Vector<Number>::print (ostream &out,
- unsigned int precision,
- bool scientific,
- bool across) const
+void Vector<Number>::print (std::ostream &out,
+ const unsigned int precision,
+ const bool scientific,
+ const bool across) const
{
Assert (dim!=0, ExcEmptyVector());
out.precision (precision);
if (scientific)
{
- out.setf (ios::scientific, ios::floatfield);
+ out.setf (std::ios::scientific, std::ios::floatfield);
} else {
- out.setf (ios::fixed, ios::floatfield);
+ out.setf (std::ios::fixed, std::ios::floatfield);
}
if (across)
out << val[i] << ' ';
else
for (unsigned int i=0; i<size(); ++i)
- out << val[i] << endl;
- out << endl;
+ out << val[i] << std::endl;
+ out << std::endl;
AssertThrow (out, ExcIO());
};
template <typename Number>
-void Vector<Number>::block_write (ostream &out) const
+void Vector<Number>::block_write (std::ostream &out) const
{
AssertThrow (out, ExcIO());
// other version of the following
- // out << size() << endl << '[';
+ // out << size() << std::endl << '[';
// reason: operator<< seems to use
// some resources that lead to
// problems in a multithreaded
template <typename Number>
-void Vector<Number>::block_read (istream &in)
+void Vector<Number>::block_read (std::istream &in)
{
AssertThrow (in, ExcIO());
in.read (&c, 1);
AssertThrow (c=='[', ExcIO());
- in.read (reinterpret_cast<void*>(begin()),
+ in.read (reinterpret_cast<char*>(begin()),
reinterpret_cast<const char*>(end())
- reinterpret_cast<const char*>(begin()));
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* vector is used, second the
* vector itself.
*/
- typedef pair<bool, Vector* > entry_type;
+ typedef std::pair<bool, Vector* > entry_type;
/**
* Array of allocated vectors.
*/
- vector<entry_type> pool;
+ std::vector<entry_type> pool;
/**
* Overall number of allocations.
GrowingVectorMemory<Vector>::GrowingVectorMemory(const unsigned int initial_size)
: pool(initial_size)
{
- for (typename vector<entry_type>::iterator i=pool.begin();
+ for (typename std::vector<entry_type>::iterator i=pool.begin();
i != pool.end();
++i)
{
GrowingVectorMemory<Vector>::~GrowingVectorMemory()
{
unsigned int n = 0;
- for (typename vector<entry_type>::iterator i=pool.begin();
+ for (typename std::vector<entry_type>::iterator i=pool.begin();
i != pool.end();
++i)
{
delete i->second;
}
deallog << "GrowingVectorMemory:Overall allocated vectors: "
- << n_alloc << endl;
+ << n_alloc << std::endl;
deallog << "GrowingVectorMemory:Maximum allocated vectors: "
- << pool.size() << endl;
+ << pool.size() << std::endl;
if (n!=0)
deallog << "GrowingVectorMemory:Vectors not deallocated: "
- << n << " Memory leak!" << endl;
+ << n << " Memory leak!" << std::endl;
}
GrowingVectorMemory<Vector>::alloc()
{
++n_alloc;
- for (typename vector<entry_type>::iterator i=pool.begin();
+ for (typename std::vector<entry_type>::iterator i=pool.begin();
i != pool.end();
++i)
{
void
GrowingVectorMemory<Vector>::free(const Vector* const v)
{
- for (typename vector<entry_type>::iterator i=pool.begin();i != pool.end() ;++i)
+ for (typename std::vector<entry_type>::iterator i=pool.begin();i != pool.end() ;++i)
{
if (v == (i->second))
{
// $Id$
// Version: $Name$
//
-// Copyright (C) 2000 by the deal.II authors
+// Copyright (C) 2000, 2001 by the deal authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// $Id$
// Version: $Name$
//
-// Copyright (C) 2000 by the deal.II authors
+// Copyright (C) 2000, 2001 by the deal authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// set new sizes
rows = r;
columns = c;
- sub_objects.resize (rows, vector<SmartPointer<SparsityPattern> > (columns));
+ sub_objects.resize (rows, std::vector<SmartPointer<SparsityPattern> > (columns));
// allocate new objects
for (unsigned int i=0; i<rows; ++i)
void
BlockSparsityPattern::collect_sizes ()
{
- vector<unsigned int> row_sizes (rows);
- vector<unsigned int> col_sizes (columns);
+ std::vector<unsigned int> row_sizes (rows);
+ std::vector<unsigned int> col_sizes (columns);
// first find out the row sizes
// from the first block column
// $Id$
// Version: $Name$
//
-// Copyright (C) 2000 by the deal.II authors
+// Copyright (C) 2000, 2001 by the deal authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// double condition = s[0]/s[dim_range-1];
if (info!=0)
- deallog << "inverting error " << info << ' ' << erg << endl;
+ deallog << "inverting error " << info << ' ' << erg << std::endl;
if (rank<(int)dim_range)
- deallog << "rank deficiency " << rank << endl;
+ deallog << "rank deficiency " << rank << std::endl;
delete[] work;
delete[] s;
delete[] matrix;
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
{
if (_log_result)
deallog << "Convergence step " << step
- << " value " << check_value << endl;
+ << " value " << check_value << endl;
return success;
}
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
-SparsityPattern::SparsityPattern (const unsigned int m,
- const unsigned int n,
- const vector<unsigned int> &row_lengths)
+SparsityPattern::SparsityPattern (const unsigned int m,
+ const unsigned int n,
+ const std::vector<unsigned int> &row_lengths)
: max_dim(0),
max_vec_len(0),
rowstart(0),
-SparsityPattern::SparsityPattern (const unsigned int m,
- const vector<unsigned int> &row_lengths)
+SparsityPattern::SparsityPattern (const unsigned int m,
+ const std::vector<unsigned int> &row_lengths)
: max_dim(0),
max_vec_len(0),
rowstart(0),
const unsigned int * const
original_last_before_side_diagonals
= (row > extra_off_diagonals ?
- lower_bound (original_row_start,
- original_row_end,
- row-extra_off_diagonals) :
+ std::lower_bound (original_row_start,
+ original_row_end,
+ row-extra_off_diagonals) :
original_row_start);
const unsigned int * const
original_first_after_side_diagonals
= (row < rows-extra_off_diagonals-1 ?
- upper_bound (original_row_start,
- original_row_end,
- row+extra_off_diagonals) :
+ std::upper_bound (original_row_start,
+ original_row_end,
+ row+extra_off_diagonals) :
original_row_end);
// find first free slot. the
unsigned int * next_free_slot = &colnums[rowstart[row]] + 1;
// copy elements before side-diagonals
- next_free_slot = copy (original_row_start,
- original_last_before_side_diagonals,
- next_free_slot);
+ next_free_slot = std::copy (original_row_start,
+ original_last_before_side_diagonals,
+ next_free_slot);
// insert left and right side-diagonals
- for (unsigned int i=1; i<=min(row,extra_off_diagonals);
+ for (unsigned int i=1; i<=std::min(row,extra_off_diagonals);
++i, ++next_free_slot)
*next_free_slot = row-i;
- for (unsigned int i=1; i<=min(extra_off_diagonals, rows-row-1);
+ for (unsigned int i=1; i<=std::min(extra_off_diagonals, rows-row-1);
++i, ++next_free_slot)
*next_free_slot = row+i;
// copy rest
- next_free_slot = copy (original_first_after_side_diagonals,
- original_row_end,
- next_free_slot);
+ next_free_slot = std::copy (original_first_after_side_diagonals,
+ original_row_end,
+ next_free_slot);
// this error may happen if the
// sum of previous elements per row
{
// simply map this function to the
// other @p{reinit} function
- const vector<unsigned int> row_lengths (m, max_per_row);
+ const std::vector<unsigned int> row_lengths (m, max_per_row);
reinit (m, n, row_lengths);
};
void
-SparsityPattern::reinit (const unsigned int m,
- const unsigned int n,
- const vector<unsigned int> &row_lengths)
+SparsityPattern::reinit (const unsigned int m,
+ const unsigned int n,
+ const std::vector<unsigned int> &row_lengths)
{
Assert (((m==0) && (n==0)) || (*max_element(row_lengths.begin(), row_lengths.end()) > 0),
ExcInvalidNumber(*max_element(row_lengths.begin(), row_lengths.end())));
// columns
unsigned int vec_len = 0;
for (unsigned int i=0; i<m; ++i)
- vec_len += min(row_lengths[i], n);
+ vec_len += std::min(row_lengths[i], n);
max_row_length = (row_lengths.size() == 0 ?
0 :
- min (*max_element(row_lengths.begin(), row_lengths.end()),
- n));
+ std::min (*std::max_element(row_lengths.begin(), row_lengths.end()),
+ n));
// allocate memory for the rowstart
// set the rowstart array
rowstart[0] = 0;
for (unsigned int i=1; i<=rows; ++i)
- rowstart[i] = rowstart[i-1]+min(row_lengths[i-1],n);
+ rowstart[i] = rowstart[i-1]+std::min(row_lengths[i-1],n);
Assert (rowstart[rows]==vec_len, ExcInternalError());
// preset the column numbers by a
// value indicating it is not in
// use
- fill_n (&colnums[0], vec_len, invalid_entry);
+ std::fill_n (&colnums[0], vec_len, invalid_entry);
// if the matrix is square: let the
// first entry in each row be the
// elements there are, in order to
// allocate the right amount of
// memory
- const unsigned int
- nonzero_elements = count_if (&colnums[rowstart[0]],
- &colnums[rowstart[rows]],
- bind2nd(not_equal_to<unsigned int>(), invalid_entry));
+ const unsigned int nonzero_elements
+ = std::count_if (&colnums[rowstart[0]],
+ &colnums[rowstart[rows]],
+ std::bind2nd(std::not_equal_to<unsigned int>(), invalid_entry));
// now allocate the respective memory
unsigned int *new_colnums = new unsigned int[nonzero_elements];
// reserve temporary storage to
// store the entries of one row
- vector<unsigned int> tmp_entries (max_row_length);
+ std::vector<unsigned int> tmp_entries (max_row_length);
// Traverse all rows
for (unsigned int line=0; line<rows; ++line)
// this case only sort the
// remaining entries, otherwise
// sort all
- sort ((rows==cols) ? &tmp_entries[1] : &tmp_entries[0],
- &tmp_entries[row_length]);
+ std::sort ((rows==cols) ? &tmp_entries[1] : &tmp_entries[0],
+ &tmp_entries[row_length]);
// insert column numbers
// into the new field
// entries at all
Assert ((rowstart[line] == next_row_start)
||
- (find (&new_colnums[rowstart[line]+1],
- &new_colnums[next_row_start],
- new_colnums[rowstart[line]]) ==
+ (std::find (&new_colnums[rowstart[line]+1],
+ &new_colnums[next_row_start],
+ new_colnums[rowstart[line]]) ==
&new_colnums[next_row_start]),
ExcInternalError());
Assert ((rowstart[line] == next_row_start)
||
- (adjacent_find(&new_colnums[rowstart[line]+1],
- &new_colnums[next_row_start]) ==
+ (std::adjacent_find(&new_colnums[rowstart[line]+1],
+ &new_colnums[next_row_start]) ==
&new_colnums[next_row_start]),
ExcInternalError());
};
// gives us a sharp bound
unsigned int m = 0;
for (unsigned int i=1; i<rows; ++i)
- m = max (m, rowstart[i]-rowstart[i-1]);
+ m = std::max (m, rowstart[i]-rowstart[i-1]);
return m;
};
// at the top of this function, so it
// may not be called for noncompressed
// structures.
- const unsigned int * const p = lower_bound (&colnums[rowstart[i]+1],
- &colnums[rowstart[i+1]],
- j);
+ const unsigned int * const p = std::lower_bound (&colnums[rowstart[i]+1],
+ &colnums[rowstart[i+1]],
+ j);
if ((*p == j) &&
(p != &colnums[rowstart[i+1]]))
return (p - &colnums[0]);
void
-SparsityPattern::print_gnuplot (ostream &out) const
+SparsityPattern::print_gnuplot (std::ostream &out) const
{
Assert ((rowstart!=0) && (colnums!=0), ExcEmptyObject());
for (unsigned int i=0; i<rows; ++i)
// is x-y, that is we have to
// exchange the order of
// output
- out << colnums[j] << " " << -static_cast<signed int>(i) << endl;
+ out << colnums[j] << " " << -static_cast<signed int>(i) << std::endl;
AssertThrow (out, ExcIO());
}
// $Id$
// Version: $Name$
//
-// Copyright (C) 1999, 2000 by the deal.II authors
+// Copyright (C) 1999, 2000, 2001 by the deal authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
-//---------------------------- vector.cc ---------------------------
+//---------------------------- std::vector.cc ---------------------------
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// to the file deal.II/doc/license.html for the text and
// further information on this license.
//
-//---------------------------- vector.cc ---------------------------
+//---------------------------- std::vector.cc ---------------------------
#include <lac/vector.templates.h>
-//---------------------------- vector.long_double.cc ---------------------------
+//---------------------------- std::vector.long_double.cc ---------------------------
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
// to the file deal.II/doc/license.html for the text and
// further information on this license.
//
-//---------------------------- vector.long_double.cc ---------------------------
+//---------------------------- std::vector.long_double.cc ---------------------------
#include <lac/vector.templates.h>
projects / dealii-svn.git / commitdiff