| Cimpl::CommitGroup | |
| Cmundy::ConcatDomainOp< Backend, Op1, Op2 >::Workspace< Y2Vector, Op1Workspace, Op2Workspace > | |
| Cmundy::ConcatRangeOp< Backend, Op1T, Op2T >::Workspace< Op1TWorkspace, Op2TWorkspace > | |
| Cmundy::CongruentMixedReducedOp< Backend, LinearOpDT, LinearOpM, LinearOpD, LinearOpL >::Workspace< DxVector, MDxVector, LMDxVector, DTWorkspace, MWorkspace, DWorkspace, LWorkspace > | |
| Cmundy::MixedReducedOp< Backend, LinearOpA, LinearOpL >::Workspace< AxVector, LAxVector, AWorkspace, LWorkspace > | |
| Cmundy::QuadraticFormOp< Backend, LinearOpDT, LinearOpM, LinearOpD >::Workspace< FVector, UVector > | |
| Cmundy::SumOp< Backend, Op1, Op2 >::Workspace< TmpVector, Op1Workspace, Op2Workspace > | |
| CKokkos::DualView | |
| Cmundy::NgpViewT< DataType *, MemorySpace > | |
| Cmundy::NgpViewT< our_size_t, MemorySpace > | |
| Cmundy::NgpViewT< DataType, Properties..., typename Kokkos::DefaultExecutionSpace::memory_space > | |
| Cmundy::NgpViewT< stk::mesh::Entity *, MemorySpace > | |
| Cmundy::NgpViewT< stk::mesh::Entity *, NgpMemSpace > | |
| Cmundy::NgpViewT< known_id_request_t *, NgpMemSpace > | |
| Cmundy::NgpViewT< ConnectionRequest *, NgpMemSpace > | |
| Cmundy::NgpViewT< LinkRelationRequest *, NgpMemSpace > | |
| Cmundy::NgpViewT< DestroyConnectionRequest *, NgpMemSpace > | |
| Cmundy::NgpViewT< DataType, Properties > | NgpViewT is an enhanced DualView with a slightly expanded interface |
| Cmundy::AABB< Scalar, MinPointType, MaxPointType > | |
| Cmundy::aggregate< TaggedComponents > | An aggregate: A bag of compile-time tagged types In other words, a compile-time unordered map of arbitrary types indexed by tag type |
| Cmundy::aggregate_has< Tag, AggType > | Check if an aggregate type has a value with the given Tag usage aggregate_has_v<Tag, AggType> |
| Cmundy::aggregate_tag< I, AggType > | The I'th aggregate tag |
| Cmundy::aggregate_tag< I, aggregate< Ts... > > | |
| Cmundy::all_have_tags< Ts > | Check if all types in a pack define an alias named tag_type |
| Cmundy::all_tags_unique< Ts > | Check if all tag_type values in a tagged value pack are unique |
| Cmundy::AMatrix< T, N, M, Accessor > | Class for an NxM (num rows x num columns) matrix with arithmetic entries |
| Cmundy::AQuaternion< T, Accessor > | AQuaternion class with floating point entries (an integer-valued quaternion doesn't make much sense) |
| Cmundy::Array< T, N > | A simplistic array type with a fixed size and type |
| Cmundy::AScalar< T, Accessor > | Class for an owning or viewing scalar-like value (an arithmetic type, or a custom scalar such as an autodiff dual) |
| Cmundy::AutoDiffScalar< T, N > | A forward-mode autodiff scalar over passive real type T with N tracked derivatives |
| Cmundy::AVector< T, N, Accessor > | Class for an Nx1 vector with scalar-like entries |
| Cmundy::BallJoint< Scalar, LineSegmentType, OwnershipType > | A ball-and-socket joint between two points |
| Cmundy::BBStepStrategy | Barzilai-Borwein step-size policy for projected-gradient descent |
| Cmundy::BoundedSpace< Scalar > | Proj(x) = min(max(x, lower_bound), upper_bound) for all x in R |
| Cmundy::CGConfig< Scalar > | |
| Cmundy::CGInvOp< Backend, Op > | Wraps an SPD operator as its inverse: apply(rhs, out) solves op * out = rhs via matrix-free CG |
| Cmundy::CGResult< Scalar > | Result of a linear-system solve: iteration count, final residual, and whether it converged |
| Cmundy::CGState< Scalar, XVector, RVector, PVector, ApVector > | The CG solve state: the x/r/p/Ap vectors and the iteration scalars |
| Cmundy::CGStrategy< ResidualPolicy, Config > | The CG strategy: initialize/iterate/done/result over (Problem, State) |
| Cmundy::Circle3D< Scalar, PointType, QuaternionType > | |
| Cmundy::ConcatDomainOp< Backend, Op1, Op2 > | The domain concatenation Op := [op1 | op2] |
| Cmundy::ConcatRangeOp< Backend, Op1T, Op2T > | The range concatenation Op := [op1T; op2T], the transpose of ConcatDomainOp |
| Cmundy::CongruentMCQPP< Backend, LinearOpDT, LinearOpM, LinearOpD, QVector, LinearOpL, FVector, ConvexSpace, WorkspaceDT, WorkspaceM, WorkspaceD, WorkspaceL > | |
| Cmundy::CongruentMixedReducedOp< Backend, LinearOpDT, LinearOpM, LinearOpD, LinearOpL > | The congruent reduced operator Op := D^T M (D - L M D) |
| Cmundy::contains_type< T, Ts > | Check if a type is in a variadic list of types |
| Cmundy::count_type< T, Types > | Count how many times a type appears in a variadic list of types |
| Cmundy::CQPP< Backend, LinearOp, QVector, ConvexSpace, Workspace > | Constrained quadratic programming problem (CQPP) formulation |
| Cmundy::DiagonalOp< Backend, DiagVector > | The diagonal operator y := diag .* x |
| Cmundy::Ellipsoid< Scalar, PointType, OrientationType > | |
| Cmundy::Euclidean | The distance types |
| Cmundy::FeneSpring< Scalar, LineSegmentType, OwnershipType > | A hookean spring between two points with a max length and spring constant |
| Cmundy::FreeSpaceMetric< Scalar > | Non-periodic (open-boundary) metric. All operations are identities |
| Cmundy::GenericNumTraits< T > | Numeric traits for an arithmetic scalar type; the reusable base NumTraits forwards to |
| Cmundy::NumTraits< NumTraits< T >::Real > | |
| Cmundy::NumTraits< AutoDiffScalar< T, N > > | Numeric traits for AutoDiffScalar. Numeric values come from the passive type; the related types remain differentiable |
| Cmundy::NumTraits< AutoDiffScalar< T, N > > | Numeric traits for AutoDiffScalar. Numeric values come from the passive type; the related types remain differentiable |
| Cmundy::NumTraits< T > | Numeric traits for a scalar-like type T |
| Cmundy::GenericNumTraits< double > | |
| Cmundy::NumTraits< double > | Double traits; nonzero fuzzy-comparison precision |
| Cmundy::NumTraits< double > | Double traits; nonzero fuzzy-comparison precision |
| Cmundy::GenericNumTraits< float > | |
| Cmundy::NumTraits< float > | Float traits; nonzero fuzzy-comparison precision |
| Cmundy::NumTraits< float > | Float traits; nonzero fuzzy-comparison precision |
| Cmundy::GenericNumTraits< long double > | |
| Cmundy::NumTraits< long double > | Long double traits; nonzero fuzzy-comparison precision |
| Cmundy::NumTraits< long double > | Long double traits; nonzero fuzzy-comparison precision |
| Cmundy::HookeanSpring< Scalar, LineSegmentType, OwnershipType > | A hookean spring between two points with a rest length and spring constant |
| Cmundy::host_ptr< T > | A reference-counted shared handle to a host-resident T whose handle is trivially copyable onto a device |
| Cmundy::impl::tuple_impl< decltype(std::make_index_sequence< sizeof...(Elements)>()), Elements... > | |
| Cmundy::tuple< Tags... > | |
| Cmundy::tuple< TaggedComponents... > | |
| Cmundy::tuple< Components... > | |
| Cmundy::tuple< NgpComponents... > | |
| Cmundy::tuple< Chunks... > | |
| Cmundy::tuple< Alts... > | |
| Cmundy::tuple< Elements > | A simple std::tuple-like class that can be used in device code with similar semantics to std::tuple (e.g., get<N>(), get<T>(), tuple_cat, etc.). Constructing a tuple from a set of values moves each one that supports moving and copies the rest; the tuple itself is copyable, movable, and default constructible if all of its elements are (respectively) |
| Cmundy::index_finder< T, Ts > | Find the index in the variadic list of types that matches the given type |
| Cmundy::index_finder< T > | |
| Cmundy::index_finder< T, First, Rest... > | |
| Cmundy::index_of_tag< Tag, Ts > | Find the index of Tag inside a pack of tagged components |
| Cmundy::KokkosBackend< ExecSpace > | Backend for Kokkos single process execution |
| Cmundy::L2Residual | Res = ||r||_2 (absolute). The classic linear-solve convergence measure |
| Cmundy::LCP< Backend, LinearOp, QVector, Workspace > | Linear complementarity problem (LCP) formulation |
| Cmundy::Line< Scalar, PointType > | |
| Cmundy::LinearSystem< Backend, LinearOp, RhsVector, Workspace > | The linear system A x = b for a square operator A |
| Cmundy::LineSegment< Scalar, StartPointType, EndPointType > | |
| Cmundy::LinfNormProjectedDiffResidual | Res = ||x - proj(x - h grad)||_inf / h for a small step h (line 17 / Eq 25 of Mazhar 2015). Works for any ValidConvexSpace |
| Cmundy::LinfNormProjectedGradientResidual | Res = ||proj_grad(x)||_inf, the max absolute projected gradient entry (Eq 2.2 of Dai & Fletcher 2005). Only defined for a non-negativity lower bound |
| Cmundy::LinfResidual | Res = ||r||_inf (max absolute residual entry), via Backend::reduce_max |
| Cmundy::LowerBoundSpace< Scalar > | Proj(x) = max(x, lower_bound) for all x in R |
| Cmundy::MaskedView< T, N, mask, Accessor > | Get a masked accessor into a contiguous accessor |
| Cmundy::MCQPP< Backend, LinearOpA, QVector, LinearOpL, FVector, ConvexSpace, WorkspaceA, WorkspaceL > | Mixed constrained quadratic programming problem (MCQPP) formulation |
| Cmundy::mesh::access::aabb< ScalarType > | Axis-aligned bounding box access: 6 scalars per entity |
| Cmundy::mesh::access::matrix< ScalarType, N, M > | Fixed-size matrix access: N * M scalars per entity |
| Cmundy::mesh::access::obb< ScalarType > | |
| Cmundy::mesh::access::quaternion< ScalarType > | Quaternion access: 4 scalars per entity |
| Cmundy::mesh::access::raw< ValueType > | Raw access: exposes entity field data as a flat array / EntityFieldData view |
| Cmundy::mesh::access::scalar< ScalarType > | Scalar access: one arithmetic value per entity |
| Cmundy::mesh::access::vector< ScalarType, N > | Fixed-size vector access: N scalars per entity |
| Cmundy::mesh::Aggregate< Components > | An aggregator of components |
| Cmundy::mesh::BulkDataClassInterface | |
| Cmundy::mesh::canonical_component_access< AccessLike, Enable > | |
| Cmundy::mesh::canonical_component_access< AABBType, std::enable_if_t< is_aabb_v< std::remove_cvref_t< AABBType > > > > | |
| Cmundy::mesh::canonical_component_access< access::aabb< ScalarType >, void > | |
| Cmundy::mesh::canonical_component_access< access::matrix< ScalarType, N, M >, void > | |
| Cmundy::mesh::canonical_component_access< access::obb< ScalarType >, void > | |
| Cmundy::mesh::canonical_component_access< access::quaternion< ScalarType >, void > | |
| Cmundy::mesh::canonical_component_access< access::raw< ValueType >, void > | |
| Cmundy::mesh::canonical_component_access< access::scalar< ScalarType >, void > | |
| Cmundy::mesh::canonical_component_access< access::vector< ScalarType, N >, void > | |
| Cmundy::mesh::canonical_component_access< Matrix3Type, std::enable_if_t< is_matrix3_v< std::remove_cvref_t< Matrix3Type > > > > | |
| Cmundy::mesh::canonical_component_access< MatrixType, std::enable_if_t< is_matrix_v< std::remove_cvref_t< MatrixType > > &&!is_matrix3_v< std::remove_cvref_t< MatrixType > > > > | |
| Cmundy::mesh::canonical_component_access< OBBType, std::enable_if_t< is_obb_v< std::remove_cvref_t< OBBType > > > > | |
| Cmundy::mesh::canonical_component_access< QuaternionType, std::enable_if_t< is_quaternion_v< std::remove_cvref_t< QuaternionType > > > > | |
| Cmundy::mesh::canonical_component_access< ScalarType, std::enable_if_t< std::is_arithmetic_v< std::remove_cvref_t< ScalarType > > > > | |
| Cmundy::mesh::canonical_component_access< VectorType, std::enable_if_t< is_vector_v< std::remove_cvref_t< VectorType > > > > | |
| Cmundy::mesh::Class | Semantic mesh class backed by synchronized data and assembly part hierarchies |
| Cmundy::mesh::Class::DeclarationSignature | Canonical declaration signature used to validate repeated declarations by name |
| Cmundy::mesh::ClassDeclaration | Helper class for declaring a class |
| Cmundy::mesh::component_access_shape< CanonicalAccess > | |
| Cmundy::mesh::component_access_shape< access::aabb< ScalarType > > | |
| Cmundy::mesh::component_access_shape< access::matrix< ScalarType, N, M > > | |
| Cmundy::mesh::component_access_shape< access::obb< ScalarType > > | |
| Cmundy::mesh::component_access_shape< access::quaternion< ScalarType > > | |
| Cmundy::mesh::component_access_shape< access::raw< ValueType > > | |
| Cmundy::mesh::component_access_shape< access::scalar< ScalarType > > | |
| Cmundy::mesh::component_access_shape< access::vector< ScalarType, N > > | |
| Cmundy::mesh::ComponentDeclaration | Unified fluent builder for declaring both field-backed and shared-backed components |
| Cmundy::mesh::EntityDeclaration | Helper class for declaring entities |
| Cmundy::mesh::EntityDeclaration::ElementBuilder | |
| Cmundy::mesh::EntityDeclaration::NodeBuilder | Nested builder for nodes |
| Cmundy::mesh::FieldComponentBase | |
| Cmundy::mesh::impl::FieldComponent< ValueType, impl::FieldDataAccessPolicy > | |
| Cmundy::mesh::FieldComponent< ValueType > | Raw field-backed component |
| Cmundy::mesh::impl::FieldComponent< ScalarType, impl::ScalarFieldAccessPolicy > | |
| Cmundy::mesh::ScalarFieldComponent< ScalarType > | |
| Cmundy::mesh::impl::FieldComponent< ScalarType, impl::VectorFieldAccessPolicy< N > > | |
| Cmundy::mesh::VectorFieldComponent< ScalarType, 1 > | |
| Cmundy::mesh::VectorFieldComponent< ScalarType, 2 > | |
| Cmundy::mesh::VectorFieldComponent< ScalarType, 3 > | |
| Cmundy::mesh::VectorFieldComponent< ScalarType, 4 > | |
| Cmundy::mesh::VectorFieldComponent< ScalarType, 5 > | |
| Cmundy::mesh::VectorFieldComponent< ScalarType, 6 > | |
| Cmundy::mesh::VectorFieldComponent< ScalarType, N > | |
| Cmundy::mesh::impl::FieldComponent< ScalarType, impl::MatrixFieldAccessPolicy< N, M > > | |
| Cmundy::mesh::MatrixFieldComponent< ScalarType, 1, 1 > | |
| Cmundy::mesh::MatrixFieldComponent< ScalarType, 2, 2 > | |
| Cmundy::mesh::MatrixFieldComponent< ScalarType, 3, 3 > | |
| Cmundy::mesh::MatrixFieldComponent< ScalarType, 4, 4 > | |
| Cmundy::mesh::MatrixFieldComponent< ScalarType, 5, 5 > | |
| Cmundy::mesh::MatrixFieldComponent< ScalarType, 6, 6 > | |
| Cmundy::mesh::MatrixFieldComponent< ScalarType, N, M > | |
| Cmundy::mesh::impl::FieldComponent< ScalarType, impl::QuaternionFieldAccessPolicy > | |
| Cmundy::mesh::QuaternionFieldComponent< ScalarType > | |
| Cmundy::mesh::impl::FieldComponent< ScalarType, impl::AABBFieldAccessPolicy > | |
| Cmundy::mesh::AABBFieldComponent< ScalarType > | |
| Cmundy::mesh::impl::FieldComponent< ScalarType, impl::OBBFieldAccessPolicy > | |
| Cmundy::mesh::OBBFieldComponent< ScalarType > | Host-side OBB field-backed component |
| Cmundy::mesh::impl::FieldComponent< double, impl::OBBFieldAccessPolicy > | |
| Cmundy::mesh::OBBFieldComponent< double > | |
| Cmundy::mesh::impl::FieldComponent< ScalarType, AccessPolicy > | |
| Cmundy::mesh::OBBFieldComponent< Scalar > | |
| Cmundy::mesh::FieldDeclaration | |
| Cmundy::mesh::FieldDeclarationT< T > | |
| Cmundy::mesh::FutureConnection | |
| Cmundy::mesh::FutureDestroyConnection | |
| Cmundy::mesh::FutureDestroyEntity | |
| Cmundy::mesh::FutureEntity | |
| Cmundy::mesh::LinkCOOData | |
| Cmundy::mesh::LinkCSRBucketConnT< MemSpace > | |
| Cmundy::mesh::LinkCSRDataT< MemSpace > | |
| Cmundy::mesh::LinkCSRPartitionT< MemSpace > | |
| Cmundy::mesh::LinkData | The main interface for interacting with the link data on the mesh |
| Cmundy::mesh::LinkDataMap | |
| Cmundy::mesh::LinkMetaData | |
| Cmundy::mesh::LinkMetaDataMap | |
| Cmundy::mesh::MeshBuilder | A helper class for building an STK BulkData entity |
| Cmundy::mesh::NgpAggregate< NgpComponents > | |
| Cmundy::mesh::NgpDestroyConnectionsT< NgpMemSpace > | |
| Cmundy::mesh::NgpDestroyEntitiesT< NgpMemSpace > | |
| Cmundy::mesh::NgpFieldComponentBase | |
| Cmundy::mesh::impl::NgpFieldComponent< NgpFieldType, impl::FieldDataAccessPolicy > | |
| Cmundy::mesh::NgpFieldComponent< NgpFieldType > | |
| Cmundy::mesh::impl::NgpFieldComponent< NgpFieldType, impl::ScalarFieldAccessPolicy > | |
| Cmundy::mesh::NgpScalarFieldComponent< NgpFieldType > | |
| Cmundy::mesh::impl::NgpFieldComponent< NgpFieldType, impl::VectorFieldAccessPolicy< N > > | |
| Cmundy::mesh::NgpVectorFieldComponent< NgpFieldType, 1 > | |
| Cmundy::mesh::NgpVectorFieldComponent< NgpFieldType, 2 > | |
| Cmundy::mesh::NgpVectorFieldComponent< NgpFieldType, 3 > | |
| Cmundy::mesh::NgpVectorFieldComponent< NgpFieldType, 4 > | |
| Cmundy::mesh::NgpVectorFieldComponent< NgpFieldType, 5 > | |
| Cmundy::mesh::NgpVectorFieldComponent< NgpFieldType, 6 > | |
| Cmundy::mesh::NgpVectorFieldComponent< NgpFieldType, N > | |
| Cmundy::mesh::impl::NgpFieldComponent< NgpFieldType, impl::MatrixFieldAccessPolicy< N, M > > | |
| Cmundy::mesh::NgpMatrixFieldComponent< NgpFieldType, 1, 1 > | |
| Cmundy::mesh::NgpMatrixFieldComponent< NgpFieldType, 2, 2 > | |
| Cmundy::mesh::NgpMatrixFieldComponent< NgpFieldType, 3, 3 > | |
| Cmundy::mesh::NgpMatrixFieldComponent< NgpFieldType, 4, 4 > | |
| Cmundy::mesh::NgpMatrixFieldComponent< NgpFieldType, 5, 5 > | |
| Cmundy::mesh::NgpMatrixFieldComponent< NgpFieldType, 6, 6 > | |
| Cmundy::mesh::NgpMatrixFieldComponent< NgpFieldType, N, M > | |
| Cmundy::mesh::impl::NgpFieldComponent< NgpFieldType, impl::QuaternionFieldAccessPolicy > | |
| Cmundy::mesh::NgpQuaternionFieldComponent< NgpFieldType > | |
| Cmundy::mesh::impl::NgpFieldComponent< NgpFieldType, impl::AABBFieldAccessPolicy > | |
| Cmundy::mesh::NgpAABBFieldComponent< NgpFieldType > | |
| Cmundy::mesh::impl::NgpFieldComponent< NgpFieldType, impl::OBBFieldAccessPolicy > | |
| Cmundy::mesh::NgpOBBFieldComponent< NgpFieldType > | Device-side OBB NGP field component |
| Cmundy::mesh::impl::NgpFieldComponent< NgpFieldType, AccessPolicy > | |
| Cmundy::mesh::NgpAABBFieldComponent< ngp_field_type > | |
| Cmundy::mesh::NgpFieldComponent< ngp_field_type > | |
| Cmundy::mesh::NgpMatrixFieldComponent< ngp_field_type, N, M > | |
| Cmundy::mesh::NgpOBBFieldComponent< ngp_field_type > | |
| Cmundy::mesh::NgpQuaternionFieldComponent< ngp_field_type > | |
| Cmundy::mesh::NgpScalarFieldComponent< ngp_field_type > | |
| Cmundy::mesh::NgpVectorFieldComponent< ngp_field_type, N > | |
| Cmundy::mesh::NgpLinkCOODataT< NgpMemSpace > | |
| Cmundy::mesh::NgpLinkDataT< NgpMemSpace > | |
| Cmundy::mesh::NgpModRequestsT< NgpMemSpace > | A helper interface for requesting mesh modifications from the device. This is intended to be used in a three-stage command pattern: |
| Cmundy::mesh::NgpRequestConnectionsT< NgpMemSpace > | |
| Cmundy::mesh::NgpRequestLinkRelationsT< NgpMemSpace > | Request helper for writing COO link relations, supporting FutureEntity linkers |
| Cmundy::mesh::NgpSharedComponent< SharedType, NgpMemSpace > | |
| Cmundy::mesh::NgpSharedComponent< ScalarType, NgpMemSpace > | |
| Cmundy::mesh::NgpSharedScalarComponent< ScalarType, NgpMemSpace > | |
| Cmundy::mesh::NgpSharedComponent< ScalarType, stk::ngp::MemSpace > | |
| Cmundy::mesh::NgpSharedScalarComponent< ScalarType, NgpMemSpace > | |
| Cmundy::mesh::NgpTaggedComponent< Tag, NgpComponentType > | A small helper type for tying a Tag to an underlying ngp-compatible component |
| Cmundy::mesh::PartDeclaration | Helper class for declaring a part |
| Cmundy::mesh::SharedComponent< SharedType > | A component that returns the same shared value for every entity |
| Cmundy::mesh::SharedComponent< AABB< ScalarType > > | |
| Cmundy::mesh::SharedAABBComponent< ScalarType > | |
| Cmundy::mesh::SharedComponent< Matrix< ScalarType, N, M > > | |
| Cmundy::mesh::SharedMatrixComponent< ScalarType, 1, 1 > | |
| Cmundy::mesh::SharedMatrixComponent< ScalarType, 2, 2 > | |
| Cmundy::mesh::SharedMatrixComponent< ScalarType, 3, 3 > | |
| Cmundy::mesh::SharedMatrixComponent< ScalarType, 4, 4 > | |
| Cmundy::mesh::SharedMatrixComponent< ScalarType, 5, 5 > | |
| Cmundy::mesh::SharedMatrixComponent< ScalarType, 6, 6 > | |
| Cmundy::mesh::SharedMatrixComponent< ScalarType, N, M > | |
| Cmundy::mesh::SharedComponent< Quaternion< ScalarType > > | |
| Cmundy::mesh::SharedQuaternionComponent< ScalarType > | |
| Cmundy::mesh::SharedComponent< ScalarType > | |
| Cmundy::mesh::SharedScalarComponent< ScalarType > | |
| Cmundy::mesh::SharedComponent< Vector< ScalarType, N > > | |
| Cmundy::mesh::SharedVectorComponent< ScalarType, 1 > | |
| Cmundy::mesh::SharedVectorComponent< ScalarType, 2 > | |
| Cmundy::mesh::SharedVectorComponent< ScalarType, 3 > | |
| Cmundy::mesh::SharedVectorComponent< ScalarType, 4 > | |
| Cmundy::mesh::SharedVectorComponent< ScalarType, 5 > | |
| Cmundy::mesh::SharedVectorComponent< ScalarType, 6 > | |
| Cmundy::mesh::SharedVectorComponent< ScalarType, N > | |
| Cmundy::mesh::TaggedComponent< Tag, ComponentType > | A small helper type for tying a Tag to an underlying component |
| Cmundy::mesh::TaggedFieldDeclarationT< FieldScalarType, Tag > | |
| Cmundy::mesh::TeamFunctor< Mesh, AlgorithmPerEntity > | |
| Cmundy::mesh::TicketIssuer< NgpMemSpace > | Issues tickets for modifications in a given memory space |
| Cmundy::mesh::TicketRange | A range of tickets issued by a TicketIssuer |
| Cmundy::metric | Runtime-polymorphic metric (stk::topology-style value class) |
| Cmundy::MixedReducedOp< Backend, LinearOpA, LinearOpL > | The reduced operator Op := A (I - L A) |
| Cmundy::MundyMathBackend | Backend for Mundy math within a kernel |
| Cmundy::NgpPoolT< DataType, MemorySpace, SizeType > | NgpPoolT is a Kokkos-compatible pool of default constructible objects |
| Cmundy::mesh::NgpEntityPoolT< typename stk::ngp::ExecSpace::memory_space, long int > | |
| Cmundy::NgpPoolT< stk::mesh::Entity, MemorySpace, long int > | |
| Cmundy::mesh::NgpEntityPoolT< MemorySpace, SizeType > | NgpEntityPoolT is a Kokkos-compatible pool of stk::mesh::Entity objects |
| Cmundy::OBB< Scalar, PointType, QuaternionType, HalfExtentsType > | Oriented Bounding Box: a center, a unit-quaternion orientation, and per-axis half-extents |
| Cmundy::OrthorhombicMetric< PeriodicAxes, Scalar > | Axis-aligned periodic metric parameterised by a compile-time axis bitmask |
| Cmundy::Ownership::Invalid | |
| Cmundy::Ownership::Mixed | |
| Cmundy::Ownership::Owns | |
| Cmundy::Ownership::Views | |
| Cmundy::passive_scalar< T > | Trait: underlying passive (non-AD) type of T. For arithmetic T: passive_scalar_t<T> == T. For AD types exposing T::value_type: passive_scalar_t<T> == typename T::value_type |
| Cmundy::passive_scalar< T > | |
| Cmundy::PGDConfig< Scalar > | |
| Cmundy::PGDResult< Scalar > | Result of a projected-gradient solve: iteration count, final residual, and whether it converged |
| Cmundy::PGDState< Scalar, XVector, GradVector, XTmpVector, GradTmpVector > | |
| Cmundy::PGDStrategy< StepPolicy, ResidualPolicy, Config > | |
| Cmundy::QuadraticFormOp< Backend, LinearOpDT, LinearOpM, LinearOpD > | The quadratic form Op := D^T M D |
| Cmundy::reference_wrapper< T > | A Kokkos-compatible wrapper around a reference |
| Cmundy::RelativeL2Residual | Res = ||r||_2 / ||b||_2 (relative to the right-hand side). Scale-independent, unlike L2Residual |
| Cmundy::Ring< Scalar, PointType, QuaternionType > | |
| Cmundy::runtime_aggregate< VariantType > | A runtime_aggregate: A bag of runtime tagged variants or, In other words, an unordered map of variants indexed by tag string |
| Cmundy::scalar_binary_op::difference | |
| Cmundy::scalar_binary_op::max | |
| Cmundy::scalar_binary_op::min | |
| Cmundy::scalar_binary_op::product | |
| Cmundy::scalar_binary_op::quotient | |
| Cmundy::scalar_binary_op::sum | |
| Cmundy::scalar_binary_op::unary_minus | |
| Cmundy::ScalarBinaryOpTraits< A, B, Op > | Determines whether a binary operation between scalar types A and B is allowed, and its result |
| Cmundy::ScalarBinaryOpTraits< A, B, Op > | Two arithmetic primitives (same or mixed) yield their promoted common type |
| Cmundy::ScalarBinaryOpTraits< AutoDiffScalar< T, N >, T, Op > | An AutoDiffScalar combined with its passive type yields an AutoDiffScalar (either order) |
| Cmundy::ScalarBinaryOpTraits< T, AutoDiffScalar< T, N >, Op > | |
| Cmundy::ScalarBinaryOpTraits< T, T, Op > | Same non-arithmetic type on both sides yields that type (e.g. autodiff dual op dual) |
| Cmundy::ScaledOp< Backend, Scalar, Op > | The scalar multiple Op := alpha * op |
| Cmundy::search::AlwaysRebuild | Rebuilder that unconditionally triggers a rebuild on every update |
| Cmundy::search::ArborX1dNeighborList< MemorySpace > | ArborX neighbor list with Cabana-style compressed 1D storage |
| Cmundy::search::ArborX2dNeighborList< MemorySpace > | ArborX neighbor list with Cabana-style dense 2D per-target storage |
| Cmundy::search::ExcludeConnectedEntities | Exclude candidate pairs that share a connected entity at a given rank |
| Cmundy::search::ExcludeNonIntersectingOBBs< Scalar, MemSpace > | Narrow-phase excluder that keeps only candidates whose OBBs intersect |
| Cmundy::search::ExcluderChain< PriorExcluder, Excluder > | Type-level chain of Kokkos-callable excluders |
| Cmundy::search::ExcludeSelfInteraction | Exclude degenerate (self) interactions |
| Cmundy::search::ExcludeSymmetricDuplicates | Builder-prepared excluder that suppresses one orientation of symmetric target/source pairs |
| Cmundy::search::ManagedNeighborList< BuilderState, Rebuilder > | A neighbor list cache driven by a stateful rebuilder policy |
| Cmundy::search::ManagedNeighborList< BuilderState, Rebuilder >::UpdateResult | Return type for update() carrying both the list and a rebuild indicator |
| Cmundy::search::NeighborListBuilder< ListType, ExecutionSpace, TargetInput, SourceInput, BroadExcluder, NarrowExcluder > | Type-state fluent neighbor-list builder |
| Cmundy::search::NeighborListBuildTraits< ListType > | Traits that couple a concrete neighbor-list type to its build logic and type-specific parameters |
| Cmundy::search::NeighborListBuildTraits< ListType >::args_type | Default empty args; specializations override this with build-specific parameters |
| Cmundy::search::NeighborListBuildTraits< ArborX1dNeighborList< MemorySpace > > | |
| Cmundy::search::NeighborListBuildTraits< ArborX1dNeighborList< MemorySpace > >::args_type | Build-specific parameters for ArborX1dNeighborList |
| Cmundy::search::NeighborListBuildTraits< ArborX2dNeighborList< MemorySpace > > | |
| Cmundy::search::NeighborListBuildTraits< ArborX2dNeighborList< MemorySpace > >::args_type | Build-specific parameters for ArborX2dNeighborList |
| Cmundy::search::NeighborListBuildTraits< PeriodicArborX1dNeighborList< MemorySpace, ImageShiftScalar > > | |
| Cmundy::search::NeighborListBuildTraits< PeriodicArborX1dNeighborList< MemorySpace, ImageShiftScalar > >::args_type | Build-specific parameters for PeriodicArborX1dNeighborList |
| Cmundy::search::NeighborListBuildTraits< PeriodicArborX2dNeighborList< MemorySpace, ImageShiftScalar > > | |
| Cmundy::search::NeighborListBuildTraits< PeriodicArborX2dNeighborList< MemorySpace, ImageShiftScalar > >::args_type | Build-specific parameters for PeriodicArborX2dNeighborList |
| Cmundy::search::NeighborListBuildTraits< PeriodicSTKSearchNeighborList< MemorySpace, ImageShiftScalar > > | |
| Cmundy::search::NeighborListBuildTraits< PeriodicSTKSearchNeighborList< MemorySpace, ImageShiftScalar > >::args_type | Build-specific parameters for PeriodicSTKSearchNeighborList (none required) |
| Cmundy::search::NeighborListBuildTraits< STKSearchNeighborList< MemorySpace > > | |
| Cmundy::search::NeighborListBuildTraits< STKSearchNeighborList< MemorySpace > >::args_type | Build-specific parameters for STKSearchNeighborList (none required) |
| Cmundy::search::NeighborListIterationTraits< ListType > | Traits class coupling a concrete neighbor-list type to its parallel dispatch strategy |
| Cmundy::search::NeighborPair< NeighborListType > | Lightweight neighbor-pair view |
| Cmundy::search::Neighbors< NeighborListType > | Lightweight neighbor-range view for one target |
| Cmundy::search::NeighborSearchCandidate< SizeType > | Non-periodic target/source candidate produced during neighbor-list construction |
| Cmundy::search::NeverRebuild | Rebuilder that suppresses all rebuilds after the first |
| Cmundy::search::NoExcluder | Empty excluder used as the starting point for neighbor-list builders |
| Cmundy::search::PeriodicArborX1dNeighborList< MemorySpace, ImageShiftScalar > | ArborX compressed 1D neighbor list whose stored pairs carry per-object periodic image shifts |
| Cmundy::search::PeriodicArborX2dNeighborList< MemorySpace, ImageShiftScalar > | ArborX dense 2D neighbor list whose stored entries carry per-object periodic image shifts |
| Cmundy::search::PeriodicNeighborSearchCandidate< ImageShiftType, SizeType > | Periodic owner-pair candidate produced during neighbor-list construction |
| Cmundy::search::PeriodicSearchInput< Component, Metric > | A SearchInput augmented with a periodicity metric for periodic neighbor-list builds |
| Cmundy::search::PeriodicSTKSearchNeighborList< MemorySpace, ImageShiftScalar > | STK coarse-search neighbor list with compressed owner-pair storage and per-object periodic image shifts |
| Cmundy::search::RebuilderChain< PriorRebuilder, Rebuilder > | Type-level OR chain of two rebuilders |
| Cmundy::search::RebuildOnAABBDisplacement< Scalar, MemorySpace, Metric > | Rebuilder that triggers when any box corner moves beyond a displacement threshold |
| Cmundy::search::RebuildOnEntityChange< MemorySpace > | Rebuilder that triggers when the target or source entity sequence changes |
| Cmundy::search::RebuildOnOBBDisplacement< Scalar, MemorySpace, Metric > | Rebuilder that triggers when any OBB escapes its inflated snapshot |
| Cmundy::search::SearchInput< Component > | A selector paired with a geometry-yielding component for a non-periodic neighbor-list build |
| Cmundy::search::STKBuildPhaseTimings | Per-phase wall-time breakdown for one STKSearchNeighborList build call |
| Cmundy::search::STKSearchNeighborList< MemorySpace > | STK coarse-search neighbor list mapped into Mundy's common access surface |
| Cmundy::SharedNormalSigned | |
| Cmundy::SharedNormalSignedFiniteDiff | Tag selecting the finite-difference-gradient variant of the shared-normal signed distance |
| Cmundy::ShiftedView< T, shift, Accessor > | Get a shifted accessor into a contiguous accessor |
| Cmundy::SinkStart | |
| Cmundy::Sphere< Scalar, PointType > | |
| Cmundy::Spherocylinder< Scalar, PointType, QuaternionType > | |
| Cmundy::SpherocylinderSegment< Scalar, PointType > | |
| Cmundy::storage< T > | Own or view a value using a simple normalized storage policy |
| Cmundy::StridedView< T, stride, Accessor > | Get a strided accessor into a contiguous accessor |
| Cmundy::StringLiteral< StrSize > | Literal class type that wraps a constant expression string |
| Cmundy::StringLiteralSink< N > | Sink that still represents a compile-time string |
| Cmundy::StringSink< Chunks > | Sink that stores streamed chunks until a string is actually needed |
| Cmundy::SumOp< Backend, Op1, Op2 > | The sum Op := op1 + op2 of two operators sharing a domain and range |
| Cmundy::tagged< Tag, T > | A small helper type for tying a Tag to an underlying value |
| Cmundy::TorsionalSpring< Scalar, VSegmentType, OwnershipType > | A hookean spring between two points with a rest angle and spring constant |
| Cmundy::TransposedView< T, N, M, Accessor > | An accessor that represents the transpose of a row-major (NxM) matrix represented by a contiguous accessor |
| Cmundy::TriclinicMetric< PeriodicAxes, Scalar > | General periodic metric for a tilted unit cell |
| Cmundy::tuple_element< I, T > | An element of a tuple |
| Cmundy::tuple_element< I, tuple< Es... > > | |
| Cmundy::tuple_size< T > | The size of a tuple |
| Cmundy::tuple_size< tuple< Es... > > | |
| Cmundy::type_at_index< I, Ts > | Get the I'th type in a variadic list of types |
| Cmundy::type_at_index< 0, Head, Tail... > | |
| Cmundy::type_at_index< I, Head, Tail... > | |
| Cmundy::UnconstrainedSpace< Scalar > | Proj(x) = x for all x in R |
| Cmundy::UpperBoundSpace< Scalar > | Proj(x) = min(x, upper_bound) for all x in R |
| Cmundy::variant< Alts > | |
| Cmundy::variant_aggregate< VariantType, Tags > | A variant_aggregate: A bag of compile-time tagged variants. In other words, a compile-time map of variants indexed by tag type |
| Cmundy::variant_aggregate_has< Tag, VarAggType > | Check whether a variant_aggregate type has a value with the given Tag. Usage: variant_aggregate_has_v<Tag, VarAggType> |
| Cmundy::variant_aggregate_tag< I, VarAggType > | The I'th variant_aggregate tag |
| Cmundy::variant_aggregate_tag< I, variant_aggregate< VariantType, Tags... > > | |
| Cmundy::variant_size< T > | |
| Cmundy::variant_size< variant< Alts... > > | |
| Cmundy::VSegment< Scalar, PointType > | |
| CNeighborListBuildTraits< ArborX1dNeighborList< MemorySpace > | Build traits for ArborX1dNeighborList: non-periodic ArborX compressed 1D storage |
| CNeighborListBuildTraits< ArborX2dNeighborList< MemorySpace > | Build traits for ArborX2dNeighborList: non-periodic ArborX dense 2D storage |
| CNeighborListBuildTraits< PeriodicArborX1dNeighborList< MemorySpace, ImageShiftScalar > | Build traits for PeriodicArborX1dNeighborList: periodic ArborX compressed 1D storage |
| CNeighborListBuildTraits< PeriodicArborX2dNeighborList< MemorySpace, ImageShiftScalar > | Build traits for PeriodicArborX2dNeighborList: periodic ArborX dense 2D storage |
| CNeighborListBuildTraits< PeriodicSTKSearchNeighborList< MemorySpace, ImageShiftScalar > | Build traits for PeriodicSTKSearchNeighborList: periodic STK coarse-search compressed storage |
| CNeighborListBuildTraits< STKSearchNeighborList< MemorySpace > | Build traits for STKSearchNeighborList: non-periodic STK coarse-search compressed storage |
| Cstd::bool_constant | |
| Cmundy::is_finite< T, std::void_t< decltype(std::remove_cv_t< T >::is_finite)> > | |
| Cmundy::is_periodic_metric< T > | True when T is any periodic metric (orthorhombic or triclinic) |
| Cstd::false_type | |
| Cmundy::contains_tag< Tag, First, Rest... > | |
| Cmundy::has_tag_type< T, std::void_t< typename T::tag_type > > | |
| Cmundy::is_ball_joint< BallJoint< Scalar, LineSegmentType, OwnershipType > > | |
| Cmundy::is_ball_joint< const BallJoint< Scalar, LineSegmentType, OwnershipType > > | |
| Cmundy::is_char_array< char[N]> | |
| Cmundy::is_char_array< const char[N]> | |
| Cmundy::is_fene_spring< FeneSpring< Scalar, LineSegmentType, OwnershipType > > | |
| Cmundy::is_fene_spring< const FeneSpring< Scalar, LineSegmentType, OwnershipType > > | |
| Cmundy::is_finite< APoint< Scalar, Accessor > > | APoint (and therefore Point) represents a finite position in space |
| Cmundy::is_finite< T, std::void_t< decltype(std::remove_cv_t< T >::is_finite)> > | |
| Cmundy::is_finite< const APoint< Scalar, Accessor > > | |
| Cmundy::is_free_space_metric< FreeSpaceMetric< Scalar > > | |
| Cmundy::is_hookean_spring< HookeanSpring< Scalar, LineSegmentType, OwnershipType > > | |
| Cmundy::is_hookean_spring< const HookeanSpring< Scalar, LineSegmentType, OwnershipType > > | |
| Cmundy::is_obb_impl< std::remove_cv_t< T > > | |
| Cmundy::is_obb< T > | |
| Cmundy::is_orthorhombic_metric< OrthorhombicMetric< PeriodicAxes, Scalar > > | |
| Cmundy::is_our_string_literal< StringLiteral< N > > | |
| Cmundy::is_scalar_impl< std::decay_t< TypeToCheck > > | |
| Cmundy::is_scalar< TypeToCheck > | Type trait to determine if a type is an AScalar |
| Cmundy::is_string_literal_sink< StringLiteralSink< N > > | |
| Cmundy::is_string_sink< StringSink< Chunks... > > | |
| Cmundy::is_torsional_spring< TorsionalSpring< Scalar, VSegmentType, OwnershipType > > | |
| Cmundy::is_torsional_spring< const TorsionalSpring< Scalar, VSegmentType, OwnershipType > > | |
| Cmundy::is_triclinic_metric< TriclinicMetric< PeriodicAxes, Scalar > > | |
| Cmundy::contains_tag< Tag, Ts > | Check if a tagged value pack contains a value with the given Tag |
| Cmundy::has_tag_type< T, typename > | Check if a type defines an alias named tag_type |
| Cmundy::is_ball_joint< T > | Type trait to determine if a type is a BallJoint |
| Cmundy::is_char_array< T > | |
| Cmundy::is_string_literal< T > | |
| Cmundy::is_fene_spring< T > | Type trait to determine if a type is a FeneSpring |
| Cmundy::is_finite< T, typename > | Trait: does a primitive type have finite spatial extent? |
| Cmundy::is_free_space_metric< T > | True when T is any instantiation of FreeSpaceMetric |
| Cmundy::is_hookean_spring< T > | Type trait to determine if a type is a HookeanSpring |
| Cmundy::is_orthorhombic_metric< T > | True when T is any instantiation of OrthorhombicMetric |
| Cmundy::is_our_string_literal< T > | |
| Cmundy::is_string_literal_sink< T > | |
| Cmundy::is_string_sink< T > | |
| Cmundy::is_torsional_spring< T > | Type trait to determine if a type is a TorsionalSpring |
| Cmundy::is_triclinic_metric< T > | True when T is any instantiation of TriclinicMetric |
| Cstd::hash< mundy::host_ptr< T > > | Hash a host_ptr by its pointed-to address, like std::hash<std::shared_ptr<T>> |
| Cstd::true_type | |
| Cmundy::has_tag_type< T, std::void_t< typename T::tag_type > > | |
| Cmundy::is_ball_joint< BallJoint< Scalar, LineSegmentType, OwnershipType > > | |
| Cmundy::is_ball_joint< const BallJoint< Scalar, LineSegmentType, OwnershipType > > | |
| Cmundy::is_char_array< char[N]> | |
| Cmundy::is_char_array< const char[N]> | |
| Cmundy::is_fene_spring< FeneSpring< Scalar, LineSegmentType, OwnershipType > > | |
| Cmundy::is_fene_spring< const FeneSpring< Scalar, LineSegmentType, OwnershipType > > | |
| Cmundy::is_finite< APoint< Scalar, Accessor > > | APoint (and therefore Point) represents a finite position in space |
| Cmundy::is_finite< const APoint< Scalar, Accessor > > | |
| Cmundy::is_free_space_metric< FreeSpaceMetric< Scalar > > | |
| Cmundy::is_hookean_spring< HookeanSpring< Scalar, LineSegmentType, OwnershipType > > | |
| Cmundy::is_hookean_spring< const HookeanSpring< Scalar, LineSegmentType, OwnershipType > > | |
| Cmundy::is_orthorhombic_metric< OrthorhombicMetric< PeriodicAxes, Scalar > > | |
| Cmundy::is_our_string_literal< StringLiteral< N > > | |
| Cmundy::is_string_literal_sink< StringLiteralSink< N > > | |
| Cmundy::is_string_sink< StringSink< Chunks... > > | |
| Cmundy::is_torsional_spring< TorsionalSpring< Scalar, VSegmentType, OwnershipType > > | |
| Cmundy::is_torsional_spring< const TorsionalSpring< Scalar, VSegmentType, OwnershipType > > | |
| Cmundy::is_triclinic_metric< TriclinicMetric< PeriodicAxes, Scalar > > | |
| Cstk::io::StkMeshIoBroker | |
| Cstk::mesh::BulkData | |
| Cmundy::mesh::BulkData | A extension of STK's BulkData, with streamlined access to Mundy's stk wrappers |
| Cstk::mesh::MetaData | |
| Cmundy::mesh::MetaData | A extension of STK's MetaData, better suited for some of Mundy's requirements |
| Czorder_knn::detail::significand< T > | |
| Czorder_knn::detail::significand< double > | |
| Czorder_knn::detail::significand< float > | |
| Czorder_knn::Less< Point, d > | |
| CPointType | |
| CQuaternionType | |
| Cconditional_t< aliases_host_storage, host_view_type, Kokkos::View< shared_type *, stk::ngp::MemSpace > > | |
| CSelector * | |
1.17.0