#include <base/smartpointer.h>
#include <lac/block_vector.h>
+/*! @addtogroup Matrix2
+ *@{
+ */
+
/**
* A matrix with several copies of the same block on the diagonal.
*
SmartPointer<const MATRIX> matrix;
};
-
+/*@}*/
//----------------------------------------------------------------------//
template <class MATRIX>
template <typename> class BlockVector;
template <typename> class Vector;
+/*! @addtogroup Matrix2
+ *@{
+ */
+
/**
* Block matrix composed of different single matrices.
unsigned int block_cols;
};
+/*@}*/
+
+/*! @addtogroup Preconditioners
+ *@{
+ */
+
/**
* Inversion of a block-triangular matrix.
bool backward;
};
-
+/*@}*/
//----------------------------------------------------------------------//
template <class MATRIX>
template <typename Number> class BlockVector;
+/*! @addtogroup Matrix1
+ *@{
+ */
+
/**
* Blocked sparse matrix. The behaviour of objects of this type is
* almost as for the @p{SparseMatrix<...>} objects, with most of the
-
+/*@}*/
/* ------------------------- Template functions ---------------------- */
template <typename number>
template <typename Number> class BlockVector;
+/*! @addtogroup Matrix1
+ *@{
+ */
+
+
/**
* A block matrix consisting of blocks of type @p{SparseMatrixEZ}.
*
Table<2, SparseMatrixEZ<Number> > blocks;
};
-
+/*@}*/
/*----------------------------------------------------------------------*/
class BlockSparsityPattern;
class CompressedBlockSparsityPattern;
+/*! @addtogroup Matrix1
+ *@{
+ */
+
/**
* This is the base class for block versions of the sparsity pattern
};
-
+/*@}*/
/*---------------------- Template functions -----------------------------------*/
class BlockVector;
+/*! @addtogroup LAC
+ *@{
+ */
+
namespace internal
{
template <typename Number2> friend class BlockVector;
};
-
+/*@}*/
/*----------------------- Inline functions ----------------------------------*/
#include <vector>
#include <set>
+/*! @addtogroup Matrix1
+ *@{
+ */
+
/**
* This class acts as an intermediate form of the
friend class SparsityPattern;
};
-
+/*@}*/
/*---------------------- Inline functions -----------------------------------*/
#include <cmath>
+/*!@addtogroup Solvers */
+/*@{*/
+
+//! Power method for eigenvalues.
/**
* Power method (von Mises).
*
AdditionalData additional_data;
};
-
+//! Inverse iteration for eigenvalues.
/**
* Inverse iteration (Wieland).
*
AdditionalData additional_data;
};
+/*@}*/
//----------------------------------------------------------------------
template <typename number> class Vector;
+/*! @addtogroup Matrix2
+ *@{
+ */
+
/**
* This class is a wrapper for linear systems of equations with simple
const bool matrix_is_symmetric) const;
};
-
+/*@}*/
/*---------------------- Inline functions -----------------------------------*/
template<typename number> class Vector;
+/*! @addtogroup Matrix1
+ *@{
+ */
+
/**
* Rectangular/quadratic full matrix.
<< " matrix dimension " << arg1);
};
-
+/*@}*/
/*-------------------------Inline functions -------------------------------*/
template<typename number> class Vector;
template<typename number> class BlockVector;
+/*! @addtogroup Matrix2
+ *@{
+ */
+
+
/**
* Poor man's matrix product. Stores two matrices $m_1$ and $m_2$ and
* implements matrix-vector multiplications for the product $m_1 m_2$
unsigned int component;
};
-
+/*@}*/
//----------------------------------------------------------------------//
template<class VECTOR>
#include <lac/sparse_matrix.h>
#include <lac/block_sparse_matrix.h>
+/*! @addtogroup LAC
+ *@{
+ */
+
/**
* Output a matrix in graphical form using the generic format
};
-
+/*@}*/
/* ---------------------- Template and inline functions ------------- */
#include <base/smartpointer.h>
#include <lac/vector_memory.h>
+/*! @addtogroup Matrix2
+ *@{
+ */
+
/**
* Abstract class for use in iterations. This class provides the
* interface required by LAC solver classes. It allows to use
SmartPointer<const MATRIX> m;
};
-
+/*@}*/
//----------------------------------------------------------------------//
template<class VECTOR>
template <typename number> class Vector;
template <typename number> class SparseMatrix;
+/*! @addtogroup Preconditioners
+ *@{
+ */
+
/**
* No preconditioning. This class helps you, if you want to use a
-
+/*@}*/
/* ---------------------------------- Inline functions ------------------- */
template<class VECTOR>
template <typename number> class FullMatrix;
template <typename number> class Vector;
+/*! @addtogroup Preconditioners
+ *@{
+ */
+
/**
* Base class for @p{PreconditionBlockJacobi},
void Tvmult (Vector<number2>&, const Vector<number2>&) const;
};
+/*@}*/
//----------------------------------------------------------------------//
template<class MATRIX, typename inverse_type>
template <class number> class SparseMatrix;
+/*! @addtogroup Preconditioners
+ *@{
+ */
+
/**
* Selects the preconditioner. The constructor of this class takes
* the name of the preconditioning and the damping parameter
const typename Vector::value_type omega;
};
-
+/*@}*/
/* --------------------- Inline and template functions ------------------- */
+/*! @addtogroup Matrix2
+ *@{
+ */
+
/**
* Schur complement of a block matrix.
*
unsigned int debug;
};
+/*@}*/
+//----------------------------------------------------------------------//
+
template <class MA_inverse, class MB, class MDt, class MC>
SchurMatrix<MA_inverse, MB, MDt, MC>
::SchurMatrix(const MA_inverse& Ainv,
#include <base/config.h>
#include <base/smartpointer.h>
+/*! @addtogroup Matrix2
+ *@{
+ */
+
/**
* Matrix with shifted diagonal values.
*
};
-
+/*@}*/
//----------------------------------------------------------------------//
template <class MATRIX>
template <class VECTOR> class VectorMemory;
class SolverControl;
+/*!@addtogroup Solvers */
+/*@{*/
+//! Base class for iterative 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.
- *
+ * This class defines possible return states of linear solvers and
+ * provides interfaces to a memory pool and the control object.
*
* @sect3{Requirements for template classes}
*
VectorMemory<VECTOR> &memory;
};
-
+/*@}*/
/*-------------------------------- Inline functions ------------------------*/
template <class VECTOR>
#include <lac/solver_control.h>
#include <cmath>
#include <base/subscriptor.h>
+
+/*!@addtogroup Solvers */
+/*@{*/
+
+//! Iterative solver Bicg-stab.
/**
* Bicgstab algorithm by van der Vorst.
*
};
+/*@}*/
/*-------------------------Inline functions -------------------------------*/
template<class VECTOR>
#include <base/subscriptor.h>
#include <cmath>
+/*!@addtogroup Solvers */
+/*@{*/
+//! Conjugate gradient method for symmetric positive definite matrices.
/**
* Preconditioned cg method.
*
AdditionalData additional_data;
};
+/*@}*/
/*------------------------- Implementation ----------------------------*/
// otherwise exit as normal
}
-
#endif
class ParameterHandler;
+/*!@addtogroup Solvers */
+/*@{*/
+//! Control of the stopping criterion for solvers
/**
* Control class for iterative solvers.
*
bool m_log_result;
};
-
+//! 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
double reduced_tol;
};
+/*@}*/
//------------------------------------------------------------//
#include <vector>
#include <cmath>
+/*!@addtogroup Solvers */
+/*@{*/
namespace internal
{
}
}
-
+//! 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.
*
FullMatrix<double> H1;
};
+/*@}*/
/* --------------------- Inline and template functions ------------------- */
#include <cmath>
#include <base/subscriptor.h>
+/*!@addtogroup Solvers */
+/*@{*/
+//! Minimal residual method for symmetric matrices.
/**
* Preconditioned MinRes method.
*
double res2;
};
-
+/*@}*/
/*------------------------- Implementation ----------------------------*/
#include <cmath>
+/*!@addtogroup Solvers */
+/*@{*/
+//! Quasi-minimal residual method for symmetric matrices.
/**
* QMRS method.
*
unsigned int step;
};
-
+/*@}*/
/*------------------------- Implementation ----------------------------*/
#include <lac/solver_control.h>
#include <base/subscriptor.h>
+/*!@addtogroup Solvers */
+/*@{*/
+
+//! Richardson's or stationary iteration.
/**
* Implementation of the richardson iteration method. The stopping criterion
* is the norm of the residual.
typename VECTOR::value_type res;
};
-
+/*@}*/
/*----------------- Implementation of the Richardson Method ------------------*/
#include <lac/precondition.h>
+/*!@addtogroup Solvers */
+/*@{*/
+
+//! 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
typename SolverGMRES<VECTOR>::AdditionalData gmres_data;
};
-
+/*@}*/
/* --------------------- Inline and template functions ------------------- */
//---------------------- sparse_decomposition.h ---------------------------
-// Copyright (C) 1998, 1999, 2000, 2001, 2002
+// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003
// by the deal.II authors and Stephen "Cheffo" Kolaroff
//
// This file is subject to QPL and may not be distributed
#include <cmath>
+/*! @addtogroup LAC
+ *@{
+ */
+
/**
* Abstract base class for sparse LU decompositions of a sparse matrix
* into another sparse matrix.
SparsityPattern *own_sparsity;
};
-
+/*@}*/
+//----------------------------------------------------------------------//
template <typename number>
inline number
+/*! @addtogroup LAC
+ *@{
+ */
+
/**
* This class provides an interface to the sparse direct solver MA27
* from the Harwell Subroutine Library. MA27 is a direct solver
const unsigned int *ICNTL);
};
-
+/*@}*/
#endif
//---------------------------- sparse_ilu.h ---------------------------
-// Copyright (C) 1998, 1999, 2000, 2001, 2002
+// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003
// by the deal.II authors and Stephen "Cheffo" Kolaroff
//
// This file is subject to QPL and may not be distributed
#include <lac/sparse_decomposition.h>
+/*! @addtogroup LAC
+ *@{
+ */
+
/**
* Incomplete LU decomposition of a sparse matrix into another sparse matrix.
* A given matrix is decomposed into a incomplete LU factorization, where
<< " is not greater or equal than zero!");
};
-
+/*@}*/
+//----------------------------------------------------------------------//
template <typename number>
template <typename somenumber>
template<typename number> class Vector;
template<typename number> class FullMatrix;
+/*! @addtogroup Matrix1
+ *@{
+ */
+
/**
* Sparse matrix.
*
template <typename somenumber> friend class SparseMatrix;
};
-
+/*@}*/
/*---------------------- Inline functions -----------------------------------*/
template<typename number> class Vector;
template<typename number> class FullMatrix;
+/*! @addtogroup Matrix1
+ *@{
+ */
+
/**
* Sparse matrix without sparsity pattern.
*
#endif
};
-
+/*@}*/
/*---------------------- Inline functions -----------------------------------*/
template <typename number>
//---------------------------- sparse_mic.h ---------------------------
-// Copyright (C) 1998, 1999, 2000, 2001, 2002
+// Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003
// by the deal.II authors and Stephen "Cheffo" Kolaroff
//
// This file is subject to QPL and may not be distributed
#include <lac/sparse_decomposition.h>
+/*! @addtogroup Preconditioners
+ *@{
+ */
+
/**
* Modified incomplete Cholesky (MIC(0)) preconditioner. This class
* conforms to the state and usage specification in
number get_rowsum (const unsigned int row) const;
};
-
+/*@}*/
#endif // __deal2__
template <typename number> class SparseVanka;
template <typename number> class SparseBlockVanka;
+/*! @addtogroup Preconditioners
+ *@{
+ */
+
/**
* Point-wise Vanka preconditioning.
* This class does Vanka preconditioning on a point-wise base.
const BlockingStrategy blocking_strategy);
};
-
+/*@}*/
#endif
+/*! @addtogroup Matrix1
+ *@{
+ */
+
/**
* Structure representing the sparsity pattern of a sparse matrix.
*
};
+/*@}*/
/*---------------------- Inline functions -----------------------------------*/
#include <string>
+/*! @addtogroup LAC
+ *@{
+ */
+
/**
* This class is a wrapper to the @p{Vector} class which allows to swap
void reload_vector (const bool set_flag);
};
-
+/*@}*/
/*---------------------------- swappable_vector.h ---------------------------*/
/* end of #ifndef __deal2__swappable_vector_h */
#include <cstdio>
+/*! @addtogroup LAC
+ *@{
+ */
+
/**
* Numerical vector of data. For this class there are different types
* of functions available. The first type of function mesures the norm
template <typename Number2> friend class Vector;
};
-
+/*@}*/
/*----------------------- Inline functions ----------------------------------*/
#include <vector>
+/*! @addtogroup LAC
+ *@{
+ */
+
/**
* Memory management for vectors. This class is used by all
* iterative methods to allocate space for auxilliary
};
-
+/*@}*/
/* --------------------- inline functions ---------------------- */