use lowercase letters and underscores to separate words.
The only exception are the iterator typedefs in Triangulation
and DoFHandler (named cell_iterator, active_line_iterator, etc)
- to make the connection to the STL classes clear.</li>
+ to make the connection to the standard library container classes clear.</li>
<li> For classes with multiple template arguments, the dimension is usually
put before the data type specifier, i.e., we use Point<dim,number> and not
*
* In contrast to this, the MemoryConsumption namespace provides
* functions that can be used to determine the memory consumption of
- * objects. For some simple classes, like the STL containers, it
- * directly determines how much memory they need (or at least gives an
- * estimate). For deal.II classes, it uses the
+ * objects. For some simple classes, like the standard library
+ * containers, it directly determines how much memory they need (or at
+ * least gives an estimate). For deal.II classes, it uses the
* <code>memory_consumption</code> member function that most classes
* have.
*
const unsigned int
n_vertices = sizeof(vertices_1) / sizeof(vertices_1[0]);
- // From this static list of vertices, we generate an STL vector of the
- // vertices, as this is the data type the library wants to see.
+ // From this static list of vertices, we generate a <tt>std::vector</tt>
+ // of the vertices, as this is the data type the library wants to see.
const std::vector<Point<dim> > vertices (&vertices_1[0],
&vertices_1[n_vertices]);
// The nonlinear function that we have to evaluate for the time stepping
// routine includes the value of the function at the present time @p current
// as well as the value at the previous time step @p old. Both values are
- // passed to the operator in the collection of source vectors @p src, which
- // is simply an STL vector of pointers to the actual solution vectors. This
- // construct of collecting several source vectors into one is necessary as
- // the cell loop in @p MatrixFree takes exactly one source and one
- // destination vector, even if we happen to use many vectors like the two in
- // this case. Note that the cell loop accepts any valid class for input and
- // output, which does not only include vectors but general data
- // types. However, only in case it encounters a
- // parallel::distributed::Vector<Number> or an STL vector collecting these
- // vectors, it calls functions that exchange data at the beginning and the
- // end of the loop. In the loop over the cells, we first have to read in the
- // values in the vectors related to the local values. Then, we evaluate the
- // value and the gradient of the current solution vector and the values of
- // the old vector at the quadrature points. Then, we combine the terms in
- // the scheme in the loop over the quadrature points. Finally, we integrate
- // the result against the test function and accumulate the result to the
- // global solution vector @p dst.
+ // passed to the operator in the collection of source vectors @p src, which is
+ // simply a <tt>std::vector</tt> of pointers to the actual solution
+ // vectors. This construct of collecting several source vectors into one is
+ // necessary as the cell loop in @p MatrixFree takes exactly one source and
+ // one destination vector, even if we happen to use many vectors like the two
+ // in this case. Note that the cell loop accepts any valid class for input and
+ // output, which does not only include vectors but general data types.
+ // However, only in case it encounters a parallel::distributed::Vector<Number>
+ // or a <tt>std::vector</tt> collecting these vectors, it calls functions that
+ // exchange data at the beginning and the end of the loop. In the loop over
+ // the cells, we first have to read in the values in the vectors related to
+ // the local values. Then, we evaluate the value and the gradient of the
+ // current solution vector and the values of the old vector at the quadrature
+ // points. Then, we combine the terms in the scheme in the loop over the
+ // quadrature points. Finally, we integrate the result against the test
+ // function and accumulate the result to the global solution vector @p dst.
template <int dim, int fe_degree>
void SineGordonOperation<dim, fe_degree>::
local_apply (const MatrixFree<dim> &data,
// artificial time.
// We create an output of the initial value. Then we also need to collect
- // the two starting solutions in an STL vector of pointers field and to
- // set up an instance of the <code> SineGordonOperation class </code>
+ // the two starting solutions in a <tt>std::vector</tt> of pointers field
+ // and to set up an instance of the <code> SineGordonOperation class </code>
// based on the finite element degree specified at the top of this file.
VectorTools::interpolate (dof_handler,
ExactSolution<dim> (1, time),
/**
* 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
- * <tt>std::map<></tt> object?), but rather to aid in the search for memory
- * bottlenecks.
+ * used up to the last bit (what is the memory used by a <tt>std::map</tt>
+ * object?), but rather to aid in the search for memory bottlenecks.
*
* This namespace has a single member function memory_consumption() and a lot
* of specializations. Depending on the argument type of the function, there
/**
* Estimate the amount of memory (in bytes) occupied by a C-style array.
* Since in this library we do not usually store simple data elements like
- * <tt>double</tt>s in such arrays (but rather use STL <tt>std::vector</tt>s
+ * <tt>double</tt>s in such arrays (but rather use <tt>std::vector</tt>s
* or deal.II <tt>Vector</tt> objects), we do not provide specializations
* like for the <tt>std::vector</tt> arrays, but always use the loop over
* all elements.
/**
* Reset all values to zero.
*
- * Note that this is partly inconsistent with the semantics of the @p
- * clear() member functions of the STL and of several other classes within
- * deal.II which not only reset the values of stored elements to zero, but
- * release all memory and return the object into a virginial state. However,
- * since the size of objects of the present type is determined by its
- * template parameters, resizing is not an option, and indeed the state
- * where all elements have a zero value is the state right after
- * construction of such an object.
+ * Note that this is partly inconsistent with the semantics of the @p clear()
+ * member functions of the standard library containers and of several other
+ * classes within deal.II, which not only reset the values of stored elements
+ * to zero, but release all memory and return the object into a virginial
+ * state. However, since the size of objects of the present type is determined
+ * by its template parameters, resizing is not an option, and indeed the state
+ * where all elements have a zero value is the state right after construction
+ * of such an object.
*/
void clear ();
struct Column
{
/**
- * Constructor needed by STL maps.
+ * Constructor needed by <tt>std::map</tt>.
*/
Column ();
/**
* Reset all values to zero.
*
- * Note that this is partly inconsistent with the semantics of the @p
- * clear() member functions of the STL and of several other classes within
- * deal.II which not only reset the values of stored elements to zero, but
- * release all memory and return the object into a virginial state. However,
- * since the size of objects of the present type is determined by its
- * template parameters, resizing is not an option, and indeed the state
- * where all elements have a zero value is the state right after
- * construction of such an object.
+ * Note that this is partly inconsistent with the semantics of the @p clear()
+ * member functions of the standard library containers and of several other
+ * classes within deal.II, which not only reset the values of stored elements
+ * to zero, but release all memory and return the object into a virginial
+ * state. However, since the size of objects of the present type is determined
+ * by its template parameters, resizing is not an option, and indeed the state
+ * where all elements have a zero value is the state right after construction
+ * of such an object.
*/
void clear ();
/**
* Reset all values to zero.
*
- * Note that this is partly inconsistent with the semantics of the @p
- * clear() member functions of the STL and of several other classes within
- * deal.II which not only reset the values of stored elements to zero, but
- * release all memory and return the object into a virginial state. However,
- * since the size of objects of the present type is determined by its
- * template parameters, resizing is not an option, and indeed the state
- * where all elements have a zero value is the state right after
- * construction of such an object.
+ * Note that this is partly inconsistent with the semantics of the @p clear()
+ * member functions of the standard library containers and of several other
+ * classes within deal.II, which not only reset the values of stored elements
+ * to zero, but release all memory and return the object into a virginial
+ * state. However, since the size of objects of the present type is determined
+ * by its template parameters, resizing is not an option, and indeed the state
+ * where all elements have a zero value is the state right after construction
+ * of such an object.
*/
void clear ();
/**
* Reset all values to zero.
*
- * Note that this is partly inconsistent with the semantics of the @p
- * clear() member functions of the STL and of several other classes within
- * deal.II which not only reset the values of stored elements to zero, but
- * release all memory and return the object into a virginial state. However,
- * since the size of objects of the present type is determined by its
- * template parameters, resizing is not an option, and indeed the state
- * where all elements have a zero value is the state right after
- * construction of such an object.
+ * Note that this is partly inconsistent with the semantics of the @p clear()
+ * member functions of the standard library containers and of several other
+ * classes within deal.II, which not only reset the values of stored elements
+ * to zero, but release all memory and return the object into a virginial
+ * state. However, since the size of objects of the present type is determined
+ * by its template parameters, resizing is not an option, and indeed the state
+ * where all elements have a zero value is the state right after construction
+ * of such an object.
*/
void clear ();
DEAL_II_NAMESPACE_CLOSE
#endif
-
-
typename VECTOR::const_reference operator[] (unsigned int i) const;
/**
- * STL conforming iterator function.
+ * Standard-conforming iterator function.
*/
typename VECTOR::iterator begin();
/**
- * STL conforming iterator function.
+ * Standard-conforming iterator function.
*/
typename VECTOR::const_iterator begin() const;
/**
- * STL conforming iterator function.
+ * Standard-conforming iterator function.
*/
typename VECTOR::iterator end();
/**
- * STL conforming iterator function.
+ * Standard-conforming iterator function.
*/
typename VECTOR::const_iterator end() const;
/**
* Declare the type as discussed above. Since we can't name it FunctionMap
* (as that would ambiguate a possible constructor of this class), name it
- * in the fashion of the STL local typedefs.
+ * in the fashion of the standard container local typedefs.
*/
typedef std::map<types::boundary_id, const Function<dim,Number>*> type;
};
const unsigned int n1);
/**
- * Need a partial ordering for the STL
+ * Need a partial ordering for sorting algorithms
*/
bool operator< (const CheapEdge &e2) const;
};
* quite inconvenient if one attempted to operate on it directly, since data
* is spread over quite a lot of arrays and other places. However, there are
* ways powerful enough to work on these data structures without knowing their
- * exact relations. This is done through the concept of iterators (see the STL
- * documentation and TriaIterator). In order to make things as easy and
- * dimension independent as possible, use of class local typedefs is made, see
- * below.
+ * exact relations. deal.II uses class local typedefs (see below) to make things
+ * as easy and dimension independent as possible.
*
- * The Triangulation class provides iterator which enable looping over all
- * cells without knowing the exact representation used to describe them. Their
- * names are typedefs imported from the Iterators class (thus making them
- * local types to this class) and are as follows:
+ * The Triangulation class provides iterators which enable looping over all
+ * cells without knowing the exact representation used to describe them. For
+ * more information see the documentation of <tt>TriaIterator</tt>. Their names
+ * are typedefs imported from the Iterators class (thus making them local types
+ * to this class) and are as follows:
*
* <ul>
* <li> <tt>cell_iterator</tt>: loop over all cells used in the Triangulation
* functions returning iterators. Take a look at the class doc to get an
* overview.
*
- * Usage of these iterators works mostly like with the STL iterators. Some
- * examples taken from the Triangulation source code follow (notice that in
- * the last two examples the template parameter @p spacedim has been omitted,
- * so it takes the default value <code>dim</code>).
+ * Usage of these iterators is similar to usage of standard container
+ * iterators. Some examples taken from the Triangulation source code follow
+ * (notice that in the last two examples the template parameter @p spacedim has
+ * been omitted, so it takes the default value <code>dim</code>).
+ *
* <ul>
* <li> <em>Counting the number of cells on a specific level</em>
* @code
* return n;
* };
* @endcode
- * Another way which uses the STL @p distance function would be to write
+ * Another way, which uses <tt>std::distance</tt>, would be to write
* @code
* template <int dim>
* int Triangulation<dim>::n_cells (const int level) const {
/**
- * This class implements an iterator, analogous to those of the standard
- * template library (STL). It fulfills the requirements of a bidirectional
- * iterator. See the C++ documentation for further details of iterator
- * specification and usage.
+ * This class implements an iterator, analogous to those used in the standard
+ * library. It fulfills the requirements of a bidirectional iterator. See the
+ * C++ documentation for further details of iterator specification and usage.
*
*
- * In addition to the STL iterators an iterator of this class provides a
+ * In addition to the standard interface, an iterator of this class provides a
* <tt>-@></tt> operator, i.e. you can write statements like
* @code
* i->set_refine_flag ();
* more functionality.
*
* Furthermore, the iterators described here satisfy the requirement of input
- * and bidirectional iterators as stated by the C++ standard and the STL
- * documentation. It is therefore possible to use the functions from the
- * algorithm section of the C++ standard, e.g. <em>count_if</em> (see the
- * documentation for Triangulation for an example) and several others.
+ * and bidirectional iterators as stated by the C++ standard. It is therefore
+ * possible to use the functions from the algorithm section of the C++ standard,
+ * e.g., <em>count_if</em> (see the documentation for Triangulation for an
+ * example) and several others.
*
* <h3>Implementation</h3>
*
typedef MatrixType BlockType;
/**
- * Type of matrix entries. In analogy to the STL container classes.
+ * Type of matrix entries. These are analogous to typedefs in the standard
+ * library containers.
*/
typedef typename BlockType::value_type value_type;
typedef value_type *pointer;
const bool alternative_output = false) const;
/**
- * STL-like iterator with the first entry.
+ * Iterator starting at the first entry.
*/
iterator begin ();
iterator end ();
/**
- * STL-like iterator with the first entry of row <tt>r</tt>.
+ * Iterator starting at the first entry of row <tt>r</tt>.
*/
iterator begin (const size_type r);
*/
iterator end (const size_type r);
/**
- * STL-like iterator with the first entry.
+ * Iterator starting at the first entry.
*/
const_iterator begin () const;
const_iterator end () const;
/**
- * STL-like iterator with the first entry of row <tt>r</tt>.
+ * Iterator starting at the first entry of row <tt>r</tt>.
*/
const_iterator begin (const size_type r) const;
/**
- * STL conforming iterator for constant and non-constant matrices.
+ * Iterator for constant and non-constant matrices.
*
* The first template argument denotes the underlying numeric type, the
* second the constness of the matrix.
typedef types::global_dof_index size_type;
/**
- * Type of matrix entries. In analogy to the STL container classes.
+ * Type of matrix entries. This typedef is analogous to <tt>value_type</tt> in
+ * the standard library containers.
*/
typedef number value_type;
typedef typename numbers::NumberTraits<number>::real_type real_type;
/**
- * Typedef of an STL conforming iterator class walking over all the nonzero
- * entries of this matrix. This iterator cannot change the values of the
- * matrix.
+ * Typedef of an iterator class walking over all the nonzero entries of this
+ * matrix. This iterator cannot change the values of the matrix.
*/
typedef
ChunkSparseMatrixIterators::Iterator<number,true>
const_iterator;
/**
- * Typedef of an STL conforming iterator class walking over all the nonzero
- * entries of this matrix. This iterator @em can change the values of the
- * matrix, but of course can't change the sparsity pattern as this is fixed
- * once a sparse matrix is attached to it.
+ * Typedef of an iterator class walking over all the nonzero entries of this
+ * matrix. This iterator @em can change the values of the matrix, but of
+ * course can't change the sparsity pattern as this is fixed once a sparse
+ * matrix is attached to it.
*/
typedef
ChunkSparseMatrixIterators::Iterator<number,false>
//@{
/**
- * STL-like iterator with the first entry of the matrix. This is the version
- * for constant matrices.
+ * Iterator starting at first entry of the matrix. This is the version for
+ * constant matrices.
*
* Note that due to the layout in ChunkSparseMatrix, iterating over matrix
* entries is considerably slower than for a sparse matrix, as the iterator
const_iterator end () const;
/**
- * STL-like iterator with the first entry of the matrix. This is the version
+ * Iterator starting at the first entry of the matrix. This is the version
* for non-constant matrices.
*
* Note that due to the layout in ChunkSparseMatrix, iterating over matrix
iterator end ();
/**
- * STL-like iterator with the first entry of row <tt>r</tt>. This is the
- * version for constant matrices.
+ * Iterator starting at the first entry of row <tt>r</tt>. This is the version
+ * for constant matrices.
*
* Note that if the given row is empty, i.e. does not contain any nonzero
* entries, then the iterator returned by this function equals
const_iterator end (const unsigned int r) const;
/**
- * STL-like iterator with the first entry of row <tt>r</tt>. This is the
- * version for non-constant matrices.
+ * Iterator starting at the first entry of row <tt>r</tt>. This is the version
+ * for non-constant matrices.
*
* Note that if the given row is empty, i.e. does not contain any nonzero
* entries, then the iterator returned by this function equals
/**
- * STL conforming iterator walking over the elements of a sparsity pattern.
+ * Iterator that walks over the elements of a sparsity pattern.
*/
class Iterator
{
* Copy constructor. This constructor is only allowed to be called if the
* matrix structure to be copied is empty. This is so in order to prevent
* involuntary copies of objects for temporaries, which can use large
- * amounts of computing time. However, copy constructors are needed if yo
- * want to use the STL data types on classes like this, e.g. to write such
+ * amounts of computing time. However, copy constructors are needed if one
+ * wants to place a ChunkSparsityPattern in a container, e.g., to write such
* statements like <tt>v.push_back (ChunkSparsityPattern());</tt>, with
* <tt>v</tt> a vector of ChunkSparsityPattern objects.
*
- * Usually, it is sufficient to use the explicit keyword to disallow
- * unwanted temporaries, but for the STL vectors, this does not work. Since
+ * Usually, it is sufficient to use the explicit keyword to disallow unwanted
+ * temporaries, but this does not work for <tt>std::vector</tt>. Since
* copying a structure like this is not useful anyway because multiple
* matrices can use the same sparsity structure, copies are only allowed for
* empty objects, as described above.
bool stores_only_added_elements () const;
/**
- * STL-like iterator with the first entry of the matrix. The resulting
- * iterator can be used to walk over all nonzero entries of the sparsity
- * pattern.
+ * Iterator starting at the first entry of the matrix. The resulting iterator
+ * can be used to walk over all nonzero entries of the sparsity pattern.
*/
iterator begin () const;
iterator end () const;
/**
- * STL-like iterator with the first entry of row <tt>r</tt>.
+ * Iterator starting at the first entry of row <tt>r</tt>.
*
* Note that if the given row is empty, i.e. does not contain any nonzero
* entries, then the iterator returned by this function equals
// so the first step is to create a sorted list of all row values that are
// possible. these values are either the rows from unconstrained dofs, or
// some indices introduced by dofs constrained to a combination of some
- // other dofs. regarding the data type, choose an STL vector of a pair of
- // unsigned ints (for global columns) and internal data (containing local
- // columns + possible jumps from constraints). Choosing an STL map or
- // anything else M.K. knows of would be much more expensive here!
+ // other dofs. regarding the data type, choose a <tt>std::vector</tt> of a
+ // pair of unsigned ints (for global columns) and internal data (containing
+ // local columns + possible jumps from constraints). Choosing
+ // <tt>std::map</tt> or anything else M.K. knows of would be much more
+ // expensive here!
// cache whether we have to resolve any indirect rows generated from
// resolving constrained dofs.
* sparsity structure to be copied is empty. This is so in order to prevent
* involuntary copies of objects for temporaries, which can use large
* amounts of computing time. However, copy constructors are needed if you
- * want to use the STL data types on classes like this, e.g. to write such
+ * want to place a DynamicSparsityPattern in a container, e.g. to write such
* statements like <tt>v.push_back (DynamicSparsityPattern());</tt>, with
* @p v a vector of @p DynamicSparsityPattern objects.
*/
// @{
/**
- * STL-like iterator with the first entry of the matrix. The resulting
+ * Iterator starting at the first entry of the matrix. The resulting
* iterator can be used to walk over all nonzero entries of the sparsity
* pattern.
*
iterator end () const;
/**
- * STL-like iterator with the first entry of row <tt>r</tt>.
+ * Iterator starting at the first entry of row <tt>r</tt>.
*
* Note that if the given row is empty, i.e. does not contain any nonzero
* entries, then the iterator returned by this function equals
};
/**
- * STL conforming iterator.
+ * Standard-conforming iterator.
*/
class const_iterator
{
typedef unsigned int size_type;
/**
- * Type of matrix entries. In analogy to the STL container classes.
+ * Type of matrix entries. This typedef is analogous to <tt>value_type</tt> in
+ * the standard library containers.
*/
typedef number value_type;
};
/**
- * STL conforming iterator.
+ * Standard-conforming iterator.
*/
class const_iterator
{
//@{
/**
- * STL-like iterator with the first entry.
+ * Iterator starting at the first entry.
*/
const_iterator begin () const;
const_iterator end () const;
/**
- * STL-like iterator with the first entry of row <tt>r</tt>.
+ * Iterator starting at the first entry of row <tt>r</tt>.
*/
const_iterator begin (const size_type r) const;
DEAL_II_NAMESPACE_OPEN
/**
- * STL conforming iterator for constant and non-constant matrices.
+ * Iterator for constant and non-constant matrices.
*
* This iterator is abstracted from the actual matrix type and can be used for
* any matrix having the required ACCESSOR type.
namespace MatrixIterators
{
/**
- * STL conforming iterator. This class acts as an iterator walking over
- * the elements of PETSc matrices. Since PETSc offers a uniform interface
- * for all types of matrices, this iterator can be used to access both
- * sparse and full matrices.
+ * This class acts as an iterator walking over the elements of PETSc
+ * matrices. Since PETSc offers a uniform interface for all types of
+ * matrices, this iterator can be used to access both sparse and full
+ * matrices.
*
* Note that PETSc does not give any guarantees as to the order of
* elements within each row. Note also that accessing the elements of a
const VectorBase &b) const;
/**
- * STL-like iterator with the first entry.
+ * Iterator starting at the first entry.
*/
const_iterator begin () const;
const_iterator end () const;
/**
- * STL-like iterator with the first entry of row @p r.
+ * Iterator starting at the first entry of row @p r.
*
* Note that if the given row is empty, i.e. does not contain any nonzero
* entries, then the iterator returned by this function equals
typedef types::global_dof_index size_type;
/**
- * STL conforming iterator.
+ * Standard-conforming iterator.
*/
class const_iterator
{
void Tstep (Vector<number2> &dst, const Vector<number2> &rhs) const;
/**
- * STL-like iterator with the first entry.
+ * Iterator starting at the first entry.
*/
const_iterator begin () const;
const_iterator end () const;
/**
- * STL-like iterator with the first entry of row @p r.
+ * Iterator starting at the first entry of row @p r.
*/
const_iterator begin (const size_type r) const;
/**
- * STL conforming iterator for constant and non-constant matrices.
+ * Iterator for constant and non-constant matrices.
*
* The typical use for these iterators is to iterate over the elements of a
* sparse matrix or over the elements of individual rows. Note that there is
typedef types::global_dof_index size_type;
/**
- * Type of matrix entries. In analogy to the STL container classes.
+ * Type of the matrix entries. This typedef is analogous to
+ * <tt>value_type</tt> in the standard library containers.
*/
typedef number value_type;
typedef typename numbers::NumberTraits<number>::real_type real_type;
/**
- * Typedef of an STL conforming iterator class walking over all the nonzero
- * entries of this matrix. This iterator cannot change the values of the
- * matrix.
+ * Typedef of an iterator class walking over all the nonzero entries of this
+ * matrix. This iterator cannot change the values of the matrix.
*/
typedef
SparseMatrixIterators::Iterator<number,true>
const_iterator;
/**
- * Typedef of an STL conforming iterator class walking over all the nonzero
- * entries of this matrix. This iterator @em can change the values of the
- * matrix, but of course can't change the sparsity pattern as this is fixed
- * once a sparse matrix is attached to it.
+ * Typedef of an iterator class walking over all the nonzero entries of this
+ * matrix. This iterator @em can change the values of the matrix, but of
+ * course can't change the sparsity pattern as this is fixed once a sparse
+ * matrix is attached to it.
*/
typedef
SparseMatrixIterators::Iterator<number,false>
public:
/**
- * STL conforming iterator.
+ * Standard-conforming iterator.
*/
class const_iterator
{
};
/**
- * Type of matrix entries. In analogy to the STL container classes.
+ * Type of matrix entries. This typedef is analogous to <tt>value_type</tt> in
+ * the standard library containers.
*/
typedef number value_type;
*/
//@{
/**
- * STL-like iterator with the first existing entry.
+ * Iterator starting at the first existing entry.
*/
const_iterator begin () const;
const_iterator end () const;
/**
- * STL-like iterator with the first entry of row @p r. If this row is empty,
- * the result is <tt>end(r)</tt>, which does NOT point into row @p r..
+ * Iterator starting at the first entry of row @p r. If this row is empty, the
+ * result is <tt>end(r)</tt>, which does NOT point into row @p r.
*/
const_iterator begin (const size_type r) const;
* Copy constructor. This constructor is only allowed to be called if the
* matrix structure to be copied is empty. This is so in order to prevent
* involuntary copies of objects for temporaries, which can use large
- * amounts of computing time. However, copy constructors are needed if yo
- * want to use the STL data types on classes like this, e.g. to write such
+ * amounts of computing time. However, copy constructors are needed if one
+ * wants to place a SparsityPattern in a container, e.g., to write such
* statements like <tt>v.push_back (SparsityPattern());</tt>, with
* <tt>v</tt> a vector of SparsityPattern objects.
*
- * Usually, it is sufficient to use the explicit keyword to disallow
- * unwanted temporaries, but for the STL vectors, this does not work. Since
+ * Usually, it is sufficient to use the explicit keyword to disallow unwanted
+ * temporaries, but this does not work for <tt>std::vector</tt>s. Since
* copying a structure like this is not useful anyway because multiple
* matrices can use the same sparsity structure, copies are only allowed for
* empty objects, as described above.
// @{
/**
- * STL-like iterator with the first entry of the matrix. The resulting
+ * Iterator starting at the first entry of the matrix. The resulting
* iterator can be used to walk over all nonzero entries of the sparsity
* pattern.
*
iterator end () const;
/**
- * STL-like iterator with the first entry of row <tt>r</tt>.
+ * Iterator starting at the first entry of row <tt>r</tt>.
*
* Note that if the given row is empty, i.e. does not contain any nonzero
* entries, then the iterator returned by this function equals
};
/**
- * STL conforming iterator. This class acts as an iterator walking over
- * the elements of Trilinos matrices. The implementation of this class is
- * similar to the one for PETSc matrices.
+ * This class acts as an iterator walking over the elements of Trilinos
+ * matrices. The implementation of this class is similar to the one for
+ * PETSc matrices.
*
* Note that Trilinos stores the elements within each row in ascending
* order. This is opposed to the deal.II sparse matrix style where the
//@{
/**
- * STL-like iterator with the first entry.
+ * Iterator starting at the first entry.
*/
const_iterator begin () const;
const_iterator end () const;
/**
- * STL-like iterator with the first entry of row @p r.
+ * Iterator starting at the first entry of row @p r.
*
* Note that if the given row is empty, i.e. does not contain any nonzero
* entries, then the iterator returned by this function equals
* Copy-constructor. Sets the dimension to that of the given vector, and
* copies all elements.
*
- * We would like to make this constructor explicit, but STL insists on using
- * it implicitly.
+ * We would like to make this constructor explicit, but standard containers
+ * insist on using it implicitly.
*/
Vector (const Vector<Number> &v);
* waste some memory, so keep this in mind. However, if <tt>N==0</tt> all
* memory is freed, i.e. if you want to resize the vector and release the
* memory not needed, you have to first call <tt>reinit(0)</tt> and then
- * <tt>reinit(N)</tt>. This cited behaviour is analogous to that of the STL
- * containers.
+ * <tt>reinit(N)</tt>. This cited behaviour is analogous to that of the
+ * standard library containers.
*
* If @p fast is false, the vector is filled by zeros. Otherwise, the
* elements are left an unspecified state.
namespace
{
/**
- * Sorts the vector @p ind as an
- * index vector of @p a in
- * increasing order. This
- * implementation of quicksort
- * seems to be faster than the
- * STL version and is needed in
- * @p refine_and_coarsen_optimize
+ * Sorts the vector @p ind as an index vector of @p a in increasing order.
+ * This implementation of quicksort seems to be faster than the standard
+ * library version and is needed in @p refine_and_coarsen_optimize.
*/
template <class Vector>