Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 123]

►Naglowav	Used for the aglowav classes for the boundary element method
►CBiClNode00	Binary node for the cluster and Haar wavelet agglomeration algorithm
CNE	Node -> rght, leaf -> elm
CBiHaar3d	Agglomerated binary wavelet space
CBiHaar3dBFSScan	Scanner of the BiHaar3d space ("breadth" first search (bfs)) (1
CBiHaar3dDFSScan	Scanner of the BiHaar3d space (depth first search (dfs)) (1
CBiTree	Binary tree
CBiTreeTraits	Traits for the binary tree algorithm
CC2_tl2	Weighted diagonal preconditioner for the binary Wavelets
CC2tl2	Inverse weighted diagonal preconditioner for the binary Wavelets (inverse of C2_tl2)
CC2W	Transformation operator from the adaptive constant space to the agglomerated wavelet space without scaling
CCGt2	Weighted diagonal preconditioner for the binary Wavelets
CClstBiTreeTraits	Traits for the binary cluster tree algorithm
CComposeN	Composes more than 2 operators
CEst01	Error estimator for the constant space
CEst02	Error estimator for the constant space
CEst03	Error estimator for the constant space
CEst04	Error estimator for the constant space
CHaar3d	Agglomerated wavelet space
CHaar3d000	Binary space element for the agglomerated wavelets
CHaar3dBFSScan	Scanner of the Haar3d space ("breadth" first search (bfs)) (1
CHaar3dDFSScan	Scanner of the Haar3d space (depth first search (dfs)) (1
►CHaar3dXXX	Abstract space element for the agglomerated wavelets
CKey	Key of the wavelet element
CM	Local transformation matrix
COne2ManyTree
COne2ManyTreeTraits	Traits for trees where the nodes have always a fixed number of leafs
CTree01	Binary tree for the cluster and agglomeration algorithm
CTree02	Binary tree for the cluster and agglomeration algorithm
CW2C	Transformation operator from the agglomerated wavelet space to the adaptive constant space without scaling
►Naglowav2	Used for the aglowav2 classes for the boundary element method
►CAglowavBF00	Bilinear form for the stiffness matrix compression with aglomerated wavelets
CCell	Entry in the cache to compute wavelet entries
CNfld	Structure to hold the one scale near field one each level
CC2W	Transformation operator from the constant one scale space to the agglomerated wavelet space (without scaling)
CDelta	Abstract class for the truncation matrix used for wavelet compression
CDelta00	Class for the truncation matrix used for wavelet compression
CDeltaFull	Class for the truncation matrix used for wavelet compression
CF00	Class for the far field matrix F
CHaar3d	Abstract wavelet space
CHaar3d0	Agglomerated wavelet space
CHaar3d000	Space element for the agglomerated wavelets
CHaar3d0BFSScan	Scanner of the Haar3d0 space ("breadth" first search (bfs)) (1
CHaar3d0DFSScan	Scanner of the Haar3d0 space (depth first search (dfs)) (1
CHaar3dBFSScan	Scanner of the Haar3d space ("breadth" first search (bfs)) (1
CHaar3dDFSScan	Scanner of the Haar3d space (depth first search (dfs)) (1
►CHaar3dXXX	Abstract wavelet space element
CKey	Key of a wavelet element
CM000	Local transformation matrix (square matrix, row wise)
CMatrix	Matrix class to convert an array to a matrix without copying
►COperator00	Stiffness matrix compressed with the agglomerated wavelets
CMatrix	Structure to hold one matrix row/column
CPattern	Structure to hold one run of the sparsity pattern
CW2C	Transformation operator from the agglomerated wavelet space to the constant one scale space (without scaling)
CWavIdentity	Identity bilinear form for wavelets
CX00	Class for the far field matrix X
CXY00	Class for the far field matrices X and Y
CY00	Class for the far field matrix Y
►Nalglib
C_ahcreport_owner
C_autogkreport_owner
C_autogkstate_owner
C_barycentricfitreport_owner
C_barycentricinterpolant_owner
C_clusterizerstate_owner
C_decisionforest_owner
C_densesolverlsreport_owner
C_densesolverreport_owner
C_dfreport_owner
C_eigsubspacereport_owner
C_eigsubspacestate_owner
C_hqrndstate_owner
C_idwinterpolant_owner
C_kdtree_owner
C_kdtreerequestbuffer_owner
C_kmeansreport_owner
C_lincgreport_owner
C_lincgstate_owner
C_linearmodel_owner
C_linlsqrreport_owner
C_linlsqrstate_owner
C_logitmodel_owner
C_lrreport_owner
C_lsfitreport_owner
C_lsfitstate_owner
C_matinvreport_owner
C_mcpdreport_owner
C_mcpdstate_owner
C_minasareport_owner
C_minasastate_owner
C_minbcreport_owner
C_minbcstate_owner
C_minbleicreport_owner
C_minbleicstate_owner
C_mincgreport_owner
C_mincgstate_owner
C_minlbfgsreport_owner
C_minlbfgsstate_owner
C_minlmreport_owner
C_minlmstate_owner
C_minnlcreport_owner
C_minnlcstate_owner
C_minnsreport_owner
C_minnsstate_owner
C_minqpreport_owner
C_minqpstate_owner
C_mlpcvreport_owner
C_mlpensemble_owner
C_mlpreport_owner
C_mlptrainer_owner
C_mnlreport_owner
C_modelerrors_owner
C_multilayerperceptron_owner
C_nleqreport_owner
C_nleqstate_owner
C_normestimatorstate_owner
C_odesolverreport_owner
C_odesolverstate_owner
C_polynomialfitreport_owner
C_polynomialsolverreport_owner
C_pspline2interpolant_owner
C_pspline3interpolant_owner
C_rbfcalcbuffer_owner
C_rbfmodel_owner
C_rbfreport_owner
C_sparsebuffers_owner
C_sparsematrix_owner
C_spline1dfitreport_owner
C_spline1dinterpolant_owner
C_spline2dinterpolant_owner
C_spline3dinterpolant_owner
C_xdebugrecord1_owner
Cae_matrix_wrapper
Cae_vector_wrapper
Cahcreport
Cap_error
Cautogkreport
Cautogkstate
Cbarycentricfitreport
Cbarycentricinterpolant
Cboolean_1d_array
Cboolean_2d_array
Cclusterizerstate
Ccomplex
Ccomplex_1d_array
Ccomplex_2d_array
Cdecisionforest
Cdensesolverlsreport
Cdensesolverreport
Cdfreport
Ceigsubspacereport
Ceigsubspacestate
Chqrndstate
Cidwinterpolant
Cinteger_1d_array
Cinteger_2d_array
Ckdtree
Ckdtreerequestbuffer
Ckmeansreport
Clincgreport
Clincgstate
Clinearmodel
Clinlsqrreport
Clinlsqrstate
Clogitmodel
Clrreport
Clsfitreport
Clsfitstate
Cmatinvreport
Cmcpdreport
Cmcpdstate
Cminasareport
Cminasastate
Cminbcreport
Cminbcstate
Cminbleicreport
Cminbleicstate
Cmincgreport
Cmincgstate
Cminlbfgsreport
Cminlbfgsstate
Cminlmreport
Cminlmstate
Cminnlcreport
Cminnlcstate
Cminnsreport
Cminnsstate
Cminqpreport
Cminqpstate
Cmlpcvreport
Cmlpensemble
Cmlpreport
Cmlptrainer
Cmnlreport
Cmodelerrors
Cmultilayerperceptron
Cnleqreport
Cnleqstate
Cnormestimatorstate
Codesolverreport
Codesolverstate
Cpolynomialfitreport
Cpolynomialsolverreport
Cpspline2interpolant
Cpspline3interpolant
Crbfcalcbuffer
Crbfmodel
Crbfreport
Creal_1d_array
Creal_2d_array
Csparsebuffers
Csparsematrix
Cspline1dfitreport
Cspline1dinterpolant
Cspline2dinterpolant
Cspline3dinterpolant
Cxdebugrecord1
►Nalglib_impl
Cae_complex
Cae_dyn_block
Cae_frame
Cae_lock
Cae_matrix
Cae_serializer
Cae_shared_pool
Cae_shared_pool_entry
Cae_smart_ptr
Cae_state
Cae_vector
Cahcreport
Capbuffers
Carmijostate
Cautogkinternalstate
Cautogkreport
Cautogkstate
Cbarycentricfitreport
Cbarycentricinterpolant
Cclusterizerstate
Cconvexquadraticmodel
Ccvreport
Cdecisionforest
Cdensesolverlsreport
Cdensesolverreport
Cdfinternalbuffers
Cdfreport
Ceigsubspacereport
Ceigsubspacestate
Cfasttransformplan
Cfblslincgstate
Cgridcalc3v1buf
Chqrndstate
Cidwinterpolant
Ckdtree
Ckdtreerequestbuffer
Ckmeansbuffers
Ckmeansreport
Clincgreport
Clincgstate
Clinearmodel
Clinlsqrreport
Clinlsqrstate
Clinminstate
Clogitmcstate
Clogitmodel
Clrreport
Clsfitreport
Clsfitstate
Cmatinvreport
Cmcpdreport
Cmcpdstate
Cminasareport
Cminasastate
Cminbcreport
Cminbcstate
Cminbleicreport
Cminbleicstate
Cmincgreport
Cmincgstate
Cminlbfgsreport
Cminlbfgsstate
Cminlmreport
Cminlmstate
Cminlmstepfinder
Cminnlcreport
Cminnlcstate
Cminnsqp
Cminnsreport
Cminnsstate
Cminqpreport
Cminqpstate
Cmlpbuffers
Cmlpcvreport
Cmlpensemble
Cmlpetrnsession
Cmlpparallelizationcv
Cmlpreport
Cmlptrainer
Cmnlreport
Cmodelerrors
Cmultilayerperceptron
Cnleqreport
Cnleqstate
Cnormestimatorstate
Cnsfitinternalreport
Codesolverreport
Codesolverstate
Cpolynomialfitreport
Cpolynomialsolverreport
Cprecbuflbfgs
Cprecbuflowrank
Cpspline2interpolant
Cpspline3interpolant
Cqpbleicbuffers
Cqpbleicsettings
Cqpcholeskybuffers
Cqpcholeskysettings
Cqpdenseaulbuffers
Cqpdenseaulsettings
Cqqpbuffers
Cqqpsettings
Crbfcalcbuffer
Crbfmodel
Crbfreport
Crbfv1calcbuffer
Crbfv1model
Crbfv1report
Crbfv2calcbuffer
Crbfv2gridcalcbuffer
Crbfv2model
Crbfv2report
Crcommstate
Csactiveset
Csboolean
Csbooleanarray
Cscomplex
Cscomplexarray
Csinteger
Csintegerarray
Csmlpgrad
Csmlptrnsession
Csnnlssolver
Csparsebuffers
Csparsematrix
Cspline1dfitreport
Cspline1dinterpolant
Cspline2dinterpolant
Cspline3dinterpolant
Csreal
Csrealarray
Cx_matrix
Cx_string
Cx_vector
Cxdebugrecord1
►Nbem	Used for the basic classes of the boundary element method
CAdaptConst3d000	A 3D adaptive BEM space with piecewise constant basis functions without any constaints
CAdaptConst3d001	A 3D adaptive BEM space with piecewise constant basis functions
CAdaptConst3d002	A 3D adaptive BEM space with piecewise constant basis functions
CAdaptiveAdjust	Class to describe adjustments to elements in an adaptive space
CAdaptiveSpace
CAdaptLaplaceDL00	Bilinear form for the Laplace double layer potential with piecewise constant shape functions and hanging nodes (=> recursive subdivision of the larger triangle)
CAdaptLaplaceDL01	Bilinear form for the Laplace double layer potential with piecewise constant shape functions and hanging nodes (=> recursive subdivision of the larger triangle)
CAdaptLaplaceDLP	Linear form for the Laplace Double Layer potential
CAdaptLaplaceSL01	Bilinear form for the Laplace Single Layer potential with piecewise constant shape functions and hanging nodes (=> recursive subdivision of the larger triangle)
CAdaptLaplaceSLP	Linear form for the Laplace Single Layer potential
CArbKrnl000	Bilinear form to compute arbitrary kernels with NO singularities
CArbKrnlGal000	Bilinear form for arbitrary kernel with NO singularities
CArbKrnlGal000Traits
CArbKrnlGal001	Bilinear form for arbitrary kernel with NO singularities
CArbKrnlGal001Traits
CCnst	Constant kernel function (used only to test quadrature schemes)
CConstant3d	A 3D space with discontinuous, piecewise constant basis functions
CConstant3d000	Constant triangular element
►CConstant3d001	Constant space element with a level dependent key
CKey	Key with some level dependent information
CConstant3d002	Constant triangular element with normed basis function
CConstDLPAbscWghtEdg	Abscissas and weights for the case of common edge, double layer potential and constant test/trial functions
CConstDLPAbscWghtVtx	Abscissas and weights for the case of common vertex, double layer potential and constant test/trial functions
CConstSLPAbscWghtEdg	Abscissas and weights for the case of common edge, single layer potential and constant test/trial functions
CConstSLPAbscWghtPnl	Abscissas and weights for the case of common panel, single layer potential and constant test/trial functions
CConstSLPAbscWghtVtx	Abscissas and weights for the case of common vertex, single layer potential and constant test/trial functions
CConstTriGraphics	Handles graphics for trianular constant elements
CD	Diagonal scaling operator for the piecewise constant basis
CD_1	Diagonal scaling operator for the piecewise constant basis
CDirac3d	A 3D space with Dirac basis functions
CDirac3d000	Dirac element on triangles (used for collocation method)
CEdgeMap	Class to map the edges to the two neighbouring panels
CExpR	$e^{-\gamma r}$
CExpR2	$e^{- r^\top \gamma r}$
CGaussAbscWght	Gauss abscissas and weights for the interval
CGaussAbscWghtSym	Symmetric Gauss abscissas and weights for the interval
CIdentity	Bilinear form to compute the mass matrix
CInv1Rn	$\frac{1}{1 + \gamma r^n}$
CLaplace	$\frac{1}{4\pi r}$
CLaplaceDL	Bilinear form to compute the Laplace double layer potential
CLaplaceDLP	Linear form to evaluate the Laplace double layer potential
CLaplaceHyp	Bilinear form to compute the Laplace hypersingular operator
CLaplacePLD	Bilinear form to compute the adjoint of the Laplace double layer potential
CLaplaceSL	Bilinear form to compute the Laplace single layer potential
CLaplaceSLP	Linear form to evaluate the Laplace single layer potential
CLinear3d	A 3D space with continuous, piecewise linear basis functions
CLinear3d000	Linear triangular element
CLinearDLPAbscWghtEdg	Abscissas and weights for the case of common edge, double layer potential and linear test/trial functions
CLinearDLPAbscWghtVtx	Abscissas and weights for the case of common vertex, double layer potential and linear test/trial functions
CLinearHYPAbscWghtEdg	Abscissas and weights for the case of common edge, hypersingular operator and linear test/trial functions
CLinearHYPAbscWghtPnl	Abscissas and weights for the case of common panel, hypersingular operator and linear test/trial functions
CLinearHYPAbscWghtVtx	Abscissas and weights for the case of common vertex, hypersingular operator and linear test/trial functions
CLinearSLPAbscWghtEdg	Abscissas and weights for the case of common edge, single layer potential and linear test/trial functions
CLinearSLPAbscWghtPnl	Abscissas and weights for the case of common panel, single layer potential and linear test/trial functions
CLinearSLPAbscWghtVtx	Abscissas and weights for the case of common vertex, single layer potential and linear test/trial functions
CLinTriGraphics	Handles graphics for trianular linear elements
CLpl000	Evaluation of the Laplace double layer potential with linear trial functions for use in the internal/external points
CLpl001	Evaluation of the Laplace double layer potential with constant trial functions for use in the internal/external points
CLpl003	Evaluation of the Laplace single layer potential with linear trial functions for use in the internal/external points
CLpl004	Evaluation of the Laplace single layer potential with constant trial functions for use in the internal/external points
CLplCol006	Evaluation of the Laplace single layer potential with linear trial functions (collocation)
CLplCol007	Evaluation of the Laplace double layer potential with linear trial functions (collocation)
CLplGal000	Evaluation of the Laplace single layer potential with linear test/trial functions
CLplGal001	Evaluation of the Laplace double layer potential with linear test/trial functions
CLplGal002	Evaluation of the Laplace hypersingular operator with linear test/trial functions
CLplGal004	Evaluation of the Laplace double layer potential with linear test/trial functions
CLplGal005	Evaluation of the Laplace hypersingular operator with linear test/trial functions
CLplGal006	Evaluation of the Laplace single layer potential with linear test/trial functions
CLplGal007	Evaluation of the Laplace double layer potential with linear test/trial functions
CLplGal008	Evaluation of the Laplace hypersingular operator with linear test/trial functions
CLplGal009	Evaluation of the Laplace double layer potential with linear test/trial functions
CLplGal010	Evaluation of the Laplace double layer potential with constant test/trial functions
CLplGal011	Evaluation of the Laplace double layer potential with constant test/trial functions
CLplGal012	Evaluation of the Laplace double layer potential with constant test/trial functions
CLplGal014	Evaluation of the Laplace double layer potential with constant test/trial functions
CLplGal018	Evaluation of the Laplace single layer potential with constant test/trial functions
CNeumann	Linear form
CNoOfIntegrationPointsToHigh	Exception class to express that the number of integration points exceeds the number of precalculated values
CPoly	Polynomial in one variable (used only to test quadrature schemes)
CRiesz	Linear form to evaluate $\int_K f v \, dx$
CStroudAbscWght	Abscissas and weights for Stroud formulas
CStroudLinTrialWght	Abscissas and weight
CTriangleGraphics	Handles graphics for triangles in 3D
►Ncluster	Used for the cluster classes for the boundary element method
CBBall	Abstract class to compute a bounding ball of an element (the leafs of a cluster tree)
CBBall000	Computes the Cebysev ball of an element
CCacheSizeExceeded	Exception class
CCebyCenter	Class to compute the Cebysev ball of a point set, i.e., the smallest ball containing all points
CCebysevKF	part of the Cebysev expansion for arbitrary kernels
CCebysevKFTraits	Interface for the kernel function used by CebysevKF
►CCebysevLaplaceF	part of the Cebysev expansion of the Laplace kernel
CFColCebyLpl	Class to hold the expansion coefficients
CClstF	Abstract class for a far field matrix F
CClstX	Abstract class for the far field matrix X
CClstXY	Abstract class for the far field matrices X and Y
CClstY	Abstract class for the far field matrix Y
►CCluster	Node of a cluster tree
CCE	Data structure to hold a pointer to an element or a child cluster
CDMultipoleX	Normal derivative of the part of the Multipole kernel expansion
CDMultipoleY	Normal derivative of the part of the Multipole kernel expansion
CDTaylorX	Normal derivative of the part of the Taylor kernel expansion
CDTaylorY	Normal derivative of the part of the Taylor kernel expansion
CExpansionF	Abstract class for the part of a kernel expansion
CExpansionXY	Abstract class for the and the part of a kernel expansion
►CF01	Far field matrix F
CFfld	Class to store the far field coefficients
►CF02	Far field matrix F
CFfld	Class to store the far field coefficients
►CF03	Far field matrix F
CFfld	Class to store the far field coefficients
►CF04	Far field matrix F
CFfld	Class to store the far field coefficients
CFColExp	Abstract class to hold the expansion coefficients
CFColF	Class to hold expansion coefficients of type F
CMultipoleLaplaceF	part of the Multipole expansion of the Laplace kernel
CMultipoleX	part of the Multipole kernel expansion
CMultipoleY	part of the Multipole kernel expansion
CNfld	Class to store a pair of clusters in the near field
►COperator01	Cluster approximation of the stiffness matrix
CNfldMatrix	Class to hold the near field entries for two clusters
COperator02	Cluster approximation of the stiffness matrix
CTaylorLaplaceF	part of the Taylor expansion of the Laplace kernel
CTaylorX	part of the Taylor kernel expansion
CTaylorY	part of the Taylor kernel expansion
CTree	Abstract class for a cluster tree
CTree01	Cluster tree
CTree02	Cluster list, i.e., all leafs are on level 0
CTree03	Cluster tree
CTreeTraits	Interface class for a node in a cluster tree
CTreeTraits01	Interface class for a node in the cluster tree Tree01
CTreeTraits02	Interface class for a node in the cluster tree Tree02
CTreeTraits03	Interface class for a node in the cluster tree Tree01
CX01	Class for far field part X
►CXY01	Class to hide some implementation details of the far field matrices X, Y
CXYCol	Data structure to hold the expansion coefficients
CXYFnc	Data structure for auxiliary vectors (one vector per cluster)
CXYColExp	Abstract class to hold the expansion coefficients
CXYColExpPtr	Abstract class for a pointer to the expansion coefficients
CXYColF	Class to hold expansion coefficients of type F
CXYColFPtr	Class for a pointer to expansion coefficients of type F
CY01	Class for far field part Y
►Nconcepts	Basic namespace for Concepts-2
►C_HashedSMatrix_iterator	STL like iterator for hashed sparse matrices
CMatrixType	Non-constant matrix for non-constant iterator
CMatrixType< _Tp_, const _Tp_ &, const _Tp_ * >	Constant matrix for constant iterator
►C_Matrix_iterator	STL iterator for matrices
CMatrixType	Non-constant matrix for non-constant iterator
CMatrixType< _Tp_, const _Tp_ &, const _Tp_ * >	Constant matrix for constant iterator
►C_Matrix_iterator_base	Base class for STL like iterator for matrices
CReturnType	Return Type reference (_Tp&) for non-constant iterator constant copy (const _Tp) for constant iterator
CReturnType< const _Tp_ & >	Return type for derefencation is constant copy for constant iterator
►C_SubMatrix_iterator	STL like iterator for sub matrices
CMatrixType	Non-constant matrix for non-constant iterator
CMatrixType< F_, const F::type &, const F::type * >	Constant matrix for constant iterator
CAbsolute	The absolute value of a element function
CAbsoluteComp	The component wise absolute value of a element function
CAdaptiveAdjust	Class to describe adjustments to elements in an adaptive space
CAdaptiveAdjustP	Class to describe adjustments to elements in an adaptive space
CAdaptiveControl	Class to describe control structures of an adaptive space
CAdaptiveControlP	Describe control structures of a high order adaptive space
CAdaptiveControlTag	Tag information which is used in AdaptiveControl
CAdaptiveModel
CAdaptiveQuadratureRule1d	Adaptive quadrature rule for numerical integration
CAdaptiveSpace	Abstract base class for an adaptive space
CAdaptivity	Abstract base class for an adaptive classes, a.o.t
CAfterIteration	Solver with after iterations
CAnasaziES
CAnasaziMV
CAnasaziOp
CArray	An array of objects
CArrayCoord	Array with coordinates of a cell
CArrayCoord< 1 >	Array with coordinates in 2D
CArrayCoord< 2 >	Array with coordinates in 2D
CArrayDeterminant	Class, which calculates the determinant for each element of the array
CArrayGramMatrix	Class, which calculates the Gram matrix M * M^T for each matrix of the array
CArrayHessian	Array of hessian matrices on quadrature points
CArrayHessian< 1, 1 >	Array of the quadratic form induced by the Hessian Matrix of the inverse transformation apllied on the tangential normal
CArrayJacobian	Array of jacobian matrices on quadrature points
CArrayJacobian< 1, 1 >	Array of jacobian determinants
CArrayJacobian< 2, 2 >	Array of jacobian matrices in 2D on 2D elements
CArrayJacobian< 3, 3 >	Array of jacobian matrices in 3D on 3D elements
CArrayLocalCoord	Array of local coordinates, e.g., inside a quad, but only along an edge
CArrayMatrixInverse	Class, which calculates the inverse matrix for each element of the array
CArrayMatrixTranspose	Class, which calculates the transpose matrix for each element of the array
CArrayReciprocal	Class, which calculates the reciprocal for each element of the array
CArrayScan	Scanner for an Array
CAssertion	Exception class for assertions
CAttribute	Attributes for elements of the topology
CAttributeBool	A function class to query attributes
CAttributesFile
CBaseSequence	Sequence with operations and output operator
CBaseSet	Set with operations and output operator
CBelosLinProb	Decorator that decorates the Class Belos::LinearProblem<T, MV, OP> with interfaces to Concepts SparseMatrix and Vector
CBelosSolver	Concepts interface to Trilinos Belos solver with different ifpack2 preconditioners and different iterative solvers
CBesselJ	Class for evaluating the Bessel function of first kind
CBesselY	Class for evaluating the Bessel function of second kind
CBiCGStab	Solves a symmetric system of linear equations with BiConjugate Gradient Stabilized (BICGSTAB)
CBiCGStabFabric	Fabric class for conjugate gradients: `BiCGStab`
CBilinearF_Sum	Sum of two bilinear forms of possible different underlying field type `F`
CBilinearF_W	Product of scalar and a bilinear form with possible different field type `F`
CBilinearForm	Abstract function class to evaluate a bilinear form
CBilinearFormContainer
CBilinearFormLiCo	A linear combination of bilinear forms
CBlendingHexahedron3d	A 3D hexahedral element map for interpolation between arbitrary curved boundary quadrilateral elements according to the Linear Blending Function Method (Gordon and Hall, 1971)
CBlendingQuad2d	A 2D element map for a curved quadrilateral
CBoundary	Class to describe an element of the boundary
CBoundaryConditions	Boundary conditions
CBuildTColumnsBase	Base class for classes for building T columns for elements in a space with help of space pre builder
CCartesianPMLFormulas	Class for Cartesian PML
CCCell_F	Curved Cell struct that holds a physical non-vertex cell with a finite number of setted point evaluations
CCCell_F_dist	Struct that provides a `CCell_F` object together with a heuristic distance between given point to the finite number of physical points of the underlying cell
CCell	A cell in a mesh consist of topological information (neighbours, connectivity, orientation) and geometrical information (coordinates)
CCell1	One dimensional cell
CCell2	Two dimensional cell
CCell3	Three dimensional cell
CCellBox	CellBox with a specific order relation
CCellCondition
CCellConditions
CCellData	Stores additional information on a cell, namely its father
CCellDiameter	Class representing a map of diameters of elements of a given Space
CCellEdgeIntegral	Integral over a edge, evaluated on a cell
CCellFaceIntegral	Integral over a face, evaluated on a cell
CCellIntegral	Integral, evaluated on a cell
CCellMap	Class representing a map to `ElementWithCells`
CCellPostprocess	Abstract class for per cell postprocessing
CCellStripeElement	Cells ordered by key numbering
CCellToCellMapping
CCellType
CCellType< 1 >
CCellType< 2 >
CCellType< 3 >
CCG	Solves a symmetric system of linear equations with conjugate gradients (CG)
CCGFabric	Fabric class for conjugate gradients: `CG`
►CCircle	Mesh for a circle
CS	Scanner over the cells
►CCircleBoundary
CS	Scanner over the cells
CCircleMappingEdge2d	2D element map for an circular arc
CCircleMappingEdge3d	A 3D circular edge element map
CCloneable	Cloneable interface
CCmplxPart	Abstract class for a function, which is one part of an complex function
CCmplxtype	Taking for a real type the appropiate real type and for a real type itself
CCmplxtype< std::complex< F > >
CCoeffIterator	Iterator for an array of coefficients
CCoeffIterator< F, F >	Iterator for an array of scalar coefficients
CCoeffIterator< F, Mapping< F, dim > >	Iterator for an array of matrix coefficients
CCoeffIterator< F, Point< F, dim > >	Iterator for an array of vector coefficients
CCombtype	Combined type
CCombtype< F, std::complex< F > >	Combined type Real * Cmplx = Cmplx
CCombtype< int, F >	Combined type int * Real = Real int * Cmplx = Cmplx
CCombtype< std::complex< F >, F >	Combined type Cmplx * Real = Cmplx
CComplexFunction	Complex function based on a real function (casting)
CCompose	Computes the product of two operators
CComposeFormulaMatVec	Computes the Matrix-vector product A * vf, where A is a matrix valued formula and vf a vector valued formula
CComposeFormulaVecEntry
CConnector	An abstract class for elements of the topology
CConnector0	A 0D element of the topology
CConnector1	A 1D element of the topology
CConnector2	A 2D element of the topology
CConnector3	A 3D element of the topology
CConnectorData	Generalization of the class which store additional information for topological entities
CConnectTwoMeshes	Connected mesh of two given meshes where edges on both outer boundaries are connected
CConstFormula	Class for a constant formula
CConstrained	Solves a linear system of equations subject to linear constraints
►CConvertMeshQuads	Mesh converter
CS	Scanner class for ConvertMeshQuads
CCoordinate
CCoordinateParam
CCos_n_phi	Class for evaluating $\cos(n\phi), n\in\mathbb{Z}$ for points $(x,y) \in \mathbb{R}^2$ in cartesian coordinates
CCos_n_x	Class for evaluating $\cos(2 \pi n x/ L), n\in\mathbb{Z}$ for points $(x,y) \in \mathbb{R}^2$ in cartesian coordinates
CCos_n_y	Class for evaluating $\cos(2 \pi n y/ L), n\in\mathbb{Z}$ for points $(x,y) \in \mathbb{R}^2$ in cartesian coordinates
CCRSConvertable	Base class for operators which can be converted to Sparse Row Storage (CRS) or Sparse Column Storage (CCS)
►CCuboid	Concepts mesh of an cuboid $[0,a] \times [0,b] \times [0,c]$ in one hexahedron
CS	Scann 3d
CCurlHField_CircularCoil
CCurvatureElementFormula	Formula for the curvature or their derivatives on edges in 2D
CDatatype	Type of the data inside a container
CDatatype< Mapping< F, DimY, DimX > >
CDatatype< Point< F, dim > >
CDDSolver	Domain Decomposition Solver
CDDSpace
CDefFile
CDenseMatrix	Dense matrix
CDiagonalMatrix	Diagonal matrix
CDiagonalSolver	A solver for diagonal matrices
CDiagonalSolverFabric	Fabric class for `DiagonalSolver`
CDimensionMismatch	Exception class to express dimensions not matching
CDirichlet	Class for calculating and holding local coefficients per element which represent the dirichlet boundary condition
CDirichletElementFormula	Dirichlet Data as element formula
CDivGradHField_CircularCoil
CDomainDecomp	Domain decomposition space
CDummySpace	Space for a given dimension but without more functionality
CDynArray	Container class: a dynamic array
CDynArrayBase	Base class for DynArray for the non-template part
CDynArrayPage	A page of a dynamic array
CEddyGeometry2D	Abstract class for holding geometry and material for eddy current problems
CEddyGeometry2DRectImport	Rectangular geometry, source current
CEddyGeometry2DRotateImport	Geometry with rotational symmetric coil
CEddyGeometry2DRotational	Rotational symmetric geometry, conductivity and source current
CEdgCorrFile
CEdge	An edge in the topology
CEdge1d	A 1D cell: edge
CEdge2d	A 1D cell: edge in 2D
CEdgeCoordinateChange	Coordinate changes for edge elements
►CEdgeCoordinateChange< 2 >
CEdgeHash	Hash function
CEdgeCoordinateChange< 3 >	Coordinate changes for edge elements in a parent hexahedron
CEdgeData	Stores additional information on an edge, namely its cells and faces
►CEdgeMesh	Base class for edge meshes
CS	Scanner over the cells
CEdgeNd	A 1D cell in any dimension: edge
CEdgeNormalVectorRule	Base class for defining rules in which direction the normal vector should point for created edges from quads
CEdgeNormalVectorRuleAttrib	Class defining the rule that the normal vector is outwards or inwards cells with giving attribute
CEdgeNormalVectorRuleMidPoint	Class defining the rule that the normal vector is outwards or inwards when looking from a given point
CEdgesOfVertices	Build a mapping from vertices (over their key) in a cell to the edges their belong to
CEdgeTraceType	Class EdgeTraceType holding the information about the TraceType, i.e
CEdgeTraceTypes	Edge Tracetypes
CEdgRadiaFile
CElement	An abstract class for an element of a space
CElementAndFacette	Container for an element and one facette (edge or face)
CElementFormula	Interface for a formula defined element by element
CElementFormulaBoundary	Element formula, which gives formula on the boundary
CElementFormulaCompose
CElementFormulaContainer
CElementFormulaLiCo
CElementFormulaRotate2D	Rotated element formula of a 2D vector (90� to right)
CElementFormulaVector	Vectorial formula created from a FE function
CElementFormulaVector< 1, F, G, H >	Scalar formula created from a FE function
CElementFormulaVectorBase	Base class for Formula created from a FE function
CElementFunction	An abstract class for a function in a FE space
CElementGraphics	Handles graphics output (to a file) of a specific element
CElementGraphicsBase	Base class for graphics output, which holds graphics types
CElementMatrix	Element matrix
CElementMatrixBase	Base class for element matrices
CElementNotInDomainOfFormula	Exception class to express that an inquired element is not in the domain
CElementPair	Gives access to a pair of elements
CElementPairList	Holds a list of `ElementPair` and allows to scan over this list
CElementWithCell	Element with cell
CEllipseMappingEdge2d	2D element map for an ellipsoidal arc (not skewed)
CEstimator
CExceptionBase	Base class for exceptions
CExp_i_n_phi	Class for evaluating $\exp(\mathrm{i}n\phi), n\in\mathbb{Z}$ for points $(x,y) \in \mathbb{R}^2$ in cartesian coordinates
CExp_i_n_x	Class for evaluating $\exp(2 \pi i n x/ L), n\in\mathbb{Z}$ for points $(x,y) \in \mathbb{R}^2$ in cartesian coordinates
CExp_i_n_y	Class for evaluating $\exp(2 \pi i n y/ L), n\in\mathbb{Z}$ for points $(x,y) \in \mathbb{R}^2$ in cartesian coordinates
CExplicitResidual
CEz4uException	Exception class to express a problem in a ez4u input file
CFaceData	Stores additional information on a face, namely its cells
CFaceNormalVectorRule	Class for defining rules in which direction the normal vector should point for created faces from hexahedrons
CFacetteTraceType	Class FacetteTraceType holding the information about the TraceType, i.e
CFacetteTraceTypes	Facette Tracetypes
CFFEF_Error	Exception class to handle errors in the FormulaFromElementFormula class
CFile	Base class for File type recognition
CFileOpenError	Indicates that there were problems in a file open operation
CFluxesError	Exception class to handle errors in the Fluxes class
CFlyweight	Flyweight memory manager
CFormula	Interface for a formula
CFormulaContainer
CFormulaExpImag1D	Formula for $u \mathrm{exp}(ik(x-x_0))$
CFormulaExpImag2D	Formula for $u \mathrm{exp}(ik(x-x_0))$
CFormulaExpImag2DGrad	Formula for gradient of a plane wave
CFormulaExpImag2DRadialDer	Formula for radial derivative of $u \mathrm{exp}(ik(x-x_0))$
CFormulaFromElementFormula	Projection class that allows to project an ElementFormula (i.e
CFormulaIncPlaneWaveSource	Formula for $-a \Delta u_{inc} + b k^2 u_{inc}$
CFormulaLayerPlaneWaveLayer	Formula for plane wave source in layered structure
CFormulaLayerPlaneWaveLayerGrad	Formula for gradient of plane wave source in layered structure
CFormulaLayerPlaneWaveSource	Formula for plane wave source in layered structure
CFormulaLayerPlaneWaveSourceGrad	Formula for plane wave source in layered structure
CFormulaLayerPlaneWaveTotal	Formula for plane wave source in layered structure
CFormulaLayerPlaneWaveTotalGrad	Formula for gradient of plane wave source in layered structure
CFormulaLiCo	Linear combination of two formulae
CFormulaNormalOuterSP2D	Computes the scalar product <n, vf> of the normal n with a vector valued formula vf, the result is a scalar formula in F
CFormulaPMLBoxRestriction
CFormulaPMLCart	Class for Cartesian PML, see Collino & Monk
CFormulaPMLCartNew	New class for Cartesian PML that gets rid of the equation coefficients in the PML structure
CFormulaPMLEdgeRadia	Class for radial PML in polar coordinates
CFormulaPMLHamburger	Class providing the formulas for hamburger PML
CFormulaPMLPowerSigma
CFormulaPMLPowerSigma2D	Class for the function $\sigma(r)$ for radial PML, see INRIA report of Collino & Monk
CFormulaPMLPowerSigmaB2D	Class for the function $\overline{\sigma}(r)$ for radial PML, see INRIA report of Collino & Monk
CFormulaPMLRadia	Class for PML in polar coordinates
CFormulaSyntaxError	Exception indication that a formula contains a syntax error reported by the parser
CFortranException	Exception indicating an error in a FORTRAN routine returning a non-zero `info` flag
CFrm_Product	Class for a product of formula
CFrm_Sum	Class for a sum of formula
CFrmE_Component	Class representing a component of an element formula
CFrmE_Component_Matrix	Class representing a component of an element formula
CFrmE_Conjugate	Conjugate complex of an element formula
CFrmE_Inverse	Inverse of an element formula
CFrmE_NormalVector	Element formula on 1D elements based on Edge2d returning the normal vector
CFrmE_NormalVector3d	Element formula on 2D elements based on Quad3d returning the normal vector
CFrmE_PMLTransformation
CFrmE_PointsToMapping
CFrmE_PointsToMapping< 2, F, G >
CFrmE_PointToMapping	Class which maps an element formula of type Point (a vector) to one of type Mapping (a matrix)
CFrmE_Product	Product of two element formulas or an element formula and a factor
CFrmE_ScalarProductNormalEdge2d	Computes the scalar product <n, vf> of the normal n with a vector valued formula vf, the result is a scalar formula in F
CFrmE_Sum	Class for a sum of element formulas
CFrmE_TangentialVector	Element formula on 1D elements based on Edge2d returning the tangential vector (left of normal vector)
CFrmE_Trace
CFunction	Abstract class for a function
CGeneralMapping	Introduction of a mapping type which is Real or Cmplx for dimension 1 and Mapping<Real,dim> or Mapping<Cmplx,dim> for higher dimensions
CGeneralMapping< F, 1 >
CGeneralPoint	Introduction of a point type which is Real or Cmplx for dimension 1 and Point<Real,dim> or Point<Cmplx,dim> for higher dimensions
CgetTypeOfObject	Return the dynamic type of a polymorphic object
CGlobalPostprocess	Global Postprocessing
►CGMRes	Solves a system of linear equations with general minimal residuals (GMRes)
CR
CGMResFabric	Fabric class for generalized minimal residual: `GMRes`
CGmshInputException	Exception class to express a problem in a gmsh (.msh) input file
CGraph	Template class to define a graph
CGraphVertex	Template class to define a graph vertex
CHamburgerPMLFormulas	Class for hamburger PML A hamburger PML is divided in three parts one rectangle in the middle region, called "steak", two semi-circles below and above the steak, called "bread"
CHash
CHash< QuadratureOrder >
CHash< ShapeFunction1DOrder >
►CHashedSparseMatrix	A matrix in sparse storage using hashes
CValue	Values of a matrix in sparse notation
CHashMap
CHex3dSubdiv2x	Subdivision strategy for hexahedrons which generates 2 children
CHex3dSubdiv2y	Subdivision strategy for hexahedrons which generates 2 children
CHex3dSubdiv2z	Subdivision strategy for hexahedrons which generates 2 children
CHex3dSubdiv4x	Subdivision strategy for hexahedrons which generates 4 children
CHex3dSubdiv4y	Subdivision strategy for hexahedrons which generates 4 children
CHex3dSubdiv4z	Subdivision strategy for hexahedrons which generates 4 children
CHex3dSubdiv8	Subdivision strategy for hexahedrons which generates 8 children
CHex3dSubdivision	Interface for geometrical subdivision strategies for hexahedrons
CHexahedron	A hexahedron in the topology
►CHexahedron3d	A 3D cell: hexahedron
CIndex	Subclass of Hexahedron3d representing its index
CHexSubdiv2x	Subdivision strategy for hexahedrons which generates 2 children perpendicular to the x direction
CHexSubdiv2y	Subdivision strategy for hexahedrons which generates 2 children perpendicular the y direction
CHexSubdiv2z	Subdivision strategy for hexahedrons which generates 2 children perpendicular to the z direction
CHexSubdiv4x	Subdivision strategy for hexahedrons which generates 4 children along the x direction
CHexSubdiv4y	Subdivision strategy for hexahedrons which generates 4 children along the y direction
CHexSubdiv4z	Subdivision strategy for hexahedrons which generates 4 children along the z direction
CHexSubdiv8	Subdivision strategy for hexahedrons which generates 8 children
CHexSubdivision	Interface for topological subdivision strategies for hexahedrons
CHField_CircularCoil
CHRefinement	Uniform h refinement
CImagPart	Function as imaginary part of an complex function
CImplicitEquilibratedA0Error
CImport2dMesh
►CImport2dMeshBase	Imports 2D mesh with triangles and quadrilaterals (possibly mixed)
CS	Scanner class for Import2dMesh
CImport2dMeshEz4u	Imports 2D mesh with triangles(currently not supported) and quadrilaterals (possibly mixed) from mesh generator ez4u
CImport2dMeshGeneral
CImport2DMeshGmsh	Imports a 2D quadrilateral mesh from mesh generator gmsh
►CImport3dMesh	Imports 3D mesh with tetrahedra and hexahedra
CNodeCell	Stores the nodes and edges of a cell to be created
CNodeHexahedron	Stores the nodes and faces of a hexahedral cell to be created
CNodeTetrahedron	Stores the nodes and faces of a tetrahedral cell to be created
CS	Scanner class for Import3dMesh
CImport3DMeshGmsh	Imports a 3D mesh consisting only of hexahedrons from created with the mesh generator gmsh
►CImport3DTetMesh	Importer for tetrahedral meshes in notation which was used in [1]
CS
CTet
CImportMesh	Base class for reading a mesh from a file
CIndex	Stores a number of indices in a ordered fashion
CIndexNotExisting	Exception class to express that an index in a dynamic array does not exist
CIndexRange	Class for a range of global indices
CInfiniteEdge	An infinite edge in the topology, which possess only one vertex as the other lies in the infinite
CInfiniteQuad	A infinite quadrilateral in the topology, which possess one Edge and two InfiniteEdges since one edge lies in the infinite
CInfiniteQuad2d	A 2D cell: infinite quadrilateral
CInfiniteRect2d	A 2D cell: infinite rectangle
CInfQuadSubdiv2V	Subdivision strategy for infinite quadrilaterals which generates two children which are infinite quadrilaterals as well
CInfQuadSubdivision	Interface for topological subdivision strategies for infinite quadrilaterals
CInnerOuterBoundary2d	Base class for mesh classes in 2D which defines its outer boundary and inner boundaries
CInnerResidual
CInOutParameters	Holds parameters in hashes
CInputAdaptiveModels	Helps for reading input parameters for single solving with AdaptiveModels
CInputEddy2DGeometries	Helps for reading input parameters for Eddy2D geometries
CInputFile	Helps for reading the input parameter of file name
CInputParameter	Abstract class for carrying information, which helps for reading input parameters from command line
CInputParser	Parses an input file and extracts parameters
►CIntegrationCell	Cell over which can be integrated
CintPoint	Integration point consisting of coordinates and intermediate data
CInverseMappingEdge2d	In existant 2D element map for an edge the direction in the edge are inversed
CInverseVertexQuadSector2d	A 2d inverse mapping from a sector to reference element
CJacobianCell	Basic template class for a Jacobian Cell
CJacobianCell< 1 >
CJacobianCell< 2 >
CJacobianCell< 3 >
CJoiner	Joiner class with multiple successors, i.e
CKarniadakis	Part of the multidimensional expansion bases for the shape functions of Karniadakis and Sherwin
CKarniadakisNew
CKey	Key class
CLaguerre	Laguerre polynomials
CLaguerreBasis	Polynomial functions which gives a basis of the semi-infinite intervals after multiplication with factor
CLapackChol	Linear solver using Lapack subroutine DPOSV
CLegendre	Class representing Legendre polynomials evaluated on quadrature points
CLevel	Level information used for multidimensional hp FEM
CLiCo	Linear combination of two operators
CLiCoI	Linear combination of an operator with the identity
CLine	Mesh for the interval of the real axis
CLinearForm	Abstract class for a linear form
CLinearFormChoice	Interface class for Linearform in that one can choice for the basis evaluation type, represented by "Basis" enum
CListScan	Scanner for a list
CLocalDtNmapFeng2D	Class that allows to apply the local DtN Boundary Conditions of Feng for the Helmholtz equation for order 1-5
CLocalEstimator	‍**
Cltidx
Cltstr
CMacroElementNode
CMap1d	An abstract class for a 1d map
CMap2d	An abstract class for a 2d map
CMap3d	An abstract class for a 3d map
CMapEdge1d	A 1D element map for an edge
CMapHexahedron3d	A 3D element map for a hexahedron
CMapParallelepiped3d	A 3D element map for a Parallelepiped
CMapping	Basic class for a 2D or 3D map
CMappingEdge2d	A 2D element map for an edge
CMappingEdge3d	Base class for an edge element map $F_K : [0,1] \to \mathbb{R}^3$
CMappingHexahedron3d	Interface for the element map of a hexahedron embedded in R^3 (analogous to the design of MappingQuad2d in two dimensions)
CMappingHexahedronEdge3d	3D element map for an edge as part of a Hexahedron
CMappingParallelEdge2d	2D element map for an edge parallel to another one
CMappingQuad2d	A 2D element map for a quadrilateral
CMappingQuadEdge2d	2D element map for an edge as part of an quad
CMappingStraightEdge2d	A 2D element map for an edge of a straight line
CMappingStraightEdge3d	A 3D straight edge element map
CMappingTriangle2d	A 2D element map for a triangle
CMapQuad2d	A 2D element map for a quadrilateral given by a formula
CMapTetrahedron3d	A 3D element map for a tetrahedron
CMapTriangle2d	A 2D element map for a triangle
CMapTriangle3d	A 3D element map for a triangle
CMatfileIO	Concepts *.mat-file tool
CMatfileIOError	Exception class to handle errors in the matfileIO class
CMatrix	Abstract class for an operator
CMatrixElementFormula	Element formula returning a matrix
CMatrixNotBuilt	Indicates that a needed matrix wasn't build yet
CMaxwellBoundary	Class for holding boundary type of Maxwell's problems
CMaxwellModel	Abstract class for Maxwell's problems
CMesh	An abstract class for meshes
CMesh1	An abstract class for 1D meshes
CMesh2	An abstract class for 2D meshes
CMesh2withBoundary	Base class for mesh classes in 2D which defines its outer boundary and inner boundaries
CMesh3	An abstract class for 3D meshes
CMeshGraph2
CMeshGraph2_Edge
CMissingFeature	Exception class to express a missing feature
CMissingParameter	Indicates that a requested parameter is not present
CModel	Base class for a model
CModelControl
CModelControl< hp2D::Eddy2D_E >
CModelControl< hp2D::Maxwell2D_E >
CModelControl< hp2D::Maxwell2D_H >
CModelControl< hp2D::Maxwell2D_H_Base >
CModelControl< hp2D::Maxwell2D_H_DD >
CModelControlBase	Base class for controlling a model
CModelNotSolved	Indicates that a model wasn't solved yet
►CMultiArray	Container typename for multidimensional Array which is based on std::map
CScanner	Class for scanning (iterating) over the array in all dimensions
►CMultiArray< 1, T >	Container typename for multidimensional Array which is based on std::map
CScanner	Class for scanning (iterating) over the array in all dimensions
CMultiEntrance
CMultiEntrance< 1, T >
CMultiIndex
Cmultilevelindex	Class for the multilevel index
CMultiple	Multiple of an operator
Cmultiplies
CMultiVector	A multivector in dimension dimC with const pointer entries
CMultiVector< 0, concepts::Set< CellBox< 1 > > >
CMultiVector< 0, concepts::Set< CellBox< 2 > > >
CMultiVector< 0, concepts::Set< CellBox< 3 > > >
CMultiVector< 0, const ElementWithCell< Cmplx > * >
CMultiVector< 0, const ElementWithCell< Real > * >
CMumps	MUMPS : MUltifrontal Massively Parallel sparse direct Solver
CMumpsException	Exception indicating that the Mumps solver failed
CMumpsFabric	Fabric class for `Mumps`
CMumpsOverlap	MUMPS : MUltifrontal Massively Parallel sparse direct Solver
CMumpsOverlapFabric	Fabric class for `Mumps` with overlaping
CMutableMesh1	Class for holding a general mutable mesh of line elements where cells can be added
CMutableMesh2	Class for holding a general mutable mesh of 2D cell where cells and other 2D meshes can be added
CMutableMeshBase	Base class for mutable meshes
CNegativeJacobian	Exception which indicates that a negative Jacobian was found
CNeumann	Abstract class for the Neumann boundary term
CNewton	Solves a non-linear system of the form A(X)=Y
CNewtonException	Exception indicating that the Newton solver failed
CNoConvergence	Exception indicating that the solver did not converge up to the desired accuracy in the given number of iterations
CNoMPIInit_Error	Exception class to handle MPI::Init() lack of call
CNotValidDof	Exception class to express that an inquired dof is not valid
CNRLSolver
Cnull_deleter
Cnumber	Name traits for number types
Cnumber< double >	Name traits for the number type `Real`
Cnumber< hp2D::hpAdaptiveSpaceH1 >
Cnumber< hp2D::hpAdaptiveSpaceL2 >
Cnumber< long double >	Name traits for the number type `Real`
Cnumber< Mapping< F, dim > >
Cnumber< Point< F, dim > >
Cnumber< std::complex< double > >	Name traits for the number type `Cmplx`
Cnumber< std::complex< long double > >	Name traits for the number type `Cmplx`
COpAdd
COperation
COperator	Abstract class for an operator
COpMult
COpRecipr
COrders	Class combining polynomial order and number of quadrature points
COrdersBase	Class containing number of quadrature points
COutputMatlab	Class for output of objects to matlab
COutputMatlab< Array< F > >	Specialisation of class `OutputMatlab<F>` for output of objects to matlab to `Array<F>`
COutputMatlab< bool >
COutputMatlab< char * >	Class for output of C strings
COutputMatlab< F * >	Class for output of pointers to matlab
COutputMatlab< Mapping< F, dim > >	Class for output of 2D and 3D matrices to matlab
COutputMatlab< Point< F, dim > >	Class for output of 2D and 3D vectors to matlab
COutputMatlab< Sequence< F > >	Specialisation of class `OutputMatlab<F>` for output of objects to matlab to `Sequence<F>`
COutputMatlab< std::map< F, G > >
COutputMatlab< std::queue< F > >
COutputMatlab< std::set< F > >
COutputMatlab< std::string >	Class for output of C++ strings
COutputMatlab< std::vector< F > >
COutputMatlab< StiffArray< dim, F > >	Specialisation of class `OutputMatlab<F>` for output of objects to matlab to `StiffArray<dim,F>`
COutputOperator	Class providing an output operator
COutputTecplot	Class for output of objects to tecplot
COutputTecplot< Array< F > >
COutputTecplot< Point< F, dim > >	Class for output of 2D and 3D vectors to matlab
COutputTecplot< std::complex< F > >
CParabelMappingEdge2d	2D element map for an parabel arc
►CParallelepiped3d	A 3D cell: parallelepiped
CIndex	Subclass of Tetrahedron3d representing its index
CPardiso	Sparse direct solver for symmetric and unsymmetric matrices
CPardisoFabric	Fabric class for `Pardiso`
CParsedFormula
CParsedFormula< Cmplx >
CParsedFormula< Real >
CParsedFormula< Real2d >
CParsedFormulaBase	Parses the given string and evaluates it on request
CParseObjectFromString	Class for parsing objects like "Circle(1.0)" or "Edge(1,2)" from a string
CPartMappingEdge2d	Part of a edge mapping
CPartMappingHexahedron3d	A 3D element map for a restriction of a given hexahedron element mapping
CPartMappingQuad2d	Part of a map of a quadrilateral
CPermutation	Permutation operator
CPETSc	Interface to the iterative solvers of the PETSc library
CPETScFabric	Fabric class for `PETSc` solvers
CPETScMat	Interface to the sparse matrices from PETSc
CPiecewiseConstDynArrayFormula	Piecewise constant function defined by attributes, base on dynamic array
CPiecewiseConstFormula	Piecewise constant function defined by the attribute of a cell
CPiecewiseConstImportFormula	Piecewise constant function defined by attributes, imported from a file
CPiecewiseElementFormula	Piecewise defined function defined by attributes
►CPiecewiseFormula	Piecewise defined function defined by attributes
CFormulaFactor
CPiecewiseFormula0	Piecewise defined function, which consists of a formula and a default value
CPiecewiseFormulaBase	Piecewise defined function on a number of cells
CPiecewiseFormulaCombine	Combines two piecewise defined formulas with an operation, e.g
CPiecewiseFormulaFun	Piecewise defined function as an analytical function of another piecewiese defined function
CPiecewiseFormulaVector
CPiecewiseFormulaVector< 1, F, G, H >
CPiecewiseFormulaVectorBase	Base class for piecewise defined formula, which are a function of a FE function
CPListScan	Scanner for a list of pointers
CPoint	Basic class for a Point or a vector
CPointerToEmptyBilinearForm	Exception class to express that the RCP pointer points to 0
CPointerToEmptyElementFormula	Exception class to express that the RCP pointer points to 0
CPointerToEmptyFormula	Exception class to express that the RCP pointer points to 0
CPointInCell	Define a point inside a geometrical cell by its connector and the coordinate in the reference cell
CPointInCell< 1 >
►CPool	Pool for blockwise memory allocation
Clink
CPrecondSolverFabric	Abstract fabric class for linear solvers with preconditoner
CPRefinement	Uniform p refinement
CProcessParameter	Reads command line
CPStlVectorScan	Scanner for a STL container std::vector of pointers
CQR_Q	Gives min(N,M) by min(N,M) - Q matrix of QR decomposition of a M by N non sparse matrix A
CQuad	A quadrilateral in the topology
CQuad2d	A 2D cell: quadrilateral
CQuad2dSubdiv2H	Subdivision strategy for quadrilaterals which generates two children
CQuad2dSubdiv2V	Subdivision strategy for quadrilaterals which generates two children
CQuad2dSubdiv4	Subdivision strategy for quadrilaterals which generates four children
CQuad2dSubdivision	Interface for geometrical subdivision strategies for quadrilaterals
CQuad3d	A quadrilateral cell in 3D
CQuadCoordinateChange	Coordinate changes for quadrilateral elements
►CQuadCoordinateChange< 3 >	Coordinate changes for quadrilateral face elements in a parent hexahedron
CQuadHash	Hash function
►CQuadNd	Base class for a quadrilateral in any dimension
CIndex	Subclass of QuadNd representing its index
CQuadrature	Basic class for numerical integration
►CQuadratureOrder
CHash
CQuadratureRule	Abtract class for quadrature rules in $\mathbb{R}^n$
CQuadratureRule1d	Quadrature rule for numerical integration
CQuadratureRule1dDynamic	Base class for quadrature rules with dynamically allocated storage for the weights and abscissas
CQuadratureRule1dGaussJacobi	Gauss Jacobi quadrature rule not including both endpoints
CQuadratureRule1dGaussLobatto	Gauss Lobatto quadrature rule including both endpoints
CQuadratureRule1dTrapeze
CQuadratureRule2d	Abstract class for quadrature rules in
CQuadratureRule2dQuadDuffy	Class representing the Generalized Duffy quadrature rule in 2d, $x = u^\beta, y = u^\beta v$ , that is for $\beta=1$ the standard duffy integration rule
CQuadratureRule2dQuadTensor	Tensor quadrature rule in 2d
CQuadRuleFactory	Class for creation of a quadrature rule
CQuadRuleFactoryBase2d	Abstract class for quadrature rule factories in 2D
CQuadRuleFactoryTensor2d	This class is the same as QuadRuleFactory, but returning integration rules in 2d
►CQuadRuleFactoryTensorDuffy2d	Class representing a quadrature factory, that holds information about cells on which generalized duffy quadrature should be applied
CDuffyData	Duffy information data, i.e. the duffy parameter and the number of points
CQuadSubdiv2H	Subdivision strategy for quadrilaterals which generates two children
CQuadSubdiv2V	Subdivision strategy for quadrilaterals which generates two children
CQuadSubdiv4	Subdivision strategy for quadrilaterals which generates four children
CQuadSubdivision	Interface for topological subdivision strategies for quadrilaterals
CRadialPML_2D	Class for providing the formulas in bilinear forms coming from the PML transformation of the radial PML (in 2D)
CRadialPMLFormulas	Class for providing the formulas in bilinear forms coming from the PML transformation of the radial PML (in 2D)
CRCP	Reference-counting pointer
CRCP< const ElementFormula< F, G > >
CRCP< const Formula< F > >
CRealPart	Function as real part of an complex function
CRealtype	Taking for a complex type the appropiate real type and for a real type itself
CRealtype< Array< F > >
CRealtype< Mapping< F, DimY, DimX > >
CRealtype< Point< F, dim > >
CRealtype< std::complex< F > >
CRelativeCells	Class which holds information about the mesh hierarchy and how the point in the reference cell changes from level to level
CResourceMonitor	Timer and resource monitor
CRestrictionSpace	Classes for restriction of spaces to a sub-domain
►CResultsTable	Organizes the results in the hashes from InOutParameters in a nice table
CtableDelimTraits	Table delimiters
CRys	Rys shape function basis over an element [a,b]
CScan	An abstract class for scanning a mesh (a set of cells) or a space (a set of elements)
CScan< Cell1 >	A scanner for a 1D mesh
CScan< Cell2 >	A scanner for a 2D mesh
CScan< Cell3 >	A scanner for a 3D mesh
CScan< Connector0 >	A scanner for 0D connectors on the processor intersection (cap)
CScan< Connector1 >	A scanner for 1D connectors on the processor intersection (cap)
CScan< Connector2 >	A scanner for 2D connectors on the processor intersection (cap)
CScan< constraints::Element< F > >
CScan< ElementWithCell< F > >
CScan< hp1D::BaseElement< F > >	Scanner of hp1D::Element
CScan< hp2D::Element< F > >	Scanner of hp2D::Element
CScan< hp3D::Element< Real > >
CScan< linDG3D::FvdgElement >	Scanner over tetrahedral elements in FV/DG-space
CScan< linearFEM::Element >
CScan< linearFEM::Line >
CScan< linearFEM::Quad >
CScan< linearFEM::Tetrahedron >
CScan< linearFEM::Triangle >
CScan< vectorial::Element< F > >
CScan< vectorial::ElementWithCell< F > >
CSchurCompl	Schur complement
CSemantics	An abstract function class to query attributes
CSequence	Sequence with operations, output operator, and method of the particular element types
CSequence< bool >
CSequence< Connector0 * >
CSequence< Connector1 * >
CSequence< Connector2 * >
CSequence< const Connector0 * >
CSequence< const Connector1 * >
CSequence< const Connector2 * >
CSequence< const Key * >
CSet	Set with operations, output operator, and method of the particular element types
CSet< Attribute >
CSet< Connector * >
CSet< Connector0 * >
CSet< Connector1 * >
CSet< Connector2 * >
CSet< const Connector * >
CSet< const Connector0 * >
CSet< const Connector1 * >
CSet< const Connector2 * >
CSet< const Key * >
►CSet< IndexRange >
Cindex_iterator
CShapeFunction1D	Abstract class for 1D shape function
►CShapeFunction1DOrder
CHash
CSharedJacobianAdj	Shared data for bilinear forms on vectorial spaces, like hp2D::RotRot and hp2D::DivDiv
CSharedJacobianDet	Shared data for bilinear forms on vectorial spaces, like Identity
CShiftAndInvertOperatorForGEVPs
CSin_n_phi	Class for evaluating $\sin(n\phi), n\in\mathbb{Z}$ for points $(x,y) \in \mathbb{R}^2$ in cartesian coordinates
CSin_n_x	Class for evaluating $\sin(2 \pi n x/ L), n\in\mathbb{Z}$ for points $(x,y) \in \mathbb{R}^2$ in cartesian coordinates
CSin_n_y	Class for evaluating $\sin(2 \pi n y/ L), n\in\mathbb{Z}$ for points $(x,y) \in \mathbb{R}^2$ in cartesian coordinates
CSingletonScan	A scanner over a single element
CSMatrix1D	One dimensional S matrix
CSMatrixBase	An abstract class for an S matrix
CSMatrixBlock	S matrix in block form for tensorised shape functions
CSMatrixCompose	Composing S matrices
CSMatrixGeneralTensor	S matrix for elements in dimensions 2 and 3 with tensorized shape functions, with arbitrary number of shape functions in each direction
CSMatrixTensor	S matrix for elements in dimensions 2 and 3 with tensorized shape functions
CSolverConjugate	Solver for a complex system
CSolverFabric	Abstract fabric class for linear solvers
CSourceFunctionF0_x	Design of the limit order source function in direction as $\nabla p_0$
CSourceFunctionF0_y	Design of the limit order source function in direction as $\nabla p_0$
CSpace	Abstract class for a space
CSpaceDebug	Class for output of all elements of a class, good for debugging
CSpaceGraph
CSpaceHelper	Class which helps to build the T Columns of the elements of a space, with the help of a space pre builder
CSpaceNotBuilt	Indicates that the space on which a function was called was not yet correctly built
CSpaceOnCells	Abstract class for a space
CSpaceOnCoarseCells	Interface class for SpacesOnCells that also allow for allCells(), that i.e
CSpacePreBuilder
CSparseMatrix	Sparse matrix
CSphere	Topological sphere connector
CSphere3d	Geometric sphere element
CSphereMapping	Geometric sphere
CSphericalFormula
CSphericalFormula< Real >	Formula in spherical polar coordinates
CSphericalFormula< Real2d >	Class representing SphericalFormulas in two in 2 components
CSphericalSurface	Topological spherical surface connector
CSphericalSurface3d	Geometric spherical surface element
CSpooles	Sparse direct solver for symmetric and unsymmetric matrices
►CSquare	Mesh for with one quadrilateral
CS
►CSquare2	Mesh for with two quadrilaterals
CS
CSquared	The square of a element function (componentwise)
►CSquareOneInfiniteRect	Mesh consisting of two cells, one Quad2d and one InfiniteRect2d
CS
►CSquareTwoInfiniteRects	Mesh consisting of three cells, one Quad2d and two InfiniteRect2d
CS
CStacktrace	Dumps a stack trace using gdb
CStiffArray	An array of objects of fix length, defined by template parameter `dim`
CStiffArray< 0, F >	Stiff Array of zero dimension makes no sense
CStiffArray< 1, F >
CStlVectorScan	Scanner working on std::vector elements
►CStraightPeriodicBoundary
CS	Scanner over the cells
CStrategyChange	Exception indicating that changing the subdivision strategy is not allowed (but was tried anyway)
CSubdivision	Common base class for QuadSubdivision and HexSubdivision
CSubMatrix
CSubMatrixN	Abstract class for an operator, which is a sub matrix of another matrix
CSubspace	Class for holding an offset of global indices of space
CSubspaceHelper
CSubVector	A sub vector, defined by another vector and an index set
CSuperLU	Direct sparse solver for unsymmetric matrices
CSuperLUFabric	Fabric class for `SuperLU`
CSymmetry	General class for symmetries on a geometrical object
CSymmetry< Edge >	Specialized template for edges
CSymmetry< Quad >	Specialized template for quadrilaterons
CTColumn	A column of a T matrix
CTColumnBlock	A column of a T matrix
CTColumnSet	A set of TColumns and polynomial degrees, sorted by a key, eg
CTColumnTensor	A column of a T matrix
CTensorVertexMap	Basic template class for a tensor map vertex
CTensorVertexMap< 1 >
CTensorVertexMap< 2 >
CTensorVertexMap< 3 >
CTetrahedron	A tetrahedron in the topology
►CTetrahedron3d	A 3D cell: tetrahedron
CIndex	Subclass of Tetrahedron3d representing its index
CTIndex	T matrix for linear and regular elements
►CTMatrix	A T matrix in sparse notation
CControl	The column header: column index and length of the column data
CData	The matrix entries: row index and data
CTMatrixBase	An abstract class for a T matrix
CTMatrixBlock	TMatrixBlock are special Tmatrices in block diagonal structure, builded with two Tmatrices itsself
CTranspose	The transpose of another matrix
CTriangle	A triangle in the topology
►CTriangle2d	A 2D cell: triangle
CIndex	Subclass of Triangle2d representing its index
►CTriangle3d	A 3D cell: triangle
CIndex	Subclass of Quad2d representing its index
CTrivExtendRestrict	Trivial extension and restriction operator
CUmfpack	Sparse direct solver for unsymmetric matrices
CUmfpackFabric	Fabric class for `Umfpack`
►CUniformlyRefinedMesh2	Wrapper class refining an existing 2d mesh uniformly
CS	Scanner class for UniformlyRefindeMesh2
CUnitNd	A vector of dimension dim and length 1
CVecOperator	Abstract class for an operator acting on vectors only, not arbitrary functions
CVector	A vector
CVectorElementFormula
CVectorElementFormula< F, 2, G >
CVectorElementFormula< F, 3, G >
CVectorElementFormulaBase	Element formula returning a vector
CVectorFormula	Element formula returning a vector
CVertex	A vertex in the topology
CVertexData	Stores additional information on a vertex, namely its cells and edges
CVertexQuad2d	A 2D element map for a quadrilateral given by a the four vertices
CVertexTriangle2d	A 2D element map for a triangle
CWrongInputException	Exception class to express an input criteria was not met
CWrongRelations	Exception class to express an illegal relation within topological lists
CWsym_x
CWsym_y
CWunsym_x
CWunsym_y
CZ2	Binary group (algebraic): only the values 0 and 1 are represented
CZ3	Algebraic group with three elements: 0, 1 and 2
CZ4	Algebraic group with four elements: 0, 1, 2 and 3
CZylindricalFormula	Formula in zylindrical coordinates
►Nconstraints	Essential boundary conditions and multi-point constraints [1]
CAnalyticalConstraint	Models an analytical constraint
CConstraintsList	List of `AnalyticalConstraint`
CElement	Element of the constraints space
CSpace	Space of constraints
►Neigensolver	Eigenvalue solvers
CArPack	Eigenvalue solver using ARPACK, the routine `dnaupd` or `znaupd`
CArPackFabric	Fabric class for ARPACK eigenvalue solver for a constrained problem
CArpackOperatorWrapper	Wrapper for general operators and general eigenproblems
CArPackppGen	EigenSolver for complex, general eigenproblems
CArPackppStd	EigenSolver for complex, standard eigenproblems
CArPackppSymGen	EigenSolver for symmetric, real-valued, general eigenproblems
CArpackStdOperatorWrapper	Wrapper for general operators and standard eigenproblems
CArPackSymm	Eigenvalue solver using ArPack, the routine `dsaupd`
CConstrained	Solves a generalized eigenvalue problem subject to linear, homogeneous constraints
CDirPowIt	Eigenvalue solver using the direct power iteration method
CEasyArPackpp	Purely virtual class providing methods and instances for its child classes EasyArPackppStd, EasyArPackppGen and EasyArPackppSymGen
CEasyArPackppGen	Tool to easily solve general eigenvalue problems
CEasyArPackppStd	Tool to easily solve standard eigenvalue problems
CEasyArPackppSymGen	Tool to easily solve general eigenvalue problems for symmetric matrices
CEigenSolver	Interafce for eigenvalue solvers
CGEVPSolver
CInexactInv	Inexact inverse iteration to solve a generalized Eigen value problem
CInexactInvFabric	Fabric class for eigensolver inexact inverse iteration
CJdbSym	Eigenvalue solver using JDBSYM
CJdbSymFabric	Fabric class for JdbSym eigenvalue solver for a constrained problem
COperatorType
COperatorType< concepts::Real, concepts::Real >
CSmallES	Eigenvalue solver using LaPack routine `dgeev` (Real) `zgeev` (Cmplx)
CSolverFabric	Abstract fabric class for eigenvalue solvers
►Nestimator
CAMarking
CAprioriVertex	‍**
CBMarking
CBuergDoerfler	Class representing the hp marking strategy proposed by Buerg in this dissertation
►CBuergRefinement	Actual refinement hp rule that generalizes dörflers bulk marking
CweightedIndictor
Cerror_index
CExactEstimator	Abstract class representing the explicit residual a posteriori error estimator
CHP_Refinement	Abstract Class for h refinement only, i.e
CImplicitResidual	Abstract class representing the implicit residual a posteriori error estimator
CImplicitResidual2D	Given a elliptic equation:
CKeysInfo
►CLocalMesh2	This is a local Neighboorhood Mesh (i.e regular) of a given node (key = K), which content is a space Element (e.g
CS
►CLocalProjectionBase
CPointProjection
CLocalProjections_P
CLocalProjections_S
CMarking	Abstract class on Marking
CMVMarking	Mean value marking strategy
CPolynomialDegrees
CPrediction	Prediction hp - adaptive refinement strategy, proposed by Melenk and Wohlmuth
CRefinement	Abstract class for all refinement strategies in arbitray dimension
►Ngeometry
Cedge_dof
CEdgePatch	Class holding the Keys of the Edges around a vertex of a regular Patch
CElementPatch	Class holding the informations of a regular patch
Cquad_loc
CVtxToEdgeSupportMap	Class representing the map from vertex keys to EdgePatches
CVtxToElmSupportMap	Class representing the map $n\mapsto\mathcal{P}_n$ from Node keys to ElementPatches
CVtxToPatchMaps	Class to build up maps form Vertexkeys to EdgePatches or ElementPatches
►Ngraphics	Graphics
CBaseDataCell	Class for writing the graphical output of a FE solution represented by a coefficient vector (and possibly an element function) to the given streams
CBaseElementFormulaCell	Writes element formula for a cell to the given streams
CBaseFormulaCell	Writes formula for a cell to the given streams
CBaseMeshCell	Writes the mesh to the given streams (for a cell)
CBaseOutputCell	Writes the mesh to the given streams
CBoundaryDXCell	Gathers information about boundary faces (or edges in 2D) and prepares information to be written to an OpenDX file
CDataDX	Draws a picture of data in DX format and stores the result in a file
CDataDXConnections	Graphics in OpenDX - connections
CDataDXCoordinates	Graphics in OpenDX - coordinates
CDataDXCounts	Graphics in OpenDX - point counter
CDataDXData	Graphics in OpenDX - data
CDataGnuplotCell	Writes the data which describe the elements to the given streams
CDataMatlab	Draws a picture of data in Matlab format and stores the result in files
CDataMatlabCell	Writes the data which describe the elements to the given streams
CDenseMatrixCollection	Class that hold and manage a std::map with `concepts::ElementMatrices` for graphical output, collected by `graphics::DenseMatrixGraphics`
CDenseMatrixGraphics	Class that collects data for graphical output and stores it in concepts::ElementMatrices and graphics::DenseMatrixCollection
CMatlabBinaryGraphics	Class that allows to store graphical infomations in .mat files to use them in Matlab
CMatlabBinaryMeshGraphics
CMatlabElasticityGraphics
CMatlabGraphics	Draws a picture of data in Matlab format and stores the result in a single file
CMatlabMesh	Routines for writing mesh and formula for a single cell for different cell types
CMatrixBaseElementFormulaCell	Class for writing the graphical output of an element formula to ElementMatrices
CMatrixBaseMeshCell	Class that iterates over a mesh and collects graphical informations in a set of ElementMatrices
CMatrixBasisOutputCell	Basis class for graphical output using dense matrices
CMatrixCounterCell	Class that collects information about the mesh/space it iterates over, that are used for MatrixBasisOutputCell and derived classes to allocate the matrices where the data will be stored
CMatrixSolutionEvaluationCell	Class for writing the values of the solution of a PDE on the quadrature points of the space in a DenseMatrix
CMatrixSpaceOutputCell	Class that collects graphical informations about a given space in a set of ElementMatrices
CMeshDAT	Creates files which are suitable for mesh input using `Import2dMesh` or `Import3dMesh`
CMeshDATCell	Cell by cell output for `MeshDAT`
CMeshDX	Draws a picture of a mesh in DX format and stores the result in a file
CMeshDXCell	Draws a picture of a mesh in DX
CMeshEPS	Draws a picture of a mesh in EPS format and stores the result in a file
CMeshEPSCell	Draws a picture of a mesh in EPS
CMeshGnuplotCell	Writes the data which describe the elements to the given streams
CMeshMatlab	Creates data for Matlab to draw the mesh
CMeshMatlabCell	Writes the data which describe the elements to the three streams
CMeshTecplot	Creates files to show the mesh using Tecplot
CMeshTecplotCell	Cell by cell output for `MeshTecplot`
COutputBase	Base class for graphical output to a file
CSize	Number of components of data types
CSize< concepts::Cmplx >
CSize< concepts::Mapping< F, dim > >
CSize< concepts::Point< F, dim > >
CSize< Real >
CspaceTraits	Traits for a space
CspaceTraits< hp2D::Space >	Traits for hp2D::Space
CspaceTraits< hp3D::Space >	Traits for hp3D::Space
CspaceTraits< linDG2D::Space >
CspaceTraits< linDG2D::SpaceP0 >
CspaceTraits< linDG2D::SpaceP1 >
CspaceTraits< linDG3D::FvdgSpace >	Traits for FvdgSpace
CspaceTraits< linDG3D::FvdgSpaceP0 >	Traits for FvdgSpaceP0
CspaceTraits< linDG3D::FvdgSpaceP1 >	Traits for FvdgSpaceP1
CspaceTraits< linearFEM::Linear2d >	Traits for linearFEM::Linear2d
CspaceTraits< linearFEM::Linear3d >	Traits for linearFEM::Linear3d
CspaceTraits< vectorial::Space< concepts::Real > >	Traits for vectorial::Space
CspcDim	Determines the traits class belonging to a space by a default template parameter
CspcPosCon	Determines the traits class belonging to a space by a default template parameter
CTecplotGraphics	Output to Tecplot
CTecplotMesh	Routines for writing mesh and formula for a single cell for different cell types
CTopologyDotty	Executor class for TopologyDottyCell
CTopologyDottyCell	Produces an input file for dot / dotty to display the topology as a directed graph
CVertexInfo	Class containing information about one single vertex
CVertexList	Class containing a list of vertices
CVtkGraphics	Class that allows to store graphical infomations in .vtk files to use them in paraview
►Ngraphicspy
CPythonGraphics
►Nhp1D	1D hp-FEM
CAdvectionElementMatrix	Element mass matrix for hp 1D FEM with Karniadakis basis on the reference intervall
CArrayElementFormula	Array of formula values on quadrature points
CBaseElement
CBiLaplace	A function class to calculate element matrices for the Bi-Laplacian
CBilinearFormHelper	Helper class for bilinearforms a(u,v), where u is i-form and v is j-form
CBilinearFormHelper< 0, 0, F >
CBilinearFormHelper< 1, 1, F >	Helper class for bilinearforms a(u,v), where u and v are 1-forms
CBilinearFormHelper< 2, 2, F >	Helper class for bilinearforms a(u,v), where u and v are 2-forms
CBilinearFormVtxHelper	Helper class for bilinearforms a(u,v), where a is a i-j Form that just works on the Vertices, like JUMP or MEAN and products of it on the end of the elements
CDualSpace	Class for a dual space to a continuous FE space on edges
CElementFormulaInterpGrad
CExplicitResidual1D
CGenericElement	1D generic element
CGrad	The gradient of the approximated function in a FE space
CGradLinearForm	Linear form on edges in nD
ChpAdaptiveSpaceL2	A 1D polynomial space spanned by Legrendre type polynomials
CIdentity	A function class to calculate element matrices for the mass matrix
CIdentityParallel	A function class to calculate element matrices for the mass matrix for elements that are shifted
CIntegrableElm	Class holding the quadrature rule and the cell of a 1D element
CJump1Jump1	A function class to calculate element matrices for the Product of the jumps of the derivative
CKarniadakisMixin	The following two types are shape function mixins
CLaplace	A function class to calculate element matrices for the Laplacian
CLegendreMixin	Legendre shape functions mixin
CLevelRiesz	This class creates a linearform corresponding to the integral:
CLevelRieszElement	This class creates a linearform corresponding to the local contribution of one cell to the integral:
CLinearFormGradInterp_Grad	Linear form on edges in nD
CLinearFormHelper	Helper class for Linearforms l(v), where v is i-form
CLinearFormHelper< 0, F >	Helper class for linearforms l(v), where v is a 0-form
CLinearFormHelper< 1, F >	Helper class for linearforms l(v), where v is a 1-form
CLineGraphics	Handles graphics for 1D hp FEM elements
CMassElementMatrix	Element mass matrix for hp 1D FEM with Karniadakis basis on the reference intervall
CMean2Jump1	A function class to calculate element matrices for the Product the mean of the second derivative and of the Jump of the derivative
CNeumann	Linear form on edges in nD
CPointEvaluation	Point evaluation in 1D
CRefineOrRaise	Refines element or raises its polynomial degree
CRiesz	Linear form on edges in nD
CRysMixin	Rys shape functions mixin
CRysSpace	A 1D polynomial space spanned by the Rys basis
CSpace	A 1D hp FEM space with continuous, picewise polynomial basis functions
CStiffElementMatrix	Element stiffness matrix for hp 1D FEM with Karniadakis basis on the reference intervall
CValue	The approximated function in a FE space
►Nhp2D	2D hp-FEM for H¹-conforming elements
►Nl2	2D hp-FEM for L²-conforming elements
CQuad	A 2D FEM element: a quad
CQuadGraphics	Handles graphics for 2D hp quadrilateral FEM elements
CQuadShapeFunctions	A class for holding the shape functions of nodal elements on quadrilaterials for a particular polynomials degree (ie
CRiesz	Linear form in 2D
CValue	The approximated function in a FE space
CAdaptiveModel
CAdvection	A function class to calculate element matrices for the bilinear form
CApproxMoments
CAPrioriGeometricRefinement	Class for holding a rule for geometric refinement towards edges and vertices
CAPrioriRefinement	Carries out a-priori given refinements
CAPrioriRefinementNew
CAPrioriRefinementRule
CAPrioriRefinementRuleFactory	Factory class for a refinement rule
CAPrioriRegularRefinement	Class for holding a rule for a particular h- and p-refinement until an maximum level and maximum polynomial degree is reached
CArrayElementFormula	Array of formula values on quadrature points
CArrayQuadWeights	Class to represent the quadrature weights on all quadrature points
CBaseEdge
CBaseQuad	A base of a 2D quad FEM element for different basis functions
CBaseQuadGraphics	Base class for handling graphics for 2D hp quadrilateral FEM elements
CBilinearFormHelper_0_0	Helper class for bilinearforms a(u,v), where u and v are 0-forms
CBilinearFormHelper_0_1_Part	Helper class for bilinear forms a(u,v) where u is a 0-form and v is a 1-form
CBilinearFormHelper_1_1	Helper class for bilinearforms a(u,v), where u and v are 1-forms, which computes intermediate data for element matrix computation
CBilinearFormHelper_2_1	Helper class for bilinearforms $a(u,\underline{v})$ , where is a 2-form and $\underline{v}$ a 1-form
CBilinearFormHelper_2_2	Helper class for bilinearforms a(u,v), where u and v are 2-forms
CBilinearFormOnePartDeriv	A function class to calculate element matrices for the bilinear form related to a partial derivative of the test functions (scalar)
CBilinearFormTwoPartDeriv	A function class to calculate element matrices for the bilinear form related to a partial derivative of the trial and (!) test functions (scalar)
CBuildDofsBase	Responsible to build the degrees of freedom in a space
CBuildEdgeDofs	Responsible to build the edge degrees of freedom in a space
CBuildH1EdgeTColumns	Responsible to build the T columns belonging to edge degrees of freedom in a H1 conforming space with shape functions in tensor product structure
CBuildH1InnerTColumns	Responsible to build the T columns belonging to inner degrees of freedom in a H1 conforming space with shape functions in tensor product structure
CBuildH1InnerTColumnsHypTrunk	Responsible to build the T columns belonging to inner degrees of freedom in a H1 conforming (trunk) space with shape functions in tensor product structure
CBuildH1InnerTColumnsLinTrunk	Responsible to build the T columns belonging to inner degrees of freedom in a H1 conforming (trunk) space with shape functions in tensor product structure
CBuildH1VtxTColumns	Responsible to build the T columns belonging to vertex degrees of freedom in a H1 conforming space with shape functions in tensor product structure
CBuildHCurlEdgeTColumns	Responsible to build the T columns belonging to edge degrees of freedom in a H(Curl) conforming space with shape functions in tensor product structure
CBuildHCurlInnerTColumns	Responsible to build the T columns belonging to inner degrees of freedom in a HCurl conforming space with shape functions in tensor product structure
CBuildInnerDofs	Responsible to build the inner degrees of freedom in a space
CBuildInnerDofsHypTrunk	Responsible to build the inner degrees of freedom in a (trunk) space
CBuildInnerDofsLinTrunk	Responsible to build the inner degrees of freedom in a (trunk) space
CBuildL2InnerTColumns	Responsible to build the T columns belonging to inner degrees of freedom in a L2 conforming space with shape functions in tensor product structure
CBuildL2InnerTColumnsHypTrunk	Responsible to build the T columns belonging to inner degrees of freedom in a L2 conforming (trunk) space with shape functions in tensor product structure
CBuildL2InnerTColumnsLinTrunk	Responsible to build the T columns belonging to inner degrees of freedom in a L2 conforming (trunk) space with shape functions in tensor product structure
CBuildTColumnsBase	Base class for classes for building T columns for elements in a space with help of a 2D space pre builder
CBuildVertexDofs	Responsible to build the vertex degrees of freedom in a space
CDegreeDim	Dimension of the degrees of freedom in a cell
CDegreeDim< concepts::InfiniteQuad >
CDegreeDim< concepts::Quad >
CDegreeDim< concepts::Triangle >
CDistancePost	A function class for weighted regularization
CDivDiv	A function class to calculate element matrices for the Div u*Div v Bilinearform
CEddy2D_dissipation	Local contribution to dissipation power loss
CEddy2D_E	Class for calculating Eddy current problem with Maxwell modell in h formulation
CEddy2D_eField	Electrical field
CEddy2D_H	Class for calculating Eddy current problem with Maxwell modell in h formulation
CEddy2D_H_Interior	Class holding size and magnetic field of embedded (interior) area
CEdgeGraphics	Handles graphics for 1D hp FEM elements
CElement	Abstract class for a 2D FEM element
CElementFormulaEdgeJump	Element formula for a jump value on edges of elements of an other element formula
CElementFormulaEdgeMean	Element formula for a mean value on edges of elements of an other element formula
CElementFormulaInterpGrad	Element formula for the gradient of an scalar element formula
CElementFormulaInterpGrad< F, 2 >
CElementFormulaInterpGradN	Element formula for the gradient of an scalar element formula
CElementFormulaInterpGradN< F, 2 >
CElementFormulaSignNormalVector	Element formula on 1D elements based on Edge2d returning the 1.0 if the normal vector is the right one and -1.0 otherwise
CElementFunction	Base class for element functions for hp elements in 2D
CElementFunction< 1, F, Q >
CEquilibratedMomentsAO
►CExplicitResidual2D	Given a elliptic equation:
CDistance	Weight class for 2d Elements
CEdgeWeight	Weight class for 1d Elements
CExtrema	An interface class that computes the maximum/minimum of a function represented as an ElementFormula on an space on `hp2D::Quad<Real>` only
CFluxes	Application of this class is to solve local Problems on one Quad
CFormulaFromWeight	Makes it possible to plot a given `Weight`
CGrad	The gradient of the approximated function in a FE space
CGradLinearForm	Linear form in 2D
CGridInfo	Class that represents grid information of a given 2d Fem space
CH1Extension	Continuous extension of a formula on edges, e.g
ChpAdaptiveSpace	Hp-adaptive space with 2D elements
ChpAdaptiveSpaceDG	Hp-adaptive FEM space in 2D composed of separate spaces hpAdapativeSpace and may be discontinuous
ChpAdaptiveSpaceH1
ChpAdaptiveSpaceHCurl
ChpAdaptiveSpaceHCurl_H1	Container class for a 2D hp edge element space with an 2D hp nodal element space
ChpAdaptiveSpaceL2
►ChpFull	Helper class for building 2D hp-FEM spaces (space pre builder)
CCause
CIdentity	A function class to calculate element matrices for the mass matrix
CImplicitEquilibratedA0
CInfiniteLaguerreQuad	A 2D FEM element: an infinite quad with basis based on Laguerre functions
CInfiniteQuad	A 2D FEM element: an infinite quad
CInfiniteQuadFunctions	Auxiliary functions for infinite quadrilaterals
CInfiniteQuadGraphics	Handles graphics for 2D hp quadrilateral infinite FEM elements
CInputEddy2D_E	Helps for reading input parameters for single solving of Eddy2D_E
CInputEddy2D_H	Helps for reading input parameters for single solving of Eddy2D_H
CInputMaxwell2D_E	Helps for reading input parameters for single solving of Maxwell2D_E
CInputMaxwell2D_H	Helps for reading input parameters for single solving of Maxwell2D_H_Base
CIntegrableQuad	Class holding the quadrature rule and the cell of a quadrilateral element
CKarniadakisDeriv2	Part of the multidimensional expansion bases for the shape functions of Karniadakis and Sherwin
CLaplace	A function class to calculate element matrices for the Laplacian
CLaplaceBase	Base class to calculate element matrices for the Laplacian, for both scalar and matrix formulas
CLaplaceMatrix	A function class to calculate element matrices for the Laplacian for matrix formulas
CLaplacian	The Laplacian of the approximated function in a FE space
CLinearFormHelper_0	Helper class for linearforms l(v), where v is a 0-form
CLinearFormHelper_1	Helper class for linearforms l(v), where v is a one form
CLinearFormHelper_2	Helper class for linearforms l(v), where v is a two form
CLocalFluxes
CMaxwell2D_dissipation	Local contribution to dissipation power loss
CMaxwell2D_E	Class for calculating Eddy current problem with Maxwell modell in e-formulation
CMaxwell2D_eField	Electrical field
CMaxwell2D_H	Class for calculating Eddy current problem with Maxwell modell in h formulation
CMaxwell2D_H_Base	Base class for calculating Eddy current problem with Maxwell modell in h formulation
CMaxwell2D_H_DD	Class for calculating Eddy current problem with Maxwell modell in h formulation, with Domain Decomposition
CMaxwell2D_hField
CMaxwellSharedData	Shared data for RotRot and DivDiv
CNeumannTrace	The Neumann trace of the approximated function in a FE space
►CNeumannTraceElement	Element on an edge representing the normal derivatives of neighbouring elements, especially their mean or jump
CmapPart
CNTShapeFunction
CNeumannTraceSpace	A the NeumannTrace space of a given 2D - Finite Element space
CNotConnectedIndex	Exception class to express that a connected index wasn't found
►CNTElement_BA	Element on an edge representing the normal derivative of neighbouring elements, especially their mean or jump
CShapeFunction
CPartial_xx	Double partial derivative in x direction of the approximated function in a FE space
CPartial_yy	Double partial derivative in y direction of the approximated function in a FE space
CPlCurl	The vectorial 2D curl of the approximated function in a FE space
CPlCurlLinearForm	Linear form in 2D
CPolyEdgeMax	Edge gets maximal polynomial degree of adjacent cells
CPolyEdgeMin	Edge gets minimum of the polynomial degrees of the adjacent cells
CPolyEdgeMinNeighMaxChild	First the maximum polynomial degree of both sides of the edge is choosen
CPolyEdgeRule	Base class for rules for polynomial degrees of edges
CPostprocess4	Computes `x` to the power of 0.4
CPostprocess7	Computes `x` to the power of 0.7
CPostprocess8	Computes `x` to the power of 0.8
CPostprocess9	Computes `x` to the power of 0.9
CPostprocessSqrt	Computes to square root of `x`
CQuad	A 2D FEM element: a quad
CQuadEdgeBase	Static class to construct an element hp1D::Element out of an hp2D::Quad
CQuadEdgeFirst
CQuadEdgeJump
CQuadEdgeMean
CQuadFunctions	Auxiliary functions for quadrilaterals
CQuadGraphics	Handles graphics for 2D hp quadrilateral FEM elements
CQuadShapeFunctions	A class for holding the shape functions of nodal elements on quadrilaterials for a particular polynomials degree (ie
CRecomputeShapefct
CRiesz	Linear form in 2D
CRotRot	A function class to calculate element matrices for the Rot u*Rot v Bilinearform
CShapeFunction2D	Collecting the data of a 2D shape function in one class
CShortestDist	A function class for weighted regularization, which returns the square of the shortest distance of a point to the singular vertices
CSingularSet	Class for handling a set of singular vertices
CSingularVertex	Class for storing a singular vertex with the coordinates
CSpace	A 2D hp FEM space with continuous, piecewise polynomial basis functions
CSpacePreBuilder	Exception class to express that an inquired dof is not valid
CSumFactorization	Sum factorization for an element matrix
CTrace	The Dirichlet trace of the approximated function in a FE space
CTraceDeriv	The tangential derivative of the Dirichlet trace of the approximated function in a FE space
CTraceSpace	Builds the trace space of an FE space
CTransmissionWeight	Weight for the 2D transmission problem
CTransmissionWeightProd	Weight for the 2D transmission problem
CTrivialWeight	A function class for trivial (constant equal 1.0) weight function
CValue	The approximated function in a FE space
►Nhp2Dedge	Hp 2D edge elements for electromagnetics
CDirichletCoefficients	Class for calculating and holding local coefficients per element which represent the dirichlet boundary condition
CDirichletIdentity	Linear form in 2D for coping the Dirichlet boundary for Identity bilinearform
CDirichletRotRot	Linear form in 2D for coping the Dirichlet boundary for RotRot bilinearform
CEdge	An edge of a 2D FEM edge element quad
CEdgeIdentity	Bilinear form in 2D, integral over an edge
CEdgeRiesz	Linear form in 2D
CGraduv	A function class to calculate element matrices for the bilinear form
CGraduvBase	Base class to calculate element matrices for the (grad u, v)-bilinearform, for both scalar and matrix formulas
CGraduvMatrix	A function class to calculate element matrices for the bilinear form
CIdentity	A function class to calculate element matrices for the mass matrix
CIdentityBase	Base class to calculate element matrices for the Identity, for both scalar and matrix formulas
CIdentityMatrix	A function class to calculate element matrices for the mass matrix with a matrix function in between
CNeumann	Linear form in 2D for the term of Neumann boundary
CQuad	A 2D FEM edge element: a quad
CQuadEdgeFunctions	A class for holding the shape functions of edge elements on quadrilaterials for a particular polynomials degree (ie
CQuadGraphics	Handles graphics for 2D hp FEM edge elements
CRecomputeShapefct
CRiesz	Linear form in 2D
CRot	The
CRotRot	A function class to calculate element matrices for the Rot u Rot v-bilinearform (Maxwell equations)
CRotuv	A function class to calculate element matrices for the bilinear form
CSpace	A 2D hp FEM space of edge elements with piecewise polynomial basis functions with two components, where the tangential component is continuous Currently, only quadrilaterials and conforming meshes are possible
CValue	The approximated function in a FE space
►Nhp3D	3D hp-FEM for H¹-conforming elements
CAdvection	A function class to calculate element matrices of the bilinear form
CAPrioriRefinement	Carries out a-priori given refinements
CArrayElementFormula	Array of formula values on quadrature points
CArrayHexaWeights	Class to represent the quadrature weights on all quadrature points
CBilinearFormTwoPartDeriv	A class to calculate the element matrices for partial derivatives
CBuildDofsBase	Responsible to build the degrees of freedom in a space
CBuildEdgeDofs	Responsible to build the edge degrees of freedom in a space
CBuildFaceDofs	Responsible to build the face degrees of freedom in a space
CBuildFaceDofsHypTrunk	Responsible to build the inner degrees of freedom in a (trunk) space
CBuildFaceDofsLinTrunk	Responsible to build the face degrees of freedom in a (trunk) space
CBuildInnerDofs	Responsible to build the inner degrees of freedom in a space
CBuildInnerDofsHypTrunk	Responsible to build the inner degrees of freedom in a (trunk) space
CBuildInnerDofsLinTrunk	Responsible to build the inner degrees of freedom in a (trunk) space
CBuildVertexDofs	Responsible to build the vertex degrees of freedom in a space
CDaugeWeight	Weight implemented by Monique Dauge in Melina
CDistancePost	A function class for weighted regularization
CDivDiv	A function class to calculate element matrices for the Div u*Div v Bilinearform
CElement	Abstract class for a 3D FEM element
CElementFormulaVectorOnTrace	Class for evaluation of solutions on the `TraceSpace` with an `ElementFunction` that is only given on the whole space
CFormulaFromWeight	Makes it possible to plot a given `Weight`
CGrad	The gradient of an approximated function in a FE space
CHexahedron	A 3D FEM element: a hexahedron
CHexahedronFaceBase	Class to construct an quadrilateral element out of an hexahedron
CHexahedronFaceFirst
CHexahedronGraphics	Handles graphics for hexahedral 3D hp FEM elements
CHexFunctions	Auxiliary functions for hexahedra
CHook	A function class to calculate element matrices for the Bilinearform of linear Elasticity
CIdentity	A function class to calculate element matrices for the mass matrix
CLaplace	A function class to calculate element matrices for the Laplacian
CLaplacian	The Laplacian of an approximated function in a FE space
CLinearElasticity	A class to calculate the element matrices for problems of linear elasticity in 3D
CLinearFormHelper_1	Helper class for linearforms l(v), where v is a one form
CMaxwellSharedData	Shared data for RotRot and DivDiv
►CNeumannTraceElement3d	Element on an edge representing the normal derivatives of neighbouring elements, especially their mean or jump
CmapPart
CNeumannTraceSpace3d	A the NeumannTrace space of a given 3D - Finite Element space
CPostprocess14	Computes `x` to the power of 1/4
CPostprocess3	Computes `x` to the power of 3
CPostprocess34	Computes `x` to the power of 3/4
CPostprocess4	Computes `x` to the power of 4
CPostprocessRoot	Returns the square root of `x`
CPostprocessRoot4	Returns the forth root of `x`
CPostprocessSquare	Squares the given `x`
CProductOfAll	Computes the product of all distances in the singular set `singularities`
CRefineOrRaise	Refines element or raises its polynomial degree
CRiesz	Linear form in 3D
CRotRot	A function class to calculate element matrices for the Rot u*Rot v Bilinearform
CShapeFunction3D	Collecting the data of a 3D shape function in one class
CShortestDist	A function class for weighted regularization, which returns the square of the shortest distance of a point to the singular edges and vertices
CShortestDistLimited	A function class for weighted regularization, which returns the minimum of a value and the square of the shortest distance of a point to the singular edges and vertices
CSingularEdge	Class for storing a singular edge with coordinates of its corners
CSingularSet	Class for handling a set of singular edges and vertices
CSingularVertex	Class for storing a singular vertex with the coordinates
CSpace	A 3D hp FEM space with continuous, picewise polynomial basis functions
CSpaceTransition	Maps a solution vector from one space to another
CSumFactorization	Sum factorization for an element matrix
CTraceSpace	Builds the trace space of a FE space consisting of hexahedral elements
CTransitionPair	Element pair for the `SpaceTransition`
CTrivialWeight	A function class for trivial (constant equal 1.0) weight function
CValue	The approximated function in a FE space
CZeroTangentialValue	Sets the outer product of the coefficients and the normal vector to zero in every node on an edge with chosen attribute
►NlinDG1D	DG FEM for 1D problems using piecewise linear shape functions
CBoundaryInt	Boundary integral for the DG FEM in 1D
CBoundaryIntStab	Stabilizing boundary integral for the DG FEM in 1D
CDGElementPair	Element pair for DG FEM
►CLinear1d	Space for linear DG FEM in 1D
CTwoElements	Data structure used for temporary data to generate `DGElementPair`
►NlinDG2D	DG FEM for 2D problems using piecewise linear shape functions
CEdgeInfo	Edge information for DG FEM
CElementPair	Element pair for DG FEM in 2D
CElementPairList	Element pair list for two DG spaces
CIdentityBf	Volume integral for the identity in DG FEM in 2D
CLaplaceFluxBf	Edge fluxes for the Laplacian in DG FEM in 2D
CLaplaceStabBf	Stabilizing edge integral for the Laplacian in DG FEM in 2D
CLaplaceTimeLf	DG right hand side for time dependent problems with diffusion in 2D
CLaplaceVolBf	Volume integral for the Laplacian in DG FEM in 2D
►CMeshInfo	Mesh info about edges for DG FEM in 2D
CS	Scanner class for MeshInfo
CScalarProductLf	Pure L2 scalar product linear form for DG in 2D
►CSpace	Abstract base class of spaces for DG FEM in 2D on triangles
CS	Scanner class for Space
CSpaceP0	Space for piecewise constant DG FEM in 2D on triangles
CSpaceP1	Space for linear DG FEM in 2D on triangles
CTriangle	Abstract base class for triangular elements in 2D DGFEM
CTriangleGraphics	Handles graphics for triangular DGFEM elements in 2D
CTriangleP0	Triangular element with constant shape function in 2D
CTriangleP1	Triangular element with orthogonal linear shape functions in 2D
►NlinDG3D	DG-FEM methods to solve elliptic and hyperbolic PDE's
CAssembly	Provides methods to assemby matrices by lists of FvdgElementPairs
CConstRhs	TimeLinearForm for constant right hand side
CFvdgBilinearForm	Bilinear Form for FV/DG purpose
CFvdgElement	Generic tetrahedral element for FV/DG method
CFvdgElementPair	Stores additional information about two adjacent elements, namely the index, area, diameter and normal of shared interface
CFvdgP0TetElem	Tetrahedral element with constant shapefunction
CFvdgP0TetGraphics	Handles graphics for FvdgP0TetElem
CFvdgP1TetElem	Tetrahedral element with linear shapefunctions
CFvdgP1TetGraphics	Handles graphics for FvdgP1TetElem
CFvdgSpace	Generic space of tetrahedral elements for FV/DGFE method
CFvdgSpaceP0	Space of piecewise constant functions on tetrahedrons
CFvdgSpaceP1	Space of piecewise linear functions on tetrahedrons
CFvdgTimeRhs	Fvdg right hand side for time dependent problems
CFvdgTimeRhsDiff	Fvdg right hand side for time dependent problems with diffusion
CIdentity	Identity bilinear form
CLaplaceBoundaryBF	Laplace bilinear form
CLaplaceInnerBF	Laplace bilinear form
CLaplaceVolBF	Laplace bilinear form
CPenaltyBF	Penalty bilinear form
►NlinearFEM	Linear FEM in 1D, 2D and 3D
CCIdentity1d	Discrete equivalent for a reaction term in 1D for linear FEM
CElement	Base class for the element for linear FEM
CIdentity1d	Discrete equivalent for a reaction term in 1D for linear FEM
CIdentity2d	Discrete equivalent for a reaction term in 2D for linear FEM
CLaplace1d	Discrete equivalent of the Laplacian in 1D for linear FEM
CLaplace2d	Discrete equivalent of the Laplacian in 2D for linear FEM
CLine	Line element with linear shape function in 1D
CLinear1d	Space for linear FEM in 1D
CLinear2d	Space for linear triangular and bilinear quadrilateral FEM in 2D
CLinear3d	Space for linear FEM in 3D using tetrahedra
CLineGraphics	Handles graphics for linear finite elements in 1D
CQuad	Quadrilateral element with bilinear shape functions in 2D
CQuadGraphics	Handles graphics for bilinear quadrilateral FEM elements in 2D
CRiesz1d	Linear form form 1D linear FEM
CRiesz2d	Linear form form 2D linear FEM
CTetrahedron	Tetrehedral element with linear shape functions in 2D
CTetrahedronGraphics	Handles graphics for linear finite elements in 3D: tetrahedra
CTriangle	Triangular element with linear shape functions in 2D
CTriangleGraphics	Handles graphics for linear triangles FEM elements in 2D
►Nmechanics
CStress3D	Element function for the stress in 3D
►Nsparseqr	SparseQR solver
CDriver	Driver class for sparse QR decomposition
CFill
CGivensRotations	Given's Rotations
CJ	Given's rotations
CMinDegree
CPacked	Row of a sparse matrix
CQmatrix	Q matrix of the QR factorization
CQR	QR factorization
CSmatrix
►Nstd
Chash< concepts::Index >	Hash function class
Chash< concepts::Orders< number > >
CIndexEqual	Key equal function class
Cless< concepts::Cell * >	Specialisation of STL class less<F> for pointers to cells
Cless< concepts::Cell1 * >
Cless< concepts::Cell2 * >
Cless< concepts::Cell3 * >
COrdersEqual	Key equal function class
►Ntest	Unit tests
CArPackppTest	Test class for the ArPackpp, EasyArPackpp classes and their wrappers
CArPackTest
CBEMSpaceTest	Tests BEM spaces
CBesselTest	Test for Bessel functions
CBiCgStabTest	Test the iterative solver BiCGStab
CBilinearFormTest	Tests the bilinear forms
CBoundariesTest	Tests the Dirichlet boundaries
CCellConditionTest	Test cell conditions for FE space hp2D::hpAdaptiveSpaceH1
CCgTest	Test the iterative solver CG
CCloneing	Test cloneing of vector valued blinear forms
CCompositionsTest	Testing linear combination and multiplication of sparse matrices and the implementation of the evaluation into a sparse matrix
CCompositionTestBase
CConstrainedEVP	Base class for constrained Eigenvalue problem testcases
CContainer
CConvertMeshQuads	Tests conversion of triangular into quadrilateral meshes
CDeadLock1	Testing work around geometric deadlock problem
CDeadLock2	Testing work around geometric deadlock problem
CDeadLock3	Testing work around geometric deadlock problem
CDeepCompositionsTest	Tests deeply nested compositions resulting from constrained Eigenvalue problems
CDGEdgeInfoTest	Testing linDG2D::EdgeInfo
CDGElementPair2dTest	Testing linDG2D::ElementPair
CDGSpace2dP1Test	Testing linDG2D::SpaceP1
CDGTriangleP1Test	Testing linDG2D::TriangleP1
CDirichletTest	Test the dirichlet boundary condition with an extension operator in the class hp2D::H1Extension
CDirPowItTest
CDomainDecomp	Tests the solving with domain decomposition
CDomainDecompTest	Test the space DomainDecomp
CDriverTest	Tests the integration of the sparseqr package into Concepts
CEddy2DRingTest
CEdgeMeshTest	Tests for generating functions of edge meshes
CEdgeTest	Test the FE hp2D::Edge
CElementFormulaTest	Test for element formulas
CElementFunctionTest	Test the element functions
CExceptionTest	Testing some exceptions
CExtremaTest
CFormula2DTest	Test the Formulas in namespace hp2D
CFormulaTest	Test for element formulas
CFrmfElmFrmTest	Tests for generating functions of edge meshes
CFunctionEvaluation	Tests the evaluation of functions like hp2D::Value
CFunctionEvaluation3d	Tests the evaluation of functions like hp3D::Value or hp3D::Grad
CGolubExample	Test solver for constrained Eigenvalue problems
CGolubExampleSum	Test solver for constrained Eigenvalue problems
CGridInfoTest	Test the FE space hp2D::NeumannTraceSpace and hp2D::NeumannTraceElement
CH1extensionTest	Test the H1 extensionoperator of the class hp2D::H1Extension
Chp2DedgeAdvectionTest
ChpAdaptiveSpaceDGTest	Tests the space hpAdaptiveSpaceDG
ChpFullTest2D	Tests distribution of dof and polynomial degrees for mesh of quads with hanging nodes
CIndexRangeTest	Test the element functions
CInfiniteMesh2dTest	Tests 2D mesh with infinite cells
CIntegralTest	Tests the integrals
CKarniadakisTest	Testing concepts::Karniadakis
CLaguerreTest	Tests of Laguerre polynomials and relative basis
CLapackTest	Testsuite for solvers based on Lapack.a
CLegendreTest	Tests for (orthonomalized) Legendre polynomials
CLevelRieszTest
CLinearFormTest	Tests the linear forms
CMappingTest	Testing concepts::Mapping
CMatfileIOTest	Test for class MatfileIO
CMaxwellTransmissionEVP	Test case from Maxwell transmission problem with weighted regularization
CMeshImp2DTest
CMixedNonContTest	Test problems with discontinuity over an interface with Lagrange multipliers for the mean of the normal derivative
CMoreCompositionsTest	Performs more tests on compositions
CMumpsTest	Test the direct solver Mumps
CmumpsTestFail	Test the direct solver Mumps (failure case)
CNeumannTraceTest	Test the FE space hp2D::NeumannTraceSpace and hp2D::NeumannTraceElement
CPardisoTest	Test the direct solver Pardiso
CPointTest	Testing concepts::Point
CProjectionTest	Tests the projections from one space to another
CQuad2dTest	Tests the projections from one space to another
CQuadratureTest	Testing concepts::Quadrature and children of concepts::QuadratureRule
CRCPTest	Test for reference-counting pointers
CResetConnector0	Classes which allow for testing purpose (!) to reset internal counter of each connector type
CResetConnector1
CResetConnector2
CResetConnector3
CRestrictionSpaceTest	Test the restriction space
CSmallESTest
CSpaceH1onInfMeshTest	Tests 2D mesh with infinite cells
CSpaceH1Test	Tests the H1 space hpAdaptiveSpaceH1
CSpaceL2Test	Tests the L2 space hpAdaptiveSpaceL2
CSpaceTest2D	Tests building and copying hp2D::Space
CSpaceTest3D	Testing degree of freedom computation
CSparseMatrixTest	Test sparse matrix class SparseMatrix
CStackTest	Testing the output of the stacktrace
CSuperLUTest	Test the direct solver SuperLU
CTestBlending	Tests the functionality of blending in quads
CTestCase	Base class for tests
CTestDiameter	Tests the functionality of CellDiameter
CTestDualSpace1D
CTestEdgeMaps2D	Tests the functionality of the 2D edge maps
CTestIntegrals1D
CTestJacobian2D	Tests the Jacobian for anisotropic and isotropic refinements of quadrilaterals in two dimensions
CTestLegendre1D
CTestLinearForm1D
CTestMatrices1D	Mass and stiffness matrices
CTestMatrices2D	Mass and stiffness matrices
CTestMatrices3D	Mass and stiffness matrices
CTestSuite	Suite of tests
CTestSuiteError	Exception for TestSuite
CToTest	Simple test case to test TestCase
CTraceSpaceTest3D	Tests for the space hp3D::TraceSpace
CTraceTest	Test the FE space hp2D::Trace
CUmfpackTest	Test the direct solver Umfpack
CVectorTest	Test Vector
►Ntimestepping	Timestepping methods used to solve PDEs in time and space
CAlpha	Timestep strategy for the Alpha algorithm of Hilber, Hughes and Taylor to solve second order problems in time with no first order time derivative
CEuler	Timestep strategy for the explicit Euler algorithm to solve first order problems in time
CLimitingEuler	Timestep strategy for the explicit Euler algorithm with limiter to solve first order problems in time
CLimitingTvdRK2	Timestep stategy for an explicit two stage TVD Runge Kutta scheme to solve problems in time
CNewmark	Timestep strategy for the Newmark algorithm to solve second order problems in time with no first order time derivative
CNystroem	Timestep strategy for a Nyström algorithm to solve second order problems in time with no first order time derivative
CRungeKutta2	Timestep strategy for the explicit 2nd order RungeKutta algorithm to solve first order problems in time
CRungeKutta4	Timestep strategy for the explicit 4th order RungeKutta algorithm to solve first order problems in time
CTheta	Timestep strategy for the Theta-Scheme algorithm for first order problems in time
CTimeLinearForm	Abstract class implementing time dependent linear forms
CTimeStepping	This class encapsulates a general timestep solver concept to solve linear PDE in time and space
CTimeStepStrategy	Abstract strategy class for the class Timestepping
CTimeVector	Class implementing time dependent vectors
CTvdRK2	Timestep stategy for an explicit two stage TVD Runge Kutta scheme to solve problems in time
►Nvectorial	Vector valued problems
CBilinearForm	Vector valued bilinear form
CBlockOperator	Operator defined by 4 operators arranged in 2x2 blocks:
CBramblePasciak	Bramble-Pasciak preconditioned solver for generalized saddle point problems
CBramblePasciakFabric	Fabric class for `BramblePasciak`
CCGUzawa	Uzawa algorithm with conjugate directions for generalized saddle point problems
CCGUzawaFabric	Fabric class for `CGUzawa`
CElement	Vector valued element
CElementBase	Base class for vector valued element
CElementFunction	Vector valued element function
CElementFunctionAllComponents	Vectorial element function with the same scalar element function on each component
CElementFunctionComponent	Element function for selecting one scalar component of the vectorial solution
CElementNotBuilt	Indicates that the vectorial element is not yet built, there is no (scalar) element inside yet
CElementPair	Vector valued element pair
CElementPairListIdentic	Element pair list for two vectorial spaces V1 and V2
CElementWithCell	Vector valued element with a cell
CGraphics	Handles graphics for vector valued elements
CLinearForm	Vector valued linear form
CLinearFormHelper	Helper class for building a linear form in `vectorial`
CSpace	Vector valued space
CSpaceBase	Base class for vector valued space
CSpaceOnCells	Vector valued space with elements on cells
CSymmetrizeTensor	Element function for the symmetrized gradient of a vector valued function
CTimeLinearForm	Vector valued time dependent linear form
CTMatrix	Vector valued T matrix
CTMatrixOffset	T matrix with an offset
CVectorial	Base class for most classes which do vector valued problems
CVectorialElementType
CVectorialElementType< concepts::Element< F > >
CVectorialElementType< concepts::ElementWithCell< F > >
CVectorizable	Interface to make bilinear forms vectorizable
►CCube	$[0,a] \times [0,b] \times [0,c]$ in one hexahedron
CS
►CCube2	[0,1]³ in two hexahedra
CS
►CCube3	$[-1,1] \times [0,1] \times [0,5]$ in two hexahedra
CS
Cfunction
CResourceTimer	More precise timer

Class List