-/* $Id$ */
-#ifndef __lac__block_vector_H
-#define __lac__block_vector_H
+//---------------------------- block_vector.h ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- block_vector.h ---------------------------
+#ifndef __deal2__block_vector_h
+#define __deal2__block_vector_h
+
#include <lac/vector.h>
#include <base/exceptions.h>
* $l_\infty$-norm of a vector.
*/
Number linfty_norm () const;
-
-
- /**
+
+
+/**
* Change the dimension of the vector to
* #N#. The reserved memory for this vector
* remains unchanged if possible, to make
// */
// const_iterator end () const;
-
-
- /**
+
+/**
* @name 2: Data-Access
*/
//@{
*/
Number& operator() (const unsigned int i);
//@}
-
-
- /**
+
+
+/**
* @name 3: Modification of vectors
*/
//@{
const Number b, const BlockVector<n_blocks,Number>& W);
//@}
-
-
- /**
+
+
+/**
* @name 5: Mixed stuff
*/
//@{
};
-
-
-
-
/*----------------------- Inline functions ----------------------------------*/
}
-
// template <int n_blocks, typename Number>
// inline
// BlockVector<n_blocks,Number>::iterator BlockVector<n_blocks,Number>::begin () {
// };
-
// template <int n_blocks, typename Number>
// inline
// BlockVector<n_blocks,Number>::const_iterator BlockVector<n_blocks,Number>::begin () const {
// };
-
// template <int n_blocks, typename Number>
// inline
// BlockVector<n_blocks,Number>::iterator BlockVector<n_blocks,Number>::end () {
// };
-
// template <typename Number>
// inline
// BlockVector<n_blocks,Number>::const_iterator BlockVector<n_blocks,Number>::end () const {
// };
-
template <int n_blocks, typename Number>
inline
Number BlockVector<n_blocks,Number>::operator() (const unsigned int i) const
}
-
template <int n_blocks, typename Number>
inline
Number& BlockVector<n_blocks,Number>::operator() (const unsigned int i)
}
-
#endif
-// $Id$
+//---------------------------- block_vector.templates.h ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- block_vector.templates.h ---------------------------
+#ifndef __deal2__block_vector_templates_h
+#define __deal2__block_vector_templates_h
-// This file was once part of the DEAL Library
-// DEAL is Copyright(1995) by
-// Roland Becker, Guido Kanschat, Franz-Theo Suttmeier
-// Revised and extended by Wolfgang Bangerth, 1998, 1999
#include <lac/block_vector.h>
#include <cmath>
};
-
template <int n_blocks, typename Number>
BlockVector<n_blocks,Number>::BlockVector ()
{
}
-
template <int n_blocks, typename Number>
BlockVector<n_blocks,Number>::BlockVector (const vector<unsigned int>& n)
{
}
-
template <int n_blocks, typename Number>
BlockVector<n_blocks,Number>::BlockVector (const BlockVector<n_blocks,Number>& v)
{
}
-
// see the .h file for why this function was disabled
//
// template <int n_blocks, typename Number>
// }
-
template <int n_blocks, typename Number>
void BlockVector<n_blocks,Number>::reinit (const vector<unsigned int>& n,
const bool fast)
}
-
template <int n_blocks, typename Number>
void BlockVector<n_blocks,Number>::reinit (const BlockVector<n_blocks,Number>& v,
const bool fast)
}
-
-
template <int n_blocks, typename Number>
BlockVector<n_blocks,Number>::~BlockVector ()
{
}
-
template <int n_blocks, typename Number>
void BlockVector<n_blocks,Number>::clear ()
{
}
-
template <int n_blocks, typename Number>
bool BlockVector<n_blocks,Number>::all_zero () const
{
}
-
template <int n_blocks, typename Number>
Number BlockVector<n_blocks,Number>::operator * (const BlockVector<n_blocks,Number>& v) const
{
}
-
template <int n_blocks, typename Number>
Number BlockVector<n_blocks,Number>::norm_sqr () const
{
};
-
template <int n_blocks, typename Number>
Number BlockVector<n_blocks,Number>::mean_value () const
{
}
-
template <int n_blocks, typename Number>
Number BlockVector<n_blocks,Number>::l1_norm () const
{
}
-
template <int n_blocks, typename Number>
Number BlockVector<n_blocks,Number>::l2_norm () const
{
}
-
template <int n_blocks, typename Number>
Number BlockVector<n_blocks,Number>::linfty_norm () const
{
}
return sum;
}
-
-
-
template <int n_blocks, typename Number>
}
-
template <int n_blocks, typename Number>
BlockVector<n_blocks,Number>& BlockVector<n_blocks,Number>::operator -= (const BlockVector<n_blocks,Number>& v)
{
}
-
template <int n_blocks, typename Number>
void BlockVector<n_blocks,Number>::add (const Number v)
{
}
-
template <int n_blocks, typename Number>
void BlockVector<n_blocks,Number>::add (const BlockVector<n_blocks,Number>& v)
{
}
-
template <int n_blocks, typename Number>
void BlockVector<n_blocks,Number>::add (const Number a,
const BlockVector<n_blocks,Number>& v)
}
-
template <int n_blocks, typename Number>
void BlockVector<n_blocks,Number>::add (const Number a,
const BlockVector<n_blocks,Number>& v,
}
-
template <int n_blocks, typename Number>
void BlockVector<n_blocks,Number>::sadd (const Number x,
const BlockVector<n_blocks,Number>& v)
}
-
template <int n_blocks, typename Number>
void BlockVector<n_blocks,Number>::sadd (const Number x, const Number a,
const BlockVector<n_blocks,Number>& v)
}
-
template <int n_blocks, typename Number>
void BlockVector<n_blocks,Number>::sadd (const Number x, const Number a,
const BlockVector<n_blocks,Number>& v,
}
-
template <int n_blocks, typename Number>
void BlockVector<n_blocks,Number>::sadd (const Number x, const Number a,
const BlockVector<n_blocks,Number>& v,
}
-
template <int n_blocks, typename Number>
void BlockVector<n_blocks,Number>::scale (const Number factor)
{
}
-
template <int n_blocks, typename Number>
void BlockVector<n_blocks,Number>::equ (const Number a,
const BlockVector<n_blocks,Number>& v,
}
-
template <int n_blocks, typename Number>
void BlockVector<n_blocks,Number>::equ (const Number a,
const BlockVector<n_blocks,Number>& v)
}
-
template <int n_blocks, typename Number>
BlockVector<n_blocks,Number>&
BlockVector<n_blocks,Number>::operator = (const BlockVector<n_blocks,Number>& v)
}
-
template <int n_blocks, typename Number>
template<typename Number2>
BlockVector<n_blocks,Number>&
}
-
template <int n_blocks, typename Number>
void BlockVector<n_blocks,Number>::block_write (ostream &out) const
{
components[i].block_read(in);
}
}
+
+#endif
-/*---------------------------- fullmatrix.h ---------------------------*/
-// $Id$
-#ifndef __lac_fullmatrix_H
-#define __lac_fullmatrix_H
-/*---------------------------- fullmatrix.h ---------------------------*/
+//---------------------------- full_matrix.h ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- full_matrix.h ---------------------------
+#ifndef __deal2__full_matrix_h
+#define __deal2__full_matrix_h
-// This file is part of the DEAL Library
-// DEAL is Copyright(1995) by
-// Roland Becker, Guido Kanschat, Franz-Theo Suttmeier
-// Revised by Wolfgang Bangerth
+/*---------------------------- fullmatrix.h ---------------------------*/
#include <base/exceptions.h>
#include <base/subscriptor.h>
template<typename number> class Vector;
-
/**
* Rectangular/quadratic full matrix.
*
*/
template<typename number2>
FullMatrix<number>& operator = (const FullMatrix<number2>& src);
-
-
- /**
+
+
+/**
* Fill rectangular block.
*
* The matrix #src# is copied
};
-
-
-
/*-------------------------Inline functions -------------------------------*/
template <typename number>
}
-
-
/*---------------------------- fullmatrix.h ---------------------------*/
-/* end of #ifndef __lac_fullmatrix_H */
+
#endif
/*---------------------------- fullmatrix.h ---------------------------*/
-// $Id$
+//---------------------------- full_matrix.templates.h ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- full_matrix.templates.h ---------------------------
+#ifndef __deal2__full_matrix_templates_h
+#define __deal2__full_matrix_templates_h
+
#include <lac/vector.h>
#include <lac/full_matrix.h>
};
-
template <typename number>
void
FullMatrix<number>::reinit (const unsigned int mm,
};
-
template <typename number>
void
FullMatrix<number>::reinit (const unsigned int n)
};
-
template <typename number>
template <typename number2>
void
}
-
template <typename number>
template <typename number2>
void FullMatrix<number>::Tvmult (Vector<number2> &dst,
}
-
template <typename number>
template <typename number2, typename number3>
double FullMatrix<number>::residual (Vector<number2>& dst,
}
-
template <typename number>
template <typename number2>
void FullMatrix<number>::forward (Vector<number2>& dst,
}
-
template <typename number>
template <typename number2>
void FullMatrix<number>::backward (Vector<number2>& dst,
}
-
template <typename number>
FullMatrix<number>&
FullMatrix<number>::operator = (const FullMatrix<number>& m)
}
-
template <typename number>
template <typename number2>
FullMatrix<number>&
}
-
template <typename number>
template <typename number2>
void FullMatrix<number>::fill (const FullMatrix<number2>& src,
}
-
template <typename number>
void FullMatrix<number>::add_row (const unsigned int i,
const number s,
}
-
template <typename number>
void FullMatrix<number>::add_row (const unsigned int i,
const number s,
}
-
template <typename number>
void FullMatrix<number>::add_col (const unsigned int i, const number s,
const unsigned int j)
}
-
template <typename number>
void FullMatrix<number>::add_col (const unsigned int i, const number s,
const unsigned int j, const number t,
}
-
template <typename number>
void FullMatrix<number>::swap_row (const unsigned int i, const unsigned int j)
{
}
-
template <typename number>
void FullMatrix<number>::swap_col (const unsigned int i, const unsigned int j)
{
}
-
template <typename number>
void FullMatrix<number>::diagadd (const number src)
{
}
-
template <typename number>
template <typename number2>
void FullMatrix<number>::mmult (FullMatrix<number2>& dst,
}
-
/*void FullMatrix<number>::mmult (FullMatrix& dst, const FullMatrix& src) const
{
Assert (val != 0, ExcEmptyMatrix());
}*/
-
template <typename number>
template <typename number2>
void FullMatrix<number>::Tmmult (FullMatrix<number2>& dst, const FullMatrix<number2>& src) const
}
-
/*void FullMatrix<number>::Tmmult(FullMatrix& dst, const FullMatrix& src) const
{
Assert (val != 0, ExcEmptyMatrix());
}*/
-
template <typename number>
template <typename number2>
double FullMatrix<number>::matrix_norm (const Vector<number2> &v) const
};
-
template <typename number>
template <typename number2>
double FullMatrix<number>::matrix_scalar_product (const Vector<number2> &u,
};
-
template <typename number>
number FullMatrix<number>::l1_norm () const
{
};
-
template <typename number>
number FullMatrix<number>::linfty_norm () const
{
};
-
template <typename number>
void
FullMatrix<number>::print (ostream& s, int w, int p) const
}
-
template <typename number>
template <typename number2>
void
}
-
template <typename number>
template <typename number2>
void
}
-
template <typename number>
template <typename number2>
void
}
-
template <typename number>
bool
FullMatrix<number>::operator == (const FullMatrix<number> &m) const
};
-
template <typename number>
double
FullMatrix<number>::determinant () const
};
-
template <typename number>
number
FullMatrix<number>::norm2 () const
}
-
template <typename number>
void FullMatrix<number>::clear ()
{
};
-
template <typename number>
void
FullMatrix<number>::invert (const FullMatrix<number> &M)
AssertThrow (false, ExcNotImplemented(dim_range));
};
};
-
template <typename number>
}
-
template <typename number>
template <typename number2>
double
for (unsigned int i=n() ; i<m() ; ++i) sum += src(i) * src(i);
return sqrt(sum);
}
+
+
+#endif
-/*---------------------------- precondition.h ---------------------------*/
-/* $Id$ */
-#ifndef __precondition_H
-#define __precondition_H
-/*---------------------------- precondition.h ---------------------------*/
-
-
+//---------------------------- precondition.h ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- precondition.h ---------------------------
+#ifndef __deal2__precondition_h
+#define __deal2__precondition_h
/**
};
-
-
/**
* Preconditioner using a matrix-builtin function.
* This class forms a preconditioner suitable for the LAC solver
};
-
/**
* Preconditioner for builtin relaxation methods.
* Application of this preconditioner includes
};
-
/* ---------------------------------- Inline functions ------------------- */
template<class VECTOR>
}
-
-
-/*---------------------------- precondition.h ---------------------------*/
-/* end of #ifndef __precondition_H */
#endif
-/*---------------------------- precondition.h ---------------------------*/
-/*---------------------------- precondition_block.h ---------------------------*/
-/* $Id$ */
-#ifndef __precondition_block_H
-#define __precondition_block_H
-/*---------------------------- precondition_block.h ---------------------------*/
+//---------------------------- precondition_block.h ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- precondition_block.h ---------------------------
+#ifndef __deal2__precondition_block_h
+#define __deal2__precondition_block_h
+
#include <lac/forward_declarations.h>
#include <base/exceptions.h>
};
-
/**
* Block SOR preconditioning.
*
};
-
-/*------------------------ precondition_block.h ---------------------------*/
-/* end of #ifndef __precondition_block_H */
#endif
-/*------------------------ precondition_block.h ---------------------------*/
-/*----------------- precondition_block.templates.h ----------------------*/
-/* $Id$ */
-/* Ralf Hartmann, University of Heidelberg */
+//---------------------------- precondition_block.templates.h ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- precondition_block.templates.h ---------------------------
+#ifndef __deal2__precondition_block_templates_h
+#define __deal2__precondition_block_templates_h
#include <lac/precondition_block.h>
A(0) {};
-
template <typename number, typename inverse_type>
PreconditionBlock<number,inverse_type>::~PreconditionBlock ()
{
}
-
template <typename number, typename inverse_type>
void PreconditionBlock<number,inverse_type>::clear ()
{
}
-
template <typename number, typename inverse_type>
void PreconditionBlock<number,inverse_type>::use_matrix(
const SparseMatrix<number> &M)
}
-
template <typename number, typename inverse_type>
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 {
return blocksize;
}
-
template <typename number, typename inverse_type>
void PreconditionBlock<number,inverse_type>::invert_diagblocks()
{
}
-
/*--------------------- PreconditionBlockSOR -----------------------*/
template<typename number, typename inverse_type>
omega(omega) {}
-
template<typename number, typename inverse_type>
PreconditionBlockSOR<number,inverse_type>::~PreconditionBlockSOR(){}
-
template <typename number, typename inverse_type>
template <typename number2>
void PreconditionBlockSOR<number,inverse_type>::operator() (Vector<number2> &dst,
}
-
-
-
-/*---------------------- precondition_block.templates.h ----------------*/
+#endif
-/*---------------------- precondition_selector.h -------------------------*/
-/* $Id$ */
-/* Ralf Hartmann, University of Heidelberg */
-#ifndef __precondition_selector_H
-#define __precondition_selector_H
-/*---------------------- precondition_selector.h -------------------------*/
+//---------------------------- precondition_selector.h ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- precondition_selector.h ---------------------------
+#ifndef __deal2__precondition_selector_h
+#define __deal2__precondition_selector_h
#include <base/smartpointer.h>
DeclException0 (ExcNoMatrixGivenToUse);
- protected:
+protected:
/**
* Stores the name of the
}
-
-/*---------------------------- precondition_selector.h ---------------------------*/
-/* end of #ifndef __precondition_selector_H */
#endif
-/*---------------------------- precondition_selector.h ---------------------------*/
-/*---------------------------- solver.h ---------------------------*/
-/* $Id$ */
-#ifndef __solver_H
-#define __solver_H
-/*---------------------------- solver.h ---------------------------*/
-
+//---------------------------- solver.h ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- solver.h ---------------------------
+#ifndef __deal2__solver_h
+#define __deal2__solver_h
#include <lac/forward_declarations.h>
-
/**
* Base class for iterative solvers.
*
enum ReturnState {
success=0, exceeded, breakdown
};
-
-
-
- /**
+
+
+/**
* Constructor. Assign a control
* object which stores the required
* precision and an object to provide
};
-
template<class Matrix, class Vector>
inline
Solver<Matrix, Vector>::Solver(SolverControl &cn, VectorMemory<Vector> &mem)
{};
-/*---------------------------- solver.h ---------------------------*/
-/* end of #ifndef __solver_H */
#endif
-/*---------------------------- solver.h ---------------------------*/
-/*---------------------------- solver_bicgstab.h ---------------------------*/
-/* $Id$ */
-#ifndef __solver_bicgstab_H
-#define __solver_bicgstab_H
-/*---------------------------- solver_bicgstab.h ---------------------------*/
+//---------------------------- solver_bicgstab.h ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- solver_bicgstab.h ---------------------------
+#ifndef __deal2__solver_bicgstab_h
+#define __deal2__solver_bicgstab_h
+
#include <base/logstream.h>
#include <lac/solver.h>
}
-
template<class Matrix, class Vector>
template<class Preconditioner>
typename Solver<Matrix,Vector>::ReturnState
}
-/*---------------------------- solver_bicgstab.h ---------------------------*/
-/* end of #ifndef __solver_bicgstab_H */
#endif
-/*---------------------------- solver_bicgstab.h ---------------------------*/
-/*---------------------------- solver_cg.h ---------------------------*/
-/* $Id$ */
-#ifndef __solver_cg_H
-#define __solver_cg_H
-/*---------------------------- solver_cg.h ---------------------------*/
-
+//---------------------------- solver_cg.h ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- solver_cg.h ---------------------------
+#ifndef __deal2__solver_cg_h
+#define __deal2__solver_cg_h
#include <lac/solver.h>
#include <cmath>
-
/**
* Preconditioned cg method.
*
};
-
-
/*------------------------- Implementation ----------------------------*/
-
+
template<class Matrix, class Vector>
SolverCG<Matrix,Vector>::SolverCG(SolverControl &cn,
};
-
template<class Matrix, class Vector>
template<class Preconditioner>
typename Solver<Matrix,Vector>::ReturnState
it++;
};
-
- // Deallocate Memory
+
+// Deallocate Memory
memory.free(Vr);
memory.free(Vp);
};
-
-
-/*---------------------------- solver_cg.h ---------------------------*/
-/* end of #ifndef __solver_cg_H */
#endif
-/*---------------------------- solver_cg.h ---------------------------*/
-/*---------------------------- solver_control.h ---------------------------*/
-/* $Id$ */
-#ifndef __solver_control_H
-#define __solver_control_H
-/*---------------------------- solver_control.h ---------------------------*/
+//---------------------------- solver_control.h ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- solver_control.h ---------------------------
+#ifndef __deal2__solver_control_h
+#define __deal2__solver_control_h
#include <base/subscriptor.h>
};
-
-
-
-
/**
* Specialization of #SolverControl# which returns #success# if either
* the specified tolerance is achieved or if the initial residual (or
* criterion.
*/
double initial_value() const;
-
- protected:
+
+protected:
/**
* Desired reduction factor.
*/
};
-
-
-/*---------------------------- solver_control.h ---------------------------*/
-/* end of #ifndef __solver_control_H */
#endif
-/*---------------------------- solver_control.h ---------------------------*/
-/*---------------------------- solver_pgmres.h ---------------------------*/
-/* $Id$ */
-#ifndef __solver_pgmres_H
-#define __solver_pgmres_H
+//---------------------------- solver_gmres.h ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- solver_gmres.h ---------------------------
+#ifndef __deal2__solver_gmres_h
+#define __deal2__solver_gmres_h
+
+
/*---------------------------- solver_pgmres.h ---------------------------*/
#include <vector>
-
/**
* Implementation of the Restarted Preconditioned Direct Generalized
* Minimal Residual Method. The stopping criterion is the norm of the
};
-
-
/* --------------------- Inline and template functions ------------------- */
};
-
template <class MATRIX, class VECTOR>
inline
void
}
-
-
template<class MATRIX, class VECTOR>
template<class Preconditioner>
typename Solver<MATRIX,VECTOR>::ReturnState
h (n_tmp_vectors-1);
- unsigned int dim = 0;
+unsigned int dim = 0;
SolverControl::State iteration_state = SolverControl::iterate;
VECTOR &v = *tmp_vectors[0];
VECTOR &p = *tmp_vectors[n_tmp_vectors-1];
-
- ///////////////////////////////////
+
+///////////////////////////////////
// outer iteration: loop until we
// either reach convergence or the
// maximum number of iterations is
};
-
-
-
template<class MATRIX, class VECTOR>
double
SolverGMRES<MATRIX,VECTOR>::criterion ()
};
-
/*---------------------------- solver_pgmres.h ---------------------------*/
-/* end of #ifndef __solver_pgmres_H */
+
#endif
/*---------------------------- solver_pgmres.h ---------------------------*/
-/*---------------------------- solver_qmrs.h ---------------------------*/
-/* $Id$ */
-#ifndef __lac__solver_qmrs_H
-#define __lac__solver_qmrs_H
-/*---------------------------- solver_qmrs.h ---------------------------*/
+//---------------------------- solver_qmrs.h ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- solver_qmrs.h ---------------------------
+#ifndef __deal2__solver_qmrs_h
+#define __deal2__solver_qmrs_h
+
//TODO: Check for programming errors!!!
};
-
-
/*------------------------- Implementation ----------------------------*/
-
+
template<class Matrix, class Vector>
SolverQMRS<Matrix,Vector>::SolverQMRS(SolverControl &cn,
};
-
template<class Matrix, class Vector>
template<class Preconditioner>
typename Solver<Matrix,Vector>::ReturnState
rho = q*v;
//deallog << "rho:" << rho << endl;
-
- while (state == SolverControl::iterate)
+
+while (state == SolverControl::iterate)
{
step++; it++;
// Step 1
}
-
-/*---------------------------- solver_qmrs.h ---------------------------*/
-/* end of #ifndef __solver_qmrs_H */
#endif
-/*---------------------------- solver_qmrs.h ---------------------------*/
-/*---------------------------- solver_richardson.h ---------------------------*/
-/* $Id$ */
-/* Ralf Hartmann, University of Heidelberg */
-#ifndef __solver_richardson_H
-#define __solver_richardson_H
-/*---------------------------- solver_richardson.h ---------------------------*/
-
+//---------------------------- solver_richardson.h ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- solver_richardson.h ---------------------------
+#ifndef __deal2__solver_richardson_h
+#define __deal2__solver_richardson_h
#include <lac/solver.h>
#include <lac/solver_control.h>
-
/**
* Implementation of the richardson iteration method. The stopping criterion
* is the norm of the residual.
};
-
-
/*----------------- Implementation of the Richardson Method ------------------*/
}
-/*------------------ solver_richardson.h ----------------------*/
-/* end of #ifndef __solver_richardson_H */
#endif
-/*------------------ solver_richardson.h ----------------------*/
-/*---------------------------- solver_selector.h ---------------------------*/
-/* $Id$ */
-/* Ralf Hartmann, University of Heidelberg */
-#ifndef __solver_selector_H
-#define __solver_selector_H
-/*---------------------------- solver_selector.h ---------------------------*/
+//---------------------------- solver_selector.h ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- solver_selector.h ---------------------------
+#ifndef __deal2__solver_selector_h
+#define __deal2__solver_selector_h
+
#include <base/smartpointer.h>
#include <lac/solver.h>
};
-
/* --------------------- Inline and template functions ------------------- */
{};
-
template <class Matrix, class Vector>
SolverSelector<Matrix, Vector>::~SolverSelector()
{};
-
template <class Matrix, class Vector>
template<class Preconditioner>
typename Solver<Matrix,Vector>::ReturnState
};
-
template <class Matrix, class Vector>
string SolverSelector<Matrix, Vector>::get_solver_names()
{
};
-
template <class Matrix, class Vector>
void SolverSelector<Matrix, Vector>::set_data(
const typename SolverGMRES<Matrix,Vector>::AdditionalData &data)
};
-
-/*---------------------------- solver_selector.h ---------------------------*/
-/* end of #ifndef __solver_selector_H */
#endif
-/*---------------------------- solver_selector.h ---------------------------*/
-/*---------------------------- matrix_decompositions.h ---------------------------*/
-/* $Id$ */
-#ifndef __sparse_ilu_H
-#define __sparse_ilu_H
-/*---------------------------- sparse_ilu.h ---------------------------*/
+//---------------------------- sparse_ilu.h ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- sparse_ilu.h ---------------------------
+#ifndef __deal2__sparse_ilu_h
+#define __deal2__sparse_ilu_h
#include <lac/sparse_matrix.h>
-
-
/**
* Incomplete LU decomposition of a sparse matrix into another sparse matrix.
* A given matrix is decomposed into a incomplete LU factorization, where
}
-
-
-/*---------------------------- sparse_ilu.h ---------------------------*/
-/* end of #ifndef __sparse_ilu_H */
#endif
-/*---------------------------- sparse_ilu.h ---------------------------*/
-/*---------------------------- matrix_decompositions.templates.h ---------------------------*/
-/* $Id$ */
-#ifndef __matrix_decompositions_templates_H
-#define __matrix_decompositions_templates_H
+//---------------------------- sparse_ilu.templates.h ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- sparse_ilu.templates.h ---------------------------
+#ifndef __deal2__sparse_ilu_templates_h
+#define __deal2__sparse_ilu_templates_h
+
+
/*---------------------------- matrix_decompositions.templates.h ---------------------------*/
#include <cmath>
-
template <typename number>
SparseILU<number>::SparseILU ()
{};
-
template <typename number>
SparseILU<number>::SparseILU (const SparsityPattern &sparsity) :
SparseMatrix<number> (sparsity)
{};
-
template <typename number>
void SparseILU<number>::reinit ()
{
};
-
template <typename number>
void SparseILU<number>::reinit (const SparsityPattern &sparsity)
{
};
-
-
template <typename number>
template <typename somenumber>
void SparseILU<number>::decompose (const SparseMatrix<somenumber> &matrix,
Assert (matrix.m()==m(), ExcSizeMismatch(matrix.m(), m()));
Assert (strengthen_diagonal>=0, ExcInvalidStrengthening (strengthen_diagonal));
-
-
- // first thing: copy over all elements
+
+
+// first thing: copy over all elements
// of #matrix# to the present object
//
// note that some elements in this
*diagonal_element += strengthen_diagonal * rowsum;
};
-
-
- // now work only on this
+
+
+// now work only on this
// matrix
const SparsityPattern &sparsity = get_sparsity_pattern();
const unsigned int * const rowstart_indices = sparsity.get_rowstart_indices();
a[i,j] -= a[i,k] * a[k,j]
*/
-
- // i := row
+
+// i := row
for (unsigned int row=1; row<m(); ++row)
{
// invert diagonal element of the
};
-
-
template <typename number>
template <typename somenumber>
void SparseILU<number>::apply_decomposition (Vector<somenumber> &dst,
};
-
-
/*---------------------------- matrix_decompositions.templates.h ---------------------------*/
-/* end of #ifndef __matrix_decompositions_templates_H */
+
#endif
/*---------------------------- matrix_decompositions.templates.h ---------------------------*/
-// $Id$
+//---------------------------- sparse_matrix.2.templates ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- sparse_matrix.2.templates ---------------------------
+
+
+
// Driver file for SparseMatrix functions with two types.
// TYPEMAT and TYPE2 are defined in sparsematrix?.cc
-/*---------------------------- sparsematrix.h ---------------------------*/
-/* $Id$ */
-#ifndef __sparsematrix_H
-#define __sparsematrix_H
-/*---------------------------- sparsematrix.h ---------------------------*/
+//---------------------------- sparse_matrix.h ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- sparse_matrix.h ---------------------------
+#ifndef __deal2__sparse_matrix_h
+#define __deal2__sparse_matrix_h
-// This file was once part of the DEAL Library
-// DEAL is Copyright(1995) by
-// Roland Becker, Guido Kanschat, Franz-Theo Suttmeier
-// Revised, modified and extended by Wolfgang Bangerth
+/*---------------------------- sparsematrix.h ---------------------------*/
#include <base/exceptions.h>
#include <lac/sparsity_pattern.h>
-
/**
* Sparse matrix.
*
* #copy_from# function.
*/
SparseMatrix (const SparseMatrix &);
-
-
- /**
+
+
+/**
* Constructor. Takes the given matrix
* sparsity structure to represent the
* sparsity pattern of this matrix. You
*/
SparseMatrix<number>& operator = (const SparseMatrix<number> &);
-
- /**
+/**
* Reinitialize the object but keep to
* the sparsity pattern previously used.
* This may be necessary if you #reinit#'d
somenumber *partial_norm) const;
- // make all other sparse matrices
+// make all other sparse matrices
// friends
template <typename somenumber> friend class SparseMatrix;
};
-
-
-
/*---------------------- Inline functions -----------------------------------*/
-
template <typename number>
inline
};
-
template <typename number>
inline
unsigned int SparseMatrix<number>::n () const
};
-
template <typename number>
inline
void SparseMatrix<number>::set (const unsigned int i,
};
-
template <typename number>
inline
void SparseMatrix<number>::add (const unsigned int i, const unsigned int j,
};
-
-
-
template <typename number>
inline
number SparseMatrix<number>::operator () (const unsigned int i,
};
-
template <typename number>
inline
number SparseMatrix<number>::diag_element (const unsigned int i) const
};
-
template <typename number>
inline
number & SparseMatrix<number>::diag_element (const unsigned int i)
};
-
template <typename number>
inline
number
};
-
template <typename number>
inline
number SparseMatrix<number>::global_entry (const unsigned int j) const
};
-
template <typename number>
inline
number & SparseMatrix<number>::global_entry (const unsigned int j)
};
-
/*---------------------------- sparsematrix.h ---------------------------*/
-/* end of #ifndef __sparsematrix_H */
+
#endif
/*---------------------------- sparsematrix.h ---------------------------*/
-// $Id$
-
-// This file was once part of the DEAL Library
-// DEAL is Copyright(1995) by
-// Roland Becker, Guido Kanschat, Franz-Theo Suttmeier
-// Revised, modified and extended by Wolfgang Bangerth, 1998, 1999
+//---------------------------- sparse_matrix.templates.h ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- sparse_matrix.templates.h ---------------------------
+#ifndef __deal2__sparse_matrix_templates_h
+#define __deal2__sparse_matrix_templates_h
#include <lac/sparse_matrix.h>
#endif
-
-
-
template <typename number>
SparseMatrix<number>::SparseMatrix () :
cols(0),
};
-
template <typename number>
SparseMatrix<number>&
SparseMatrix<number>::operator = (const SparseMatrix<number> &m)
};
-
template <typename number>
SparseMatrix<number>::SparseMatrix (const SparsityPattern &c) :
cols(&c),
};
-
template <typename number>
SparseMatrix<number>::~SparseMatrix ()
{
};
-
template <typename number>
void
SparseMatrix<number>::reinit ()
}
-
template <typename number>
void
SparseMatrix<number>::reinit (const SparsityPattern &sparsity)
};
-
template <typename number>
void
SparseMatrix<number>::clear ()
};
-
template <typename number>
bool
SparseMatrix<number>::empty () const
};
-
template <typename number>
unsigned int
SparseMatrix<number>::n_nonzero_elements () const
};
-
template <typename number>
template <typename somenumber>
SparseMatrix<number> &
};
-
template <typename number>
template <typename somenumber>
void
};
-
template <typename number>
template <typename somenumber>
void
};
-
template <typename number>
template <typename somenumber>
void
};
-
template <typename number>
template <typename somenumber>
void
}
-
template <typename number>
template <typename somenumber>
void
}
-
template <typename number>
template <typename somenumber>
somenumber
};
-
template <typename number>
template <typename somenumber>
void
};
-
template <typename number>
template <typename somenumber>
void
};
-
template <typename number>
template <typename somenumber>
void
}
-
template <typename number>
template <typename somenumber>
void
};
-
template <typename number>
template <typename somenumber>
void
}
-
template <typename number>
const SparsityPattern &
SparseMatrix<number>::get_sparsity_pattern () const
};
-
template <typename number>
void SparseMatrix<number>::print (ostream &out) const {
Assert (cols != 0, ExcMatrixNotInitialized());
};
-
template <typename number>
void SparseMatrix<number>::print_formatted (ostream &out,
const unsigned int precision,
// out.setf (0, ios::floatfield); // reset output format
};
+#endif
-/*---------------------------- sparse_vanka.h ---------------------------*/
-/* $Id$ */
-#ifndef __sparse_vanka_H
-#define __sparse_vanka_H
-/* Copyright Guido Kanschat, 1999 */
-/*---------------------------- sparse_vanka.h ---------------------------*/
+//---------------------------- sparse_vanka.h ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- sparse_vanka.h ---------------------------
+#ifndef __deal2__sparse_vanka_h
+#define __deal2__sparse_vanka_h
+
+/* Copyright Guido Kanschat, 1999 */
#include <base/smartpointer.h>
};
-
/**
* Block version of the sparse Vanka preconditioner. This class
* divides the matrix into blocks and works on the diagonal blocks
};
-
-
-
-/*---------------------------- sparse_vanka.h ---------------------------*/
-/* end of #ifndef __sparse_vanka_H */
#endif
-/*---------------------------- sparse_vanka.h ---------------------------*/
-// $Id$
-// Copyright Guido Kanschat, 1999
+//---------------------------- sparse_vanka.templates.h ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- sparse_vanka.templates.h ---------------------------
+#ifndef __deal2__sparse_vanka_templates_h
+#define __deal2__sparse_vanka_templates_h
+
#include <lac/sparse_vanka.h>
#include <lac/full_matrix.h>
#include <map>
-
template<typename number>
SparseVanka<number>::SparseVanka(const SparseMatrix<number> &M,
const vector<bool> &selected,
}
-
template <typename number>
void
SparseVanka<number>::compute_inverses ()
};
-
template <typename number>
void
SparseVanka<number>::compute_inverses (const unsigned int begin,
};
-
template <typename number>
void
SparseVanka<number>::compute_inverse (const unsigned int row,
};
-
-
template<typename number>
template<typename number2>
void
};
-
-
template<typename number>
template<typename number2>
void
= matrix->get_sparsity_pattern();
- // store whether we shall work on
+// store whether we shall work on
// the whole matrix, or only on
// blocks. this variable is used to
// optimize access to vectors a
};
-
-
template <typename number>
SparseBlockVanka<number>::SparseBlockVanka (const SparseMatrix<number> &M,
const vector<bool> &selected,
};
-
template <typename number>
void
SparseBlockVanka<number>::compute_dof_masks (const SparseMatrix<number> &M,
};
-
-
template <typename number>
template <typename number2>
void SparseBlockVanka<number>::operator() (Vector<number2> &dst,
apply_preconditioner (dst, src,
&dof_masks[block]);
#endif
- };
-};
+ }
+}
+
+#endif
-/*---------------------------- sparsity_pattern.h ---------------------------*/
-/* $Id$ */
-#ifndef __sparsity_pattern_H
-#define __sparsity_pattern_H
-/*---------------------------- sparsity_pattern.h ---------------------------*/
-
+//---------------------------- sparsity_pattern.h ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- sparsity_pattern.h ---------------------------
+#ifndef __deal2__sparsity_pattern_h
+#define __deal2__sparsity_pattern_h
#include <base/exceptions.h>
#include <vector>
-
-
/**
* Structure representing the sparsity pattern of a sparse matrix.
*
* information!
*/
const unsigned int * get_column_numbers () const;
-
-
- /**
+
+
+/**
* Exception
*/
DeclException1 (ExcInvalidNumber,
*/
bool compressed;
-
- template <typename number> friend class SparseMatrix;
-};
-
+template <typename number> friend class SparseMatrix;
+};
/*---------------------- Inline functions -----------------------------------*/
-
inline
unsigned int
SparsityPattern::n_rows () const
};
-
inline
unsigned int
SparsityPattern::n_cols () const
};
-
inline
bool
SparsityPattern::is_compressed () const
};
-
inline
const unsigned int *
SparsityPattern::get_rowstart_indices () const
};
-
inline
const unsigned int *
SparsityPattern::get_column_numbers () const
};
-
inline
unsigned int
SparsityPattern::row_length (const unsigned int row) const
}
-
inline
unsigned int
SparsityPattern::column_number (const unsigned int row,
}
-
inline
unsigned int
SparsityPattern::n_nonzero_elements () const
};
-
-/*---------------------------- sparsity_pattern.h ---------------------------*/
-/* end of #ifndef __sparsity_pattern_H */
#endif
-/*---------------------------- sparsity_pattern.h ---------------------------*/
-/*---------------------------- vector.h ---------------------------*/
-/* $Id$ */
-#ifndef __vector_H
-#define __vector_H
-/*---------------------------- vector.h ---------------------------*/
+//---------------------------- vector.h ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- vector.h ---------------------------
+#ifndef __deal2__vector_h
+#define __deal2__vector_h
-// This file was once part of the DEAL Library
-// DEAL is Copyright(1995) by
-// Roland Becker, Guido Kanschat, Franz-Theo Suttmeier
-// Revised and extended by Wolfgang Bangerth
#include <base/exceptions.h>
#include <cstdio>
-
/**
* Numerical Vector of data. For this class there are different
* types of functions available. The first type of function mesures
typedef value_type& reference;
typedef const value_type& const_reference;
typedef size_t size_type;
-
- /**
+
+/**
* @name 1: Basic Object-handling
*/
//@{
* $l_\infty$-norm of a vector.
*/
Number linfty_norm () const;
-
-
- /**
+
+
+/**
* Change the dimension of the vector to
* #N#. The reserved memory for this vector
* remains unchanged if possible, to make
*/
const_iterator end () const;
//@}
-
-
- /**
+
+
+/**
* @name 2: Data-Access
*/
//@{
*/
Number& operator() (const unsigned int i);
//@}
-
-
- /**
+
+
+/**
* @name 3: Modification of vectors
*/
//@{
void ratio (const Vector<Number> &a,
const Vector<Number> &b);
//@}
-
-
- /**
+
+
+/**
* @name 5: Mixed stuff
*/
//@{
};
-
-
-
-
/*----------------------- Inline functions ----------------------------------*/
}
-
template <typename Number>
inline
Vector<Number>::iterator Vector<Number>::begin () {
};
-
template <typename Number>
inline
Vector<Number>::const_iterator Vector<Number>::begin () const {
};
-
template <typename Number>
inline
Vector<Number>::iterator Vector<Number>::end () {
};
-
template <typename Number>
inline
Vector<Number>::const_iterator Vector<Number>::end () const {
};
-
template <typename Number>
inline
Number Vector<Number>::operator() (const unsigned int i) const
}
-
template <typename Number>
inline
Number& Vector<Number>::operator() (const unsigned int i)
}
-
-
-
-/*---------------------------- vector.h ---------------------------*/
-/* end of #ifndef __vector_H */
#endif
-/*---------------------------- vector.h ---------------------------*/
-// $Id$
+//---------------------------- vector.templates.h ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- vector.templates.h ---------------------------
+#ifndef __deal2__vector_templates_h
+#define __deal2__vector_templates_h
-// This file was once part of the DEAL Library
-// DEAL is Copyright(1995) by
-// Roland Becker, Guido Kanschat, Franz-Theo Suttmeier
-// Revised and extended by Wolfgang Bangerth, 1998, 1999
#include <lac/vector.h>
#include <cmath>
};
-
template <typename Number>
Vector<Number>::Vector () :
dim(0),
{}
-
template <typename Number>
Vector<Number>::Vector (const unsigned int n) :
dim(0),
}
-
template <typename Number>
Vector<Number>::Vector (const Vector<Number>& v) :
dim(v.size()),
}
-
// see the .h file for why this function was disabled
//
// template <typename Number>
// }
-
template <typename Number>
void Vector<Number>::reinit (const unsigned int n, const bool fast) {
if (n==0)
}
-
template <typename Number>
void Vector<Number>::reinit (const Vector<Number>& v, const bool fast) {
reinit (v.size(), fast);
};
-
-
template <typename Number>
Vector<Number>::~Vector ()
{
}
-
template <typename Number>
void Vector<Number>::clear () {
if (dim>0)
}
-
template <typename Number>
bool Vector<Number>::all_zero () const {
Assert (dim!=0, ExcEmptyVector());
};
-
template <typename Number>
Number Vector<Number>::operator * (const Vector<Number>& v) const
{
}
-
template <typename Number>
Number Vector<Number>::norm_sqr () const
{
};
-
template <typename Number>
Number Vector<Number>::mean_value () const
{
};
-
template <typename Number>
Number Vector<Number>::l1_norm () const
{
};
-
template <typename Number>
Number Vector<Number>::l2_norm () const
{
};
-
template <typename Number>
Number Vector<Number>::linfty_norm () const {
Assert (dim!=0, ExcEmptyVector());
return max (max(max0, max1),
max(max2, max3));
};
-
-
-
template <typename Number>
}
-
template <typename Number>
Vector<Number>& Vector<Number>::operator -= (const Vector<Number>& v)
{
}
-
template <typename Number>
void Vector<Number>::add (const Number v)
{
}
-
template <typename Number>
void Vector<Number>::add (const Vector<Number>& v)
{
}
-
template <typename Number>
void Vector<Number>::add (const Number a, const Vector<Number>& v)
{
}
-
template <typename Number>
void Vector<Number>::add (const Number a, const Vector<Number>& v,
const Number b, const Vector<Number>& w)
}
-
template <typename Number>
void Vector<Number>::sadd (const Number x, const Vector<Number>& v)
{
}
-
template <typename Number>
void Vector<Number>::sadd (const Number x, const Number a, const Vector<Number>& v)
{
}
-
template <typename Number>
void Vector<Number>::sadd (const Number x, const Number a,
const Vector<Number>& v, const Number b, const Vector<Number>& w)
}
-
template <typename Number>
void Vector<Number>::sadd (const Number x, const Number a,
const Vector<Number>& v, const Number b,
}
-
template <typename Number>
void Vector<Number>::scale (const Number factor)
{
}
-
template <typename Number>
void Vector<Number>::equ (const Number a, const Vector<Number>& u,
const Number b, const Vector<Number>& v)
}
-
template <typename Number>
void Vector<Number>::equ (const Number a, const Vector<Number>& u)
{
}
-
template <typename Number>
void Vector<Number>::ratio (const Vector<Number> &a, const Vector<Number> &b) {
Assert (dim!=0, ExcEmptyVector());
};
-
template <typename Number>
Vector<Number>& Vector<Number>::operator = (const Number s)
{
}
-
template <typename Number>
Vector<Number>&
Vector<Number>::operator = (const Vector<Number>& v)
}
-
template <typename Number>
template<typename Number2>
Vector<Number>&
}
-
template <typename Number>
void Vector<Number>::print (FILE* f, const char* format) const
{
}
-
template <typename Number>
void Vector<Number>::print (const char* format) const
{
}
-
template <typename Number>
void Vector<Number>::print (ostream &out,
unsigned int precision,
};
-
template <typename Number>
void Vector<Number>::block_write (ostream &out) const {
AssertThrow (out, ExcIO());
};
-
template <typename Number>
void Vector<Number>::block_read (istream &in) {
AssertThrow (in, ExcIO());
in >> c;
AssertThrow (c==']', ExcIO());
AssertThrow (in, ExcIO());
-};
+}
+#endif
-/*---------------------------- vector_memory.h ---------------------------*/
-/* $Id$ */
-#ifndef __lac__vector_memory_H
-#define __lac__vector_memory_H
-/*---------------------------- vector_memory.h ---------------------------*/
+//---------------------------- vector_memory.h ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- vector_memory.h ---------------------------
+#ifndef __deal2__vector_memory_h
+#define __deal2__vector_memory_h
#include <base/subscriptor.h>
#include <vector>
-
/**
* Memory management for vectors. This class is used by all
* iterative methods to allocate space for auxilliary
};
-
-
-
/**
* Simple memory management. This memory class is just made for
* tests. It just allocates and deletes
};
-
/* --------------------- inline functions ---------------------- */
}
-
template<typename Vector>
GrowingVectorMemory<Vector>::~GrowingVectorMemory()
{
}
-
template<typename Vector>
Vector*
GrowingVectorMemory<Vector>::alloc()
return t.second;
}
-
-
+
template<typename Vector>
void
GrowingVectorMemory<Vector>::free(const Vector* const v)
}
-/*---------------------------- vector_memory.h ---------------------------*/
-/* end of #ifndef __vector_memory_H */
#endif
-/*---------------------------- vector_memory.h ---------------------------*/
-// $Id$
+//---------------------------- full_matrix.double.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- full_matrix.double.cc ---------------------------
-// Driver for FullMatrix template instantiation.
-
-/* Instantiation is controlled by preprocessor symbols:
- *
- * 1. TYPEMAT : numerical type used in the matrix
- * 2. TYPEVEC : numerical type for vector entries
- * 3. TYPERES : numerical type for entries in the right hand side vector
- * 4. TYPEMAT2: numerical type for the second matrix
- */
#include <lac/full_matrix.templates.h>
-// $Id$
+//---------------------------- full_matrix.float.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- full_matrix.float.cc ---------------------------
-// Driver for FullMatrix template instantiation.
-
-/* Instantiation is controlled by preprocessor symbols:
- *
- * 1. TYPEMAT : numerical type used in the matrix
- * 2. TYPEVEC : numerical type for vector entries
- * 3. TYPERES : numerical type for entries in the right hand side vector
- * 4. TYPEMAT2: numerical type for the second matrix
- */
#include <lac/full_matrix.templates.h>
-/*---------------------------- precondition_block.cc ---------------------------*/
-/* $Id$ */
-/* Ralf Hartmann, University of Heidelberg */
-
+//---------------------------- precondition_block.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- precondition_block.cc ---------------------------
#include <lac/precondition_block.templates.h>
-
-
// explicit instantiations for "float" PreconditionBlock
template class PreconditionBlock<float, float>;
// higher precision than the matrix itself
-
// explicit instantiations for "double" PreconditionBlockSOR
template class PreconditionBlockSOR<double, float>;
Vector<double> &, const Vector<double> &) const;
-
-
-
-
-/*---------------------------- precondition_block.cc ---------------------------*/
-// $Id$
+//---------------------------- solver_control.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- solver_control.cc ---------------------------
+
#include <base/logstream.h>
#include <lac/solver_control.h>
{
deallog << "Starting value " << check_value << endl;
}
-
- if (step>=maxsteps)
+
+if (step>=maxsteps)
{
if (log_result)
deallog << "Failure step " << step
};
-
double
SolverControl::last_value() const
{
};
-
unsigned int
SolverControl::last_step() const
{
};
-
-
/*----------------------- ReductionControl ---------------------------------*/
-
ReductionControl::ReductionControl(const unsigned int n,
const double tol,
const double red,
ReductionControl::initial_value() const {
return initial_val;
};
-
SolverControl::State
-/* $Id$ */
+//---------------------------- sparse_ilu.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- sparse_ilu.cc ---------------------------
+
#include <lac/sparse_ilu.templates.h>
-// $Id$
+//---------------------------- sparse_matrix.double.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- sparse_matrix.double.cc ---------------------------
-// SparseMatrix template instantiation
-
-
-/* Instantiation is controlled by preprocessor symbols:
- *
- * 1. TYPEMAT : numerical type used in the matrix
- * 2. TYPE2 : numerical type for function arguments
- */
#include <cmath>
#include <lac/sparse_matrix.templates.h>
-// $Id$
+//---------------------------- sparse_matrix.float.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- sparse_matrix.float.cc ---------------------------
-// SparseMatrix template instantiation
-
-
-/* Instantiation is controlled by preprocessor symbols:
- *
- * 1. TYPEMAT : numerical type used in the matrix
- * 2. TYPE2 : numerical type for function arguments
- */
#include <cmath>
#include <lac/sparse_matrix.templates.h>
-// $Id$
+//---------------------------- sparse_matrix.long_double.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- sparse_matrix.long_double.cc ---------------------------
-// SparseMatrix template instantiation
-
-
-/* Instantiation is controlled by preprocessor symbols:
- *
- * 1. TYPEMAT : numerical type used in the matrix
- * 2. TYPE2 : numerical type for function arguments
- */
#include <cmath>
#include <lac/sparse_matrix.templates.h>
-/* $Id$ */
+//---------------------------- sparse_vanka.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- sparse_vanka.cc ---------------------------
+
#include <lac/sparse_vanka.templates.h>
-// $Id$
-
-// This file was once part of the DEAL Library
-// DEAL is Copyright(1995) by
-// Roland Becker, Guido Kanschat, Franz-Theo Suttmeier
-// Revised, modified and extended by Wolfgang Bangerth, 1998, 1999
+//---------------------------- sparsity_pattern.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- sparsity_pattern.cc ---------------------------
#include <lac/sparse_matrix.h>
};
-
SparsityPattern::SparsityPattern (const SparsityPattern &s) :
Subscriptor(),
max_dim(0),
};
-
SparsityPattern::SparsityPattern (const unsigned int m,
const unsigned int n,
const unsigned int max_per_row)
};
-
SparsityPattern::SparsityPattern (const unsigned int m,
const unsigned int n,
const vector<unsigned int> &row_lengths)
};
-
SparsityPattern::SparsityPattern (const unsigned int n,
const unsigned int max_per_row)
: max_dim(0),
};
-
SparsityPattern::SparsityPattern (const unsigned int m,
const vector<unsigned int> &row_lengths)
: max_dim(0),
};
-
SparsityPattern::SparsityPattern (const SparsityPattern &original,
const unsigned int max_per_row,
const unsigned int extra_off_diagonals)
};
-
SparsityPattern::~SparsityPattern ()
{
if (rowstart != 0) delete[] rowstart;
}
-
SparsityPattern &
SparsityPattern::operator = (const SparsityPattern &s)
{
};
-
-
void
SparsityPattern::reinit (const unsigned int m,
const unsigned int n,
};
-
void
SparsityPattern::reinit (const unsigned int m,
const unsigned int n,
*max_element(row_lengths.begin(), row_lengths.end()));
- // allocate memory for the rowstart
+// allocate memory for the rowstart
// values, if necessary
if (rows > max_dim)
{
// now allocate the respective memory
unsigned int *new_colnums = new unsigned int[nonzero_elements];
-
- // reserve temporary storage to
+
+// reserve temporary storage to
// store the entries of one row
vector<unsigned int> tmp_entries (max_row_length);
};
-
bool
SparsityPattern::empty () const {
// let's try to be on the safe side of
};
-
unsigned int
SparsityPattern::max_entries_per_row () const
{
};
-
unsigned int
SparsityPattern::operator () (const unsigned int i,
const unsigned int j) const
}
-
void
SparsityPattern::add (const unsigned int i,
const unsigned int j)
}
-
void
SparsityPattern::print_gnuplot (ostream &out) const
{
}
-
unsigned int
SparsityPattern::bandwidth () const
{
-// $Id$
+//---------------------------- vector.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- vector.cc ---------------------------
+
#include <lac/vector.templates.h>
-// $Id$
+//---------------------------- vector.long_double.cc ---------------------------
+// $Id$
+// Version: $Name$
+//
+// Copyright (C) 1998, 1999, 2000 by the deal.II authors
+//
+// This file is subject to QPL and may not be distributed
+// without copyright and license information. Please refer
+// to the file deal.II/doc/license.html for the text and
+// further information on this license.
+//
+//---------------------------- vector.long_double.cc ---------------------------
+
#include <lac/vector.templates.h>
projects / dealii-svn.git / commitdiff