Here are the classes, structs, unions and interfaces with brief descriptions:
| Sundance::AbstractEvalMediator | Base class for evaluation mediator objects |
| TSFExtended::AccessibleVector< Scalar > | TSFExtended::AccessibleVector defines an interface through which elements for a vector can be accessed |
| Sundance::ADReal | First-order automatic differentiation of a multivariable function |
| Sundance::AlgebraSpecifier | AlgebraSpecifier is used to indicate whether a given object represents a vector, scalar, component of a vector, etc |
| TSFExtended::AmesosSolver | |
| TSFExtended::AnasaziEigensolver< Scalar > | Object wrapper for Anasazi eigenvalue solver |
| Sundance::ApplySimpleDiffOp | Apply a simple diff op |
| Sundance::ArrayOfTuples< T > | Class ArrayOfTuples packs an heterogeneous array of tuples into a single 1D array |
| Sundance::Assembler | |
| Sundance::AssemblyKernelBase | AssemblyKernelBase abstracts the operations that must be done in an assembly loop |
| Sundance::AssociateHungryDiffOpWithOperand | Transform a product by associating any hungry diff op in the left operand with the right operand:
|
| Sundance::AToCDensitySampler | AToCDensitySampler samples a distribution of particles to compute a density function on a discrete space |
| Sundance::AToCPointLocator | AToCPointLocator finds the cell index for a point within an unstructured mesh |
| TSFExtended::AztecSolver | |
| Sundance::BadSymbolicsError | BadSymbolicsError is thrown when a mathematically nonsensical expression is detected |
| Sundance::BamgMeshReader | BamgMeshReader reads a mesh stored in Frederic Hecht's g format |
| Sundance::BasicSimplicialMesh | A no-frills parallel simplicial mesh |
| Sundance::BasicSimplicialMeshType | BasicSimplicialMeshType is used to create BasicSimplicialMesh objects |
| Sundance::BasisArray | |
| Sundance::BasisDOFTopologyBase | Abstract interface for specification of the topology of degree-of-freedom (DOF) assignments on reference cells in any dimension |
| Sundance::BasisFamily | BasisFamily is the user-level handle class for specifying the basis with which a test, unknown, or discrete function is represented |
| Sundance::BasisFamilyBase | |
| Sundance::BasisReferenceEvaluationBase | Abstract interface for evaluation of basis functions and their spatial derivatives on reference cells |
| TSFExtended::BelosSolver | |
| Sundance::Bernstein | Bernstein basis |
| TSFExtended::BICGSTABSolver< Scalar > | |
| Sundance::BinaryCellFilter | BinaryCellFilter implements cell filters that do binary logical operations on cell sets |
| Sundance::BinaryEvaluator< ExprType > | |
| Sundance::BinaryExpr | BinaryExpr is a base class for binary expressions, e.g., sums and products |
| Sundance::Block | |
| Sundance::BlockArray | |
| TSFExtended::BlockOperatorBase< Scalar > | Class BlockOperatorBase provides an abstract interface for accessing blocks of block operators |
| TSFExtended::BlockTriangularSolver< Scalar > | |
| Sundance::BoundaryCellFilter | BoundaryCellFilter identifies all cells of dimension  on the boundary |
| Sundance::BoundaryCellPredicate | BoundaryCellPredicate tests whether a cell is on the boundary of the domain |
| Sundance::BoundedDomain | |
| Sundance::BrickQuadrature | Get abscissas and weights for Gaussian quadrature on Brick cells (cuboids) |
| Sundance::BringConstantOutsideDiffOp | Bring a constant outside a diff op
|
| Sundance::Bubble | Bubble function for use in error estimation |
| Sundance::CartesianCoordinateSystem | |
| Sundance::CellCurvePredicate | |
| Sundance::CellDiameterExpr | Expression that returns a characteristic size for each cell on which it is evaluated |
| Sundance::CellDiameterExprEvaluator | |
| Sundance::CellFilter | CellFilter is a user-level object representing a filter that selects from a mesh all cells that satisfy some condition |
| Sundance::CellFilterBase | Base class for CellFilter objects |
| Sundance::CellIterator | CellIterator is an iterator for walking through cell sets |
| Sundance::CellJacobianBatch | A CellJacobianBatch is a collection of Jacobian matrices for many quadrature points distributed over batch of cells |
| Sundance::CellLIDMappedFieldWrapper | |
| Sundance::CellPredicate | User-level handle for predicates (deriving from CellPredicateBase) used to decide whether a given cell passes a CellFilter |
| Sundance::CellPredicateBase | CellPredicateBase is the base class for predicate objects that test cells against some condition |
| Sundance::CellPredicateFunctorBase | |
| Sundance::CellReorderer | User-level handle class for abstract specification of cell reordering algorithms |
| Sundance::CellReordererFactoryBase | Factory class to instantiate cell reorderers for specific meshes |
| Sundance::CellReordererImplemBase | Abstract interface for the low-level objects that implement cell reordering |
| Sundance::CellSet | CellSet is, you guessed it, a set of cells in a mesh |
| Sundance::CellSetBase | CellSetBase is the base class for cell sets |
| Sundance::CellVectorEvaluator | |
| Sundance::CellVectorExpr | Expression that returns a component of a cell-determined vector for each cell on which it is evaluated |
| Sundance::CFMeshPair | |
| Sundance::ChainRuleEvaluator | |
| Sundance::ChainRuleSum | |
| Sundance::ClosedNewtonCotes | Closed Newton-Cotes quadrature rules for lines and triangles |
| Sundance::ClosedNewtonCotesType | Generates closed Newton-Cotes quadrature rules |
| TSFExtended::CollectivelyConfigurableMatrixFactory | Class CollectivelyConfigurableMatrixFactory provides an abstract interface for all-at-once matrix structure configuration |
| Sundance::CommonFuncDataStub | CommonFuncDataStub is a placeholder for data to be shared between multiple components of a symbolic or discrete function |
| Sundance::ComplexExpr | Complex expression |
| TSFExtended::CompoundTester< Scalar > | |
| Sundance::ConstantEvaluator | |
| Sundance::ConstantExpr | ConstantExpr contains an immutable constant, to be distinguished from a parameter that is constant in space but can change during the course of a simulation |
| Sundance::ConstHandleTraits< X > | This traits class is used to extract the non-const version of a template argument |
| Sundance::ConstHandleTraits< const X > | Specialization of CHT to types "const X" |
| TSFExtendedOps::ConvertibleToVector< Scalar > | |
| Sundance::CoordDeriv | CoordDeriv represents a single first-order derivative with respect to a coordinate function |
| Sundance::CoordExpr | CoordExpr is an expression that returns one of the cartesian coordinates for each point at which it evaluated |
| Sundance::CoordExprEvaluator | |
| Sundance::CoordinateSystem | |
| Sundance::CoordinateSystemBase | |
| Sundance::CoordinateSystemBuilder | |
| Sundance::CoordinateValueCellPredicate | |
| Sundance::CoordinateValueCellPredicateFunctor | |
| Coupled1DTest | |
| Sundance::CToAInterpolator | CToAInterpolator interpolates a discrete function at particle positions |
| Sundance::CubicHermite | CubicHermite basis |
| Sundance::CurveDomain | Class defines mesh domain based on parametrized curve |
| Sundance::CurveEvalMediator | |
| Sundance::CurveIntegralCalc | Class to compute the intersection/quadrature points of a cell with a curve in 2/3D |
| Sundance::CurveNormEvaluator | Evaluator for the normal vector component (normal to one parameterized curve) |
| Sundance::CurveNormExpr | CurveNormExpr is an expression that returns the Cartesian coordinate component of the normal vector |
| Sundance::CurveQuadratureIntegral | Integration by quadrature over a maximal cell |
| TSFExtended::DefaultLTIProblemFactory< Scalar > | |
| Sundance::DefaultObjectWithVerbosity | Simple implementation of ObjectWithVerbosityBase interface |
| TSFExtended::DenseLUSolver | |
| TSFExtended::DenseSerialMatrix | Linear operator implemented as a dense matrix |
| TSFExtended::DenseSerialMatrixFactory | |
| TSFExtended::DenseSerialVector | Serial vector with math operations |
| Sundance::Deriv | The purpose of this class is to represent first-order spatial or functional differential operators |
| Sundance::Derivative | Derivative is an expression subtype representing a first-order spatial partial derivative operator |
| Sundance::DerivOfSymbFunc | Specialization of DiffOp to the case where the argument is a symbolic function, allowing optimized evaluation |
| Sundance::DerivOfSymbFuncEvaluator | |
| Sundance::DerivProduct | |
| Sundance::DerivSet | DerivSet is a set of multiple derivatives, sorted by increasing differentiation order |
| Sundance::DiffOp | |
| Sundance::DiffOpEvaluator | |
| Sundance::DimensionalCellFilter | DimensionalCellFilter is a filter that identifies all cells of a specified dimension |
| Sundance::DiscreteFuncDataStub | DiscreteFuncDataStub is a placeholder for data to be shared between multiple components of a discrete function |
| Sundance::DiscreteFuncElement | DiscreteFuncElement represents a scalar-valued element of a (possibly) vector-valued discrete function |
| Sundance::DiscreteFuncElementEvaluator | |
| Sundance::DiscreteFunction | DiscreteFunction represents a function that is discretized on a finite-element space |
| Sundance::DiscreteFunctionData | DiscreteFunctionData |
| Sundance::DiscreteFunctionStub | DiscreteFunctionStub is the base class for discrete functions |
| Sundance::DiscreteSpace | DiscreteSpace represents a discrete finite-element space (i.e., a mesh and a basis) |
| Sundance::DistributeSumOfDiffOps | Distribute a sum of diff ops over their operand
|
| Sundance::DOFMapBase | Base interface for implementations of a degree of freedom map |
| Sundance::DOFMapBuilder | |
| Sundance::Rivara::Edge | Class Edge is a one-dimensional edge in a simplicial mesh |
| Sundance::EdgeLocalizedBasis | EdgeLocalizedBasis is a basis function defined only on edges |
| Sundance::EFDEEvaluator | |
| Sundance::Eigensolution | |
| TSFExtended::Eigensolver< Scalar > | Handle class for eigensolvers |
| TSFExtended::EigensolverBase< Scalar > | Base class for eigensolvers for linear eigenvalue problems
|
| Sundance::Rivara::Element | Class Element is a maximal-dimension element in a simplicial mesh |
| Sundance::ElementIntegral | ElementIntegral encapsulates the common data needed for the integration of groups of related zero-forms, one-forms, and two-forms |
| Sundance::Rivara::ElementIterator | |
| Sundance::EnumTypeField< T > | |
| Epetra::Epetra_TSFOperator | |
| TSFExtended::EpetraGhostImporter | Ghost element importer for Epetra vectors |
| TSFExtended::EpetraGhostView | Ghost element viewer for Epetra vectors |
| TSFExtended::EpetraMatrix | |
| TSFExtended::EpetraMatrixFactory | |
| TSFExtended::EpetraMultiVector | TSF extension of Thyra::EpetraMultiVector, implementing the LoadableMultiVector interface allowing an application to access elements |
| TSFExtended::EpetraVector | TSF extension of Thyra::EpetraVector, implementing the LoadableVector interface allowing an application to access elements |
| TSFExtended::EpetraVectorSpace | Adaptor wrapping Epetra map in the Thyra vector space system |
| TSFExtended::EpetraVectorType | TSF extension of Thyra::EpetraVectorSpaceFactory, allowing use in handles and more extensive capability for creating distributed spaces |
| Sundance::EquationSet | Source: SundanceEquationSet.cpp |
| Sundance::ErrNormCalculatorBase | Base class for objects that compute error norms |
| TSFExtended::EuclideanOpWithBackwardsCompatibleApply< Scalar > | |
| Sundance::EvalContext | Different contexts might require the same expression to be evaluated to different orders of functional differentiation; for example, in setting up a linear system, second-order derivatives are required, but in evaluating a functional only zeroth derivs are required |
| Sundance::EvalContextStub | |
| Sundance::EvalManager | EvalManager provides methods for interfacing to the framework through an AbstractEvalMediator and managing temporary variables through a TempStack |
| Sundance::EvaluatableExpr | |
| Sundance::Evaluator | Base class for evaluator objects |
| Sundance::EvaluatorFactory | |
| Sundance::EvalVector | |
| Sundance::EvalVectorArray | |
| Sundance::ExodusMeshReader | ExodusMeshReader reads a mesh from an ExodusII file |
| Sundance::ExodusNetCDFMeshReader | ExodusNetCDFMeshReader reads a mesh from a NetCDF dump of an Exodus file |
| Sundance::ExodusWriter | ExodusWriter writes a mesh or fields to an ExodusII file |
| Sundance::ExplicitCellIterator | |
| Sundance::ExplicitCellSet | ExplicitCellSet is a cell set subtype where the cell LIDs are stored explicitly in an STL set |
| Sundance::ExplicitFunctionalDerivativeElement | Scalar element of an explicit user-level functional derivative |
| TSFExtended::ExplicitlyTransposeableOp< Scalar > | Base interface for operators whose transpose can be formed explicitly |
| TSFExtended::ExplicitlyTransposedLTIProblemFactory< Scalar > | This class produces LTI problems where any transpose solves are done using explicit transforms |
| Sundance::Expr | User-level expression class |
| Sundance::ExprBase | |
| Sundance::ExprFieldWrapper | |
| Sundance::ExprWithChildren | ExprWithChildren is a base class for any evaluatable expression that has child nodes, for example, sums and unary operators |
| Sundance::ExtrusionMeshTransformation | ExtrusionMeshTransformation extrudes a 2D mesh to 3D |
| Sundance::Rivara::Face | Class Face is a two-dimensional face in a simplicial mesh |
| Sundance::Rivara::FaceNodes | |
| Sundance::FeketeBrickQuadrature | Get abscissas and weights for Gauss-Lobatto quadrature on brick cells (cuboids) (Gauss-Lobatto points are Fekete points on tensor elements) |
| Sundance::FeketeQuadQuadrature | Get abscissas and weights for Gauss-Lobatto quadrature on quadrilateral (Gauss-Lobatto points are Fekete points on tensor elements) |
| Sundance::FeketeQuadrature | Family of Fekete approach integration rules, suitable for integration over arbitrary regions (For tensor elements the Gauss-Lobatto points are Fekete points) |
| Sundance::FeketeQuadratureType | Family of Fekete approach integration rules, suitable for integration over arbitrary regions (For tensor elements the Gauss-Lobatto points are Fekete points) |
| Sundance::FeketeTriangleQuadrature | Get abscissas and weights for Fekete point quadrature on triangles |
| Sundance::FieldBase | |
| Sundance::FieldWriter | FieldWriter is the user level object for writing fields and meshes to output stream |
| Sundance::FieldWriterBase | FieldWriterBase is a base class for objects that write fields and/or meshes to a stream |
| Sundance::FileIOChacoPartitioner | This partitioner makes a system call to run Chaco, passing partitioning information to it through file IO |
| Sundance::FixedArray< N, T > | A simple fixed-size array |
| Sundance::ForwardProblemTestBase | |
| Sundance::FuncElementBase | FuncElementBase defines the interface for scalar-valued elements of Sundance functions |
| Sundance::FuncSetAccumulator | This abstract class defines the interface for accumulating sets of functions that are available in an expression |
| Sundance::Functional | |
| Sundance::FunctionalAssemblyKernel | FunctionalAssemblyKernel does assembly of a functional value |
| Sundance::FunctionalEvaluator | |
| Sundance::FunctionalGradientAssemblyKernel | FunctionalGradientAssemblyKernel does assembly of a functional and its gradient |
| Sundance::FunctionalPolynomial | Specialized class for representing polynomials in symbolic functions and their derivatives |
| Sundance::FunctionIdentifier | FunctionIdentifier provides a means for distinguishing between different functions and different vector components of the same function |
| Sundance::FunctionSupportResolver | |
| Sundance::FunctionWithID | This is a base class for functions or elements that need an ID object |
| Sundance::FunctorDomain | |
| Sundance::FuncWithBasis | |
| Sundance::Gauss1D | Get abscissas and weights for Gauss-Legendre quadrature on a line segement |
| Sundance::GaussianQuadrature | Family of optimal Gaussian integration rules, e.g., Gauss-Legendre on lines, Dunavant on triangles |
| Sundance::GaussianQuadratureType | Family of optimal Gaussian integration rules, e.g., Gauss-Legendre on lines, Dunavant on triangles |
| Sundance::GaussLobatto1D | Get abscissas and weights for Gauss-Lobatto-Legendre quadrature on a line segment |
| Sundance::GenericCellReordererFactory< T > | Factory class to instantiate cell reorderers for specific meshes |
| Sundance::GenericEvaluatorFactory< ExprT, EvalT > | |
| TSFExtended::GenericLeftPreconditioner< Scalar > | A one-size-fits-most left preconditioner that can be constructed by accepting an operator for the left op of the preconditioner |
| TSFExtended::GenericRightPreconditioner< Scalar > | A one-size-fits-most right preconditioner that can be constructed by accepting an operator for the right op of the preconditioner |
| TSFExtended::GhostImporter< Scalar > | In many applications it is necessary to view some subset of off-processor, or "ghost", elements of a vector |
| TSFExtended::GhostView< Scalar > | GhostView is an interface for read-only views of vector elements including selected off-processor elements |
| Sundance::GIDCellPredicate | GIDCellPredicate tests whether a cell's GID is contained in a specified set of GIDs |
| TSFExtended::GMRESSolver< Scalar > | |
| NOX::TSF::Group | |
| Sundance::GrouperBase | Grouper |
| Sundance::Handle< PointerType > | Class Sundance::Handle provides a general implementation of the common features of reference-counted handles |
| Sundance::Handleable< Base > | Class Handleable provides an abstract interface for polymorphic conversion from raw pointers to smart pointers |
| Sundance::HCurlVectorBasis | Base class for bases living in H(curl) |
| Sundance::HDivVectorBasis | Base class for bases living in H(div) |
| TSFExtended::HeatOperator1D | |
| Helmholtz1DTest | Solves the Helmholtz equation in 1D with Lagrange(2) basis functions |
| Sundance::HNDoFMapBase | The abstract class which extends the functionalities of the DOF map The only additional functionality is that we have a restriction on the DOFs , with the pre-fill transformations these constraints can be build in into the matrix |
| Sundance::HNMesh2D | Class for 2D hierarchical structured quad Mesh The main internal idea of the mesh ist that there are different numberings of the elements ID -> each element has an ID (also those which are completely outside the mesh domain, and those which are not leaf) In the code sometimes internaly LID is used instead of ID due to legacy !! :-P GID -> all leaf elements which are visible to Sundance (only the leaf elements should be visible) LID -> all the elements which have GID and belong and either belong to the local processor or are in the ghost cells |
| Sundance::HNMesh3D | Class for 3D hierarchical structured quad Mesh The main internal idea of the mesh ist that there are different numberings of the elements ID -> each element has an ID (also those which are completely outside the mesh domain, and those which are not leaf) In the code sometimes internaly LID is used instead of ID due to legacy !! :-P GID -> all leaf elements which are visible to Sundance (only the leaf elements should be visible) LID -> all the elements which have GID and belong and either belong to the local processor or are in the ghost cells |
| Sundance::HNMesher2D | |
| Sundance::HNMesher3D | |
| Sundance::HNMeshType2D | Class for a simple capable to refine, and to work in parallel structured 2D mesh type Mesh is based on the trisection refinement |
| Sundance::HNMeshType3D | Class for a simple capable to refine, and to work in parallel structured 3D mesh type Mesh is based on the trisection refinement |
| Sundance::HomogeneousDOFMap | A HomogeneousDOFMap is a DOF map for the special (and common) case in which every function has the same basis and is defined on every cell in the mesh |
| TSFExtended::HomogeneouslyBlockedLinearOp< Scalar > | HomogeneouslyBlockedLinearOp is a helper class providing a convenient way to build operators having a block structure in which all blocks have the same domain and range |
| Sundance::IdentifyPolynomialSum | Rewrite a sum as a polynomial object, if possible |
| Sundance::IdentityReorderer | |
| Sundance::IdentityReordererImplem | The identity reorderer walks through cells in whatever order they are numbered the the mesh |
| TSFExtended::IfpackOperator | |
| TSFExtended::ILUFactorizableOp< Scalar > | Base interface for operators for which incomplete LU factorizations can be obtained |
| TSFExtended::ILUKPreconditionerFactory< Scalar > | |
| Sundance::ImplicitCellSet | ImplicitCellSet is a cell set subtype where the set of cell LIDs is never stored |
| Sundance::increasingOrder< T > | |
| Sundance::increasingOrder< MultipleDeriv > | Functor increasingOrder() is used as a comparison method for MultipleDeriv objects |
| TSFExtended::IncrementallyConfigurableMatrixFactory | Class IncrementallyConfigurableMatrixFactory provides an abstract interface for row-at-a-time configuration of matrix factories |
| Sundance::IncrementallyCreatableMesh | IncrementallyCreatableMesh is an interface for the creation of meshes by adding vertices, then elements |
| TSFExtended::IndexableVector< Scalar > | TSFExtended::IndexableVector defines an interface through which elements for a vector can be accessed for both reading and writing through indexing operators |
| Sundance::IndexPair | |
| Sundance::InhomogeneousNodalDOFMap | |
| TSFExtended::InitTraits< MV, OP > | |
| TSFExtended::InitTraits< MultiVectorBase< double >, LinearOpBase< double > > | |
| TSFExtended::InitTraits< SimpleMV, LinearOperator< double > > | |
| Sundance::IntegralGroup | IntegralGroup collects together several integrals having common properties that can be used either to eliminate redundant computations or to share storage an eliminate repeated allocations |
| Sundance::InternalError | InternalError is thrown when an "impossible" case is detected in Sundance's internals |
| Sundance::IntHashSet | |
| TSFExtended::InverseLTIOp< Scalar > | InverseLTIOp encapsulates a block operator representation of timestepping for a linear, time-invariant system of ODEs |
| TSFExtended::InverseOperator< Scalar > | TSFInverseOperator represents the inverse of some other operator |
| TSFExtended::IterativeSolver< Scalar > | |
| Sundance::KillDiffOpOnConstant | Kill a diff op acting on a constant
|
| TSFExtended::KrylovSolver< Scalar > | |
| Sundance::L2NormCalculator | Object to compute L2 norms of errors |
| Sundance::L2Projector | L2Projector projects an expression onto a DiscreteSpace |
| Sundance::LabelCellPredicate | LabelCellPredicate tests whether a cell's label is equal to a reference label |
| Sundance::LabeledSubsetCellFilter | |
| Sundance::Lagrange | Lagrange basis |
| TSFExtended::LAPACKGeneralMatrix | Linear operator implemented as a LAPACK dense matrix |
| TSFExtendedOps::LC2< Scalar, Node1, Node2 > | Class LC2 is a 2-term linear combination |
| TSFExtended::LinearCombinationTester< Scalar > | |
| Sundance::LinearEigenproblem | |
| LinearOpBase | |
| TSFExtended::LinearOperator< Scalar > | User-level linear operator class |
| Sundance::LinearProblem | LinearProblem encapsulates all information needed to form a discrete linear problem |
| Sundance::LinearSolveDriver | |
| TSFExtended::LinearSolver< Scalar > | |
| TSFExtended::LinearSolverBase< Scalar > | |
| TSFExtended::LinearSolverBuilder | |
| Sundance::LineDomain | This class bundles together a sequence of uniform meshes of the 1D interval [a,b] with cell filters defining the interior and boundaries |
| Sundance::ListExpr | |
| TSFExtended::LoadableBlockOperator< Scalar > | Class LoadableBlockOperator provides a LoadableMatrix interface for a physically-partitioned block 2x2 matrix, making it appear to the fill routine as if the block matrix is a single matrix |
| TSFExtended::LoadableBlockVector | LoadableBlockVector provides a LoadableVector interface to a physically-partitioned block 1x2 vector, making it appear to the fill routine as if the block vector is a single vector |
| TSFExtended::LoadableMatrix< Scalar > | Class LoadableMatrix provides an abstract interface for loading elements into a matrix |
| Sundance::LoadableVector | LoadableVector is the interface through which a framework inserts values into a symbolic expression |
| TSFExtended::LoadableVector< Scalar > | LoadableVector defines an interface through which elements can be loaded into a vector |
| Sundance::LocalDOFMap | LocalDOFMap bundles several compact tables used for fast lookup of local DOFs |
| Sundance::LocalMatrixContainer | LocalMatrixContainer is a container for local matrix and vector values |
| Sundance::LowerBoundedDomain | |
| Thyra::LOWSFactoryBuilder | Provides a static method that creates a LOWSFactor given a parameter list |
| Sundance::LP1DTestBase | |
| Sundance::LPTestBase | |
| Sundance::LPTestSpec | |
| Sundance::LPTestSuite | |
| TSFExtended::LTIProblemFactoryBase< Scalar > | LTIProblemFactoryBase is an interface for building operators related to reduced-order LTI problems |
| map | |
| Sundance::Map< Key, Value, Compare > | Extension of STL map, adding some nicer put/get/contains syntax and an iostream insertion operator |
| Sundance::MapBundle | MapBundle collects several data structures needed for DOF mapping |
| Sundance::MapStructure | |
| Sundance::MatlabWriter | MatlabWriter writes a 1D mesh to a matlab file |
| TSFExtended::MatrixFactory< Scalar > | MatrixFactory is an abstract builder for empty matrices |
| TSFExtended::MatrixLaplacian1D | |
| TSFExtended::MatrixMatrixTester< Scalar > | |
| Sundance::MatrixVectorAssemblyKernel | MatrixVectorAssemblyKernel does assembly of a matrix and vector |
| Sundance::MaximalCellFilter | MaximalCellFilter is a filter that identifies all mesh cells of maximal dimension |
| Sundance::MaximalCellSet | |
| Sundance::MaximalCofacetBatch | MaximalCofacetBatch is used to store the maximal cofacets of a batch of cells of codimension one |
| Sundance::MaximalQuadratureIntegral | Integration by quadrature over a maximal cell |
| Sundance::MeridionalCylindricalCoordinateSystem | |
| Sundance::Mesh | Mesh is the user-level object representing discrete geometry |
| Sundance::MeshBase | Abstract interface to a mesh |
| Sundance::MeshBuilder | |
| Sundance::MeshDomainBase | Base class for mesh refinement , but also to define computational domain (which must not be the same as the mesh domain) |
| Sundance::MeshDomainDef | |
| Sundance::MeshReaderBase | MeshReaderBase is a base class for mesh sources that get a mesh from a file |
| Sundance::MeshSource | MeshSource is the user-level interface for objects such as mesh generators and mesh file readers |
| Sundance::MeshSourceBase | MeshSourceBase provides the internal interface for mesh sources, i.e., objects such as mesh generators and file readers that can produce a mesh object |
| Sundance::MeshTransformation | MeshTransformation is the user-level interface for mesh filters, i.e., objects that take an input mesh and produce a new mesh |
| Sundance::MeshTransformationBase | MeshSourceBase provides the internal interface for mesh filters, i.e., objects that take an input mesh and produce a new mesh |
| Sundance::MeshType | Class MeshType is a user-level object for specification of which internal mesh representation is to be used when building or reading a mesh |
| Sundance::MeshTypeBase | MeshTypeBase is a factory class for empty meshes, allowing generic mesh sources to build a mesh of user-specified type |
| Sundance::MixedDOFMap | A MixedDOFMap is a DOF map for the case where every function is defined on every cell in the mesh, but where functions may have different bases |
| Sundance::MixedDOFMapHN | A MixedDOFMapHN is a DOF map for the case where every function is defined on every cell in the mesh, but where functions may have different bases |
| TSFExtended::MLOperator | |
| Thyra::MLPreconditionerFactory | Concrete preconditioner factory subclass based on ML |
| Sundance::MoveConstantsToLeftOfProduct | Transform a product by moving any constants to the left:
|
| Sundance::MoveConstantsToLeftOfSum | Transform a sum by moving any constants to the left:
|
| Sundance::MoveUnaryMinusOutsideProduct | Transform a product by any unary minus operations outside the product
|
| Sundance::MultiIndex | An integer vector representing a multivariate derivative |
| Sundance::MultipleDeriv | Class MultipleDeriv is a multiple functional derivative operator represented as a multiset of first-order derivatives |
| Sundance::MultiplyConstants | Multiply two constant exprs without transformation |
| multiset | |
| Sundance::MultiSet< Key > | Extension of STL multiset, adding some nicer syntax and an iostream insertion operator |
| TSFExtended::MultiVector< Scalar > | |
| TSFExtended::MultiVectorOperator< Scalar > | A MultiVectorOperator is a linear operator whose rows or columns are represented as a multivector |
| Anasazi::MultiVecTraits< double, SimpleMV > | |
| Sundance::NamedObject | NamedObject provides an interface for getting and setting names of an object |
| Sundance::Nedelec | Lowest-order Nedelec basis |
| Sundance::NLOp | NLOp encapsulates a discrete nonlinear problem, and can be passed to a nonlinear solver such as NOX |
| Sundance::NodalDOFMap | |
| Sundance::NodalDOFMapHN | |
| Sundance::Rivara::Node | Class Node is a vertex in a simplicial mesh |
| Sundance::Noncopyable | Noncopyable has a private copy ctor and assignment operator, which prevents any classes dervied from it from being copied |
| TSFExtended::NonlinearOperator< Scalar > | User-level nonlinear operator class |
| TSFExtended::NonlinearOperatorBase< Scalar > | Base class for nonlinear operators |
| Sundance::NonlinearProblem | NonlinearProblem encapsulates a discrete nonlinear problem |
| TSFExtended::NonlinearSolverBase< Scalar > | Here I am |
| Sundance::NonlinearUnaryOp | |
| Sundance::NonlinearUnaryOpEvaluator | |
| Sundance::NonzeroDomain | |
| TSFExtended::NOXSolver | |
| Sundance::NullCellFilter | NullCellFilter is used as a placeholder cell filter in those equations defined independently of geometry, i.e., equations involving only global parameters |
| Sundance::NullEvaluator | |
| Sundance::ObjectWithClassVerbosity< X > | ObjectWithClassVerbosity and the related verbosity() method provide a method for getting/setting verbosity flags for entire classes |
| Sundance::ObjectWithInstanceID< T > | ObjectWithInstanceID provides a common method for the generation of instance-specific ID numbers |
| Sundance::ObjectWithVerbosityBase | Abstract interface for getting/setting verbosity levels |
| Sundance::OneTetMesher | Create a mesh having one tet |
| Sundance::OneTriangleMesher | Create a mesh having one triangle |
| TSFExtended::OperatorBuilder< Scalar > | Base class for building test operators |
| Anasazi::OperatorTraits< double, SimpleMV, LinearOperator< double > > | |
| TSFExtendedOps::OpTimesLC< Scalar, Node > | Class OpTimesLC holds an operator times something convertible to a vector |
| TSFExtended::OpWithBackwardsCompatibleApply< Scalar > | |
| Sundance::OrderedHandle< PointerType > | Class OrderedHandle is an extension to Sundance::Handle that includes a comparison operator ("<" operator) so that the handle can be used in ordered containers such as STL maps and sets |
| Sundance::OrderedPair< A, B > | OrderedPair provides a means of lexigraphic comparison of a pair of objects |
| Sundance::OrderedQuartet< A, B, C, D > | Lexigraphically-comparable quartet of objects |
| Sundance::OrderedTriple< A, B, C > | Lexigraphically-comparable triple of objects |
| Sundance::Out | |
| Sundance::Pair< T > | |
| Sundance::Parameter | A Parameter is an expression subtype used to represent a spatially-constant parameter that may change during the course of a simulation, for example, the time in a transient simulation or a continuation parameter when using a homotopy method |
| Sundance::ParameterControlledObjectWithVerbosity< X > | |
| Sundance::ParameterData | ParameterData is the specialization of DiscreteFuncDataStub to the case of a constant-valued discrete function |
| TSFExtended::ParameterListPreconditionerFactory | |
| Sundance::PartialElementDOFMap | PartialElementDOFMap is a DOF map specialized to the case of element-based DOFs on a subset of cells in the domain |
| Sundance::PartitionedLineMesher | PartitionedLineMesher meshes the one-dimensional interval ![$\left[a_x, b_x\right]$](form_154.png) with  elements per processor |
| TSFExtended::PartitionedMatrixFactory | |
| Sundance::PartitionedRectangleMesher | PartitionedRectangleMesher meshes the rectangle ![$ \left[a_x, b_x\right] \otimes \left[a_y, b_y\right] $](form_156.png) with  elements per processor |
| TSFExtended::PartitionedToMonolithicConverter | |
| TSFExtended::PCDPreconditionerFactory | |
| Sundance::PeanoMesher2D | |
| Sundance::PeanoMesher3D | |
| Sundance::PeanoMeshType2D | PeanoMeshType is used to create PeanoMesh objects |
| Sundance::PeanoMeshType3D | PeanoMeshType is used to create PeanoMesh objects |
| Sundance::PeriodicLineMesher | Create a mesh having one triangle |
| Sundance::PeriodicMesh1D | Periodic mesh in 1D |
| Sundance::PeriodicMeshType1D | |
| Sundance::Point | Point represents a spatial point |
| Sundance::PointCellPredicate | |
| Sundance::PointCellPredicateFunctor | |
| Sundance::PointwiseUserDefFunctor0 | PointwiseUserDefFunctor0 is an implementation of UserDefFunctor for which the user writes code to evaluate the function at a single quadrature point |
| Sundance::PointwiseUserDefFunctor1 | PointwiseUserDefFunctor1 is an implementation of UserDefFunctor for which the user writes code to evaluate the function at a single quadrature point |
| Sundance::PointwiseUserDefFunctor2 | PointwiseUserDefFunctor2 is an implementation of UserDefFunctor for which the user writes code to evaluate the function at a single quadrature point |
| Poisson1DTest | Solves the Poisson equation in 1D with user-specified basis functions |
| TSFExtended::PoissonBoltzmannJacobian | |
| TSFExtended::PoissonBoltzmannOp | |
| Sundance::PositionalCellPredicate | PositionalCellPredicate tests whether the cell's nodes satisfy a condition on their positions |
| Sundance::PositiveDomain | |
| Sundance::PowerFunctor | |
| TSFExtended::Preconditioner< Scalar > | |
| TSFExtended::PreconditionerBase< Scalar > | Base class for preconditioners |
| TSFExtended::PreconditionerFactory< Scalar > | PreconditionerFactory builds an implementation-specific preconditioner from an abstract specification |
| TSFExtended::PreconditionerFactoryBase< Scalar > | Base class for preconditioner factories |
| Sundance::Printable | Printable defines an interface for writing an object to a stream |
| Sundance::ProductEvaluator | |
| Sundance::ProductExpr | ProductExpr represents a product of two scalar-valued expressions |
| Sundance::ProductTransformation | ProductTransformation is a base class for any transformation which takes the two operands of a product (left, right) and produces a new expression mathematically equivalent to the original product |
| Sundance::ProductTransformationSequence | ProductTransformationSequence is a sequence of transformations to be applied to a product, producing a transformed expression |
| Projection1DTest | Performs L2 projection in 1D with user-specified basis functions |
| Sundance::QuadQuadrature | Get abscissas and weights for Gaussian quadrature on quadrilateral |
| Sundance::QuadratureEvalMediator | |
| Sundance::QuadratureFamily | QuadratureFamily is a geometry-independent specification of a method by which quadrature is to be carried out |
| Sundance::QuadratureFamilyBase | QuadratureFamilyBase extends QuadratureFamilyStub to provide an interface for getting quadrature points for a given cell type |
| Sundance::QuadratureFamilyStub | |
| Sundance::QuadratureIntegral | |
| Sundance::QuadratureIntegralBase | |
| Sundance::QuadratureType | QuadratureFamily is a geometry-independent specification of a method by which quadrature is to be carried out |
| Sundance::QuadratureTypeBase | QuadratureTypeBase |
| Sundance::RadialSphericalCoordinateSystem | |
| TSFExtended::RandomBlockMatrixBuilder< Scalar > | |
| TSFExtended::RandomSparseMatrixBuilder< Scalar > | |
| Sundance::RaviartThomas | Lowest-order Raviart-Thomas basis |
| TSFExtended::RawDataAccessibleVector< Scalar > | Base class for vector types that support raw data access |
| Sundance::RearrangeLeftProductWithConstant | Rearrange a product whose left operand is a product including a constant such that constants are grouped on the left:
|
| Sundance::RearrangeLeftSumWithConstant | Rearrange a sum whose left operand is a sum including a constant such that constants are grouped on the left:
|
| Sundance::RearrangeRightProductWithConstant | Rearrange a product whose right operand is a product including a constant such that constants are grouped on the left:
|
| Sundance::RearrangeRightSumWithConstant | Rearrange a sum whose right operand is a sum including a constant such that constants are grouped on the left:
|
| Sundance::RefinementTransformation | |
| Sundance::RefIntegral | RefIntegral represents the integrals of a product of basis functions (or their derivatives) over a reference cell |
| Sundance::RegionQuadCombo | Expressions may appear in more than one subregions of a problem, for instance in an internal domain and also on a boundary |
| Sundance::RemoveMinusOneFromProduct | Transform a product by removing multiplication by -1.0:
|
| Sundance::RemoveOneFromProduct | Transform a product by removing multiplication by 1.0:
|
| Sundance::RemoveUnaryMinusFromSum | Simplify sums involving unary minuses
|
| Sundance::RemoveZeroFromProduct | Transform a product by removing a zero term:
|
| Sundance::RemoveZeroFromSum | Transform a sum by removing a zero term:
|
| Sundance::ReorderSum | Put terms in a standard order |
| Sundance::Rivara::RivaraMesh | |
| TSFExtended::RowAccessibleOp< Scalar > | Base interface for operators for which a row may be extracted |
| Sundance::RuntimeError | RuntimeError is an exception that occurs as a result of invalid user-level code |
| NOX::StatusTest::SafeCombo | Arbitrary combination of status tests, implemented with safe memory management |
| Sundance::ScalarBasis | Base class for scalar-valued basis families |
| Sundance::ScalarExpr | |
| TSFExtended::SequentialIterator< Scalar > | |
| TSFExtended::SerialGhostImporter | Ghost element importer for serial vectors |
| TSFExtended::SerialGhostView | Dummy ghost element viewer for serial vectors |
| Sundance::SerialPartitionerBase | Base class for mesh partitioners that run in serial |
| TSFExtended::SerialVector | TSF implementation of a serial vector, implementing the LoadableVector interface allowing an application to access elements |
| TSFExtended::SerialVectorSpace | |
| TSFExtended::SerialVectorType | |
| Sundance::Set< Key, Compare > | Extension of STL set, adding some nicer syntax and an iostream insertion operator |
| TSFExtended::SetableBlockOperatorBase< Scalar > | Class SetableBlockOperatorBase provides an abstract interface for setting blocks of block operators |
| Sundance::SideCellFilter | |
| TSFExtended::SimpleAddedOp< Scalar > | Represent a sum of operators A_0 + A_1 + .. |
| TSFExtended::SimpleBlockOp< Scalar > | Array-based block operator |
| TSFExtended::SimpleComposedOp< Scalar > | Represent a composed operator A_0 * A_1 * .. |
| TSFExtended::SimpleDiagonalOp< Scalar > | |
| TSFExtended::SimpleIdentityOp< Scalar > | |
| Anasazi::SimpleMV | |
| SimplePoisson1DTest | This class sets up a test that checks convergence rate for solution of the Poisson equation in 1D with Lagrange(2) basis functions |
| TSFExtended::SimpleScaledOp< Scalar > | Represent a scaled operator |
| TSFExtended::SimpleTransposedOp< Scalar > | Represent the transpose of an operator |
| TSFExtended::SimpleZeroOp< Scalar > | |
| TSFExtended::SimplifiedLinearOpBase< Scalar > | SimplifiedLinearOpBase provides a simplified apply() interface in terms of handle classes |
| TSFExtended::SimplifiedLinearOpWithSpaces< Scalar > | SimplifiedLinearOpWithSpaces extends SimplifiedLinearOpBase to store the range and domain spaces |
| TSFExtended::SolverState< Scalar > | |
| Sundance::SortedPair< T > | |
| Sundance::SparsitySuperset | |
| Sundance::SpatialDerivSpecifier | This class is a compact description of type of spatial derivative acting on an operative function: partial derivative, divergence, or normal derivative |
| Sundance::SpatiallyConstantExpr | |
| Sundance::SpatiallyHomogeneousDOFMapBase | |
| NOX::TSF::StatusTestBuilder | |
| Sundance::StdFwkEvalMediator | StdFwkEvalMediator evaluates mesh-dependent functions in the standard framework |
| Sundance::StdProductTransformations | Apply a standard set of transformations |
| Sundance::StdSumTransformations | Apply a standard set of transformations |
| Sundance::StochBlockJacobiSolver | |
| Sundance::StringEvalMediator | |
| Sundance::SubsetCellFilter | |
| Sundance::SubsetManager | SubsetManager keeps maps from cell filters to their subsets |
| Sundance::SubtypeEvaluator< ExprType > | |
| Sundance::SumConstants | Sum two constant exprs without transformation |
| Sundance::SumEvaluator | |
| Sundance::SumExpr | SumExpr is the internal representation of an addition or subtraction node in the expression tree |
| Sundance::SumIntegrals | Transform sum of integrals to SumOfIntegral objects |
| Sundance::SumOfBCs | SumOfBCs represents a sum of essential boundary conditions in integral form |
| Sundance::SumOfIntegrals | SumOfIntegrals represents a sum of integrals, grouped by region and quadrature rule |
| Sundance::SumTransformation | SumTransformation is a base class for any transformation which takes the two operands of a sum (left, right) and produces a new expression mathematically equivalent to the original sum |
| Sundance::SumTransformationSequence | SumTransformationSequence is a sequence of transformations to be applied to a sum, producing a transformed expression |
| Sundance::SundanceGlobal | Class Sundance provides several static methods for managing the environment of a simulation |
| Sundance::SymbolicFunc | SymbolicFunc is a base class for functions such as test and unknown functions that are "variables" in a weak form |
| Sundance::SymbolicFuncDescriptor | This is a base class for functions or elements that need to report whether they're test or unknown functions |
| Sundance::SymbolicFuncElement | SymbolicFuncElement represents a scalar-valued element of a (possibly) list-valued SymbolicFunction |
| Sundance::SymbolicFuncElementEvaluator | |
| Sundance::SymbolicTransformation | SumTransformation is a base class for any transformation which takes the two operands of a sum (left, right) and produces a new expression mathematically equivalent to the original sum |
| Sundance::SymbPreprocessor | |
| Sundance::Tabs | Tabbing utility for output |
| Sundance::TakeConstantUnderIntegralSign | Rearrange a product of a constant and an integral so that the constant is under the integral sign:
|
| Sundance::TempStack | TempStack provides a stack of temporary variables for use during evaluation |
| Sundance::TensorBasisBase | |
| TSFExtended::TesterBase< Scalar > | |
| Sundance::TestFuncDataStub | TestFuncDataStub is a placeholder for data to be shared between multiple components of a test function |
| Sundance::TestFuncElement | TestFuncElement represents a scalar-valued element of a (possibly) list-valued TestFunction |
| Sundance::TestFunction | TestFunction represents a test function in a finite element problem |
| Sundance::TestFunctionData | TestFunctionData contains the specification of a test function's basis |
| Sundance::TestFunctionStub | TestFunctionStub is the base class for unknown functions |
| Thyra::TestSpecifier< Scalar > | |
| Sundance::TetQuadrature | Get abscissas and weights for Gaussian quadrature on tetrahedra |
| Sundance::Rivara::TreeNode | Class TreeNode represents a node in a Rivara mesh refinement tree |
| Sundance::TriangleMeshReader | TriangleMeshReader reads a mesh stored in Shewchuk's Triangle format |
| Sundance::TriangleQuadrature | Get abscissas and weights for Gaussian quadrature on triangles |
| Sundance::TriangleWriter | TriangleWriter writes a mesh or fields to a file in Shewchuk's Triangle format |
| Sundance::TrivialGrouper | Grouper |
| Sundance::UnaryEvaluator< ExprType > | |
| Sundance::UnaryExpr | UnaryExpr is a base class for operators that map a single scalar expr to another scalar expr |
| Sundance::UnaryFunctor | |
| Sundance::UnaryMinus | |
| Sundance::UnaryMinusEvaluator | |
| Sundance::UnboundedDomain | |
| Sundance::UnknownFuncDataStub | UnknownFuncDataStub is a placeholder for data to be shared between multiple components of an unknown function |
| Sundance::UnknownFuncElement | UnknownFuncElement represents a scalar-valued element of a (possibly) list-valued UnknownFunction |
| Sundance::UnknownFunction | UnknownFunction represents an unknown function in a finite element problem |
| Sundance::UnknownFunctionData | UnknownFunctionData contains the specification of an unknown function's basis |
| Sundance::UnknownFunctionStub | UnknownFunctionStub is the base class for unknown functions |
| Sundance::UnknownParameter | |
| Sundance::UnknownParameterElement | UnknownParameterElement represents an element of an unknown spatially-constant parameter |
| Sundance::UserDefFunctor | UserDefFunctor defines an interface for callbacks used to implement user-defined nonlinear operators in the Sundance Expr system |
| Sundance::UserDefFunctorElement | Scalar-valued element of a vector-valued functor |
| Sundance::UserDefOp | UserDefOp provides a hook for inserting a user-defined nonlinear function into the Sundance Expr system |
| Sundance::UserDefOpCommonEvaluator | UserDefOpCommonEvaluator provides a single evaluation point for all components of a vector-valued functor |
| Sundance::UserDefOpElement | Scalar element of a vector-valued user-defined expression |
| Sundance::UserDefOpEvaluator | |
| NOX::TSF::Vector | Implementation of the NOX::Abstract::Vector interface for TSFExtended::Vector<double> (using TSFExtended handle to TSFCore) |
| TSFExtended::Vector< Scalar > | User-level vector class |
| Sundance::VectorAssemblyKernel | VectorAssemblyKernel builds load vectors |
| Sundance::VectorBasis | |
| Sundance::VectorBasisComponent | This class is for the representation of a single component of a vector-valued basis family |
| Sundance::VectorFillingAssemblyKernel | VectorFillingAssemblyKernel provides a common implementation of multivector-filling capabilities needed by matrix-vector assembly, multivector assembly, and functional gradient evaluation |
| TSFExtended::VectorSpace< Scalar > | Implementation of the Handle for the Vector class |
| TSFExtended::VectorTester< Scalar > | Run comparisons between element-wise calculations and Vector member functions |
| TSFExtended::VectorType< Scalar > | Vector type objects are used by the application code to create vector spaces and operators of a given type |
| TSFExtended::VectorTypeExtensions< Scalar > | VectorTypeExtensions provides extensions to the Thyra::VectorSpaceFactoryBase object, appropriate to the interface with applications codes |
| Sundance::VerboseFieldWriter | VerboseFieldWriter dumps every imaginable bit of information about a mesh |
| Sundance::VerbosityTraits< X > | Defines traits for getting default verbosity parameters from a class |
| Sundance::VersionString | |
| Sundance::VertexView | VertexView is a read-only "view" of a cell's vertices, where the vertices are stored contiguously in a large master array |
| Sundance::VTKWriter | VTKWriter writes a mesh or fields to a VTK file |
| Sundance::WatchFlag | Class WatchFlag is used to mark individual expressions for possibly increased verbosity for diagnostic output |
| Sundance::ZeroExpr |
![\[ (u D_x) v \rightarrow u D_x u \]](form_126.png)
![\[ D_x (\alpha u) \rightarrow \alpha D_x u \]](form_129.png)
![\[ (D_1 + D_2) u \rightarrow D_1 u + D_2 u \]](form_130.png)
![\[ K x = \lambda M x. \]](form_186.png)
![\[ D_x \alpha \rightarrow 0 \]](form_127.png)
![\[ D_x (\alpha + u) \rightarrow D_x u \]](form_128.png)
![\[ x \times a \rightarrow a \times x \]](form_122.png)
![\[ x + a \rightarrow a + x \]](form_140.png)
![\[ (-x) \times y \rightarrow -(x \times y) \]](form_123.png)
![\[ x \times (-y) \rightarrow -(x \times y) \]](form_124.png)
![\[ )-x) \times (-y) \rightarrow x \times y \]](form_125.png)
![\[ (\alpha u)\beta \rightarrow \alpha\beta u \]](form_133.png)
![\[ (\alpha u)v \rightarrow \alpha (u v) \]](form_134.png)
![\[ (\alpha + s_1 u) + s_2 \beta \rightarrow (\alpha + s_2 \beta) + s_1 u \]](form_143.png)
![\[ (\alpha + s_1 u) + s_2 v \rightarrow \alpha + (s_1 u + s_2 v) \]](form_144.png)
![\[ \alpha (\beta u) \rightarrow (\alpha\beta) u \]](form_131.png)
![\[ u (\alpha v) \rightarrow \alpha (u v) \]](form_132.png)
![\[ \alpha + s_1 (\beta + s_2 u) \rightarrow (\alpha + s_1 \beta) + s_1 s_2 u \]](form_141.png)
![\[ u + s_1 (\alpha + s_2 v) \rightarrow s_1 \alpha + (u + s_1 s_2 v) \]](form_142.png)
![\[ x \times (-1.0) \rightarrow -x. \]](form_120.png)
![\[ -1.0 \times x \rightarrow -x. \]](form_121.png)
![\[ x \times 1.0 \rightarrow x. \]](form_118.png)
![\[ 1.0 \times x \rightarrow x. \]](form_119.png)
![\[ x + (-y) \rightarrow x-y. \]](form_136.png)
![\[ (-x) + (-y) \rightarrow -(x+y). \]](form_137.png)
![\[ (-x) + y \rightarrow y-x. \]](form_138.png)
![\[ x \times 0 \rightarrow 0. \]](form_116.png)
![\[ 0 \times x \rightarrow 0. \]](form_117.png)
![\[ x + 0 \rightarrow x. \]](form_139.png)
![\[ \alpha \int u \rightarrow \int \alpha u \]](form_135.png)