// $Id$
// Version: $Name$
//
-// Copyright (C) 2004, 2005 by the deal.II authors
+// Copyright (C) 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* system_matrix.print_formatted(cout);
* @endcode
*
- * @ingroup output
+ * @ingroup textoutput
* @author Ralf Hartmann, Wolfgang Bangerth, 2004
*/
class ConditionalOStream
// $Id$
// Version: $Name$
//
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* implementations of these non-standard methods is left to a user.
*
* The number of cells and the number of DoFs may be added to the table by
- * calling e.g. <tt>add_value("n cells", n_cells)</tt>. The table
- * data is also added by calling add_value().
- * Before the output of the table the functions evaluate_convergence_rates() and
- * evaluate_all_convergence_rates() may be called (even multiply).
+ * calling e.g. <tt>add_value("n cells", n_cells)</tt>. The table data is
+ * also added by calling add_value(). Before the output of the table the
+ * functions evaluate_convergence_rates() and evaluate_all_convergence_rates()
+ * may be called (even multiply).
*
* There are two possibilities of how to evaluate the convergence rates of multiple
* columns in the same RateMode.
* that are not signed to be omitted.
* </ol>
*
+ * A detailed discussion of this class can also be found in the step-7 and
+ * step-13 example programs.
*
+ * @ingroup textoutput
* @author Ralf Hartmann, 1999
*/
class ConvergenceTable: public TableHandler
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* identifier. There exists a library object <tt>dealjobid</tt> of this
* class. This object can be accessed by all output functions to
* provide an id for the current job.
+ *
+ * @ingroup utilities
*/
class JobIdentifier
{
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* <li> <tt>deallog.pop()</tt> when leaving that stage entered with <tt>push</tt>.
* </ul>
*
- * @ingroup output
+ * @ingroup textoutput
* @author Guido Kanschat, Wolfgang Bangerth, 1999, 2003
*/
class LogStream
// $Id$
// Version: $Name$
//
-// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
/**
- * @brief Monomial of degree n.
- *
* Class generates Polynomial objects representing a monomial of
* degree n, that is, the function $x^n$.
*
// $Id$
// Version: $Name$
//
-// Copyright (C) 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* table is needed here. Furthermore, you may want to store, say, the
* gradients of shape functions, so the data type is not a single
* scalar value, but a tensor itself.
- *
+ *
+ * @ingroup data
* @author Wolfgang Bangerth, 2002.
*/
template <int N, typename T>
* dimensions. See there, and in the documentation of the base class
* for more information.
*
+ * @ingroup data
* @author Wolfgang Bangerth, 2002
*/
template <int N,typename T>
* For the rationale of this class, and a description of the
* interface, see the base class.
*
+ * @ingroup data
* @author Wolfgang Bangerth, 2002
*/
template <typename T>
* compatibility with a predecessor class (<tt>vector2d</tt>), some
* additional functions are provided.
*
+ * @ingroup data
* @author Wolfgang Bangerth, 2002
*/
template <typename T>
-/**
- * A class representing a transpose two-dimensional table, i.e. a matrix of
- * objects (not necessarily only numbers) in column first numbering (FORTRAN
- * convention). The only real difference is therefore really in the storage
- * format.
- *
- * This class copies the functions of Table<2,T>, but the element
- * access and the dimensions will be for the transpose ordering of the
- * data field in TableBase.
- *
- * @author Guido Kanschat, 2005
- */
-template <typename T>
-class TransposeTable : public TableBase<2,T>
-{
- public:
- /**
- * Default constructor. Set all
- * dimensions to zero.
- */
- TransposeTable ();
-
- /**
- * Constructor. Pass down the
- * given dimensions to the base
- * class.
- */
- TransposeTable (const unsigned int size1,
- const unsigned int size2);
-
- /**
- * Reinitialize the object. This
- * function is mostly here for
- * compatibility with the earlier
- * <tt>vector2d</tt> class. Passes
- * down to the base class by
- * converting the arguments to
- * the data type requested by the
- * base class.
- */
- void reinit (const unsigned int size1,
- const unsigned int size2);
-
- /**
- * Direct access to one element
- * of the table by specifying all
- * indices at the same time. Range
- * checks are performed.
- *
- * This version of the function
- * only allows read access.
- */
- const T & operator () (const unsigned int i,
- const unsigned int j) const;
-
-
- /**
- * Direct access to one element
- * of the table by specifying all
- * indices at the same time. Range
- * checks are performed.
- *
- * This version of the function
- * allows read-write access.
- */
- T & operator () (const unsigned int i,
- const unsigned int j);
-
-
- /**
- * Number of rows. This function
- * really makes only sense since
- * we have a two-dimensional
- * object here.
- */
- unsigned int n_rows () const;
-
- /**
- * Number of columns. This function
- * really makes only sense since
- * we have a two-dimensional
- * object here.
- */
- unsigned int n_cols () const;
-
- protected:
- /**
- * Return a read-write reference
- * to the element <tt>(i,j)</tt>.
- *
- * This function does no bounds
- * checking and is only to be
- * used internally and in
- * functions already checked.
- *
- * These functions are mainly
- * here for compatibility with a
- * former implementation of these
- * table classes for 2d arrays,
- * then called <tt>vector2d</tt>.
- */
- T & el (const unsigned int i,
- const unsigned int j);
-
- /**
- * Return the value of the
- * element <tt>(i,j)</tt> as a
- * read-only reference.
- *
- * This function does no bounds
- * checking and is only to be
- * used internally and in
- * functions already checked.
- *
- * We return the requested value
- * as a constant reference rather
- * than by value since this
- * object may hold data types
- * that may be large, and we
- * don't know here whether
- * copying is expensive or not.
- *
- * These functions are mainly
- * here for compatibility with a
- * former implementation of these
- * table classes for 2d arrays,
- * then called <tt>vector2d</tt>.
- */
- const T & el (const unsigned int i,
- const unsigned int j) const;
-};
-
-
-
/**
* A class representing a three-dimensional table of objects (not
* necessarily only numbers).
* For the rationale of this class, and a description of the
* interface, see the base class.
*
+ * @ingroup data
* @author Wolfgang Bangerth, 2002
*/
template <typename T>
* For the rationale of this class, and a description of the
* interface, see the base class.
*
+ * @ingroup data
* @author Wolfgang Bangerth, Ralf Hartmann 2002
*/
template <typename T>
* For the rationale of this class, and a description of the
* interface, see the base class.
*
+ * @ingroup data
* @author Wolfgang Bangerth, Ralf Hartmann 2002
*/
template <typename T>
* For the rationale of this class, and a description of the
* interface, see the base class.
*
+ * @ingroup data
* @author Wolfgang Bangerth, Ralf Hartmann 2002
*/
template <typename T>
* For the rationale of this class, and a description of the
* interface, see the base class.
*
+ * @ingroup data
* @author Wolfgang Bangerth, 2002, Ralf Hartmann 2004
*/
template <typename T>
+/**
+ * A class representing a transpose two-dimensional table, i.e. a matrix of
+ * objects (not necessarily only numbers) in column first numbering (FORTRAN
+ * convention). The only real difference is therefore really in the storage
+ * format.
+ *
+ * This class copies the functions of Table<2,T>, but the element
+ * access and the dimensions will be for the transpose ordering of the
+ * data field in TableBase.
+ *
+ * @ingroup data
+ * @author Guido Kanschat, 2005
+ */
+template <typename T>
+class TransposeTable : public TableBase<2,T>
+{
+ public:
+ /**
+ * Default constructor. Set all
+ * dimensions to zero.
+ */
+ TransposeTable ();
+
+ /**
+ * Constructor. Pass down the
+ * given dimensions to the base
+ * class.
+ */
+ TransposeTable (const unsigned int size1,
+ const unsigned int size2);
+
+ /**
+ * Reinitialize the object. This
+ * function is mostly here for
+ * compatibility with the earlier
+ * <tt>vector2d</tt> class. Passes
+ * down to the base class by
+ * converting the arguments to
+ * the data type requested by the
+ * base class.
+ */
+ void reinit (const unsigned int size1,
+ const unsigned int size2);
+
+ /**
+ * Direct access to one element
+ * of the table by specifying all
+ * indices at the same time. Range
+ * checks are performed.
+ *
+ * This version of the function
+ * only allows read access.
+ */
+ const T & operator () (const unsigned int i,
+ const unsigned int j) const;
+
+
+ /**
+ * Direct access to one element
+ * of the table by specifying all
+ * indices at the same time. Range
+ * checks are performed.
+ *
+ * This version of the function
+ * allows read-write access.
+ */
+ T & operator () (const unsigned int i,
+ const unsigned int j);
+
+
+ /**
+ * Number of rows. This function
+ * really makes only sense since
+ * we have a two-dimensional
+ * object here.
+ */
+ unsigned int n_rows () const;
+
+ /**
+ * Number of columns. This function
+ * really makes only sense since
+ * we have a two-dimensional
+ * object here.
+ */
+ unsigned int n_cols () const;
+
+ protected:
+ /**
+ * Return a read-write reference
+ * to the element <tt>(i,j)</tt>.
+ *
+ * This function does no bounds
+ * checking and is only to be
+ * used internally and in
+ * functions already checked.
+ *
+ * These functions are mainly
+ * here for compatibility with a
+ * former implementation of these
+ * table classes for 2d arrays,
+ * then called <tt>vector2d</tt>.
+ */
+ T & el (const unsigned int i,
+ const unsigned int j);
+
+ /**
+ * Return the value of the
+ * element <tt>(i,j)</tt> as a
+ * read-only reference.
+ *
+ * This function does no bounds
+ * checking and is only to be
+ * used internally and in
+ * functions already checked.
+ *
+ * We return the requested value
+ * as a constant reference rather
+ * than by value since this
+ * object may hold data types
+ * that may be large, and we
+ * don't know here whether
+ * copying is expensive or not.
+ *
+ * These functions are mainly
+ * here for compatibility with a
+ * former implementation of these
+ * table classes for 2d arrays,
+ * then called <tt>vector2d</tt>.
+ */
+ const T & el (const unsigned int i,
+ const unsigned int j) const;
+};
+
+
+
+
/* --------------------- Template and inline functions ---------------- */
#ifndef DOXYGEN
// $Id$
// Version: $Name$
//
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* Abstract base class for the <tt>TableEntry</tt> class. See there.
* This class is not to be used by the user.
*
+ * @ingroup textoutput
* @author Ralf Hartmann, 1999
*/
class TableEntryBase
*
* For more detail see the <tt>TableHandler</tt> class.
*
+ * @ingroup textoutput
* @author Ralf Hartmann, 1999
*/
template <typename value_type>
* to prescribe the format and the captions the columns are written
* with in tex mode.
*
+ * A detailed explanation of this class is also given in the step-13 tutorial
+ * program.
+ *
+ *
* <h3>Example</h3>
*
* This is a simple example demonstrating the usage of this class. The
* out_file.close();
* @endcode
*
+ * @ingroup textoutput
* @author Ralf Hartmann, 1999
*/
class TableHandler
// $Id$
// Version: $Name$
//
-// Copyright (C) 2005 by the deal.II authors
+// Copyright (C) 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* not only stores indices into the TableBase class, but also the sizes of the
* table in its various coordinates.
*
+ * @ingroup data
* @author Wolfgang Bangerth, 2002
*/
template <int N>
* of and access to data is done by the TableIndicesBase base
* class of a specializations.
*
+ * @ingroup data
* @author Wolfgang Bangerth, 2002
*/
template <int N>
* data is done by the TableIndicesBase base class of a
* specializations.
*
+ * @ingroup data
* @author Wolfgang Bangerth, 2002
*/
template <>
* specializations. Actual storage of and access to data is done by
* the TableIndicesBase base class of a specializations.
*
+ * @ingroup data
* @author Wolfgang Bangerth, 2002
*/
template <>
* specializations. Actual storage of and access to data is done by
* the TableIndicesBase base class of a specializations.
*
+ * @ingroup data
* @author Wolfgang Bangerth, 2002
*/
template <>
* specializations. Actual storage of and access to data is done by
* the TableIndicesBase base class of a specializations.
*
+ * @ingroup data
* @author Wolfgang Bangerth, Ralf Hartmann 2002
*/
template <>
* specializations. Actual storage of and access to data is done by
* the TableIndicesBase base class of a specializations.
*
+ * @ingroup data
* @author Wolfgang Bangerth, Ralf Hartmann 2002
*/
template <>
* specializations. Actual storage of and access to data is done by
* the TableIndicesBase base class of a specializations.
*
+ * @ingroup data
* @author Wolfgang Bangerth, Ralf Hartmann 2002
*/
template <>
* specializations. Actual storage of and access to data is done by
* the TableIndicesBase base class of a specializations.
*
+ * @ingroup data
* @author Wolfgang Bangerth, 2002, Ralf Hartmann 2004
*/
template <>
// $Id$
// Version: $Name$
//
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* returned, not only vectors, as for them the size can be determined
* similarly simply.
*
+ * @ingroup functions
* @author Guido Kanschat, 1999
*/
template <int rank, int dim>
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* right now. In this case, we would like to sum up the time needed by
* all children. Furthermore, a wall clock option would be nice.
*
+ * @ingroup utilities
* @author G. Kanschat, W. Bangerth
*/
//TODO:[?] make class work with multithreading as well. better docs.
// $Id$
// Version: $Name$
//
-// Copyright (C) 2005 by the deal.II authors
+// Copyright (C) 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* finite element computing or numerical programs, but nevertheless are needed
* in various contexts when writing applications.
*
+ * @ingroup utilities
* @author Wolfgang Bangerth, 2005
*/
namespace Utilities
/**
* A namespace for utility functions that
* probe system properties.
+ *
+ * @ingroup utilities
*/
namespace System
{
// $Id$
// Version: $Name$
//
-// Copyright (C) 2004, 2005 by the deal.II authors
+// Copyright (C) 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
#include <base/exceptions.h>
/**
- * Filter a range out of any object having a random access operator
- * <tt>[] (unsigned int)</tt> and a function <tt>size() const</tt>.
+ * Filter a range out of any object having a random access <tt>operator[]
+ * (unsigned int)</tt> and a function <tt>size() const</tt>.
*
- * The use of this object is straight forward. It reduplicates the
+ * The use of this object is straightforward. It reduplicates the
* random access operator of the <tt>VECTOR</tt> and adds an offset to
* every index.
*
* }
* @endcode
*
+ * @ingroup data
* @author Guido Kanschat, 2004
*/
template <class VECTOR>
// $Id$
// Version: $Name$
//
-// Copyright (C) 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
/**
- * Declare a data type which denotes a mapping between a boundary
- * indicator and the function denoting the boundary values on this
- * part of the boundary. This type is required in many functions where
- * depending on boundary indicators different functions are used,
- * e.g. for boundary value interpolation, etc. As a variable of this
- * type is often declared in certain contexts where these functions
- * are used, this variable is also used by some functions that are not
- * actually interested in the function pointer itself, but only in the
- * list of selected boundary indicators.
+ * Declare a data type which denotes a mapping between a boundary indicator
+ * and the function denoting the boundary values on this part of the
+ * boundary. This type is required in many functions where depending on the
+ * boundary indicator, different functions are used. An example is boundary
+ * value interpolation.
*
+ * It seems odd at first to declare this typedef inside a class, rather than
+ * declaring a typedef at global scope. The reason is that C++ does not allow
+ * to define templated typedefs, where here in fact we want a typdef that
+ * depends on the space dimension.
+ *
+ * @ingroup functions
* @author Wolfgang Bangerth, Ralf Hartmann, 2001
*/
template<int dim>
// $Id$
// Version: $Name$
//
-// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* You can suppress coarsening or refining by giving zero as the fraction
* for one of the operations.
*
+ * @ingroup grid
* @author Wolfgang Bangerth, 1998, 2000; Thomas Richter, 2000
*/
class GridRefinement
// $Id$
// Version: $Name$
//
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* no dimension is attributed to the first parameter, which here is
* DoFHandler (and could equally well be Triangulation or MGDoFHandler).
*
+ * @ingroup grid
* @author Wolfgang Bangerth, 1999
*/
template <template <int> class GridClass, int dim>
// $Id$
// Version: $Name$
//
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
*
* At present, only GNUPLOT output is supported.
*
- *
+ *
+ * @ingroup textoutput
* @author Wolfgang Bangerth, 1999
*/
class Histogram
* particular value and all other components are zero. Some more
* specialized functions are also defined in the Functions namespace.
*
+ *
+ * <h3>Time dependent functions</h3>
+ *
* For time dependent computations, boundary conditions and/or right
* hand side functions may also change with time. Since at a given
* time step one is usually only interested in the spatial dependence
* referencing a particular time. In above example, one would set the
* time of the function object to the present time step before handing
* it off to the VectorTools::interpolate_boundary_values method.
+ *
+ *
+ * <h3>Tensor-valued functions</h3>
+ *
+ * The Function class is the most frequently used, but sometimes one needs a
+ * function the values of which are tensors, rather than scalars. The
+ * TensorFunction template can do this for you. Apart from the return type,
+ * the interface is most the same as that of the Function class.
*/
* triangulations, computing the diameter of a domain, or subdividing it into
* chunks of roughly equal size for parallel computations.
*
+ * The GridRefinement class implements a number of mesh refinement algorithms,
+ * based on refinement indicators given to its member functions.
+ *
*
* <h3>Internal classes</h3>
*
*/
/**
- * @defgroup output Output
+ * @defgroup output Graphical output
*
* deal.II generates three types of output: it can write triangulations/meshes
* in formats understood by several mesh readers (including those of deal.II
* itself), and it can create output used for visualization of data. Finally,
* it can output matrices in a graphical format.
*
- * In addition, deal.II has a number of helper classes for
- * output. They are introduced in sections of their own below.
- *
*
* <h3>Visualization of data</h3>
*
* MatrixOut class uses the DataOutBase for output. Therefore, matrices can be
* visualized in all formats supported by the latter class.
*
+ * @ingroup IO
+ */
+
+/**
+ * @defgroup textoutput Textual output
*
- * <h3>The ConditionalOStream class</h3>
- *
- * The ConditionalOStream class is a class that acts like
- * <code>std::ostream</code> in that you can pipe output into it using
- * <code>operator <<</code>. However, it only writes these
- * things to a file (or the screen) if a flag is set. This is useful
- * in parallel programs, and is discussed in the step-17 tutorial
- * program.
- *
- *
- * <h3>The LogStream class</h3>
- *
- * The LogStream class is used to write status output of programs to
- * logfiles. It, again, acts like <code>std::ostream</code>, but
- * instead of writing things to a file or the screen only, it has the
- * ability to write things to both a log file as well as the
- * screen. It can also add a time stamp to each line of output, and
- * can selectively write only certain parts of the output that are
- * interesting enough to the screen, and suppress other parts that
- * then only show up in the log file.
+ * In addition to classes that provide graphical output formats (see the @ref
+ * output module), deal.II has a number of classes that facilitate textual
+ * output in a number of ways. They are collected in this module. See the
+ * documentation of these classes for more details.
*
* @ingroup IO
*/
* estimate). For deal.II classes, it uses the
* <code>memory_consumption</code> member function that most classes
* have.
+ *
+ * @ingroup utilities
*/
--- /dev/null
+//-------------------------------------------------------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 2006 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.
+//
+//-------------------------------------------------------------------------
+
+/**
+ * @defgroup utilities Utility functions and classes
+ *
+ * This module simply collects a number of functions and classes that provide
+ * general tools for tasks that do not usually have much to do with finite
+ * element programs in particular, but happen to be required there just as
+ * well.
+ */
+
+
+/**
+ * @defgroup data Data storage primitives
+ *
+ * Here are a few simple classes that help in storage and viewing data. For
+ * example, the Table templates allow to use not only arrays of objects (for
+ * which one might want to use the std::vector class), but also
+ * two-dimensional (rectangular) tables of arbitrary objects, as well as
+ * higher-order analogs up to tables with (presently) seven indices.
+ *
+ * Similarly, the VectorSlice function is a primitive that takes anything that
+ * has an interface that resembles a vector (for example the deal.II Vector or
+ * the std::vector classes) and presents a view on it as if it were a vector
+ * in itself.
+ *
+ * @ingroup utilities
+ */
// $Id$
// Version: $Name$
//
-// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* useful if a matrix is composed of several blocks, where you have to
* translate global row and column indices to local ones.
*
+ * @ingroup data
* @author Wolfgang Bangerth, Guido Kanschat, 2000
*/
class BlockIndices
// $Id$
// Version: $Name$
//
-// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
/*!@addtogroup Solvers */
/*@{*/
-//! Power method for eigenvalues.
/**
- * Power method (von Mises).
+ * Power method (von Mises) for eigenvalue computations.
*
* This method determines the largest eigenvalue of a matrix by
* applying increasing powers of this matrix to a vector. If there is
AdditionalData additional_data;
};
-//! Inverse iteration for eigenvalues.
/**
- * Inverse iteration (Wieland).
+ * Inverse iteration (Wieland) for eigenvalue computations.
*
* This class implements an adaptive version of the inverse iteration by Wieland.
*
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
/*!@addtogroup Solvers */
/*@{*/
-//! Base class for iterative solvers.
/**
* This class defines possible return states of linear solvers and
* provides interfaces to a memory pool and the control object.
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
/*!@addtogroup Solvers */
/*@{*/
-//! Iterative solver Bicg-stab.
/**
* Bicgstab algorithm by van der Vorst.
*
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
/*!@addtogroup Solvers */
/*@{*/
-//! Conjugate gradient method for symmetric positive definite matrices.
/**
- * Preconditioned cg method.
+ * Preconditioned cg method for symmetric positive definite matrices.
*
* For the requirements on matrices and vectors in order to work with
* this class, see the documentation of the Solver base class.
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
/*!@addtogroup Solvers */
/*@{*/
-//! Control of the stopping criterion for solvers
/**
* Control class for iterative solvers.
*
};
-//! Control of the stopping criterion depending on the initial residual.
/**
* Specialization of @p SolverControl which returns @p success if either
* the specified tolerance is achieved or if the initial residual (or
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
* @endcond
*/
-//! Generalized minimal residual method.
/**
* Implementation of the Restarted Preconditioned Direct Generalized
* Minimal Residual Method. The stopping criterion is the norm of the
SolverGMRES (const SolverGMRES<VECTOR>&);
};
-//! Generalized minimal residual method with flexible preconditioning.
/**
- * Flexible GMRES.
+ * Implementation of the Generalized minimal residual method with flexible
+ * preconditioning method.
*
* This version of the GMRES method allows for the use of a different
* preconditioner in each iteration step. Therefore, it is also more
// $Id$
// Version: $Name$
//
-// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
/*!@addtogroup Solvers */
/*@{*/
-//! Minimal residual method for symmetric matrices.
/**
- * Preconditioned MinRes method.
+ * Minimal residual method for symmetric matrices.
*
* For the requirements on matrices and vectors in order to work with
* this class, see the documentation of the Solver base class.
// $Id$
// Version: $Name$
//
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
/*!@addtogroup Solvers */
/*@{*/
-//! Quasi-minimal residual method for symmetric matrices.
/**
- * QMRS method.
+ * Quasi-minimal residual method for symmetric matrices.
*
* The QMRS method is supposed to solve symmetric indefinite linear
* systems with symmetric, not necessarily definite preconditioners.
// $Id$
// Version: $Name$
//
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
/*!@addtogroup Solvers */
/*@{*/
-//! Richardson's or stationary iteration.
/**
* Implementation of the richardson iteration method. The stopping criterion
* is the norm of the residual.
// $Id$
// Version: $Name$
//
-// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
/*!@addtogroup Solvers */
/*@{*/
-//! Selects a solver by changing a parameter.
/**
+ * Selects a solver by changing a parameter.
+ *
* By calling the @p solve function of this @p SolverSelector, it selects
* the @p solve function of that @p Solver that was specified in the constructor
* of this class.
// $Id$
// Version: $Name$
//
-// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 by the deal.II authors
+// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 by the deal.II authors
//
// This file is subject to QPL and may not be distributed
// without copyright and license information. Please refer
/*!@addtogroup VMemory */
/*@{*/
-//! Base class for vector memory management
/**
* Memory management base class for vectors. This is an abstract base
* class used, among other places, by all iterative methods to
-//! Sample implementation using system memory management.
/**
* Simple memory management. See the documentation of the base class
* for a description of its purpose.
-//! Keeps all vectors and avoids reallocation.
/**
* A pool based memory management class. See the documentation of the
* base class for a description of its purpose.