Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 123]

▼Ntdls
▼Ndetail
Cadaptor_context	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
CArrowheadRecomputedBlock	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
CArrowheadStreamedBlock	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
Cconst_data_pointer	Element pointer type of a dense object, const flavour
Cconst_data_pointer< T, true >	Element pointer type of a dense object whose data() returns a (pointer, stride) pair, const flavour
CDeducedSync	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
Chas_data	Detects a data() member returning a pointer
Chas_data< T, std::void_t< decltype(std::declval< const T & >().data())> >
Chas_get_stride	Detects a getStride() member
Chas_get_stride< T, std::void_t< decltype(std::declval< const T & >().getStride())> >
Chas_indexing_policy	Detects a nested indexing_policy type
Chas_indexing_policy< T, std::void_t< typename T::indexing_policy > >
Chas_pair_data	Detects a data() member returning a (pointer, stride) pair: the shape of strided views, whose data pointer must not be mistaken for contiguous storage
Chas_pair_data< T, std::void_t< decltype(std::declval< const T & >().data().first), decltype(std::declval< const T & >().data().second)> >
Chas_storage_traits	Detects a complete storage_traits: the structural contract or a user specialization
Chas_storage_traits< T, std::void_t< typename storage_traits< T >::value_type > >
Chas_stride	Detects a stride() member
Chas_stride< T, std::void_t< decltype(std::declval< const T & >().stride())> >
Cis_solver_config	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
Cis_solver_config< TiledLUppConfig< Scalar > >	TiledLUppConfig values are accepted
Cmatrix_scalar_of	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
Cmutable_data_pointer	Element pointer type of a dense object, mutable flavour
Cmutable_data_pointer< T, true >	Element pointer type of a dense object whose data() returns a (pointer, stride) pair, mutable flavour
Cpivot_access	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
CArrowheadLUppConfig	Compile-time knobs of the ArrowheadLUpp solvers, carrying the tuned defaults
▼CArrowheadLUppSolverDynamic	Arrowhead solver with a runtime shape
CRecomputedBlock	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
CStreamedBlock	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
CArrowheadLUppSolverStatic	Arrowhead solver with a compile-time shape
CArrowheadShape	Shape of an arrowhead matrix: a template argument of the compile-time solver, a function argument of the runtime one
CArrowheadStorageMap	Index of every entry of an arrowhead matrix in its storage
CAutoSync	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)
CCooperativeLUppConfig	Compile-time knobs of the CooperativeLUpp solvers, carrying the defaults
CCooperativeLUppSolverDynamic	Runtime-size dense LU factorization with partial pivoting shared by a group of threads, solving one n x n system per group
CCooperativeLUppSolverStatic	Dense LU factorization with partial pivoting held in the registers of a group of threads, solving one NxN system per group
CNoSync	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)
Cstorage_traits	Storage description of a dense object: element type, extents, element pointer and element stride
Cstorage_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
CStructuralReal	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
CTiledLUppConfig	Compile-time knobs of the TiledLUpp solvers, carrying the tuned defaults
CTiledLUppSolverDynamic	Runtime-size tiled dense LU factorization with logical partial pivoting and out-of-tile pivot recovery, solving one n x n system per call
CTiledLUppSolverStatic	Tiled dense LU factorization with logical partial pivoting and out-of-tile pivot recovery, solving one NxN system per call
CTiledLUppTileOperations	Tile_size x tile_size register-tile micro-kernels of the TiledLUpp solvers: the shared kernels plus the LU column elimination
CTileOperations	Tile_size x tile_size register-tile micro-kernels shared by the solver families