This inheritance list is sorted roughly, but not completely, alphabetically:

[detail level 12]

Ctdls::detail::adaptor_context< MatrixType, Config >	Common compile-time context of the adaptor entry points: resolves the scalar type, the dimension and the TiledLUpp solvers from the matrix argument and the configuration value
Ctdls::ArrowheadLUppConfig< T >	Compile-time knobs of the ArrowheadLUpp solvers, carrying the tuned defaults
Ctdls::ArrowheadLUppSolverDynamic< T, Config >	Arrowhead solver with a runtime shape
Ctdls::ArrowheadLUppSolverStatic< T, Shape, Config >	Arrowhead solver with a compile-time shape
Ctdls::ArrowheadShape	Shape of an arrowhead matrix: a template argument of the compile-time solver, a function argument of the runtime one
Ctdls::ArrowheadStorageMap< Storage, Coupling, Layout >	Index of every entry of an arrowhead matrix in its storage
▼Ctdls::detail::ArrowheadStreamedBlock< T, S, B, col, diag >	Block k of a streamed solve of ArrowheadLUppSolverStatic (ArrowheadLUppSolverStatic::StreamedBlock): the working arrays of the solver themselves, which the caller fills through the accessors when the solver asks for the block; the factorization and the solve then run in place. Only a save is copied (D_k, and [A_kb \| y_k] when the column-major check reads the forward stage), to store a refused block as given. Entries in logical order whatever the layout and the storage. The arrays come uninitialized, or holding another block: the caller writes every entry, zeros included, by assignment
Ctdls::detail::ArrowheadRecomputedBlock< T, S, B, col, diag >	Block k of a recomputed solve (solve_inplace_recomputed, solve_inplace_recomputed_or_tangent): a StreamedBlock, the same accessors, and whether the solver asks for the block again, in its recovery. A provider taking a StreamedBlock& serves too; one taking a RecomputedBlock&, or auto&, reads the flag. The streamed entry points keep the StreamedBlock alone, so that their code is that of a solver without the recomputed ones
Ctdls::AutoSync	Barrier argument of the cooperative solvers that asks them to deduce the barrier from the compilation target: the default, so most calls pass nothing. A barrier is needed only where the compiler asks for one, or for a group that is not the lanes of one warp on GPU nor threads running concurrently on CPU (see core/group.hpp, which also lists what the solvers check)
▼Cstd::bool_constant
Ctdls::detail::has_pair_data< T, std::void_t< decltype(std::declval< const T & >().data().first), decltype(std::declval< const T & >().data().second)> >
Ctdls::detail::const_data_pointer< T, bool >	Element pointer type of a dense object, const flavour
Ctdls::detail::const_data_pointer< T, true >	Element pointer type of a dense object whose data() returns a (pointer, stride) pair, const flavour
Ctdls::CooperativeLUppConfig< T >	Compile-time knobs of the CooperativeLUpp solvers, carrying the defaults
Ctdls::CooperativeLUppSolverDynamic< T, Config >	Runtime-size dense LU factorization with partial pivoting shared by a group of threads, solving one n x n system per group
Ctdls::CooperativeLUppSolverStatic< T, N, Config >	Dense LU factorization with partial pivoting held in the registers of a group of threads, solving one NxN system per group
Ctdls::detail::DeducedSync< T >	The barrier deduced from the compilation target, for a group of several threads. A group of one thread, possible with the runtime solver, does nothing
▼Cstd::false_type
Ctdls::detail::has_data< T, typename >	Detects a data() member returning a pointer
Ctdls::detail::has_get_stride< T, typename >	Detects a getStride() member
Ctdls::detail::has_indexing_policy< T, typename >	Detects a nested indexing_policy type
Ctdls::detail::has_pair_data< T, typename >	Detects a data() member returning a (pointer, stride) pair: the shape of strided views, whose data pointer must not be mistaken for contiguous storage
Ctdls::detail::has_storage_traits< T, typename >	Detects a complete storage_traits: the structural contract or a user specialization
Ctdls::detail::has_stride< T, typename >	Detects a stride() member
Ctdls::detail::is_solver_config< ConfigType >	Detects the configuration value types accepted by the entry points. Only the TiledLUpp family exists today; a specialization per family can join when another one lands
▼Cstd::is_pointer
Ctdls::detail::has_data< T, std::void_t< decltype(std::declval< const T & >().data())> >
Ctdls::detail::matrix_scalar_of< MatrixType >	Scalar type of a dense matrix argument, read from its storage description; a matrix argument without storage_traits is rejected here with an explicit message
Ctdls::detail::mutable_data_pointer< T, bool >	Element pointer type of a dense object, mutable flavour
Ctdls::detail::mutable_data_pointer< T, true >	Element pointer type of a dense object whose data() returns a (pointer, stride) pair, mutable flavour
Ctdls::NoSync	Barrier that does nothing, valid only when one thread solves a system. The compile-time solver refuses it for a group of several threads at compile time. The runtime solver, whose group size depends on n, stops the program when n exceeds rows_per_thread, wherever the pass can stop it (see core/group.hpp)
Ctdls::detail::pivot_access< PivotType, N >	Pivot argument unwrapping: accepts a raw int pointer/array (treated as contiguous caller-local storage) or any int object with storage_traits, vector-like and of the system dimension when both are fixed-size
Ctdls::storage_traits< DenseType, typename >	Storage description of a dense object: element type, extents, element pointer and element stride
Ctdls::storage_traits< DenseType, std::enable_if_t< detail::is_dense_v< DenseType > > >	Storage description of dense objects matching the structural contract: a data() member (plain pointer or (pointer, stride) pair) and an indexing_policy type with constexpr extents
▼Ctdls::ArrowheadLUppSolverDynamic< T, Config >::StreamedBlock	Block k of a streamed solve: a view of the areas of the workspace where the solver factors and solves the block, which the caller fills through the accessors when the solver asks for it; the factorization and the solve then run in place; only a save, after the areas of the stored path, is copied to store a refused block as given. The accessors are those of ArrowheadLUppSolverStatic::StreamedBlock, so that one provider serves both solvers. Entries in logical order whatever the layout and the storage. The areas hold the previous block: the caller writes every entry, zeros included, by assignment
Ctdls::ArrowheadLUppSolverDynamic< T, Config >::RecomputedBlock	Block k of a recomputed solve (solve_inplace_recomputed, solve_inplace_recomputed_or_tangent): a StreamedBlock, the same view and accessors, and whether the solver asks for the block again, in its recovery. A provider taking a StreamedBlock& serves too; one taking a RecomputedBlock&, or auto&, reads the flag. The streamed entry points keep the StreamedBlock alone, so that their code is that of a solver without the recomputed ones
Ctdls::StructuralReal< T >	Floating-point value stored as an odd integer mantissa and a power-of-two exponent, admissible as a template argument on every compiler supporting class-type non-type template parameters
Ctdls::TiledLUppConfig< T >	Compile-time knobs of the TiledLUpp solvers, carrying the tuned defaults
Ctdls::TiledLUppSolverDynamic< T, Config >	Runtime-size tiled dense LU factorization with logical partial pivoting and out-of-tile pivot recovery, solving one n x n system per call
Ctdls::TiledLUppSolverStatic< T, N, Config >	Tiled dense LU factorization with logical partial pivoting and out-of-tile pivot recovery, solving one NxN system per call
▼Ctdls::TileOperations< T, tile_size, unroll_loops >	Tile_size x tile_size register-tile micro-kernels shared by the solver families
Ctdls::TiledLUppTileOperations< T, tile_size, unroll_loops >	Tile_size x tile_size register-tile micro-kernels of the TiledLUpp solvers: the shared kernels plus the LU column elimination
▼Cstd::true_type
Ctdls::detail::has_get_stride< T, std::void_t< decltype(std::declval< const T & >().getStride())> >
Ctdls::detail::has_indexing_policy< T, std::void_t< typename T::indexing_policy > >
Ctdls::detail::has_storage_traits< T, std::void_t< typename storage_traits< T >::value_type > >
Ctdls::detail::has_stride< T, std::void_t< decltype(std::declval< const T & >().stride())> >
Ctdls::detail::is_solver_config< TiledLUppConfig< Scalar > >	TiledLUppConfig values are accepted