Library deal

[ Keywords | Classes | Data | Functions ]

Quick Index


Classes

AdaptiveInfo
To be redesigned.
Adaptor
Base class for refinement strategies.
AdaptorSort
Provides a sorted list of cells to adapt.
ArrayList
Combination of array and list structure
ArrayNode
Linked memory block
AssembleData
Block
BlockFunction
BlockVector
BoundaryLine
BoundaryQuad
Cell
Base class for all polygons and polyhedra of a grid.
CellPtr
CellPtrBase
Base class for CellPtr
DListBase
Base class for DoubleList
DoubleList
Double linked intrusive list
DoubleNode
Implementation class for DoubleList
Element
Base class for shape function classes
Error
Base class for error handlers.
ExtraQuadFace
FMatrix
Full matrix of T
Face
File
Function2D
Function3D
H1
H1Hybrid
HangingNodes
Hex
IntError
Error of integer number
IterationInfo
To be redesigned.
IterationMem
L1
L1to2D
L2to2D
Line
LineFace
LineHang
LocalSystem
MGInfo
MGMatrix
Multi-grid matrix for the use of element-matrices.
MGStructure
MGVector
Multi-grid version of VECTOR
NCAdaptor
Numerus clausus Adaptor
P1
P1Hybrid
P2
P2LOCAL
Polygon
Pool
ProtoMatrix
Prototype
PtFace
Ptr
Q1
Q1Hybrid
Q2
Q2LOCAL
Quad
QuadFace
QuadHang
ReadFile
RefinedLineFace
RefinedPtFace
RefinedQuadFace
RefinedTriFace
RelativeAdaptor
Adaptor refining according to maximum criterion().
RelativeIterationInfo
To be redesigned.
RelativeMGInfo
SparseArray
Packed 2D array with varying length of lines
StringError
Error with variable string
StringIntError
Error of integer number with additional string
TimeInfo
Timer
System Time
Tri
TriFace
TriHang
Triangulation
All data of a mesh.
Vector
Full matrix of T
VectorBase
Vertex
2D Vertices of triangulation cells.
VertexPtr
Replacement for VERTEX*
WriteFile
dDMatrix
dEMatrix
dFMatrix
Double precision full matrix
dRMatrix
dSMatrix
dSMatrixStruct
dVRMatrix
dVector
fFMatrix
Double precision full matrix
iVector

Back to the top of deal

Data

TQuadrature QTMidpoint
TQuadrature QTTrapez
TQuadrature QTSimpson
TQuadrature QTGauss3
TQuadrature QTGauss7
TQuadrature QTGaussRadau16
QQuadrature QQMidpoint
QQuadrature QQSimpson
QQuadrature QQTrapez
QQuadrature QQGauss4
QQuadrature QQGauss9
QQuadrature QQGauss16
QQuadrature QQGauss36
HQuadrature QHMidpoint
HQuadrature QHGauss8
HQuadrature QHGauss64
HQuadrature QHSimpson
typedef DoubleNode* DoubleNodePtr;
typedef const DoubleNode* cDoubleNodePtr;
typedef enum FaceQual;

Back to the top of deal

Global Functions

ThreshAdaptor(Triangulation& t, float tolerance, float refine_thresh , float double_thresh , float coarse_thresh ) ;
void new_tolerance(float t) ;
template<class MATRIX,class VECTOR,class MEM> int bicgstab(MATRIX& A, VECTOR& x, VECTOR& b, MEM& mem, IterationInfo& info)
template<class MATRIX,class VECTOR,class MEM> int bicgstab_ex(MATRIX& A, VECTOR& x, const VECTOR& b, MEM& mem, IterationInfo& info)
template<class MT, class VT, class MEM> int cg_simple(MT& A, VT& x, VT& b, MEM& mem, IterationInfo& info)
template <class MT,class VT,class MEM> int cg(MT& M,VT& x,VT& b,MEM& mem, IterationInfo& info)
template <class MT,class VT,class MEM> void cr(MT& M,VT& x,VT& b,MEM& mem,IterationInfo& info)
fVector();
fVector(const fVector& v);
fVector(int n);
~fVector();
void reinit(int n, int fast );
void reinit(const fVector&, int fast );
void reinit(const dVector&, int fast );
int n() const;
float operator()(int i) const;
float& operator()(int i);
double operator*(const fVector& v) const;
fVector& operator=(double s);
fVector& operator=(const fVector& v);
void add(const double);
void add(const fVector&);
void add(double, const fVector&);
void add(double, const fVector&, double, const fVector&);
void sadd(double, const fVector&);
void sadd(double, double, const fVector&);
void sadd(double, double, const fVector&, double, const fVector&);
void sadd(double, double, const fVector&, double, const fVector&, double, const fVector&);
void equ(double, const fVector&);
void equ(double, const fVector&, double, const fVector&);
void czero(int);
void cequ(int, const VectorBase&, double, int);
void cequ(int, const VectorBase&, double, int, double, int);
void cequ(int, const VectorBase&, double, int, double, int, double, int, double, int);
void cadd(int, const VectorBase&, double, int);
void cadd(int, const VectorBase&, double, int, double, int);
void cadd(int, const VectorBase&, double, int, double, int, double, int, double, int);
const char* name() const;
void print(FILE* fp, const char* format ) const;
template<class MATRIX, class VECTOR, class MEM> int gmres(MATRIX& A, VECTOR& x, VECTOR& b, MEM& mem, IterationInfo& info)
template<class MATRIX, class VECTOR, class MEM> int pgmres(MATRIX& A, VECTOR& x, VECTOR& b, MEM& mem, IterationInfo& info)
template<class MATRIX, class VECTOR, class MEM> int pgmres0(MATRIX& A, VECTOR& x, VECTOR& b, MEM& mem, IterationInfo& info)
template<class MATRIX, class VECTOR, class MEM> double mgstep( int l, MATRIX& A, VECTOR& u, VECTOR& f, MEM& mem, MGInfo& info, double& res)
template<class MATRIX, class VECTOR, class MEM> void mg( MATRIX& A, VECTOR& u, VECTOR& f, MEM& mem, MGInfo& info)
template<class MATRIX, class VECTOR, class MEM> void mg_nores( MATRIX& A, VECTOR& u, VECTOR& f, MEM& mem, MGInfo& info)
void reinit();
template<class MT, class VT, class MEM> int nl(MT& A, VT& u, MEM& mem, IterationInfo& info)
template<class MT, class VT, class MEM> int nonlinear(MT& A, VT& u, MEM& mem, IterationInfo& info)
template<class MT> int nonlinear_light(MT& A, IterationInfo& info)
template<class MATRIX,class VECTOR,class MEM> int qmr(MATRIX& A, VECTOR& x, const VECTOR& b, MEM& mem, IterationInfo& info)
template<class MATRIX, class VECTOR, class MEM> int richardson(MATRIX& A, VECTOR& x, VECTOR& b, MEM& mem, IterationInfo& info) ;
template<class T> void swap(T* a, T* b) ;
template<class T> void simple_sort(long n, T* field) ;
template<class T> void heapsort(int n, T* field)
template<class T> void quicksort(long r, T* a, long l ) ;
template<class PROBLEM, class VECTOR> void timestepping(PROBLEM& P,VECTOR& u,VECTOR& b,TimeInfo& info) ;

Back to the top of deal

ThreshAdaptor(Triangulation& t, float tolerance, float refine_thresh , float double_thresh , float coarse_thresh ) ;

#include "adaptor.h"

Constructor taking as arguments the triangulation as well as a local tolerance 

  ThreshAdaptor(Triangulation& t, float tolerance, float refine_thresh = 1.,
		float double_thresh = 1.e30, float coarse_thresh = 0.)
    ;

Function is currently defined inline.


Back to the top of deal

void new_tolerance(float t) ;

#include "adaptor.h"

Change tolerance to a new value 

  void new_tolerance(float t)             
;

Function is currently defined inline.


Back to the top of deal

TQuadrature QTTrapez

#include "allquadratures.h"

extern TQuadrature QTMidpoint

Back to the top of deal

TQuadrature QTSimpson

#include "allquadratures.h"

extern TQuadrature QTTrapez

Back to the top of deal

TQuadrature QTGauss3

#include "allquadratures.h"

extern TQuadrature QTSimpson

Back to the top of deal

TQuadrature QTGauss7

#include "allquadratures.h"

extern TQuadrature QTGauss3

Back to the top of deal

TQuadrature QTGaussRadau16

#include "allquadratures.h"

extern TQuadrature QTGauss7

Back to the top of deal

QQuadrature QQMidpoint

#include "allquadratures.h"

extern TQuadrature QTGaussRadau16

Back to the top of deal

QQuadrature QQSimpson

#include "allquadratures.h"

extern QQuadrature QQMidpoint

Back to the top of deal

QQuadrature QQTrapez

#include "allquadratures.h"

extern QQuadrature QQSimpson

Back to the top of deal

QQuadrature QQGauss4

#include "allquadratures.h"

extern QQuadrature QQTrapez

Back to the top of deal

QQuadrature QQGauss9

#include "allquadratures.h"

extern QQuadrature QQGauss4

Back to the top of deal

QQuadrature QQGauss16

#include "allquadratures.h"

extern QQuadrature QQGauss9

Back to the top of deal

QQuadrature QQGauss36

#include "allquadratures.h"

extern QQuadrature QQGauss16

Back to the top of deal

HQuadrature QHMidpoint

#include "allquadratures.h"

extern QQuadrature QQGauss36

Back to the top of deal

HQuadrature QHGauss8

#include "allquadratures.h"

extern HQuadrature QHMidpoint

Back to the top of deal

HQuadrature QHGauss64

#include "allquadratures.h"

extern HQuadrature QHGauss8

Back to the top of deal

HQuadrature QHSimpson

#include "allquadratures.h"

extern HQuadrature QHGauss64

Back to the top of deal

HQuadrature QHSimpson

#include "allquadratures.h"

extern HQuadrature QHSimpson

Back to the top of deal

template<class MATRIX,class VECTOR,class MEM> int bicgstab(MATRIX& A, VECTOR& x, VECTOR& b, MEM& mem, IterationInfo& info)

#include "bicgstab.h"

Bi-cgstab Verfahren 

template<class MATRIX,class VECTOR,class MEM>
inline int bicgstab(MATRIX& A, VECTOR& x,  VECTOR& b,
		    MEM& mem, IterationInfo& info)

Function is currently defined inline.


Back to the top of deal

template<class MATRIX,class VECTOR,class MEM> int bicgstab_ex(MATRIX& A, VECTOR& x, const VECTOR& b, MEM& mem, IterationInfo& info)

#include "bicgstab.h"

Bi-cgstab Verfahren mit exakter Residuumsberechnung 

template<class MATRIX,class VECTOR,class MEM>
inline int bicgstab_ex(MATRIX& A, VECTOR& x, const VECTOR& b,
		    MEM& mem, IterationInfo& info)

Function is currently defined inline.


Back to the top of deal

template<class MT, class VT, class MEM> int cg_simple(MT& A, VT& x, VT& b, MEM& mem, IterationInfo& info)

#include "cg.h"

GROUP: Iterative Linear Solvers 

template<class MT, class VT, class MEM>
inline int cg_simple(MT& A, VT& x, VT& b, MEM& mem, IterationInfo& info)

Function is currently defined inline.


Back to the top of deal

template <class MT,class VT,class MEM> int cg(MT& M,VT& x,VT& b,MEM& mem, IterationInfo& info)

#include "cg.h"

template <class MT,class VT,class MEM>
inline int cg(MT& M,VT& x,VT& b,MEM& mem, IterationInfo& info)

Function is currently defined inline.


Back to the top of deal

template <class MT,class VT,class MEM> void cr(MT& M,VT& x,VT& b,MEM& mem,IterationInfo& info)

#include "cr.h"

GROUP: Iterative Linear Solvers 

template <class MT,class VT,class MEM>
void cr(MT& M,VT& x,VT& b,MEM& mem,IterationInfo& info)

Back to the top of deal

typedef DoubleNode* DoubleNodePtr;

#include "doublelist.h"

typedef DoubleNode* DoubleNodePtr;

Back to the top of deal

typedef const DoubleNode* cDoubleNodePtr;

#include "doublelist.h"

typedef const DoubleNode* cDoubleNodePtr;

Back to the top of deal

typedef enum FaceQual;

#include "face.h"

typedef enum
{
  face_normal = 0,
  face_fulltop = 1,
  face_numeric = 2,
  face_norecursion = 4
} FaceQual;

Back to the top of deal

fVector();

#include "fvector.h"

  fVector();

Back to the top of deal

fVector(const fVector& v);

#include "fvector.h"

  fVector(const fVector& v);

Back to the top of deal

fVector(int n);

#include "fvector.h"

  fVector(int n);

Back to the top of deal

~fVector();

#include "fvector.h"

  ~fVector();

Back to the top of deal

void reinit(int n, int fast );

#include "fvector.h"

  void reinit(int n, int fast = 0);

Back to the top of deal

void reinit(const fVector&, int fast );

#include "fvector.h"

  void reinit(const fVector&, int fast = 0);

Back to the top of deal

void reinit(const dVector&, int fast );

#include "fvector.h"

  void reinit(const dVector&, int fast = 0);

Back to the top of deal

int n() const;

#include "fvector.h"

  int n() const; // Abfrage der Dimension

Back to the top of deal

float operator()(int i) const;

#include "fvector.h"

  float operator()(int i) const; // read-only Zugriff

Back to the top of deal

float& operator()(int i);

#include "fvector.h"

  float& operator()(int i); //Zugriff auf die Komponenten

Back to the top of deal

double operator*(const fVector& v) const;

#include "fvector.h"

  double operator*(const fVector& v) const; //Skalarprodukt

Back to the top of deal

fVector& operator=(double s);

#include "fvector.h"

  fVector& operator=(double s);

Back to the top of deal

fVector& operator=(const fVector& v);

#include "fvector.h"

  fVector& operator=(const fVector& v);

Back to the top of deal

void add(const double);

#include "fvector.h"

  void add(const double);

Back to the top of deal

void add(const fVector&);

#include "fvector.h"

  void add(const fVector&);

Back to the top of deal

void add(double, const fVector&);

#include "fvector.h"

  void add(double, const fVector&);

Back to the top of deal

void add(double, const fVector&, double, const fVector&);

#include "fvector.h"

  void add(double, const fVector&, double, const fVector&);

Back to the top of deal

void sadd(double, const fVector&);

#include "fvector.h"

  void sadd(double, const fVector&);

Back to the top of deal

void sadd(double, double, const fVector&);

#include "fvector.h"

  void sadd(double, double, const fVector&);

Back to the top of deal

void sadd(double, double, const fVector&, double, const fVector&);

#include "fvector.h"

  void sadd(double, double, const fVector&, double, const fVector&);

Back to the top of deal

void sadd(double, double, const fVector&, double, const fVector&, double, const fVector&);

#include "fvector.h"

  void sadd(double, double, const fVector&, double, const fVector&, 
	    double, const fVector&);

Back to the top of deal

void equ(double, const fVector&);

#include "fvector.h"

  void equ(double, const fVector&);

Back to the top of deal

void equ(double, const fVector&, double, const fVector&);

#include "fvector.h"

  void equ(double, const fVector&, double, const fVector&);

Back to the top of deal

void czero(int);

#include "fvector.h"

  void czero(int);

Back to the top of deal

void cequ(int, const VectorBase&, double, int);

#include "fvector.h"

  void cequ(int, const VectorBase&, double, int);

Back to the top of deal

void cequ(int, const VectorBase&, double, int, double, int);

#include "fvector.h"

  void cequ(int, const VectorBase&, double, int, double, int);

Back to the top of deal

void cequ(int, const VectorBase&, double, int, double, int, double, int, double, int);

#include "fvector.h"

  void cequ(int, const VectorBase&, double, int, double, int, double, int, double, int);

Back to the top of deal

void cadd(int, const VectorBase&, double, int);

#include "fvector.h"

  void cadd(int, const VectorBase&, double, int);

Back to the top of deal

void cadd(int, const VectorBase&, double, int, double, int);

#include "fvector.h"

  void cadd(int, const VectorBase&, double, int, double, int);

Back to the top of deal

void cadd(int, const VectorBase&, double, int, double, int, double, int, double, int);

#include "fvector.h"

  void cadd(int, const VectorBase&, double, int, double, int, double, int, double, int);

Back to the top of deal

const char* name() const;

#include "fvector.h"

  virtual const char* name() const;

Back to the top of deal

void print(FILE* fp, const char* format ) const;

#include "fvector.h"

Output of the vector in user-defined format. 

  void print(FILE* fp, const char* format = 0) const;

Back to the top of deal

template<class MATRIX, class VECTOR, class MEM> int gmres(MATRIX& A, VECTOR& x, VECTOR& b, MEM& mem, IterationInfo& info)

#include "gmres.h"

template<class MATRIX, class VECTOR, class MEM>
inline int gmres(MATRIX& A, VECTOR& x, VECTOR& b,
		      MEM& mem, IterationInfo& info)

Function is currently defined inline.


Back to the top of deal

template<class MATRIX, class VECTOR, class MEM> int pgmres(MATRIX& A, VECTOR& x, VECTOR& b, MEM& mem, IterationInfo& info)

#include "gmres.h"

template<class MATRIX, class VECTOR, class MEM>
inline int pgmres(MATRIX& A, VECTOR& x, VECTOR& b,
		      MEM& mem, IterationInfo& info)

Function is currently defined inline.


Back to the top of deal

template<class MATRIX, class VECTOR, class MEM> int pgmres0(MATRIX& A, VECTOR& x, VECTOR& b, MEM& mem, IterationInfo& info)

#include "gmres.h"

template<class MATRIX, class VECTOR, class MEM>
inline int pgmres0(MATRIX& A, VECTOR& x, VECTOR& b,
		      MEM& mem, IterationInfo& info)

Function is currently defined inline.


Back to the top of deal

template<class MATRIX, class VECTOR, class MEM> double mgstep( int l, MATRIX& A, VECTOR& u, VECTOR& f, MEM& mem, MGInfo& info, double& res)

#include "mg.h"

template<class MATRIX, class VECTOR, class MEM>
inline double mgstep( int l, MATRIX& A, 
	     VECTOR& u, VECTOR& f, MEM& mem, MGInfo& info, double& res)

Function is currently defined inline.


Back to the top of deal

template<class MATRIX, class VECTOR, class MEM> void mg( MATRIX& A, VECTOR& u, VECTOR& f, MEM& mem, MGInfo& info)

#include "mg.h"

template<class MATRIX, class VECTOR, class MEM>
inline void mg( MATRIX& A, VECTOR& u, VECTOR& f, MEM& mem, MGInfo& info)

Function is currently defined inline.


Back to the top of deal

template<class MATRIX, class VECTOR, class MEM> void mg_nores( MATRIX& A, VECTOR& u, VECTOR& f, MEM& mem, MGInfo& info)

#include "mg.h"

template<class MATRIX, class VECTOR, class MEM>
inline void mg_nores( MATRIX& A, VECTOR& u, VECTOR& f, MEM& mem, MGInfo& info)

Function is currently defined inline.


Back to the top of deal

void reinit();

#include "mgtriangulation.h"

  void reinit();

Back to the top of deal

template<class MT, class VT, class MEM> int nl(MT& A, VT& u, MEM& mem, IterationInfo& info)

#include "nonlinear.h"

template<class MT, class VT, class MEM>
inline int nl(MT& A, VT& u, MEM& mem, IterationInfo& info)

Function is currently defined inline.


Back to the top of deal

template<class MT, class VT, class MEM> int nonlinear(MT& A, VT& u, MEM& mem, IterationInfo& info)

#include "nonlinear.h"

template<class MT, class VT, class MEM>
inline int nonlinear(MT& A, VT& u, MEM& mem, IterationInfo& info)

Function is currently defined inline.


Back to the top of deal

template<class MT> int nonlinear_light(MT& A, IterationInfo& info)

#include "nonlinear.h"

template<class MT>
inline int nonlinear_light(MT& A, IterationInfo& info)

Function is currently defined inline.


Back to the top of deal

template<class MATRIX,class VECTOR,class MEM> int qmr(MATRIX& A, VECTOR& x, const VECTOR& b, MEM& mem, IterationInfo& info)

#include "qmr.h"

QMR-Verfahren 

template<class MATRIX,class VECTOR,class MEM>
inline int qmr(MATRIX& A, VECTOR& x, const VECTOR& b,
		    MEM& mem, IterationInfo& info)

Function is currently defined inline.


Back to the top of deal

template<class MATRIX, class VECTOR, class MEM> int richardson(MATRIX& A, VECTOR& x, VECTOR& b, MEM& mem, IterationInfo& info) ;

#include "richardson.h"

template<class MATRIX, class VECTOR, class MEM>
inline int richardson(MATRIX& A, VECTOR& x, VECTOR& b,
		      MEM& mem, IterationInfo& info)
                                                                                                                                                                                                                                                                                                                                  
;

Function is currently defined inline.


Back to the top of deal

template<class T> void swap(T* a, T* b) ;

#include "sort.h"

template<class T>
inline void swap(T* a, T* b)
                                    
;

Function is currently defined inline.


Back to the top of deal

template<class T> void simple_sort(long n, T* field) ;

#include "sort.h"

template<class T>
inline void simple_sort(long n, T* field)
                                                                                                                                                       
;

Function is currently defined inline.


Back to the top of deal

template<class T> void heapsort(int n, T* field)

#include "sort.h"

template<class T>
inline void heapsort(int n, T* field)

Function is currently defined inline.


Back to the top of deal

template<class T> void quicksort(long r, T* a, long l ) ;

#include "sort.h"

template<class T>
inline void quicksort(long r, T* a, long l = 1)
                                                                                                                                                                                                                                                                         
;

Function is currently defined inline.


Back to the top of deal

template<class PROBLEM, class VECTOR> void timestepping(PROBLEM& P,VECTOR& u,VECTOR& b,TimeInfo& info) ;

#include "timestepping.h"

template<class PROBLEM, class VECTOR>
void timestepping(PROBLEM& P,VECTOR& u,VECTOR& b,TimeInfo& info)
                                                                                                                                                                                          
;

Function is currently defined inline.


Back to the top of deal