*/
template <typename T>
LogStream & operator << (const T &t);
-
+
/**
* Output a function. This really is not
* to output the function, but calls the
template <int dim>
inline
-int DoFObjectAccessor<1, dim>::dof_index (const unsigned int i) const {
+int DoFObjectAccessor<1,dim>::dof_index (const unsigned int i) const {
Assert (dof_handler != 0, ExcInvalidObject());
// make sure a FE has been selected
// and enough room was reserved
template <int dim>
inline
-int DoFObjectAccessor<1, dim>::vertex_dof_index (const unsigned int vertex,
+int DoFObjectAccessor<1,dim>::vertex_dof_index (const unsigned int vertex,
const unsigned int i) const {
Assert (dof_handler != 0, ExcInvalidObject());
Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
template <int dim>
inline
void
-DoFObjectAccessor<1, dim>::get_dof_indices (vector<int> &dof_indices) const {
+DoFObjectAccessor<1,dim>::get_dof_indices (vector<int> &dof_indices) const {
Assert (dof_handler != 0, ExcInvalidObject());
Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
Assert (dof_indices.size() == (2*dof_handler->get_fe().dofs_per_vertex +
template <int dim>
inline
-TriaIterator<dim,DoFObjectAccessor<1, dim> >
-DoFObjectAccessor<1, dim>::child (const unsigned int i) const {
- TriaIterator<dim,DoFObjectAccessor<1, dim> > q (tria,
+TriaIterator<dim,DoFObjectAccessor<1,dim> >
+DoFObjectAccessor<1,dim>::child (const unsigned int i) const {
+ TriaIterator<dim,DoFObjectAccessor<1,dim> > q (tria,
present_level+1,
child_index (i),
dof_handler);
template <int dim>
inline
void
-DoFObjectAccessor<1, dim>::copy_from (const DoFObjectAccessor<1, dim> &a) {
+DoFObjectAccessor<1,dim>::copy_from (const DoFObjectAccessor<1,dim> &a) {
BaseClass::copy_from (a);
set_dof_handler (a.dof_handler);
};
-/*------------------------- Functions: DoFObjectAccessor<2, dim> -----------------------*/
+/*------------------------- Functions: DoFObjectAccessor<2,dim> -----------------------*/
template <int dim>
inline
-int DoFObjectAccessor<2, dim>::dof_index (const unsigned int i) const {
+int DoFObjectAccessor<2,dim>::dof_index (const unsigned int i) const {
Assert (dof_handler != 0, ExcInvalidObject());
// make sure a FE has been selected
// and enough room was reserved
template <int dim>
inline
-int DoFObjectAccessor<2, dim>::vertex_dof_index (const unsigned int vertex,
+int DoFObjectAccessor<2,dim>::vertex_dof_index (const unsigned int vertex,
const unsigned int i) const {
Assert (dof_handler != 0, ExcInvalidObject());
Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
template <int dim>
inline
void
-DoFObjectAccessor<2, dim>::get_dof_indices (vector<int> &dof_indices) const {
+DoFObjectAccessor<2,dim>::get_dof_indices (vector<int> &dof_indices) const {
Assert (dof_handler != 0, ExcInvalidObject());
Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
Assert (dof_indices.size() == (4*dof_handler->get_fe().dofs_per_vertex +
template <int dim>
inline
-TriaIterator<dim,DoFObjectAccessor<1, dim> >
-DoFObjectAccessor<2, dim>::line (const unsigned int i) const {
+TriaIterator<dim,DoFObjectAccessor<1,dim> >
+DoFObjectAccessor<2,dim>::line (const unsigned int i) const {
Assert (i<4, ExcIndexRange (i, 0, 4));
- return TriaIterator<dim,DoFObjectAccessor<1, dim> >
+ return TriaIterator<dim,DoFObjectAccessor<1,dim> >
(
tria,
present_level,
template <int dim>
inline
-TriaIterator<dim,DoFObjectAccessor<2, dim> >
-DoFObjectAccessor<2, dim>::child (const unsigned int i) const {
- TriaIterator<dim,DoFObjectAccessor<2, dim> > q (tria,
+TriaIterator<dim,DoFObjectAccessor<2,dim> >
+DoFObjectAccessor<2,dim>::child (const unsigned int i) const {
+ TriaIterator<dim,DoFObjectAccessor<2,dim> > q (tria,
present_level+1,
child_index (i),
dof_handler);
template <int dim>
inline
void
-DoFObjectAccessor<2, dim>::copy_from (const DoFObjectAccessor<2, dim> &a) {
+DoFObjectAccessor<2,dim>::copy_from (const DoFObjectAccessor<2,dim> &a) {
BaseClass::copy_from (a);
set_dof_handler (a.dof_handler);
};
template <int dim>
inline
-int DoFObjectAccessor<3, dim>::dof_index (const unsigned int i) const {
+int DoFObjectAccessor<3,dim>::dof_index (const unsigned int i) const {
Assert (dof_handler != 0, ExcInvalidObject());
// make sure a FE has been selected
// and enough room was reserved
template <int dim>
inline
-int DoFObjectAccessor<3, dim>::vertex_dof_index (const unsigned int vertex,
+int DoFObjectAccessor<3,dim>::vertex_dof_index (const unsigned int vertex,
const unsigned int i) const {
Assert (dof_handler != 0, ExcInvalidObject());
Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
template <int dim>
inline
void
-DoFObjectAccessor<3, dim>::get_dof_indices (vector<int> &dof_indices) const {
+DoFObjectAccessor<3,dim>::get_dof_indices (vector<int> &dof_indices) const {
Assert (dof_handler != 0, ExcInvalidObject());
Assert (dof_handler->selected_fe != 0, ExcInvalidObject());
Assert (dof_indices.size() == (8*dof_handler->get_fe().dofs_per_vertex +
template <int dim>
inline
-TriaIterator<dim,DoFObjectAccessor<1, dim> >
-DoFObjectAccessor<3, dim>::line (const unsigned int i) const {
- TriaIterator<dim,TriaObjectAccessor<1, dim> > l = BaseClass::line(i);
- return TriaIterator<dim,DoFObjectAccessor<1, dim> >
+TriaIterator<dim,DoFObjectAccessor<1,dim> >
+DoFObjectAccessor<3,dim>::line (const unsigned int i) const {
+ TriaIterator<dim,TriaObjectAccessor<1,dim> > l = BaseClass::line(i);
+ return TriaIterator<dim,DoFObjectAccessor<1,dim> >
(
tria,
present_level,
template <int dim>
inline
-TriaIterator<dim,DoFObjectAccessor<2, dim> >
-DoFObjectAccessor<3, dim>::quad (const unsigned int i) const {
+TriaIterator<dim,DoFObjectAccessor<2,dim> >
+DoFObjectAccessor<3,dim>::quad (const unsigned int i) const {
Assert (i<6, ExcIndexRange (i, 0, 6));
- return TriaIterator<dim,DoFObjectAccessor<2, dim> >
+ return TriaIterator<dim,DoFObjectAccessor<2,dim> >
(
tria,
present_level,
template <int dim>
inline
-TriaIterator<dim,DoFObjectAccessor<3, dim> >
-DoFObjectAccessor<3, dim>::child (const unsigned int i) const {
- TriaIterator<dim,DoFObjectAccessor<3, dim> > q (tria,
+TriaIterator<dim,DoFObjectAccessor<3,dim> >
+DoFObjectAccessor<3,dim>::child (const unsigned int i) const {
+ TriaIterator<dim,DoFObjectAccessor<3,dim> > q (tria,
present_level+1,
child_index (i),
dof_handler);
template <int dim>
-void DoFObjectAccessor<3, dim>::copy_from (const DoFObjectAccessor<3, dim> &a) {
+void DoFObjectAccessor<3,dim>::copy_from (const DoFObjectAccessor<3,dim> &a) {
BaseClass::copy_from (a);
set_dof_handler (a.dof_handler);
};
* Pointer to the #i#th
* child.
*/
- TriaIterator<dim,TriaObjectAccessor<celldim, dim> >
+ TriaIterator<dim,TriaObjectAccessor<celldim,dim> >
child (const unsigned int i) const;
/**
template <int dim>
inline
bool
-TriaObjectAccessor<1, dim>::used () const {
+TriaObjectAccessor<1,dim>::used () const {
Assert (state() == valid, ExcDereferenceInvalidObject());
return tria->levels[present_level]->lines.used[present_index];
};
template <int dim>
inline
bool
-TriaObjectAccessor<1, dim>::user_flag_set () const {
+TriaObjectAccessor<1,dim>::user_flag_set () const {
Assert (used(), ExcCellNotUsed());
return tria->levels[present_level]->lines.user_flags[present_index];
};
template <int dim>
inline
void
-TriaObjectAccessor<1, dim>::set_user_flag () const {
+TriaObjectAccessor<1,dim>::set_user_flag () const {
Assert (used(), ExcCellNotUsed());
tria->levels[present_level]->lines.user_flags[present_index] = true;
};
template <int dim>
inline
void
-TriaObjectAccessor<1, dim>::clear_user_flag () const {
+TriaObjectAccessor<1,dim>::clear_user_flag () const {
Assert (used(), ExcCellNotUsed());
tria->levels[present_level]->lines.user_flags[present_index] = false;
};
template <int dim>
inline
-TriaIterator<dim,TriaObjectAccessor<1, dim> >
-TriaObjectAccessor<1, dim>::child (const unsigned int i) const {
+TriaIterator<dim,TriaObjectAccessor<1,dim> >
+TriaObjectAccessor<1,dim>::child (const unsigned int i) const {
Assert (i<2, ExcIndexRange(i,0,2));
- TriaIterator<dim,TriaObjectAccessor<1, dim> > q (tria, present_level+1, child_index (i));
+ TriaIterator<dim,TriaObjectAccessor<1,dim> > q (tria, present_level+1, child_index (i));
#ifdef DEBUG
if (q.state() != past_the_end)
template <int dim>
inline
int
-TriaObjectAccessor<1, dim>::child_index (unsigned int i) const {
+TriaObjectAccessor<1,dim>::child_index (unsigned int i) const {
Assert (i<2, ExcIndexRange(i,0,2));
return tria->levels[present_level]->lines.children[present_index]+i;
};
template <int dim>
inline
bool
-TriaObjectAccessor<1, dim>::has_children () const {
+TriaObjectAccessor<1,dim>::has_children () const {
Assert (state() == valid, ExcDereferenceInvalidObject());
return (tria->levels[present_level]->lines.children[present_index] != -1);
}
template <int dim>
inline
unsigned int
-TriaObjectAccessor<1, dim>::max_refinement_depth () const
+TriaObjectAccessor<1,dim>::max_refinement_depth () const
{
if (!has_children())
return 0;
template <int dim>
inline
void
-TriaObjectAccessor<1, dim>::operator ++ () {
+TriaObjectAccessor<1,dim>::operator ++ () {
++present_index;
// is index still in the range of
// the vector?
template <int dim>
inline
void
-TriaObjectAccessor<1, dim>::operator -- () {
+TriaObjectAccessor<1,dim>::operator -- () {
--present_index;
// is index still in the range of
// the vector?
template <int dim>
inline
bool
-TriaObjectAccessor<2, dim>::used () const {
+TriaObjectAccessor<2,dim>::used () const {
Assert (state() == valid, ExcDereferenceInvalidObject());
return tria->levels[present_level]->quads.used[present_index];
};
template <int dim>
inline
bool
-TriaObjectAccessor<2, dim>::user_flag_set () const {
+TriaObjectAccessor<2,dim>::user_flag_set () const {
Assert (used(), ExcCellNotUsed());
return tria->levels[present_level]->quads.user_flags[present_index];
};
template <int dim>
inline
void
-TriaObjectAccessor<2, dim>::set_user_flag () const {
+TriaObjectAccessor<2,dim>::set_user_flag () const {
Assert (used(), ExcCellNotUsed());
tria->levels[present_level]->quads.user_flags[present_index] = true;
};
template <int dim>
inline
void
-TriaObjectAccessor<2, dim>::clear_user_flag () const {
+TriaObjectAccessor<2,dim>::clear_user_flag () const {
Assert (used(), ExcCellNotUsed());
tria->levels[present_level]->quads.user_flags[present_index] = false;
};
template <int dim>
inline
-TriaIterator<dim,TriaObjectAccessor<1, dim> >
-TriaObjectAccessor<2, dim>::line (const unsigned int i) const {
+TriaIterator<dim,TriaObjectAccessor<1,dim> >
+TriaObjectAccessor<2,dim>::line (const unsigned int i) const {
return
- TriaIterator<dim,TriaObjectAccessor<1, dim> >
+ TriaIterator<dim,TriaObjectAccessor<1,dim> >
(
tria,
present_level,
template <int dim>
inline
unsigned int
-TriaObjectAccessor<2, dim>::line_index (unsigned int i) const {
+TriaObjectAccessor<2,dim>::line_index (unsigned int i) const {
Assert (i<4, ExcIndexRange(i,0,4));
return tria->levels[present_level]->quads.quads[present_index].line(i);
template <int dim>
inline
-TriaIterator<dim,TriaObjectAccessor<2, dim> >
-TriaObjectAccessor<2, dim>::child (const unsigned int i) const {
+TriaIterator<dim,TriaObjectAccessor<2,dim> >
+TriaObjectAccessor<2,dim>::child (const unsigned int i) const {
Assert (i<4, ExcIndexRange(i,0,4));
- TriaIterator<dim,TriaObjectAccessor<2, dim> > q (tria, present_level+1, child_index (i));
+ TriaIterator<dim,TriaObjectAccessor<2,dim> > q (tria, present_level+1, child_index (i));
#ifdef DEBUG
if (q.state() != past_the_end)
template <int dim>
inline
-int TriaObjectAccessor<2, dim>::child_index (unsigned int i) const {
+int TriaObjectAccessor<2,dim>::child_index (unsigned int i) const {
Assert (i<4, ExcIndexRange(i,0,4));
return tria->levels[present_level]->quads.children[present_index]+i;
};
template <int dim>
inline
bool
-TriaObjectAccessor<2, dim>::has_children () const {
+TriaObjectAccessor<2,dim>::has_children () const {
Assert (state() == valid, ExcDereferenceInvalidObject());
return (tria->levels[present_level]->quads.children[present_index] != -1);
};
template <int dim>
inline
unsigned int
-TriaObjectAccessor<2, dim>::max_refinement_depth () const
+TriaObjectAccessor<2,dim>::max_refinement_depth () const
{
if (!has_children())
return 0;
template <int dim>
inline
void
-TriaObjectAccessor<2, dim>::operator ++ () {
+TriaObjectAccessor<2,dim>::operator ++ () {
++present_index;
// is index still in the range of
// the vector?
template <int dim>
inline
void
-TriaObjectAccessor<2, dim>::operator -- () {
+TriaObjectAccessor<2,dim>::operator -- () {
--present_index;
// is index still in the range of
// the vector?
template <int dim>
inline
bool
-TriaObjectAccessor<3, dim>::used () const {
+TriaObjectAccessor<3,dim>::used () const {
Assert (state() == valid, ExcDereferenceInvalidObject());
return tria->levels[present_level]->hexes.used[present_index];
};
template <int dim>
inline
bool
-TriaObjectAccessor<3, dim>::user_flag_set () const {
+TriaObjectAccessor<3,dim>::user_flag_set () const {
Assert (used(), ExcCellNotUsed());
return tria->levels[present_level]->hexes.user_flags[present_index];
};
template <int dim>
inline
void
-TriaObjectAccessor<3, dim>::set_user_flag () const {
+TriaObjectAccessor<3,dim>::set_user_flag () const {
Assert (used(), ExcCellNotUsed());
tria->levels[present_level]->hexes.user_flags[present_index] = true;
};
template <int dim>
inline
-void TriaObjectAccessor<3, dim>::clear_user_flag () const {
+void TriaObjectAccessor<3,dim>::clear_user_flag () const {
Assert (used(), ExcCellNotUsed());
tria->levels[present_level]->hexes.user_flags[present_index] = false;
};
template <int dim>
inline
-TriaIterator<dim,TriaObjectAccessor<1, dim> >
-TriaObjectAccessor<3, dim>::line (const unsigned int i) const {
+TriaIterator<dim,TriaObjectAccessor<1,dim> >
+TriaObjectAccessor<3,dim>::line (const unsigned int i) const {
Assert (used(), ExcCellNotUsed());
Assert (i<12, ExcIndexRange (i,0,12));
return this->quad(4)->line(3);
};
Assert (false, ExcIndexRange(i,0,12));
- return TriaIterator<dim,TriaObjectAccessor<1, dim> >(tria, -1, -1, 0);
+ return TriaIterator<dim,TriaObjectAccessor<1,dim> >(tria, -1, -1, 0);
};
template <int dim>
inline
-TriaIterator<dim,TriaObjectAccessor<2, dim> >
-TriaObjectAccessor<3, dim>::quad (const unsigned int i) const {
+TriaIterator<dim,TriaObjectAccessor<2,dim> >
+TriaObjectAccessor<3,dim>::quad (const unsigned int i) const {
Assert (used(), ExcCellNotUsed());
return
- TriaIterator<dim,TriaObjectAccessor<2, dim> >
+ TriaIterator<dim,TriaObjectAccessor<2,dim> >
(
tria,
present_level,
template <int dim>
inline
unsigned int
-TriaObjectAccessor<3, dim>::line_index (unsigned int i) const {
+TriaObjectAccessor<3,dim>::line_index (unsigned int i) const {
Assert (i<12, ExcIndexRange(i,0,12));
if (i<4)
template <int dim>
inline
unsigned int
-TriaObjectAccessor<3, dim>::quad_index (unsigned int i) const {
+TriaObjectAccessor<3,dim>::quad_index (unsigned int i) const {
Assert (i<6, ExcIndexRange(i,0,6));
return tria->levels[present_level]->hexes.hexes[present_index].quad(i);
template <int dim>
inline
-TriaIterator<dim,TriaObjectAccessor<3, dim> >
-TriaObjectAccessor<3, dim>::child (const unsigned int i) const {
+TriaIterator<dim,TriaObjectAccessor<3,dim> >
+TriaObjectAccessor<3,dim>::child (const unsigned int i) const {
Assert (i<6, ExcIndexRange(i,0,6));
- TriaIterator<dim,TriaObjectAccessor<3, dim> > q (tria, present_level+1, child_index (i));
+ TriaIterator<dim,TriaObjectAccessor<3,dim> > q (tria, present_level+1, child_index (i));
#ifdef DEBUG
if (q.state() != past_the_end)
template <int dim>
inline
-int TriaObjectAccessor<3, dim>::child_index (unsigned int i) const {
+int TriaObjectAccessor<3,dim>::child_index (unsigned int i) const {
Assert (i<8, ExcIndexRange(i,0,8));
return tria->levels[present_level]->hexes.children[present_index]+i;
};
template <int dim>
-bool TriaObjectAccessor<3, dim>::has_children () const {
+bool TriaObjectAccessor<3,dim>::has_children () const {
Assert (state() == valid, ExcDereferenceInvalidObject());
return (tria->levels[present_level]->hexes.children[present_index] != -1);
};
template <int dim>
inline
unsigned int
-TriaObjectAccessor<3, dim>::max_refinement_depth () const
+TriaObjectAccessor<3,dim>::max_refinement_depth () const
{
if (!has_children())
return 0;
template <int dim>
inline
void
-TriaObjectAccessor<3, dim>::operator ++ () {
+TriaObjectAccessor<3,dim>::operator ++ () {
++present_index;
// is index still in the range of
// the vector?
template <int dim>
inline
void
-TriaObjectAccessor<3, dim>::operator -- () {
+TriaObjectAccessor<3,dim>::operator -- () {
--present_index;
// is index still in the range of
// the vector?
template <int celldim, int dim>
inline
bool
-TriaObjectAccessor<celldim, dim>::used () const
+TriaObjectAccessor<celldim,dim>::used () const
{
Assert (state() == valid, ExcDereferenceInvalidObject());
return tria->levels[present_level]->hexes.used[present_index];
template<int celldim, int dim>
inline
bool
-TriaObjectAccessor<celldim, dim>::user_flag_set () const
+TriaObjectAccessor<celldim,dim>::user_flag_set () const
{
Assert (used(), ExcCellNotUsed());
return tria->levels[present_level]->hexes.user_flags[present_index];
template<int celldim, int dim>
inline
void
-TriaObjectAccessor<celldim, dim>::set_user_flag () const
+TriaObjectAccessor<celldim,dim>::set_user_flag () const
{
Assert (used(), ExcCellNotUsed());
tria->levels[present_level]->hexes.user_flags[present_index] = true;
template<int celldim, int dim>
inline
-void TriaObjectAccessor<celldim, dim>::clear_user_flag () const
+void TriaObjectAccessor<celldim,dim>::clear_user_flag () const
{
Assert (used(), ExcCellNotUsed());
tria->levels[present_level]->hexes.user_flags[present_index] = false;
template<int celldim, int dim>
inline
-TriaIterator<dim,TriaObjectAccessor<1, dim> >
-TriaObjectAccessor<celldim, dim>::line (const unsigned int i) const
+TriaIterator<dim,TriaObjectAccessor<1,dim> >
+TriaObjectAccessor<celldim,dim>::line (const unsigned int i) const
{
Assert (used(), ExcCellNotUsed());
Assert (i < GeometryInfo<celldim>::lines_per_cell,
{
case 2:
return
- TriaIterator<dim,TriaObjectAccessor<1, dim> >
+ TriaIterator<dim,TriaObjectAccessor<1,dim> >
(
tria,
present_level,
Assert(false, ExcNotImplemented());
}
- return TriaIterator<dim,TriaObjectAccessor<1, dim> >(tria, -1, -1, 0);
+ return TriaIterator<dim,TriaObjectAccessor<1,dim> >(tria, -1, -1, 0);
};
template<int celldim, int dim>
inline
-TriaIterator<dim,TriaObjectAccessor<2, dim> >
-TriaObjectAccessor<celldim, dim>::quad (const unsigned int i) const
+TriaIterator<dim,TriaObjectAccessor<2,dim> >
+TriaObjectAccessor<celldim,dim>::quad (const unsigned int i) const
{
Assert (used(), ExcCellNotUsed());
Assert (i < GeometryInfo<celldim>::quads_per_cell,
ExcIndexRange(i,0,GeometryInfo<celldim>::quads_per_cell));
return
- TriaIterator<dim,TriaObjectAccessor<2, dim> >
+ TriaIterator<dim,TriaObjectAccessor<2,dim> >
(
tria,
present_level,
template<int celldim, int dim>
inline
unsigned int
-TriaObjectAccessor<celldim, dim>::line_index (unsigned int i) const
+TriaObjectAccessor<celldim,dim>::line_index (unsigned int i) const
{
Assert (i < GeometryInfo<celldim>::lines_per_cell,
ExcIndexRange(i,0,GeometryInfo<celldim>::lines_per_cell));
template<int celldim, int dim>
inline
unsigned int
-TriaObjectAccessor<celldim, dim>::quad_index (unsigned int i) const
+TriaObjectAccessor<celldim,dim>::quad_index (unsigned int i) const
{
Assert (i < GeometryInfo<celldim>::quads_per_cell,
ExcIndexRange(i,0,GeometryInfo<celldim>::quads_per_cell));
template<int celldim, int dim>
inline
-TriaIterator<dim,TriaObjectAccessor<celldim, dim> >
-TriaObjectAccessor<celldim, dim>::child (const unsigned int i) const
+TriaIterator<dim,TriaObjectAccessor<celldim,dim> >
+TriaObjectAccessor<celldim,dim>::child (const unsigned int i) const
{
Assert (i < GeometryInfo<celldim>::children_per_cell,
ExcIndexRange(i,0,GeometryInfo<celldim>::children_per_cell));
- TriaIterator<dim,TriaObjectAccessor<celldim, dim> > q (tria, present_level+1, child_index (i));
+ TriaIterator<dim,TriaObjectAccessor<celldim,dim> > q (tria, present_level+1, child_index (i));
#ifdef DEBUG
if (q.state() != past_the_end)
template<int celldim, int dim>
inline
-int TriaObjectAccessor<celldim, dim>::child_index (unsigned int i) const
+int TriaObjectAccessor<celldim,dim>::child_index (unsigned int i) const
{
Assert (i < GeometryInfo<celldim>::children_per_cell,
ExcIndexRange(i,0,GeometryInfo<celldim>::children_per_cell));
template<int celldim, int dim>
-bool TriaObjectAccessor<celldim, dim>::has_children () const
+bool TriaObjectAccessor<celldim,dim>::has_children () const
{
Assert (state() == valid, ExcDereferenceInvalidObject());
return (tria->levels[present_level]->hexes.children[present_index] != -1);
template<int celldim, int dim>
inline
unsigned int
-TriaObjectAccessor<celldim, dim>::max_refinement_depth () const
+TriaObjectAccessor<celldim,dim>::max_refinement_depth () const
{
if (!has_children())
return 0;
template<int celldim, int dim>
inline
void
-TriaObjectAccessor<celldim, dim>::operator ++ () {
+TriaObjectAccessor<celldim,dim>::operator ++ () {
++present_index;
// is index still in the range of
// the vector?
template<int celldim, int dim>
inline
void
-TriaObjectAccessor<celldim, dim>::operator -- ()
+TriaObjectAccessor<celldim,dim>::operator -- ()
{
--present_index;
// is index still in the range of
template<class SOLVER, class MATRIX, class PRECOND>
-MGCoarseGridLACIteration<SOLVER, MATRIX, PRECOND>::
+MGCoarseGridLACIteration<SOLVER,MATRIX,PRECOND>::
MGCoarseGridLACIteration(SOLVER &s,
const MATRIX &m,
const PRECOND &p)
template<class SOLVER, class MATRIX, class PRECOND>
void
-MGCoarseGridLACIteration<SOLVER, MATRIX, PRECOND>::
+MGCoarseGridLACIteration<SOLVER,MATRIX,PRECOND>::
operator() (const unsigned int /* level */,
Vector<double> &dst,
const Vector<double> &src) const
* that of V, all components are copied
* from V
*/
- BlockVector (const BlockVector<n_blocks, Number>& V);
+ BlockVector (const BlockVector<n_blocks,Number>& V);
// note: I disabled this function for the time being, since egcs1.1.2
/**
* $U(0-N) = s$: fill all components.
*/
- BlockVector<n_blocks, Number> & operator= (const Number s);
+ BlockVector<n_blocks,Number> & operator= (const Number s);
/**
* $U = V$: copy all components.
*/
- BlockVector<n_blocks, Number> &
- operator= (const BlockVector<n_blocks, Number>& V);
+ BlockVector<n_blocks,Number> &
+ operator= (const BlockVector<n_blocks,Number>& V);
/**
* $U = V$ for different types.
*/
template<typename Number2>
- BlockVector<n_blocks, Number> &
+ BlockVector<n_blocks,Number> &
operator= (const BlockVector<n_blocks, Number2>& V);
/**
* $U = U * V$: scalar product.
*/
- Number operator* (const BlockVector<n_blocks, Number>& V) const;
+ Number operator* (const BlockVector<n_blocks,Number>& V) const;
/**
* Return square of the $l_2$-norm.
* this function is the same as calling
* #reinit (V.size(), fast)#.
*/
- void reinit (const BlockVector<n_blocks, Number> &V,
+ void reinit (const BlockVector<n_blocks,Number> &V,
const bool fast=false);
/**
* Addition operator.
* Fast equivalent to #U.add(1, V)#.
*/
- BlockVector<n_blocks, Number> &
- operator += (const BlockVector<n_blocks, Number> &V);
+ BlockVector<n_blocks,Number> &
+ operator += (const BlockVector<n_blocks,Number> &V);
/**
* Subtraction operator.
* Fast equivalent to #U.add(-1, V)#.
*/
- BlockVector<n_blocks, Number> &
- operator -= (const BlockVector<n_blocks, Number> &V);
+ BlockVector<n_blocks,Number> &
+ operator -= (const BlockVector<n_blocks,Number> &V);
/**
* $U(0-DIM)+=s$.
* Simple vector addition, equal to the
* #operator +=#.
*/
- void add (const BlockVector<n_blocks, Number>& V);
+ void add (const BlockVector<n_blocks,Number>& V);
/**
* U+=a*V.
* Simple addition of a scaled vector.
*/
- void add (const Number a, const BlockVector<n_blocks, Number>& V);
+ void add (const Number a, const BlockVector<n_blocks,Number>& V);
/**
* U+=a*V+b*W.
* Multiple addition of scaled vectors.
*/
- void add (const Number a, const BlockVector<n_blocks, Number>& V,
- const Number b, const BlockVector<n_blocks, Number>& W);
+ void add (const Number a, const BlockVector<n_blocks,Number>& V,
+ const Number b, const BlockVector<n_blocks,Number>& W);
/**
* U=s*U+V.
* Scaling and simple vector addition.
*/
- void sadd (const Number s, const BlockVector<n_blocks, Number>& V);
+ void sadd (const Number s, const BlockVector<n_blocks,Number>& V);
/**
* U=s*U+a*V.
* Scaling and simple addition.
*/
- void sadd (const Number s, const Number a, const BlockVector<n_blocks, Number>& V);
+ void sadd (const Number s, const Number a, const BlockVector<n_blocks,Number>& V);
/**
* U=s*U+a*V+b*W.
* Scaling and multiple addition.
*/
void sadd (const Number s, const Number a,
- const BlockVector<n_blocks, Number>& V,
- const Number b, const BlockVector<n_blocks, Number>& W);
+ const BlockVector<n_blocks,Number>& V,
+ const Number b, const BlockVector<n_blocks,Number>& W);
/**
* U=s*U+a*V+b*W+c*X.
* Scaling and multiple addition.
*/
void sadd (const Number s, const Number a,
- const BlockVector<n_blocks, Number>& V,
- const Number b, const BlockVector<n_blocks, Number>& W,
- const Number c, const BlockVector<n_blocks, Number>& X);
+ const BlockVector<n_blocks,Number>& V,
+ const Number b, const BlockVector<n_blocks,Number>& W,
+ const Number c, const BlockVector<n_blocks,Number>& X);
/**
* Scale each element of the vector by the
/**
* U=a*V. Replacing.
*/
- void equ (const Number a, const BlockVector<n_blocks, Number>& V);
+ void equ (const Number a, const BlockVector<n_blocks,Number>& V);
/**
* U=a*V+b*W.
* Replacing by sum.
*/
- void equ (const Number a, const BlockVector<n_blocks, Number>& V,
- const Number b, const BlockVector<n_blocks, Number>& W);
+ void equ (const Number a, const BlockVector<n_blocks,Number>& V,
+ const Number b, const BlockVector<n_blocks,Number>& W);
//@}
template <int n_blocks, typename Number>
inline
-unsigned int BlockVector<n_blocks, Number>::size () const
+unsigned int BlockVector<n_blocks,Number>::size () const
{
return start[n_blocks];
}
// template <int n_blocks, typename Number>
// inline
-// BlockVector<n_blocks, Number>::iterator BlockVector<n_blocks, Number>::begin () {
+// BlockVector<n_blocks,Number>::iterator BlockVector<n_blocks,Number>::begin () {
// return &val[0];
// };
// template <int n_blocks, typename Number>
// inline
-// BlockVector<n_blocks, Number>::const_iterator BlockVector<n_blocks, Number>::begin () const {
+// BlockVector<n_blocks,Number>::const_iterator BlockVector<n_blocks,Number>::begin () const {
// return &val[0];
// };
// template <int n_blocks, typename Number>
// inline
-// BlockVector<n_blocks, Number>::iterator BlockVector<n_blocks, Number>::end () {
+// BlockVector<n_blocks,Number>::iterator BlockVector<n_blocks,Number>::end () {
// return &val[dim];
// };
// template <typename Number>
// inline
-// BlockVector<n_blocks, Number>::const_iterator BlockVector<n_blocks, Number>::end () const {
+// BlockVector<n_blocks,Number>::const_iterator BlockVector<n_blocks,Number>::end () const {
// return &val[dim];
// };
template <int n_blocks, typename Number>
inline
-Number BlockVector<n_blocks, Number>::operator() (const unsigned int i) const
+Number BlockVector<n_blocks,Number>::operator() (const unsigned int i) const
{
// Assert (i<start[n_blocks], ExcInvalidIndex(i,dim));
template <int n_blocks, typename Number>
inline
-Number& BlockVector<n_blocks, Number>::operator() (const unsigned int i)
+Number& BlockVector<n_blocks,Number>::operator() (const unsigned int i)
{
// Assert (i<dim, ExcInvalidIndex(i,dim));
template <int n_blocks, typename Number>
inline
Vector<Number>&
-BlockVector<n_blocks, Number>::block(unsigned int i)
+BlockVector<n_blocks,Number>::block(unsigned int i)
{
Assert(i<n_blocks, ExcIndexRange(i,0,n_blocks));
template <int n_blocks, typename Number>
inline
const Vector<Number>&
-BlockVector<n_blocks, Number>::block(unsigned int i) const
+BlockVector<n_blocks,Number>::block(unsigned int i) const
{
Assert(i<n_blocks, ExcIndexRange(i,0,n_blocks));
template <int n_blocks, typename Number>
-BlockVector<n_blocks, Number>::BlockVector ()
+BlockVector<n_blocks,Number>::BlockVector ()
{
for (unsigned int i=0;i<=n_blocks;++i)
start[n_blocks] = 0;
template <int n_blocks, typename Number>
-BlockVector<n_blocks, Number>::BlockVector (const vector<unsigned int>& n)
+BlockVector<n_blocks,Number>::BlockVector (const vector<unsigned int>& n)
{
Assert(n.size()==n_blocks, ExcDimensionMismatch(n.size(), n_blocks));
template <int n_blocks, typename Number>
-BlockVector<n_blocks, Number>::BlockVector (const BlockVector<n_blocks, Number>& v)
+BlockVector<n_blocks,Number>::BlockVector (const BlockVector<n_blocks,Number>& v)
{
for (unsigned int i=0;i<n_blocks;++i)
{
//
// template <int n_blocks, typename Number>
// template <typename OtherNumber>
-// BlockVector<n_blocks, Number>::Vector (const BlockVector<n_blocks, OtherNumber>& v) :
+// BlockVector<n_blocks,Number>::Vector (const BlockVector<n_blocks, OtherNumber>& v) :
// dim(v.size()),
// maxdim(v.size()),
// val(0)
template <int n_blocks, typename Number>
-void BlockVector<n_blocks, Number>::reinit (const vector<unsigned int>& n,
+void BlockVector<n_blocks,Number>::reinit (const vector<unsigned int>& n,
const bool fast)
{
Assert (n.size() == n_blocks,
template <int n_blocks, typename Number>
-void BlockVector<n_blocks, Number>::reinit (const BlockVector<n_blocks, Number>& v,
+void BlockVector<n_blocks,Number>::reinit (const BlockVector<n_blocks,Number>& v,
const bool fast)
{
for (unsigned int i=0;i<n_blocks;++i)
template <int n_blocks, typename Number>
-BlockVector<n_blocks, Number>::~BlockVector ()
+BlockVector<n_blocks,Number>::~BlockVector ()
{
}
template <int n_blocks, typename Number>
-void BlockVector<n_blocks, Number>::clear ()
+void BlockVector<n_blocks,Number>::clear ()
{
for (unsigned int i=0;i<n_blocks;++i)
{
template <int n_blocks, typename Number>
-bool BlockVector<n_blocks, Number>::all_zero () const
+bool BlockVector<n_blocks,Number>::all_zero () const
{
bool result = true;
for (unsigned int i=0;i<n_blocks;++i)
template <int n_blocks, typename Number>
-Number BlockVector<n_blocks, Number>::operator * (const BlockVector<n_blocks, Number>& v) const
+Number BlockVector<n_blocks,Number>::operator * (const BlockVector<n_blocks,Number>& v) const
{
Number sum = 0.;
for (unsigned int i=0;i<n_blocks;++i)
template <int n_blocks, typename Number>
-Number BlockVector<n_blocks, Number>::norm_sqr () const
+Number BlockVector<n_blocks,Number>::norm_sqr () const
{
Number sum = 0.;
for (unsigned int i=0;i<n_blocks;++i)
template <int n_blocks, typename Number>
-Number BlockVector<n_blocks, Number>::mean_value () const
+Number BlockVector<n_blocks,Number>::mean_value () const
{
Number sum = 0.;
for (unsigned int i=0;i<n_blocks;++i)
template <int n_blocks, typename Number>
-Number BlockVector<n_blocks, Number>::l1_norm () const
+Number BlockVector<n_blocks,Number>::l1_norm () const
{
Number sum = 0.;
for (unsigned int i=0;i<n_blocks;++i)
template <int n_blocks, typename Number>
-Number BlockVector<n_blocks, Number>::l2_norm () const
+Number BlockVector<n_blocks,Number>::l2_norm () const
{
return sqrt(norm_sqr());
}
template <int n_blocks, typename Number>
-Number BlockVector<n_blocks, Number>::linfty_norm () const
+Number BlockVector<n_blocks,Number>::linfty_norm () const
{
Number sum = 0.;
for (unsigned int i=0;i<n_blocks;++i)
template <int n_blocks, typename Number>
-BlockVector<n_blocks, Number>& BlockVector<n_blocks, Number>::operator += (const BlockVector<n_blocks, Number>& v)
+BlockVector<n_blocks,Number>& BlockVector<n_blocks,Number>::operator += (const BlockVector<n_blocks,Number>& v)
{
add (v);
return *this;
template <int n_blocks, typename Number>
-BlockVector<n_blocks, Number>& BlockVector<n_blocks, Number>::operator -= (const BlockVector<n_blocks, Number>& v)
+BlockVector<n_blocks,Number>& BlockVector<n_blocks,Number>::operator -= (const BlockVector<n_blocks,Number>& v)
{
for (unsigned int i=0;i<n_blocks;++i)
{
template <int n_blocks, typename Number>
-void BlockVector<n_blocks, Number>::add (const Number v)
+void BlockVector<n_blocks,Number>::add (const Number v)
{
for (unsigned int i=0;i<n_blocks;++i)
{
template <int n_blocks, typename Number>
-void BlockVector<n_blocks, Number>::add (const BlockVector<n_blocks, Number>& v)
+void BlockVector<n_blocks,Number>::add (const BlockVector<n_blocks,Number>& v)
{
for (unsigned int i=0;i<n_blocks;++i)
{
template <int n_blocks, typename Number>
-void BlockVector<n_blocks, Number>::add (const Number a,
- const BlockVector<n_blocks, Number>& v)
+void BlockVector<n_blocks,Number>::add (const Number a,
+ const BlockVector<n_blocks,Number>& v)
{
for (unsigned int i=0;i<n_blocks;++i)
{
template <int n_blocks, typename Number>
-void BlockVector<n_blocks, Number>::add (const Number a,
- const BlockVector<n_blocks, Number>& v,
+void BlockVector<n_blocks,Number>::add (const Number a,
+ const BlockVector<n_blocks,Number>& v,
const Number b,
- const BlockVector<n_blocks, Number>& w)
+ const BlockVector<n_blocks,Number>& w)
{
for (unsigned int i=0;i<n_blocks;++i)
{
template <int n_blocks, typename Number>
-void BlockVector<n_blocks, Number>::sadd (const Number x,
- const BlockVector<n_blocks, Number>& v)
+void BlockVector<n_blocks,Number>::sadd (const Number x,
+ const BlockVector<n_blocks,Number>& v)
{
for (unsigned int i=0;i<n_blocks;++i)
{
template <int n_blocks, typename Number>
-void BlockVector<n_blocks, Number>::sadd (const Number x, const Number a,
- const BlockVector<n_blocks, Number>& v)
+void BlockVector<n_blocks,Number>::sadd (const Number x, const Number a,
+ const BlockVector<n_blocks,Number>& v)
{
for (unsigned int i=0;i<n_blocks;++i)
{
template <int n_blocks, typename Number>
-void BlockVector<n_blocks, Number>::sadd (const Number x, const Number a,
- const BlockVector<n_blocks, Number>& v,
+void BlockVector<n_blocks,Number>::sadd (const Number x, const Number a,
+ const BlockVector<n_blocks,Number>& v,
const Number b,
- const BlockVector<n_blocks, Number>& w)
+ const BlockVector<n_blocks,Number>& w)
{
for (unsigned int i=0;i<n_blocks;++i)
{
template <int n_blocks, typename Number>
-void BlockVector<n_blocks, Number>::sadd (const Number x, const Number a,
- const BlockVector<n_blocks, Number>& v,
+void BlockVector<n_blocks,Number>::sadd (const Number x, const Number a,
+ const BlockVector<n_blocks,Number>& v,
const Number b,
- const BlockVector<n_blocks, Number>& w,
+ const BlockVector<n_blocks,Number>& w,
const Number c,
- const BlockVector<n_blocks, Number>& y)
+ const BlockVector<n_blocks,Number>& y)
{
for (unsigned int i=0;i<n_blocks;++i)
{
template <int n_blocks, typename Number>
-void BlockVector<n_blocks, Number>::scale (const Number factor)
+void BlockVector<n_blocks,Number>::scale (const Number factor)
{
for (unsigned int i=0;i<n_blocks;++i)
{
template <int n_blocks, typename Number>
-void BlockVector<n_blocks, Number>::equ (const Number a,
- const BlockVector<n_blocks, Number>& v,
+void BlockVector<n_blocks,Number>::equ (const Number a,
+ const BlockVector<n_blocks,Number>& v,
const Number b,
- const BlockVector<n_blocks, Number>& w)
+ const BlockVector<n_blocks,Number>& w)
{
for (unsigned int i=0;i<n_blocks;++i)
{
template <int n_blocks, typename Number>
-void BlockVector<n_blocks, Number>::equ (const Number a,
- const BlockVector<n_blocks, Number>& v)
+void BlockVector<n_blocks,Number>::equ (const Number a,
+ const BlockVector<n_blocks,Number>& v)
{
for (unsigned int i=0;i<n_blocks;++i)
{
template <int n_blocks, typename Number>
-BlockVector<n_blocks, Number>& BlockVector<n_blocks, Number>::operator = (const Number s)
+BlockVector<n_blocks,Number>& BlockVector<n_blocks,Number>::operator = (const Number s)
{
for (unsigned int i=0;i<n_blocks;++i)
{
template <int n_blocks, typename Number>
-BlockVector<n_blocks, Number>&
-BlockVector<n_blocks, Number>::operator = (const BlockVector<n_blocks, Number>& v)
+BlockVector<n_blocks,Number>&
+BlockVector<n_blocks,Number>::operator = (const BlockVector<n_blocks,Number>& v)
{
for (unsigned int i=0;i<n_blocks;++i)
{
template <int n_blocks, typename Number>
template<typename Number2>
-BlockVector<n_blocks, Number>&
-BlockVector<n_blocks, Number>::operator = (const BlockVector<n_blocks, Number2>& v)
+BlockVector<n_blocks,Number>&
+BlockVector<n_blocks,Number>::operator = (const BlockVector<n_blocks, Number2>& v)
{
for (unsigned int i=0;i<n_blocks;++i)
{
template <int n_blocks, typename Number>
-void BlockVector<n_blocks, Number>::print (ostream &out,
+void BlockVector<n_blocks,Number>::print (ostream &out,
unsigned int precision,
bool scientific,
bool across) const
template <int n_blocks, typename Number>
-void BlockVector<n_blocks, Number>::block_write (ostream &out) const
+void BlockVector<n_blocks,Number>::block_write (ostream &out) const
{
for (unsigned int i=0;i<n_blocks;++i)
{
template <int n_blocks, typename Number>
-void BlockVector<n_blocks, Number>::block_read (istream &in)
+void BlockVector<n_blocks,Number>::block_read (istream &in)
{
for (unsigned int i=0;i<n_blocks;++i)
{
template<class SOLVER, class MATRIX, class PRECOND>
-MGCoarseGridLACIteration<SOLVER, MATRIX, PRECOND>::
+MGCoarseGridLACIteration<SOLVER,MATRIX,PRECOND>::
MGCoarseGridLACIteration(SOLVER &s,
const MATRIX &m,
const PRECOND &p)
template<class SOLVER, class MATRIX, class PRECOND>
void
-MGCoarseGridLACIteration<SOLVER, MATRIX, PRECOND>::
+MGCoarseGridLACIteration<SOLVER,MATRIX,PRECOND>::
operator() (const unsigned int /* level */,
Vector<double> &dst,
const Vector<double> &src) const
-/*-------------------- precondition.h --------------------*/
-//$Id$
-// Guido Kanschat, University of Heidelberg, 1999
+/*---------------------------- precondition.h ---------------------------*/
+/* $Id$ */
+#ifndef __precondition_H
+#define __precondition_H
+/*---------------------------- precondition.h ---------------------------*/
+
+
-#ifndef __lac_precondition_h
-#define __lac_precondition_h
/**
* No preconditioning.
}
template<class MATRIX, class VECTOR>
-PreconditionUseMatrix<MATRIX, VECTOR>::PreconditionUseMatrix(const MATRIX& M,
+PreconditionUseMatrix<MATRIX,VECTOR>::PreconditionUseMatrix(const MATRIX& M,
function_ptr method)
:
matrix(M), precondition(method)
template<class MATRIX, class VECTOR>
void
-PreconditionUseMatrix<MATRIX, VECTOR>::operator() (VECTOR& dst,
+PreconditionUseMatrix<MATRIX,VECTOR>::operator() (VECTOR& dst,
const VECTOR& src) const
{
(matrix.*precondition)(dst, src);
}
template<class MATRIX, class VECTOR>
-PreconditionRelaxation<MATRIX, VECTOR>::PreconditionRelaxation(const MATRIX& M,
+PreconditionRelaxation<MATRIX,VECTOR>::PreconditionRelaxation(const MATRIX& M,
function_ptr method,
double omega)
:
template<class MATRIX, class VECTOR>
void
-PreconditionRelaxation<MATRIX, VECTOR>::operator() (VECTOR& dst,
+PreconditionRelaxation<MATRIX,VECTOR>::operator() (VECTOR& dst,
const VECTOR& src) const
{
(matrix.*precondition)(dst, src, omega);
//////////////////////////////////////////////////////////////////////
template<class SOLVER, class MATRIX, class PRECONDITION>
-PreconditionLACSolver<SOLVER, MATRIX, PRECONDITION>
+PreconditionLACSolver<SOLVER,MATRIX,PRECONDITION>
::PreconditionLACSolver(SOLVER& solver,
const MATRIX& matrix,
const PRECONDITION& precondition)
template<class SOLVER, class MATRIX, class PRECONDITION>
template<class VECTOR>
void
-PreconditionLACSolver<SOLVER, MATRIX, PRECONDITION>::operator() (VECTOR& dst,
+PreconditionLACSolver<SOLVER,MATRIX,PRECONDITION>::operator() (VECTOR& dst,
const VECTOR& src) const
{
solver.solve(matrix, dst, src, precondition);
+
+/*---------------------------- precondition.h ---------------------------*/
+/* end of #ifndef __precondition_H */
#endif
+/*---------------------------- precondition.h ---------------------------*/
*/
template<typename number,
typename inverse_type = number>
-class PreconditionBlockSOR : public PreconditionBlock<number, inverse_type>
+class PreconditionBlockSOR : public PreconditionBlock<number,inverse_type>
{
public:
/**
template <typename number, typename inverse_type>
-PreconditionBlock<number, inverse_type>::PreconditionBlock ():
+PreconditionBlock<number,inverse_type>::PreconditionBlock ():
blocksize(0),
A(0) {};
template <typename number, typename inverse_type>
-PreconditionBlock<number, inverse_type>::~PreconditionBlock ()
+PreconditionBlock<number,inverse_type>::~PreconditionBlock ()
{
if (inverse.size()!=0)
inverse.erase(inverse.begin(), inverse.end());
}
template <typename number, typename inverse_type>
-void PreconditionBlock<number, inverse_type>::clear ()
+void PreconditionBlock<number,inverse_type>::clear ()
{
if (inverse.size()!=0)
inverse.erase(inverse.begin(), inverse.end());
}
template <typename number, typename inverse_type>
-void PreconditionBlock<number, inverse_type>::use_matrix(
+void PreconditionBlock<number,inverse_type>::use_matrix(
const SparseMatrix<number> &M)
{
A = &M;
template <typename number, typename inverse_type>
-void PreconditionBlock<number, inverse_type>::set_block_size(unsigned int bsize) {
+void PreconditionBlock<number,inverse_type>::set_block_size(unsigned int bsize) {
blocksize=bsize;
}
template <typename number, typename inverse_type>
-unsigned int PreconditionBlock<number, inverse_type>::block_size() const {
+unsigned int PreconditionBlock<number,inverse_type>::block_size() const {
return blocksize;
}
template <typename number, typename inverse_type>
-void PreconditionBlock<number, inverse_type>::invert_diagblocks()
+void PreconditionBlock<number,inverse_type>::invert_diagblocks()
{
Assert (A!=0, ExcNoMatrixGivenToUse());
const SparseMatrix<number> &M=*A;
/*--------------------- PreconditionBlockSOR -----------------------*/
template<typename number, typename inverse_type>
-PreconditionBlockSOR<number, inverse_type>::PreconditionBlockSOR(const number omega):
+PreconditionBlockSOR<number,inverse_type>::PreconditionBlockSOR(const number omega):
omega(omega) {}
template<typename number, typename inverse_type>
-PreconditionBlockSOR<number, inverse_type>::~PreconditionBlockSOR(){}
+PreconditionBlockSOR<number,inverse_type>::~PreconditionBlockSOR(){}
template <typename number, typename inverse_type>
template <typename number2>
-void PreconditionBlockSOR<number, inverse_type>::operator() (Vector<number2> &dst,
- const Vector<number2> &src) const
+void PreconditionBlockSOR<number,inverse_type>::operator() (Vector<number2> &dst,
+ const Vector<number2> &src) const
{
Assert(A!=0, ExcNoMatrixGivenToUse());
const SparseMatrix<number> &M=*A;
template <class Matrix, class Vector>
-PreconditionSelector<Matrix, Vector>
+PreconditionSelector<Matrix,Vector>
::PreconditionSelector(string preconditioning,
const typename Vector::value_type &omega) :
preconditioning(preconditioning),
template <class Matrix, class Vector>
-PreconditionSelector<Matrix, Vector>::~PreconditionSelector()
+PreconditionSelector<Matrix,Vector>::~PreconditionSelector()
{
// release the matrix A
A=0;
template <class Matrix, class Vector>
-void PreconditionSelector<Matrix, Vector>::use_matrix(const Matrix &M)
+void PreconditionSelector<Matrix,Vector>::use_matrix(const Matrix &M)
{
A=&M;
}
template <class Matrix, class Vector>
-void PreconditionSelector<Matrix, Vector>::operator() (Vector &dst,
- const Vector &src) const
+void PreconditionSelector<Matrix,Vector>::operator() (Vector &dst,
+ const Vector &src) const
{
if (preconditioning=="none")
{
template <class Matrix, class Vector>
-string PreconditionSelector<Matrix, Vector>::get_precondition_names()
+string PreconditionSelector<Matrix,Vector>::get_precondition_names()
{
return "none|jacobi|sor|ssor";
}