* second component and so forth. If this
* function is also time dependent, then
* it is necessary to specify it by
- * setting the #time_dependent parameter
+ * setting the <tt>time_dependent</tt> parameter
* to true. An exception is thrown if
* the number of variables specified here
* is different from dim (if this
* This class contains as static members information on vertices and
* faces of a @p dim-dimensional grid cell. The interface is the same
* for all dimensions. If a value is of no use in a low dimensional
- * cell, it is (correctly) set to zero, e.g. #subfaces_per_cell in
+ * cell, it is (correctly) set to zero, e.g. #subfaces_per_face in
* 1d.
*
* This information should always replace hard-coded numbers of
* of the mesh cells.
*
* @ingroup grid
- * @ref Instantiations: few (dim = 1,2,3,4 and a specialization for dim=0)
+ * @ref Instantiations few (dim = 1,2,3,4 and a specialization for dim=0)
* @author Wolfgang Bangerth, 1998, Ralf Hartmann, 2005
*/
template <int dim>
/* -------------- declaration of explicit specializations ------------- */
-
+#ifndef DOXYGEN
template <>
inline
(p[2] >= 0.) && (p[2] <= 1.);
}
-
+#endif // DOXYGEN
#endif
// now comes the implementation of these functions
-/// @if NoDoc
-
namespace MemoryConsumption
{
inline
}
}
-/// @endif
#endif
* machine, please refer to the
* documentation in
* <tt>multithread_info.cc</tt>
- * near to the #error directive.
+ * near to the <tt>error</tt> directive.
*/
const unsigned int n_cpus;
/*------------------------------- Inline functions: Point ---------------------------*/
+#ifndef DOXYGEN
template <int dim>
inline
return (Point<dim>(*this) /= factor);
}
+#endif // DOXYGEN
/*------------------------------- Global functions: Point ---------------------------*/
/**
* Global operator scaling a point vector by a scalar.
+ * @relates Point
*/
template <int dim>
inline
/**
* Output operator for points. Print the elements consecutively,
* with a space in between.
+ * @relates Point
*/
template <int dim>
inline
/**
* Output operator for points. Print the elements consecutively,
* with a space in between.
+ * @relates Point
*/
template <int dim>
inline
}
+#ifndef DOXYGEN
/**
* Output operator for points of dimension 1. This is implemented
return out;
}
+#endif // DOXYGEN
+
#endif
std::vector<unsigned int> index_map_inverse;
};
-/// @if NoDoc
/* -------------- declaration of explicit specializations --- */
-/// @endif
-
#endif
/*@}*/
-/// @if NoDoc
/* -------------- declaration of explicit specializations ------------- */
+#ifndef DOXYGEN
+
template <>
void
QProjector<1>::project_to_face (const Quadrature<0> &,
const unsigned int n_copies);
-/// @endif
+#endif // DOXYGEN
#endif
* necessary to provide a class Point@<0@> to make the compiler
* happy. This class also does nothing.
*
- * @ref Instantiations: few
+ * @ref Instantiations few
*
* @author Wolfgang Bangerth, Guido Kanschat, 1998, 1999, 2000, 2005
*/
/*@}*/
-/// @if NoDoc
+#ifndef DOXYGEN
/* -------------- declaration of explicit specializations ------------- */
template <>
const std::vector<double> & Quadrature<0>::get_weights () const;
-/// @endif
+#endif // DOXYGEN
#endif
* Standard constructor for null
* pointer. @deprecated Since
* this constructor will leave
- * #id empty, it should be
+ * SmartPointer::id empty, it should be
* avoided wherever possible and
* replaced by SmartPointer(0,id).
*/
// ------------------------- inline functions ------------------------
-///@if NoDoc
+#ifndef DOXYGEN
namespace internal
{
return std::sqrt(t);
}
-///@endif
+#endif // DOXYGEN
/* ----------------- Non-member functions operating on tensors. ------------ */
};
-///@if NoDoc
+
/* --------------------- Template and inline functions ---------------- */
+#ifndef DOXYGEN
template <int N, typename T>
TableBase<N,T>::TableBase ()
*this->table_size[6] + o];
}
-///@endif
+#endif // DOXYGEN
#endif
/*--------------------------- Inline functions -----------------------------*/
-/// @if NoDoc
+#ifndef DOXYGEN
template <int rank_, int dim>
inline
return sizeof(Tensor<rank_,dim>);
}
-/// @endif
+#endif // DOXYGEN
/* ----------------- Non-member functions operating on tensors. ------------ */
return out;
}
+#ifndef DOXYGEN
/**
* Specialization for 1D.
return out;
}
+#endif // DOXYGEN
/**
return tt;
}
-/// @if NoDoc
+#ifndef DOXYGEN
/**
* Return the transpose of the given tensor. This is the
return Tensor<2,3>(x);
}
-/// @endif
+#endif // DOXYGEN
/**
template <int dim>
std::ostream & operator << (std::ostream &out, const Tensor<1,dim> &p);
-/// @if NoDoc
+#ifndef DOXYGEN
/*------------------------------- Inline functions: Tensor ---------------------------*/
return tt;
}
-/// @endif
+#endif // DOXYGEN
#endif
unsigned int x_to_the_dim (const unsigned int x);
};
-/// @if NoDoc
+#ifndef DOXYGEN
template <int dim>
inline
}
-/// @endif
+#endif // DOXYGEN
/**
};
-/// @if NoDoc
+#ifndef DOXYGEN
/* -------------- declaration of explicit specializations --- */
AnisotropicPolynomials<3>::compute_index(const unsigned int n,
unsigned int (&index)[3]) const;
-/// @endif
+#endif // DOXYGEN
#endif
} // end declarations of namespace Threads
/* ----------- implementation of functions in namespace Threads ---------- */
-/// @if NoDoc
+#ifndef DOXYGEN
namespace Threads
{
template <typename ForwardIterator>
}
}
-///@endif
+#endif // DOXYGEN
namespace Threads
{
{
/**
- * Convert a number #i to a string, with
+ * Convert a number @p i to a string, with
* as many digits as given to fill with
* leading zeros.
*/
/**
* Given a string that contains text
- * separated by a #delimiter, split it into
+ * separated by a @p delimiter, split it into
* its components; for each component,
* remove leading and trailing spaces.
*
/**
* Generate a random number from a
* normalized Gaussian probability
- * distribution centered around #a and
- * with standard deviation #sigma.
+ * distribution centered around @p a and
+ * with standard deviation @p sigma.
*/
double
generate_normal_random_number (const double a,
* using the same interface as
* <tt>std::vector</tt>.
*/
- typename VECTOR::reference operator[] (unsigned int);
+ typename VECTOR::reference operator[] (unsigned int i);
/**
* Access an element of a
* interface as
* <tt>std::vector</tt>.
*/
- typename VECTOR::const_reference operator[] (unsigned int) const;
+ typename VECTOR::const_reference operator[] (unsigned int i) const;
private:
/**
* The vector we extract from.
/**
- * Define some types which differ between the dimensions. This class
- * is analogous to the TriaDimensionInfo class hierarchy.
+ * Define some types which differ between the dimensions.
*
* @ref DoFDimensionInfo<1>
* @ref DoFDimensionInfo<2>
+ * @ref DoFDimensionInfo<3>
*
* @ingroup dofs
* @author Wolfgang Bangerth, 1998
/**
* Define some types for the DoF handling in one dimension.
*
- * The types have the same meaning as those declared in TriaDimensionInfo<2>.
- *
* @ingroup dofs
* @author Wolfgang Bangerth, 1998
*/
/**
* Define some types for the DoF handling in two dimensions.
*
- * The types have the same meaning as those declared in TriaDimensionInfo<2>.
- *
* @ingroup dofs
* @author Wolfgang Bangerth, 1998
*/
/**
* Define some types for the DoF handling in two dimensions.
*
- * The types have the same meaning as those declared in TriaDimensionInfo<3>.
- *
* @ingroup dofs
* @author Wolfgang Bangerth, 1998
*/
* indices of degrees of freedom on different parts may be intermixed.
*
* Degrees of freedom on the boundary but not on one of the specified
- * boundary parts are given the index #invalid_dof_index, as if
+ * boundary parts are given the index DoFHandler::invalid_dof_index, as if
* they were in the interior. If no boundary indicator was given or if
* no face of a cell has a boundary indicator contained in the given
* list, the vector of new indices consists solely of
- * #invalid_dof_index.
+ * DoFHandler::invalid_dof_index.
*
* The question what a degree of freedom on the boundary is, is not so
* easy. It should really be a degree of freedom of which the
* @deprecated This is the old
* form of the previous
* function. It generates a table
- * of #Coupling values and calls
+ * of DoFTools::Coupling values and calls
* it.
*/
template <int dim, class SparsityPattern>
};
/* @} */
-/// @if NoDoc
+#ifndef DOXYGEN
// declaration of explicit specializations of member variables, if the
const unsigned int FE_DGP<3>::Matrices::n_projection_matrices;
#endif
-/// @endif
+#endif // DOXYGEN
#endif
/*@}*/
-/// @if NoDoc
+#ifndef DOXYGEN
// declaration of explicit specializations of member variables, if the
// compiler allows us to do that (the standard says we must)
const unsigned int FE_DGPNonparametric<3>::Matrices::n_projection_matrices;
#endif
-/// @endif
+#endif // DOXYGEN
#endif
/*@}*/
-/// @if NoDoc
+#ifndef DOXYGEN
/* -------------- declaration of explicit specializations ------------- */
const unsigned int FE_Nedelec<3>::Matrices::n_constraint_matrices;
#endif
-/// @endif
+#endif // DOXYGEN
#endif
/* -------------- declaration of explicit specializations ------------- */
-/// @if NoDoc
+#ifndef DOXYGEN
template <>
void FE_RaviartThomas<1>::initialize_unit_face_support_points ();
get_interpolation_matrix (const FiniteElement<1> &,
FullMatrix<double> &) const;
-/// @endif
+#endif // DOXYGEN
#endif
/*@}*/
-///@if NoDoc
+#ifndef DOXYGEN
/*------------------------ Inline functions: FEValuesBase ------------------------*/
return this->boundary_forms[i];
}
-///@endif
+#endif // DOXYGEN
#endif
/* -------------- declaration of explicit specializations ------------- */
-/// @if NoDoc
+#ifndef DOXYGEN
template <> void MappingC1<1>::add_line_support_points (
const Triangulation<1>::cell_iterator &,
std::vector<Point<2> > &) const;
-/// @endif
+#endif // DOXYGEN
#endif
/* -------------- declaration of explicit specializations ------------- */
-/// @if NoDoc
+#ifndef DOXYGEN
template <> void MappingCartesian<1>::fill_fe_face_values (
const Triangulation<1>::cell_iterator &,
std::vector<Tensor<1,1> >&,
std::vector<Point<1> >&) const;
-/// @endif
+#endif // DOXYGEN
#endif
/* -------------- declaration of explicit specializations ------------- */
-/// @if NoDoc
+#ifndef DOXYGEN
template<> MappingQ<1>::MappingQ (const unsigned int);
template<> MappingQ<1>::~MappingQ ();
const Triangulation<3>::cell_iterator &cell,
std::vector<Point<3> > &a) const;
-/// @endif
+#endif // DOXYGEN
#endif
/* -------------- declaration of explicit specializations ------------- */
-/// @if NoDoc
+#ifndef DOXYGEN
// declaration of explicit specializations of member variables, if the
// compiler allows us to do that (the standard says we must)
std::vector<Tensor<1,1> >&,
std::vector<Point<1> >&) const;
-/// @endif
+#endif // DOXYGEN
#endif
/* -------------- declaration of explicit specializations ------------- */
-/// @if NoDoc
+#ifndef DOXYGEN
template <>
void
const std::vector<Point<3> > &vertices,
std::ostream &out);
-/// @endif
+#endif // DOXYGEN
#endif
/*------------------------------------------------------------------------*/
+//TODO:[WB] remove reference to non-existing TriaDimensionInfo
/**
* Structure which is passed to the
/* -------------- declaration of explicit specializations ------------- */
-/// @if NoDoc
+#ifndef DOXYGEN
template <> Triangulation<1>::cell_iterator Triangulation<1>::begin (const unsigned int level) const;
template <> Triangulation<1>::raw_cell_iterator Triangulation<1>::end () const;
template <> void Triangulation<1>::update_number_cache_hexes ();
template <> void Triangulation<2>::update_number_cache_hexes ();
-/// @endif
+#endif // DOXYGEN
#endif
/* -------------- declaration of explicit specializations ------------- */
-/// @if NoDoc
+#ifndef DOXYGEN
template <> Point<2> TriaObjectAccessor<2, 2>::barycenter () const;
template <> Point<3> TriaObjectAccessor<2, 3>::barycenter () const;
// include more templates in debug and optimized mode
# include "tria_accessor.templates.h"
-/// @endif
+#endif // DOXYGEN
#endif
/* -------------- declaration of explicit specializations ------------- */
-/// @if NoDoc
+#ifndef DOXYGEN
template <>
void
get_intermediate_points_on_quad (const Triangulation<3>::quad_iterator &quad,
std::vector<Point<3> > &points) const;
-/// @endif
+#endif // DOXYGEN
#endif
/* -------------- declaration of explicit specializations ------------- */
-/// @if NoDoc
+#ifndef DOXYGEN
template <>
Point<1>
get_normals_at_vertices (const Triangulation<1>::face_iterator &,
Boundary<1>::FaceVertexNormals &) const;
-/// @endif
+#endif // DOXYGEN
#endif
* and the state of the element pointed to.
*
* Past-the-end iterators may also be used to compare an iterator with the
- * @em{before-the-start} value, when running backwards. There is no
+ * <i>before-the-start</i> value, when running backwards. There is no
* distiction between the iterators pointing past the two ends of a vector.
*
* By defining only one value to be past-the-end and making all other values
* earlier than for past-the-end iterators an exception is raised.
*
* @ref Triangulation
- * @ref TriaDimensionInfo<1>
- * @ref TriaDimensionInfo<2>
- * @ref TriaDimensionInfo<3>
* @ingroup grid
* @ingroup Iterators
* @author Wolfgang Bangerth, 1998
//---------------------------------------------------------------------------
+#ifndef DOXYGEN
+
template <class MATRIX, class RELAX, typename number>
inline
MGSmootherBlock<MATRIX, RELAX, number>::MGSmootherBlock(
deallog.pop();
}
-
+#endif // DOXYGEN
#endif
/*@}*/
-/// @if NoDoc
+#ifndef DOXYGEN
/* ------------------ Functions for MGCoarseGridLACIteration ------------ */
work.least_squares(dst, aux);
}
-/// @endif
+#endif // DOXYGEN
#endif
/* ------------------------------- Inline functions -------------------------- */
+#ifndef DOXYGEN
+
template <class VECTOR>
inline void
MGSmootherIdentity<VECTOR>::smooth (
}
+#endif // DOXYGEN
#endif
/*@}*/
-/// @if NoDoc
+#ifndef DOXYGEN
/* --------------------------- inline functions --------------------- */
Assert(false, ExcNotImplemented());
}
-/// @endif
+#endif // DOXYGEN
#endif
* globally to avoid allocation
* of memory in the threads.
*
- * The #index_to_patch_map is
+ * The #cell_to_patch_index_map is
* an array that stores for index
* <tt>[i][j]</tt> the number of the
* patch that associated with the
* if access to an object describing the exact form of the boundary is needed, the
* pointer stored within the triangulation object is accessed.
*
- * @ref Instantiations: some (Vector<float>, Vector<double>, BlockVector<float>, BlockVector<double>, see also individual functions)
+ * @ref Instantiations : some (Vector<float>, Vector<double>, BlockVector<float>, BlockVector<double>, see also individual functions)
* @author Wolfgang Bangerth, Ralf Hartmann, Guido Kanschat, 1998, 1999, 2000, 2001
*/
class VectorTools
* make the result continuous
* again.
*
- * @ref Instantiations: some (the
+ * @ref Instantiations : some (the
* standard vector types
* mentioned in the class
* documentation are
/**
* Compute the projection of
- * @function to the finite element space.
+ * @p function to the finite element space.
*
* By default, projection to the boundary
* and enforcement of zero boundary values
* matrix of the finite element
* space on the present grid. To
* this end, the mass matrix is
- * assembled exactly using the
- * @p create_mass_matrix
- * function in the
- * MatrixTools
- * collection. This function
- * performs numerical quadrature
- * using the given quadrature
- * rule; you should therefore
- * make sure that the given
- * quadrature formula is also
- * sufficient for the integration
- * of the mass matrix.
+ * assembled exactly using
+ * MatrixTools::create_mass_matrix. This
+ * function performs numerical
+ * quadrature using the given
+ * quadrature rule; you should
+ * therefore make sure that the
+ * given quadrature formula is
+ * also sufficient for the
+ * integration of the mass
+ * matrix.
*
* See the general documentation of this
* class for further information.
* See the general documentation of this
* class for more information.
*
- * @ref Instantiations: some
+ * @ref Instantiations : some
* (InVectors as in the
* documentation of the class,
* OutVector only Vector<double>
/*@}*/
-///@if NoDoc
+#ifndef DOXYGEN
//---------------------------------------------------------------------------
template <typename number>
-///@endif
+#endif // DOXYGEN
#endif
* you attempt anyway, you will likely get a number of compiler
* errors.
*
- * @ref Instantiations: some (<tt>@<float@> @<double@></tt>).
+ * @ref Instantiations : some (<tt>@<float@> @<double@></tt>).
* @author Wolfgang Bangerth, 2000, 2004
*/
template <typename MatrixType>
* allocation of vectors and provides functions that are specific to the
* underlying vector type.
*
- * @ref Instantiations: some (<tt>@<float@> @<double@></tt>)
+ * @ref Instantiations : some (<tt>@<float@> @<double@></tt>)
*
* @author Wolfgang Bangerth, Guido Kanschat, 1999, 2000, 2001, 2002, 2004
*/
/*@}*/
-/// @if NoDoc
+#ifndef DOXYGEN
/*----------------------- Inline functions ----------------------------------*/
BaseClass::scale (v);
}
-///@endif
+#endif // DOXYGEN
/*! @addtogroup Vectors
/*----------------------- Inline functions ----------------------------------*/
-///@if NoDoc
+#ifndef DOXYGEN
namespace internal
{
namespace BlockVectorIterators
return components[local_index.first](local_index.second);
}
-///@endif
+#endif // DOXYGEN
#endif
* vector argument to functions. If there is no argument with a number
* type, the matrix number type is used.
*
- * @ref Instantiations: some (<tt>@<float@> @<double@></tt>)
+ * @ref Instantiations : some (<tt>@<float@> @<double@></tt>)
*
* @author Guido Kanschat, Franz-Theo Suttmeier, Wolfgang Bangerth, 1993-2004
*/
/**
* @deprecated Old name for
- * frobenius_norm().
+ * FullMatrix::frobenius_norm().
*/
number norm2 () const;
/*@}*/
-/// @if NoDoc
+#ifndef DOXYGEN
/*-------------------------Inline functions -------------------------------*/
return const_iterator(this, r+1, 0);
}
-///@endif
+#endif // DOXYGEN
#endif
* compute the vector <i>x</i> minimizing <i>||Ax-b||</i> for a given
* vector <i>b</i>.
*
- * @ref Instantiations: some (<tt>@<float@> @<double@></tt>)
+ * @ref Instantiations : some (<tt>@<float@> @<double@></tt>)
*
* @author Guido Kanschat, 2005
*/
/*@}*/
-/// @if NoDoc
+#ifndef DOXYGEN
/*-------------------------Inline functions -------------------------------*/
// QR-transformation cf. Stoer 1 4.8.2 (p. 191)
-///@endif
+#endif // DOXYGEN
#endif
* vmult_add() and Tvmult_add() start the iteration with a zero
* vector.
*
- * @ref Instantiations: some (Vector<float>, Vector<double>, BlockVector<float>, BlockVector<double>)
+ * @ref Instantiations : some (Vector<float>, Vector<double>, BlockVector<float>, BlockVector<double>)
* @author Guido Kanschat, 2005
*/
template<class VECTOR>
-/// @if NoDoc
+#ifndef DOXYGEN
// -------------------------- inline and template functions ----------------------
(index < static_cast<unsigned int>(end)));
}
-/// @endif
+#endif // DOXYGEN
}
};
-/// @if NoDoc
+#ifndef DOXYGEN
// ------------------ template and inline functions -------------
return communicator;
}
-/// @endif
+#endif // DOXYGEN
}
}
};
-/// @if NoDoc
+#ifndef DOXYGEN
// ------------------ template and inline functions -------------
return *this;
}
-/// @endif
+#endif // DOXYGEN
}
u.swap (v);
}
-///@if NoDoc
+#ifndef DOXYGEN
namespace internal
{
inline
}
-///@endif
+#endif // DOXYGEN
}
#endif // DEAL_II_USE_PETSC
/**
* Preconditioning with Richardson's method. This preconditioner just
* scales the vector with a constant relaxation factor provided by the
- * #AdditionalData object.
+ * AdditionalData object.
*
* In Krylov-space methods, this preconditioner should not have any
* effect. Using SolverRichardson, the two relaxation parameters will
* Block Jacobi preconditioning.
* See PreconditionBlock for requirements on the matrix.
*
- * @ref Instantiations: some (SparseMatrix<double>, SparseMatrix<float>, <tt>double</tt>, <tt>float</tt>)
+ * @ref Instantiations : some (SparseMatrix<double>, SparseMatrix<float>, <tt>double</tt>, <tt>float</tt>)
* @author Ralf Hartmann, Guido Kanschat, 1999, 2000, 2003
*/
template<class MATRIX, typename inverse_type = typename MATRIX::value_type>
* arbitrarily.
*
* See PreconditionBlock for requirements on the matrix.
- * @ref Instantiations: some (SparseMatrix<double>, SparseMatrix<float>, <tt>double</tt>, <tt>float</tt>)
+ * @ref Instantiations : some (SparseMatrix<double>, SparseMatrix<float>, <tt>double</tt>, <tt>float</tt>)
* @author Ralf Hartmann, Guido Kanschat, 1999, 2000, 2001, 2002, 2003
*/
template<class MATRIX, typename inverse_type = typename MATRIX::value_type>
* class requires storage of the diagonal blocks and their inverses.
*
* See PreconditionBlock for requirements on the matrix.
- * @ref Instantiations: some (SparseMatrix<double>, SparseMatrix<float>, <tt>double</tt>, <tt>float</tt>)
+ * @ref Instantiations : some (SparseMatrix<double>, SparseMatrix<float>, <tt>double</tt>, <tt>float</tt>)
* @author Ralf Hartmann, Guido Kanschat, 1999, 2000
*/
template<class MATRIX, typename inverse_type = typename MATRIX::value_type>
/*@}*/
/*-------------------------Inline functions -------------------------------*/
+#ifndef DOXYGEN
+
template<class VECTOR>
SolverBicgstab<VECTOR>::SolverBicgstab (SolverControl &cn,
VectorMemory<VECTOR> &mem,
// otherwise exit as normal
}
+#endif // DOXYGEN
#endif
/*------------------------- Implementation ----------------------------*/
-
+#ifndef DOXYGEN
template <class VECTOR>
inline
// otherwise exit as normal
}
+#endif // DOXYGEN
+
#endif
/*@}*/
//---------------------------------------------------------------------------
+#ifndef DOXYGEN
inline unsigned int
SolverControl::max_steps () const
return old;
}
+#endif // DOXYGEN
+
#endif
/*@}*/
/*------------------------- Implementation ----------------------------*/
+#ifndef DOXYGEN
template<class VECTOR>
SolverMinRes<VECTOR>::SolverMinRes (SolverControl &cn,
// otherwise exit as normal
}
+#endif // DOXYGEN
#endif
/*@}*/
/*------------------------- Implementation ----------------------------*/
+#ifndef DOXYGEN
template<class VECTOR>
SolverQMRS<VECTOR>::SolverQMRS(SolverControl &cn,
return false;
}
+#endif // DOXYGEN
#endif
/*@}*/
/*----------------- Implementation of the Richardson Method ------------------*/
-
+#ifndef DOXYGEN
template <class VECTOR>
inline
additional_data.omega=om;
}
+#endif // DOXYGEN
#endif
/*@}*/
//---------------------------------------------------------------------------
+#ifndef DOXYGEN
+
template <typename number>
inline number
SparseLUDecomposition<number>::
{}
+#endif // DOXYGEN
+
#endif // __deal2__sparse_decomposition_h
* Refer to SparseLUDecomposition documentation for suggested
* usage and state management.
*
- * @ref Instantiations: some (float, double)
+ * @ref Instantiations : some (float, double)
* @author Wolfgang Bangerth, 1999, based on a similar implementation
* by Malte Braack; unified interface: Ralf Hartmann
*/
/*@}*/
-/// @if NoDoc
+#ifndef DOXYGEN
/*---------------------- Inline functions -----------------------------------*/
return end();
}
-/// @endif
+#endif // DOXYGEN
/*---------------------------- sparse_matrix.h ---------------------------*/
const unsigned int end = r.start + r.length;
unsigned int i = r.start;
+ // If diagonal exists and this
+ // column is higher, start only
+ // after diagonal.
if (r.diagonal != RowInfo::invalid_diagonal && col >= row)
i += r.diagonal;
// Find position of entry
// If no more space is available
// for this row, insert new
// elements into the vector.
+//TODO:[GK] We should not extend this row if i<end
if (row != row_info.size()-1)
{
if (end >= row_info[row+1].start)
* whether this might pose some problems in the inversion of the local matrices.
* Maybe someone would like to check this.
*
- * @ref Instantiations: some (float, double)
+ * @ref Instantiations : some (float, double)
* @author Guido Kanschat, Wolfgang Bangerth; 1999, 2000
*/
template<typename number>
/*@}*/
/*---------------------- Inline functions -----------------------------------*/
-/// @if NoDoc
+#ifndef DOXYGEN
namespace internals
}
-/// @endif
+#endif // DOXYGEN
#endif
* @p reload is called. If it is not available, @p reload waits until
* the detached thread has loaded the data.
*
- * @ref Instantiations: some (<tt>@<float@> @<double@></tt>)
+ * @ref Instantiations : some (<tt>@<float@> @<double@></tt>)
* @author Wolfgang Bangerth, 1999, 2000
*/
template <typename number>
};
//---------------------------------------------------------------------------
-///@if NoDoc
+#ifndef DOXYGEN
template<typename number>
unsigned int
}
-///@endif
+#endif // DOXYGEN
#endif
* @p vector (with a lowercase "v"), this class implements an element
* of a vector space suitable for numerical computations.
*
- * @ref Instantiations: some (<tt>@<float@> @<double@></tt>)
+ * @ref Instantiations : some (<tt>@<float@> @<double@></tt>)
* @author Guido Kanschat, Franz-Theo Suttmeier, Wolfgang Bangerth
*/
template <typename Number>
/*@}*/
-/// @if NoDoc
+#ifndef DOXYGEN
/* --------------------- inline functions ---------------------- */
return result;
}
-///@endif
+#endif // DOXYGEN
#endif
projects / dealii-svn.git / commitdiff