Discontinuous Galerkin Library
#include "dg/algorithm.h"
Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 123456]
 Cdg::ABS< T >\( f(x) = |x|\)
 Cdg::AbsMax< T >\( f(x,y) = \max(|x|,|y|)\)
 Cdg::AbsMin< T >\( f(x,y) = \min(|x|,|y|)\)
 Cdg::aCommunicator< LocalContainer >Struct that performs collective scatter and gather operations across processes on distributed vectors using MPI
 ►Cdg::aCommunicator< Vector >
 Cdg::Adaptive< Stepper >Driver class for adaptive timestep ODE integration
 Cdg::Advection< Geometry, Matrix, Container >Upwind discretization of advection operator \( \vec v\cdot\nabla f\)
 Cdg::AndersonAcceleration< ContainerType >Anderson Acceleration of Fixed Point/Richardson Iteration for the nonlinear equation \( f(x) = b\)
 ►Cdg::AnyMatrixTagTensor_category base class
 ►Cdg::AnyPolicyTagExecution Policy base class
 Cdg::ArakawaX< Geometry, Matrix, Container >Arakawa's scheme for Poisson bracket \( \{ f,g\} \)
 ►Cdg::aRealMPITopology2d< real_type >2D MPI abstract grid class
 ►Cdg::aRealMPITopology3d< real_type >3D MPI Grid class
 ►Cdg::aRealRefinement1d< real_type >Abstract base class for 1d grid refinement that increases the number of grid cells of a fixed basis grid
 ►Cdg::aRealRefinementX2d< real_type >Abstract base class for 2d grid refinement that increases the number of grid cells of a fixed basis grid
 ►Cdg::aRealTopology2d< real_type >An abstract base class for two-dimensional grids
 ►Cdg::aRealTopology2d< double >
 ►Cdg::aRealTopology3d< real_type >An abstract base class for three-dimensional grids
 ►Cdg::aRealTopologyX2d< real_type >A 2D grid class with X-point topology
 ►Cdg::aRealTopologyX3d< real_type >A 3D grid class with X-point topology
 Cdg::ARKStep< ContainerType >Additive Runge Kutta (semi-implicit) time-step with error estimate following The ARKode library
 ►Cdg::aTimeloop< ContainerType >Abstract timeloop independent of stepper and ODE
 Cdg::Average< ContainerType >Topological average computations in a Cartesian topology
 Cdg::Average< MPI_Vector< container > >MPI specialized class for average computations
 Cdg::Axpby< T >\( y\leftarrow ax+by \)
 Cdg::Axpbypgz< T >\( z\leftarrow ax+by+gz \)
 Cdg::AxyPby< T >\( y\leftarrow axy+by \)
 Cdg::BathRZ\(f(R,Z) = A B \sum_\vec{k} \sqrt{E_k} \alpha_k \cos{\left(k \kappa_k + \theta_k \right)} \)
 Cdg::BICGSTABl< ContainerType >Preconditioned BICGSTAB(l) method to solve \( Ax=b\)
 Cdg::Buffer< T >Manager class that invokes the copy constructor on the managed ptr when copied (deep copy)
 Cdg::Buffer< Index >
 Cdg::Buffer< thrust::host_vector< get_value_type< Vector > > >
 Cdg::Buffer< typename Collective::buffer_type >
 Cdg::Buffer< typename Collective::container_type >
 Cdg::Buffer< value_type >
 Cdg::Buffer< Vector >
 Cdg::ButcherTableau< real_type >Manage coefficients of a (extended) Butcher tableau
 Cdg::ButcherTableau< value_type >
 Cdg::Cauchy\( f(x,y) = \begin{cases} Ae^{1 + \left(\frac{(x-x_0)^2}{\sigma_x^2} + \frac{(y-y_0)^2}{\sigma_y^2} - 1\right)^{-1}} \text{ if } \frac{(x-x_0)^2}{\sigma_x^2} + \frac{(y-y_0)^2}{\sigma_y^2} < 1\\ 0 \text{ else} \end{cases} \)
 Cdg::CauchyX\( f(x,y) = \begin{cases} Ae^{1 + \left(\frac{(x-x_0)^2}{\sigma_x^2} - 1\right)^{-1}} \text{ if } \frac{(x-x_0)^2}{\sigma_x^2} < 1\\ 0 \text{ else} \end{cases} \)
 Cdg::ChebyshevIteration< ContainerType >Preconditioned Chebyshev iteration for solving \( PAx=Pb\)
 Cdg::ChebyshevPreconditioner< Matrix, ContainerType >Chebyshev Polynomial Preconditioner \( C( A)\)
 Cdg::ClonePtr< Cloneable >Manager class that invokes the clone() method on the managed ptr when copied
 Cdg::ClonePtr< Collective >
 Cdg::ClonePtr< dg::aRealRefinement1d< real_type > >
 Cdg::Composite< Matrix >
 Cdg::CONSTANT\( f(x) = f(x,y) = f(x,y,z) = c\)
 Cdg::ConvertsToButcherTableau< real_type >Convert identifiers to their corresponding dg::ButcherTableau
 Cdg::ConvertsToMultistepTableau< real_type >Convert identifiers to their corresponding dg::MultistepTableau
 Cdg::ConvertsToShuOsherTableau< real_type >Convert identifiers to their corresponding dg::ShuOsherTableau
 Cdg::CooSparseBlockMat< value_type >Coo Sparse Block Matrix format
 Cdg::CosXCosY\( f(x,y) =B+ A \cos(k_x x) \cos(k_y y) \)
 Cdg::CosY\( f(x,y) =B+ A \cos(k_y y) \)
 Cdg::CSRAverageFilterAverage filter that computes the average of all points in the stencil
 Cdg::CSRMedianFilterCompute (lower) Median of input numbers
 Cdg::CSRSlopeLimiter< real_type >Generalized slope limiter for dG methods
 Cdg::CSRSWMFilter< real_type >Switching median filter
 Cdg::CSRSymvFilterTest filter that computes the symv csr matrix-vector product if used
 Cdg::DefaultSolver< ContainerType >PCG Solver class for solving \( (y-\alpha\hat I(t,y)) = \rho\)
 Cdg::DIRKStep< ContainerType >Embedded diagonally implicit Runge Kutta time-step with error estimate \( \begin{align} k_i = f\left( t^n + c_i \Delta t, u^n + \Delta t \sum_{j=1}^{i} a_{ij} k_j\right) \\ u^{n+1} = u^{n} + \Delta t\sum_{j=1}^s b_j k_j \\ \tilde u^{n+1} = u^{n} + \Delta t\sum_{j=1}^s \tilde b_j k_j \\ \delta^{n+1} = u^{n+1} - \tilde u^{n+1} = \Delta t\sum_{j=1}^s (b_j-\tilde b_j) k_j \end{align} \)
 Cdg::Distance\( f(x,y) = \sqrt{ (x-x_0)^2 + (y-y_0)^2} \)
 Cdg::divides\( y = x_1/x_2 \)
 Cdg::divides_equals\( y = y/x\)
 Cdg::DLT< real_type >Struct holding coefficients for Discrete Legendre Transformation (DLT) related operations
 Cdg::DLT< double >
 Cdg::DPolynomialHeaviside\( f(x) = \begin{cases} 0 \text{ if } x < x_b-a || x > x_b+a \\ (35 (a + x - x_b)^3 (a - x + x_b)^3)/(32 a^7) \text{ if } |x-x_b| < a \end{cases}\) The derivative of PolynomialHeaviside approximates delta(x)
 Cdg::Elliptic1d< Geometry, Matrix, Container >A 1d negative elliptic differential operator \( -\partial_x ( \chi \partial_x ) \)
 Cdg::Elliptic2d< Geometry, Matrix, Container >A 2d negative elliptic differential operator \( -\nabla \cdot ( \mathbf{\chi}\cdot \nabla ) \)
 Cdg::Elliptic3d< Geometry, Matrix, Container >A 3d negative elliptic differential operator \( -\nabla \cdot ( \mathbf{\chi}\cdot \nabla ) \)
 Cdg::EllSparseBlockMat< value_type >Ell Sparse Block Matrix format
 Cdg::EmbeddedPairSum\( y = \sum_i a_i x_i + b y,\quad \tilde y = \sum_i \tilde a_i x_i + \tilde b y \)
 Cdg::EntireDomainThe domain that contains all points
 Cdg::equals\( y=x\)
 Cdg::ERKStep< ContainerType >Embedded Runge Kutta explicit time-step with error estimate \( \begin{align} k_i = f\left( t^n + c_i \Delta t, u^n + \Delta t \sum_{j=1}^{i-1} a_{ij} k_j\right) \\ u^{n+1} = u^{n} + \Delta t\sum_{j=1}^s b_j k_j \\ \tilde u^{n+1} = u^{n} + \Delta t\sum_{j=1}^s \tilde b_j k_j \\ \delta^{n+1} = u^{n+1} - \tilde u^{n+1} = \Delta t\sum_{j=1}^s (b_j - \tilde b_j) k_j \end{align} \)
 Cdg::Evaluate< BinarySub, Functor >\( f( y, g(x_0, ..., x_s)) \)
 Cdg::EVE< ContainerType >The Eigen-Value-Estimator (EVE) finds largest Eigenvalue of \( M^{-1}Ax = \lambda_\max x\)
 ►Cstd::exception
 Cdg::EXP< T >\( f(x) = \exp( x)\)
 Cdg::ExplicitMultistep< ContainerType >General explicit linear multistep ODE integrator \( \begin{align} v^{n+1} = \sum_{j=0}^{s-1} a_j v^{n-j} + \Delta t\left(\sum_{j=0}^{s-1}b_j \hat f\left(t^{n}-j\Delta t, v^{n-j}\right)\right) \end{align} \)
 Cdg::ExponentialFilter\( f(i) = \begin{cases} 1 \text{ if } \eta < \eta_c \\ \exp\left( -\alpha \left(\frac{\eta-\eta_c}{1-\eta_c} \right)^{2s}\right) \text { if } \eta \geq \eta_c \\ 0 \text{ else} \\ \eta=\frac{i}{1-n} \end{cases}\)
 Cdg::ExpProfX\( f(x) = f(x,y) = f(x,y,z) = A\exp(-x/L_n) + B \)
 Cdg::Extrapolation< ContainerType >Extrapolate a polynomial passing through up to three points
 Cdg::FilteredERKStep< ContainerType >EXPERIMENTAL: Filtered Embedded Runge Kutta explicit time-step with error estimate \( \begin{align} k_i = f\left( t^n + c_i \Delta t, \Lambda\Pi \left[u^n + \Delta t \sum_{j=1}^{i-1} a_{ij} k_j\right]\right) \\ u^{n+1} = \Lambda\Pi\left[u^{n} + \Delta t\sum_{j=1}^s b_j k_j\right] \\ \delta^{n+1} = \Delta t\sum_{j=1}^s (\tilde b_j - b_j) k_j \end{align} \)
 Cdg::FilteredExplicitMultistep< ContainerType >EXPERIMENTAL: General explicit linear multistep ODE integrator with Limiter / Filter \( \begin{align} \tilde v &= \sum_{j=0}^{s-1} a_j v^{n-j} + \Delta t\left(\sum_{j=0}^{s-1}b_j \hat f\left(t^{n}-j\Delta t, v^{n-j}\right)\right) \\ v^{n+1} &= \Lambda\Pi \left( \tilde v\right) \end{align} \)
 Cdg::Gaussian\( f(x,y) = Ae^{-\left(\frac{(x-x_0)^2}{2\sigma_x^2} + \frac{(y-y_0)^2}{2\sigma_y^2}\right)} \)
 Cdg::Gaussian3d\( f(x,y,z) = Ae^{-\left(\frac{(x-x_0)^2}{2\sigma_x^2} + \frac{(y-y_0)^2}{2\sigma_y^2} + \frac{(z-z_0)^2}{2\sigma_z^2}\right)} \)
 Cdg::GaussianDamping\( f(\psi) = \begin{cases} 1 \text{ if } \psi < \psi_{\max}\\ 0 \text{ if } \psi > (\psi_{\max} + 4\alpha) \\ \exp\left( - \frac{(\psi - \psi_{\max})^2}{2\alpha^2}\right), \text{ else} \end{cases} \)
 Cdg::GaussianX\( f(x,y) = Ae^{-\frac{(x-x_0)^2}{2\sigma_x^2} } \)
 Cdg::GaussianY\( f(x,y) = Ae^{-\frac{(y-y_0)^2}{2\sigma_y^2}} \)
 Cdg::GaussianZ\( f(x,y,z) = Ae^{-\frac{(z-z_0)^2}{2\sigma_z^2}} \)
 Cdg::GeneralHelmholtz< Matrix, Container >A general Helmholtz-type operator \( (\chi-\alpha F) \)
 Cdg::Heaviside\( f(x) = \begin{cases} 0 \text{ if } x < x_b \\ 1 \text{ else} \end{cases}\)
 Cdg::Helmholtz2< Geometry, Matrix, Container >DEPRECATED, Matrix class that represents a more general Helmholtz-type operator
 Cdg::Histogram< container >Compute a histogram on a 1D grid
 Cdg::Histogram2D< container >Compute a histogram on a 2D grid
 Cdg::Horner2d\( f(x,y) = \sum_{i=0}^{M-1} \sum_{j=0}^{N-1} c_{iN+j} x^i y^j \)
 Cdg::IDENTITY\( f(x) = x\)
 Cdg::IdentityFilterA filter that does nothing
 Cdg::ImExMultistep< ContainerType >Semi-implicit multistep ODE integrator \( \begin{align} v^{n+1} = \sum_{q=0}^{s-1} a_q v^{n-q} + \Delta t\left[\left(\sum_{q=0}^{s-1}b_q \hat E(t^{n}-q\Delta t, v^{n-q}) + \sum_{q=1}^{s} c_q \hat I( t^n - q\Delta t, v^{n-q})\right) + c_0\hat I(t^{n}+\Delta t, v^{n+1})\right] \end{align} \)
 Cdg::ImplicitMultistep< ContainerType >Implicit multistep ODE integrator \( \begin{align} v^{n+1} &= \sum_{i=0}^{s-1} a_i v^{n-i} + \Delta t \sum_{i=1}^{s} c_i\hat I(t^{n+1-i}, v^{n+1-i}) + \Delta t c_{0} \hat I (t + \Delta t, v^{n+1}) \\ \end{align} \)
 Cdg::InvCoshXsq\( f(x,y) =A/\cosh^2(k_x x) \)
 Cdg::InverseKroneckerTriDiagonal2d< Container >Fast inverse tridiagonal sparse matrix in 2d \( T_y^{-1}\otimes T_x^{-1}\)
 Cdg::InverseTensorMultiply2d< value_type >\( y_i \leftarrow \lambda T^{-1}_{ij} x_i + \mu y_i\)
 Cdg::InverseTensorMultiply3d< value_type >\( y_i \leftarrow \lambda T^{-1}_{ij} x_i + \mu y_i\)
 Cdg::InverseTriDiagonal< value_type >Fast inverse tridiagonal sparse matrix
 Cdg::INVERT< T >\( f(x) = 1/x \)
 Cdg::InvSqrt< T >\( f(x) = \frac{1}{\sqrt{x}}\)
 Cdg::IPolynomialHeaviside\( f(x) = \begin{cases} x_b \text{ if } x < x_b-a \\ x_b + ((35 a^3 - 47 a^2 (x - x_b) + 25 a (x - x_b)^2 - 5 (x - x_b)^3) (a + x - x_b)^5)/(256 a^7) \text{ if } |x-x_b| < a \\ x \text{ if } x > x_b + a \end{cases}\) The integral of PolynomialHeaviside approximates xH(x)
 Cdg::Iris\( f(\psi) = \begin{cases} 1 \text{ if } \psi_{\min} < \psi < \psi_{\max}\\ 0 \text{ else} \end{cases}\)
 Cdg::IslandXY\( f(x,y) = \lambda \ln{(\cosh{(x/\lambda) } +\epsilon \cos(y/\lambda)) } \)
 Cdg::ISNFINITE< T >\( f(x) = \mathrm{!std::isfinite(x)}\)
 Cdg::ISNSANE< T >\( f(x) =\begin{cases} \mathrm{true\ if}\ |x| > 10^{100}\\ \mathrm{false\ else} \end{cases}\)
 Cdg::KroneckerTriDiagonal2d< Container >Fast tridiagonal sparse matrix in 2d \( T_y\otimes T_x\)
 Cdg::Lamb\( f(x,y) = \begin{cases} 2\lambda U J_1(\lambda r) / J_0(\gamma)\cos(\theta) \text{ for } r<R \\ 0 \text{ else} \end{cases} \)
 Cdg::LeastSquaresExtrapolation< ContainerType0, ContainerType1 >Evaluate a least squares fit
 Cdg::LeastSquaresPreconditioner< Matrix, InnerPreconditioner, ContainerType >Least Squares Polynomial Preconditioner \( M^{-1} s( AM^{-1})\)
 Cdg::LGMRES< ContainerType >Functor class for the right preconditioned LGMRES method to solve \( Ax=b\)
 Cdg::Line\( f(x) = y_1\frac{x-x_0}{x_1-x_0} + y_0\frac{x-x_1}{x_0-x_1}\)
 Cdg::LinearX\( f(x) = f(x,y) = f(x,y,z) = ax+b \)
 Cdg::LinearY\( f(x,y) = f(x,y,z) = ay+b \)
 Cdg::LinearZ\( f(x,y,z) = az+b \)
 Cdg::LN< T >\( f(x) = \ln(x)\)
 Cdg::MessageSmall class holding a stringstream
 Cdg::MinMod\( f(x_1, x_2, ...) = \begin{cases} \min(x_1, x_2, ...) &\text{ for } x_1, x_2, ... >0 \\ \max(x_1, x_2, ...) &\text{ for } x_1, x_2, ... <0 \\ 0 &\text{ else} \end{cases} \)
 Cdg::minus_equals\( y=y-x\)
 Cdg::MOD< T >\( f(x) = \) x mod m > 0 ? x mod m : x mod m + m
 Cdg::ModifiedChebyshevPreconditioner< Matrix, ContainerType >Approximate inverse Chebyshev Polynomial Preconditioner \( A^{-1} = \frac{c_0}{2} I + \sum_{k=1}^{r}c_kT_k( Z)\)
 Cdg::MPI_Vector< container >Mpi Vector class
 Cdg::MPIDistMat< LocalMatrix, Collective >Distributed memory matrix class
 Cdg::MPITagDistributed memory system
 Cdg::MultigridCG2d< Geometry, Matrix, Container >Solve
 Cdg::MultiMatrix< MatrixType, ContainerType >Struct that applies given matrices one after the other
 Cdg::MultistepTableau< real_type >Manage coefficients of Multistep methods
 Cdg::MultistepTableau< value_type >
 Cdg::NearestNeighborComm< Index, Buffer, Vector >Communicator for asynchronous nearest neighbor communication
 Cdg::NestedGrids< Geometry, Matrix, Container >Hold nested grids and provide dg fast interpolation and projection matrices
 Cdg::NoPolicyTagIndicate that a type does not have an execution policy
 Cdg::NotATensorTagIndicate that a type is not a tensor
 Cdg::ONE\( f(x) = f(x,y) = f(x,y,z) = 1\)
 Cdg::OneDimensionalTag1d
 Cdg::Operator< T >A square nxn matrix
 Cdg::Operator< double >
 Cdg::Operator< int >
 Cdg::Operator< real_type >
 Cdg::Operator< value_type >
 Cdg::PairSum\( y = \sum_i a_i x_i \)
 Cdg::PCG< ContainerType >Preconditioned conjugate gradient method to solve \( Ax=b\)
 Cdg::Plus< T >\( y\leftarrow y+a \)
 Cdg::PLUS< T >\( f(x) = x + c\)
 Cdg::plus_equals\( y=y+x\)
 Cdg::PointwiseDivide< T >\( z\leftarrow ax/y + bz \)
 Cdg::PointwiseDot< T >\( z\leftarrow ax_1y_1+bx_2y_2+gz \)
 Cdg::Poisson< Geometry, Matrix, Container >Direct discretization of Poisson bracket \( \{ f,g\} \)
 Cdg::PolynomialHeaviside\( f(x) = \begin{cases} 0 \text{ if } x < x_b-a \\ ((16 a^3 - 29 a^2 (x - x_b) + 20 a (x - x_b)^2 - 5 (x - x_b)^3) (a + x - x_b)^4)/(32 a^7) \text{ if } |x-x_b| < a \\ 1 \text{ if } x > x_b + a \end{cases}\)
 Cdg::PolynomialRectangle\( f(x) = \begin{cases} 0 \text{ if } x < x_l-a_l \\ ((16 a_l^3 - 29 a_l^2 (x - x_l) + 20 a_l (x - x_l)^2 - 5 (x - x_l)^3) (a_l + x - x_l)^4)/(32 a_l^7) \text{ if } |x-x_l| < a_l \\ 1 \text{ if } x_l + a_l < x < x_r-a_r \\ ((16 a_r^3 - 29 a_r^2 (x - x_r) + 20 a_r (x - x_r)^2 - 5 (x - x_r)^3) (a_r + x - x_l)^4)/(32 a_r^7) \text{ if } |x-x_r| < a_r \\ 0 \text{ if } x > x_r + a_r \end{cases}\)
 Cdg::POSVALUE< T >\( f(x) = \begin{cases} x \text{ for } x>0 \\ 0 \text{ else} \end{cases} \)
 Cdg::PsiPupil\( f(\psi) = \begin{cases} \psi_{\max} \text{ if } \psi > \psi_{\max} \\ \psi \text{ else} \end{cases}\)
 Cdg::Pupil\( f(\psi) = \begin{cases} 0 \text{ if } \psi > \psi_{\max} \\ 1 \text{ else} \end{cases}\)
 Cdg::RealGrid1d< real_type >1D grid
 Cdg::RealGrid1d< double >
 Cdg::RealGridX1d< real_type >1D grid for X-point topology
 Cdg::RefinedElliptic< Geometry, IMatrix, Matrix, Container >The refined version of Elliptic
 Cdg::RowColDistMat< LocalMatrixInner, LocalMatrixOuter, Collective >Distributed memory matrix class, asynchronous communication
 Cdg::Scal< T >\( y\leftarrow ay \)
 Cdg::SharedTagShared memory system
 Cdg::ShuOsher< ContainerType >Shu-Osher fixed-step explicit ODE integrator with Slope Limiter / Filter \( \begin{align} u_0 &= u_n \\ u_i &= \Lambda\Pi \left(\sum_{j=0}^{i-1}\left[ \alpha_{ij} u_j + \Delta t \beta_{ij} f( t_j, u_j)\right]\right)\\ u^{n+1} &= u_s \end{align} \)
 Cdg::ShuOsherTableau< real_type >Manage coefficients in Shu-Osher form
 Cdg::ShuOsherTableau< value_type >
 Cdg::Sign< T >\( f(x) = \text{sgn}(x) = \begin{cases} -1 \text{ for } x < 0 \\ 0 \text{ for } x = 0 \\ +1 \text{ for } x > 0 \end{cases}\)
 Cdg::Simpsons< ContainerType >Time integration based on Simpson's rule
 Cdg::SinProfX\( f(x) = f(x,y) = f(x,y,z) = B + A(1 - \sin(k_xx )) \)
 Cdg::SinX\( f(x) = f(x,y) = f(x,y,z) =B+ A \sin(k_x x) \)
 Cdg::SinXCosY\( f(x,y) =B+ A \sin(k_x x) \cos(k_y y) \)
 Cdg::SinXSinY\( f(x,y) =B+ A \sin(k_x x) \sin(k_y y) \)
 Cdg::SinY\( f(x,y) =B+ A \sin(k_y y) \)
 Cdg::SlopeLimiter< Limiter >\( \text{up}(v, g_m, g_0, g_p, h_m, h_p ) = \begin{cases} +h_m \Lambda( g_0, g_m) &\text{ if } v \geq 0 \\ -h_p \Lambda( g_p, g_0) &\text{ else} \end{cases} \)
 Cdg::SlopeLimiterProduct< Limiter >\( \text{up}(v, g_m, g_0, g_p, h_m, h_p ) = v \begin{cases} +h_m \Lambda( g_0, g_m) &\text{ if } v \geq 0 \\ -h_p \Lambda( g_p, g_0) &\text{ else} \end{cases} \)
 Cdg::SparseTensor< container >Class for 2x2 and 3x3 matrices sharing elements
 Cdg::SparseTensor< Container >
 Cdg::SQRT< T >\( f(x) = \sqrt{x}\)
 Cdg::Square\( f(x) = x^2\)
 Cdg::Sum\( y = \sum_i x_i \)
 Cdg::TanhProfX\( f(x) = B + 0.5 A(1+ \text{sign} \tanh((x-x_b)/\alpha ) ) \)
 Cdg::TensorDeterminant2d< value_type >\( y = t_{00} t_{11} - t_{10}t_{01} \)
 Cdg::TensorDeterminant3d< value_type >\( y = t_{00} t_{11}t_{22} + t_{01}t_{12}t_{20} + t_{02}t_{10}t_{21} - t_{02}t_{11}t_{20} - t_{01}t_{10}t_{22} - t_{00}t_{12}t_{21} \)
 Cdg::TensorDot2d< value_type >\( y = \lambda\mu v_i T_{ij} w_j \)
 Cdg::TensorDot3d< value_type >\( y = \lambda \mu v_i T_{ij} w_j \)
 Cdg::TensorMultiply2d< value_type >\( y_i \leftarrow \lambda T_{ij} x_i + \mu y_i\)
 Cdg::TensorMultiply3d< value_type >\( y_i \leftarrow \lambda T_{ij} x_i + \mu y_i\)
 Cdg::TensorTraits< Vector, Enable >The vector traits
 Cdg::TensorTraits< CooSparseBlockMat< T > >
 Cdg::TensorTraits< cusp::coo_matrix< I, V, M > >
 Cdg::TensorTraits< cusp::csr_matrix< I, V, M > >
 Cdg::TensorTraits< cusp::dia_matrix< I, V, M > >
 Cdg::TensorTraits< cusp::ell_matrix< I, V, M > >
 Cdg::TensorTraits< cusp::hyb_matrix< I, V, M > >
 Cdg::TensorTraits< EllSparseBlockMat< T > >
 Cdg::TensorTraits< MPI_Vector< container > >Prototypical MPI vector
 Cdg::TensorTraits< MPIDistMat< L, C > >
 Cdg::TensorTraits< RowColDistMat< LI, LO, C > >
 Cdg::TensorTraits< std::array< T, N >, std::enable_if_t< !std::is_arithmetic< T >::value > >
 Cdg::TensorTraits< std::array< T, N >, std::enable_if_t< std::is_arithmetic< T >::value > >
 Cdg::TensorTraits< std::map< Key, T > >Behaves like a RecursiveVector
 Cdg::TensorTraits< std::vector< T >, std::enable_if_t< !std::is_arithmetic< T >::value > >Prototypical Recursive Vector
 Cdg::TensorTraits< std::vector< T >, std::enable_if_t< std::is_arithmetic< T >::value > >
 Cdg::TensorTraits< T, std::enable_if_t< std::is_arithmetic< T >::value > >Recognize arithmetic types as scalars
 Cdg::TensorTraits< thrust::device_vector< T > >Prototypical Shared Vector with Cuda or Omp Tag
 Cdg::TensorTraits< thrust::host_vector< T > >Prototypical Shared Vector with Serial Tag
 Cdg::TensorTraits< View< ThrustVector > >A View has identical value_type and execution_policy as the underlying container
 Cdg::ThreeDimensionalTag3d
 Cdg::TimerSimple tool for performance measuring
 Cdg::times_equals\( y=xy\)
 Cdg::TopologyTraits< Topology >
 Cdg::TriDiagonal< Container >Fast (shared memory) tridiagonal sparse matrix
 Cdg::TripletSum\( y = \sum_i a_i x_i y_i \)
 Cdg::TwoDimensionalTag2d
 Cdg::Upwind\( \text{up}(v, b, f ) = \begin{cases} b &\text{ if } v \geq 0 \\ f &\text{ else} \end{cases} \)
 Cdg::UpwindProduct\( \text{up}(v, b, f ) = v \begin{cases} b &\text{ if } v \geq 0 \\ f &\text{ else} \end{cases} \)
 Cdg::VanLeer\( f(x_1,x_2) = 2\begin{cases} \frac{x_1x_2}{x_1+x_2} &\text{ if } x_1x_2 > 0 \\ 0 & \text { else } \end{cases} \)
 Cdg::View< ThrustVector >A vector view class, usable in dg functions
 Cdg::Vortex\(f(x,y) =\begin{cases} \frac{u_d}{1.2965125} \left( r\left(1+\frac{\beta_i^2}{g_i^2}\right) - R \frac{\beta_i^2}{g_i^2} \frac{J_1(g_ir/R)}{J_1(g_i)}\right)\cos(\theta) \text{ if } r < R \\ \frac{u_d}{1.2965125} R \frac{K_1(\beta_i {r}/{R})}{K_1(\beta)} \cos(\theta) \text{ else } \end{cases} \)
 Cdg::WallDistanceShortest Distance to a collection of vertical and horizontal lines
 Cdg::ZERO\( f(x) = f(x,y) = f(x,y,z) = 0\)