# Class List

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 | |

CExpR2 | |

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 | |

CLaplace | |

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 |

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 for points in cartesian coordinates |

CCos_n_x | Class for evaluating for points in cartesian coordinates |

CCos_n_y | Class for evaluating for points 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 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 for points in cartesian coordinates |

CExp_i_n_x | Class for evaluating for points in cartesian coordinates |

CExp_i_n_y | Class for evaluating for points 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 |

CFormulaExpImag2D | Formula for |

CFormulaExpImag2DGrad | Formula for gradient of a plane wave |

CFormulaExpImag2DRadialDer | Formula for radial derivative of |

CFormulaFromElementFormula | Projection class that allows to project an ElementFormula (i.e |

CFormulaIncPlaneWaveSource | Formula for |

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 for radial PML, see INRIA report of Collino & Monk |

CFormulaPMLPowerSigmaB2D | Class for the function 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 |

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 |

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, , that is for 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 for points in cartesian coordinates |

CSin_n_x | Class for evaluating for points in cartesian coordinates |

CSin_n_y | Class for evaluating for points 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 |

CSourceFunctionF0_y | Design of the limit order source function in direction as |

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 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^{1}-conforming elements |

►Nl2 | 2D hp-FEM for L^{2}-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 , where is a 2-form and 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^{1}-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 | in one hexahedron |

CS | |

►CCube2 | [0,1]^{3} in two hexahedra |

CS | |

►CCube3 | in two hexahedra |

CS | |

Cfunction | |

CResourceTimer | More precise timer |