Contents Menu Expand Light mode Dark mode Auto light/dark, in light mode Auto light/dark, in dark mode Skip to content
dune-gdt v2026.3.0 Manual
dune-gdt v2026.3.0 Manual

Documentation

  • Tutorials
    • Tutorial: data functions and interpolation
    • Tutorial: continuous FEM for the stationary heat equation
  • Examples
    • Example: prolongations and computing products and norms
    • Example: Grid adaptation
    • Example: structured 1d grids (YASP_1D vs OneDGrid)
    • Example: the ALU cube grid (3d hexahedra)
    • Example: a posteriori error estimates based on flux reconstruction
    • Example: working with gmsh grids
    • Example: mixed-element and prism grids
    • Example: Taylor-Hood P2/P1 Stokes
    • Example: custom Python functions as C++ (grid) functions
    • Example: residual-based a posteriori error estimates
    • Tutorial: discontinuous IPDG for the stationary heat equation
    • Example: SIPDG for the instationary heat equation
    • Example: LA eigensolvers
    • Example: linear transport via finite volumes
  • Benchmarks
  • Bibliography

C++ API Reference

  • API Reference
    • Namespace Dune
      • FloatCmp
        • EpsilonType<std::complex<T>>
      • GDT
        • Data
          • BurgersProblem<G>
          • ESV2007DiffusionProblem<GV>
          • StokesDirichletProblem<GV>
          • stokes_testcase1_dirichlet
          • stokes_testcase1_exact_solution_p
          • stokes_testcase1_exact_solution_u
        • Exceptions
          • assembler_error
          • basis_error
          • bilinear_form_error
          • discrete_function_error
          • dof_vector_error
          • finite_element_error
          • functional_error
          • integrand_error
          • interpolation_error
          • mapper_error
          • newton_error
          • not_bound_to_an_element_yet
          • numerical_flux_error
          • operator_error
          • projection_error
          • prolongation_error
          • restricted_space_error
          • space_error
          • tools_error
        • LocalIPDGIntegrands
          • internal
            • default_intersection_diameter
          • BoundaryPenalty<I>
          • InnerPenalty<I>
        • LocalJumpIntegrands
          • Boundary<I, r>
          • Inner<I, r>
        • LocalLaplaceIPDGIntegrands
          • DirichletCoupling<I>
          • InnerCoupling<I>
        • LocalLinearAdvectionUpwindIntegrands
          • DirichletCoupling<I>
          • InnerCoupling<I>
        • Test
          • BoundaryInterpolationOnLeafViewTest<G>
          • DefaultInterpolationOnLeafViewTest<G>
          • ESV2007DiffusionTest<G>
          • InstationaryEocStudy<GridView, m_, la>
          • InstationaryNonconformingHyperbolicEocStudy<G, m, la>
          • IntegrandTest<G>
          • InviscidCompressibleFlowEulerExplicitTest<G>
          • InviscidCompressibleFlowEulerProblem<G>
          • InviscidCompressibleFlowEulerTest<G>
          • LinearTransportExplicitTest<G>
          • LinearTransportImplicitTest<G>
          • LinearTransportProblem<G>
          • LinearTransportTest<G>
          • OS2015MultiscaleProblem<GV>
          • OS2015MultiscaleTest<G>
          • OswaldInterpolationOperatorOnCubicLeafViewTest<G>
          • OswaldInterpolationOperatorOnLeafViewTest<G>
          • RaviartThomasInterpolationOnLeafViewTest<G>
          • StationaryDiffusionIpdgEocStudy<G, la>
          • StationaryEocStudy<GridView, m_, la>
          • StokesDirichletTest<G>
          • StokesTestcase1<G>
          • compute_temporal_l_infty_norm
          • solve_instationary_system_explicit_euler
          • solve_instationary_system_implicit_euler
          • update_relative_mass_conservation_errors
        • internal
          • AdaptiveButcherArrayProvider<RangeFieldType, method>
          • AdaptiveButcherArrayProvider<RangeFieldType, TimeStepperMethods::adaptive_rungekutta_other>
          • AdaptiveButcherArrayProvider<RangeFieldType, TimeStepperMethods::bogacki_shampine>
          • AdaptiveButcherArrayProvider<RangeFieldType, TimeStepperMethods::dormand_prince>
          • AssertArgumentsOfConstDiscreteFunction<Vector, GridView>
          • BlockedEigenvectorWrapper<AnalyticalFluxType, block_size>
          • ButcherArrayProvider<RangeFieldType, method>
          • ButcherArrayProvider<RangeFieldType, TimeStepperMethods::explicit_rungekutta_other>
          • ButcherArrayProvider<RangeFieldType, TimeStepperMethods::explicit_euler>
          • ButcherArrayProvider<RangeFieldType, TimeStepperMethods::explicit_rungekutta_second_order_ssp>
          • ButcherArrayProvider<RangeFieldType, TimeStepperMethods::explicit_rungekutta_third_order_ssp>
          • ButcherArrayProvider<RangeFieldType, TimeStepperMethods::explicit_rungekutta_classic_fourth_order>
          • ConstLocalDofVectorTraits<Vector, GridView>
          • DummyEigenVectorWrapper<AnalyticalFluxType, VectorImp>
          • EigenvectorWrapper<AnalyticalFluxType, MatrixType, VectorType>
          • EigenvectorWrapperBase<AnalyticalFluxType, MatrixImp, VectorImp>
          • FloatCmpLt
          • LocalDofVectorTraits<Vector, GridView>
          • LocalElementDivProductIntegrandBase
          • LocalFiniteElementInterpolationLagrangepointsAccessor<Implementation, DomainType>
          • ThisNumericalFluxIsNotAvailableForTheseDimensions<Intersection, d, m, R>
          • is_space_helper<S>
          • setUnion<T>
          • add_matrix_to_matrix
          • any_entry_above_threshold
          • apply_raviart_thomas_switches
          • compute_2x2_block_eigenvectors
          • hyperbolic_default_eigensolver_options
          • insert_index_cross_product
          • insert_intersection_couplings
          • restrict_data_to_element
          • smallest_nonzero_generalized_eigenvalue
          • symmetrized_laplace_pair
        • AdaptationHelper<V, GV, r, rC, RF>
        • AdaptiveRungeKuttaTimeStepper<OperatorImp, DiscreteFunctionImp, method>
        • AdvectionDgOperator<AGV, m, F, M, RGV, SGV>
        • AdvectionFvOperator<AGV, m, F, M, RGV, SGV>
        • AdvectionWithPointwiseReconstructionOperator<AdvectionOperatorImp, ReconstructionOperatorImp>
        • AdvectionWithReconstructionOperator<AdvectionOperatorImp, ReconstructionOperatorImp>
        • BilinearForm<AssemblyGridView, s_r, s_rC, r_r, r_rC, F, SGV, RGV>
        • BilinearFormAssembler<AGV, s_r, s_rC, r_r, r_rC, F, SGV, RGV>
        • BilinearFormInterface<SourceGridView, source_dim, source_dim_cols, range_dim, range_dim_cols, Field, RangeGridView>
        • BochnerSpace<GV, r, rC, R>
        • BurgersExplicitTest<G>
        • BurgersTest<G>
        • CentralSlope<E, EigenVectorWrapperType, stencil_size>
        • ConstDiscreteFunction<Vector, GridView, range_dim, range_dim_cols, RangeField>
        • ConstDofVector<Vector, GridView>
        • ConstLincombOperator<AGV, s_r, s_rC, r_r, r_rC, F, M, SGV, RGV>
        • ConstLocalDiscreteFunction<Vector, GridView, range_dim, range_dim_cols, RangeField>
        • ConstLocalDofVector<Vector, GridView, Traits>
        • ConstMatrixOperator<AGV, s_r, s_rC, r_r, r_rC, F, M, SGV, RGV>
        • ConstVectorBasedFunctional<V, GV, r, rC, F>
        • ConstantForwardOperator<SGV, s_r, s_rC, r_r, r_rC, F, V, RGV>
        • ConstantOperator<AGV, s_r, s_rC, r_r, r_rC, F, M, SGV, RGV>
        • ContinuousFlatTopSpace<GV, r, R>
        • ContinuousLagrangeSpace<GV, r, R>
        • ContinuousLagrangeSpaceOnCubicLeafViewTest<G, r, R, p>
        • ContinuousLagrangeSpaceOnMixedLeafViewTest<G, r, R, p>
        • ContinuousLagrangeSpaceOnPrismLeafViewTest<G, r, R, p>
        • ContinuousLagrangeSpaceOnSimplicialLeafViewTest<G, r, R, p>
        • ContinuousLagrangeSpaceTest<G, r, R, p>
        • ContinuousMapper<GV, LocalFiniteElementFamily>
        • DataEntityGatherScatter<GatherScatter>
        • DataGatherScatter<GatherScatter>
        • DefaultGlobalBasis<GV, r, rC, R>
        • DefaultInterpolationElementFunctor<GV, r, rC, R, V, IGV>
        • DirichletConstraints<IntersectionType, SpaceType>
        • DiscontinuousLagrangeSpace<GV, r, R>
        • DiscontinuousLagrangeSpaceOnCubicLeafViewTest<G, r, R, p>
        • DiscontinuousLagrangeSpaceOnMixedLeafViewTest<G, r, R, p>
        • DiscontinuousLagrangeSpaceOnPrismLeafViewTest<G, r, R, p>
        • DiscontinuousLagrangeSpaceOnSimplicialLeafViewTest<G, r, R, p>
        • DiscontinuousLagrangeSpaceTest<G, r, R, p>
        • DiscontinuousMapper<GV, LocalFiniteElementFamily>
        • DiscreteBochnerFunction<V, GV, r, rC, R>
        • DiscreteFunction<Vector, GridView, range_dim, range_dim_cols, RangeField>
        • DiscreteFunctionDataHandle<DiscreteFunctionType>
        • DiscreteValuedGridFunction<GV, rangeDim, rangeDimCols, RangeField>
        • DisjointPartitioningDataHandle<GV, r, rD, R, VectorType>
        • DisjointPartitioningGatherScatter<RankIndex>
        • DofCommunicationChooser<ViewImp, is_parallel>
        • DofDataCommunicationDescriptor<E>
        • DofVector<Vector, GridView>
        • EntityDataCommunicationDescriptor<E>
        • EulerTools<d, R>
        • ExplicitRungeKuttaTimeStepper<OperatorImp, DiscreteFunctionImp, method>
        • FiniteVolumeGlobalBasis<GV, r, R>
        • FiniteVolumeMapper<GV, r, rC>
        • FiniteVolumeSkeletonMapper<GV, r, rC>
        • FiniteVolumeSkeletonSpace<GV, r, rC, R>
        • FiniteVolumeSkeletonSpace<GV, 1, 1, R>
        • FiniteVolumeSpace<GV, r, rC, R>
        • FiniteVolumeSpace<GV, r, 1, R>
        • ForwardOperator<AssemblyGridView, s_r, s_rC, r_r, r_rC, F, V, SGV, RGV>
        • ForwardOperatorAssembler<ForwardOperatorType>
        • ForwardOperatorInterface<SGV, s_r, s_rC, r_r, r_rC, F, Vector, RGV>
        • FractionalTimeStepper<FirstStepperImp, SecondStepperImp>
        • FunctionalInterface<SourceVector, SourceGridView, source_dim, source_dim_cols, Field>
        • GenericLocalBinaryElementIntegrand<E, t_r, t_rC, TF, F, a_r, a_rC, AF>
        • GenericLocalBinaryIntersectionIntegrand<I, t_r, t_rC, TF, F, a_r, a_rC, AF>
        • GenericLocalCouplingIntersectionBilinearForm<I, t_r, t_rC, TR, F, a_r, a_rC, AR>
        • GenericLocalElementBilinearForm<E, t_r, t_rC, TR, F, a_r, a_rC, AR>
        • GenericLocalElementOperator<SV, SGV, s_r, s_rC, SF, r_r, r_rC, RF, RGV, RV>
        • GenericLocalIntersectionOperator<I, SV, SGV, s_r, s_rC, SF, r_r, r_rC, RF, IRGV, IRV, ORGV, ORV>
        • GenericLocalUnaryElementIntegrand<E, r, rC, R, F>
        • GenericLocalUnaryIntersectionIntegrand<I, r, rC, RF, F>
        • GenericNumericalFlux<I, d, m, R>
        • GenericParallelHelper<GV, r, rD, R>
        • GhostDataHandle<GV, r, rD, R, VectorType>
        • GhostGatherScatter
        • GlobalBasisInterface<GV, range_dim, range_dim_columns, RangeField>
        • IdentityOperator<GV, r, rC, F, M>
        • L2VolumeVectorFunctional<V, GV, r, rC, F, AssemblyGridView>
        • LaplaceIpdgFluxReconstructionOperator<AssemblyGridView, F, V, SGV, RGV>
        • LeftSlope<E, EigenVectorWrapperType, stencil_size>
        • LincombOperator<AGV, s_r, s_rC, r_r, r_rC, F, M, SGV, RGV>
        • LinearReconstructionOperator<AnalyticalFluxImp, BoundaryValueImp, GV, MatrixImp, EigenvectorWrapperImp>
        • LinearSlopeElementFunctor<AnalyticalFluxType, BoundaryValueType, GV, EigenvectorWrapperType>
        • Local0dFiniteElement<D, R, r>
        • Local0dFiniteElementBasis<D, R, r>
        • Local0dFiniteElementCoefficients<D>
        • Local0dFiniteElementInterpolation<D, R, r>
        • LocalAdvectionDgArtificialViscosityShockCapturingOperator<SV, SGV, m, SF, RF, RGV, RV>
        • LocalAdvectionDgBoundaryTreatmentByCustomExtrapolationOperator<I, SV, SGV, m, SF, RF, RGV, RV>
        • LocalAdvectionDgBoundaryTreatmentByCustomNumericalFluxOperator<I, SV, SGV, m, SF, RF, RGV, RV>
        • LocalAdvectionDgCouplingOperator<I, SV, SGV, m, SR, IRR, IRGV, IRV, ORR, ORGV, ORV>
        • LocalAdvectionDgVolumeOperator<SV, SGV, m, SF, RF, RGV, RV>
        • LocalAdvectionFvBoundaryTreatmentByCustomExtrapolationOperator<I, SV, SGV, m, SF, RF, RGV, RV>
        • LocalAdvectionFvBoundaryTreatmentByCustomNumericalFluxOperator<I, SV, SGV, m, SF, RF, RGV, RV>
        • LocalAdvectionFvCouplingOperator<I, SV, SGV, m, SR, RR, IRGV, IRV, ORR, ORGV, ORV>
        • LocalBinaryElementIntegrandInterface<Element, test_range_dim, test_range_dim_cols, TestRangeField, Field, ansatz_range_dim, ansatz_range_dim_cols, AnsatzRangeField>
        • LocalBinaryElementIntegrandSum<E, t_r, t_rC, TF, F, a_r, a_rC, AF>
        • LocalBinaryIntersectionIntegrandInterface<Intersection, test_range_dim, test_range_dim_cols, TestRangeField, Field, ansatz_range_dim, ansatz_range_dim_cols, AnsatzRangeField>
        • LocalBinaryIntersectionIntegrandSum<I, t_r, t_rC, TF, F, a_r, a_rC, AF>
        • LocalBinaryToUnaryElementIntegrand<E, t_r, t_rC, TF, F, a_r, a_rC, AF>
        • LocalBinaryToUnaryIntersectionIntegrand<I, t_r, t_rC, TF, F, a_r, a_rC, AF>
        • LocalCouplingIntersectionBilinearFormAssembler<Matrix, GridView, t_r, t_rC, TR, TGV, AGV, a_r, a_rC, AR>
        • LocalCouplingIntersectionBilinearFormIndicatorOperator<I, SV, SGV, s_r, s_rC, SF, RF, IRGV, IRV, ORGV, ORV>
        • LocalCouplingIntersectionBilinearFormInterface<Intersection, test_range_dim, test_range_dim_cols, TestRangeField, Field, ansatz_range_dim, ansatz_range_dim_cols, AnsatzRangeField>
        • LocalCouplingIntersectionIntegralBilinearForm<I, t_r, t_rC, TR, F, a_r, a_rC, AR>
        • LocalCouplingIntersectionProductIntegrand<I, r, TR, F, AR>
        • LocalCouplingIntersectionRestrictedIntegralBilinearForm<I, t_r, t_rC, TR, F, a_r, a_rC, AR>
        • LocalDiscreteFunction<V, GV, r, rC, R>
        • LocalDofVector<Vector, GridView>
        • LocalElementAbsIntegrand<E, r, rC, R, F>
        • LocalElementAnsatzDivTestValueProductIntegrand<E, TR, F, AR>
        • LocalElementAnsatzValueTestDivProductIntegrand<E, TR, F, AR>
        • LocalElementBilinearFormAssembler<Matrix, GridView, t_r, t_rC, TR, TGV, AGV, a_r, a_rC, AR>
        • LocalElementBilinearFormIndicatorOperator<SV, SGV, s_r, s_rC, SF, RF, RGV, RV>
        • LocalElementBilinearFormInterface<Element, test_range_dim, test_range_dim_cols, TestRangeField, Field, ansatz_range_dim, ansatz_range_dim_cols, AnsatzRangeField>
        • LocalElementFunctionalAccumulator<GridView, r, rC, R, F>
        • LocalElementFunctionalAssembler<Vector, GridView, r, rC, R, SpaceGridView>
        • LocalElementFunctionalInterface<Element, range_dim, range_dim_cols, RangeField, Field>
        • LocalElementGradientValueIntegrand<E, r, rC, TR, F, AR, use_test_gradient>
        • LocalElementIdentityIntegrand<E, r, rC, R, F>
        • LocalElementIntegralBilinearForm<E, t_r, t_rC, TR, F, a_r, a_rC, AR>
        • LocalElementIntegralFunctional<E, r, rC, R, F>
        • LocalElementOperatorFiniteDifferenceJacobianAssembler<M, SGV, s_r, s_rC, F, r_r, r_rC, RGV>
        • LocalElementOperatorInterface<SourceVector, SourceGridView, source_range_dim, source_range_dim_cols, SourceField, range_range_dim, range_range_dim_cols, RangeField, RangeGridView, RangeVector>
        • LocalElementProductIntegrand<E, r, TR, F, AR>
        • LocalFiniteElementBasisInterface<DomainField, domain_dim, RangeField, range_dim, range_dim_columns>
        • LocalFiniteElementBasisWrapper<Implementation, D, d, R, r, rC>
        • LocalFiniteElementCoefficientsInterface<DomainField, domain_dim>
        • LocalFiniteElementCoefficientsWrapper<Implementation, D, d>
        • LocalFiniteElementDefault<D, d, R, r, rC>
        • LocalFiniteElementFamilyInterface<DomainField, domain_dim, RangeField, range_dim, range_dim_columns>
        • LocalFiniteElementInterface<DomainField, domain_dim, RangeField, range_dim, range_dim_columns>
        • LocalFiniteElementInterpolationInterface<DomainField, domain_dim, RangeField, range_dim, range_dim_columns>
        • LocalFiniteElementInterpolationWrapper<Implementation, D, d, R, r, rC>
        • LocalFiniteElementWrapper<Implementation, D, d, R, r, rC>
        • LocalFlatTop2dCubeFiniteElement<D, R>
        • LocalFlatTop2dCubeFiniteElementBasis<D, R>
        • LocalFlatTopFiniteElementFactory<D, d, R, r>
        • LocalFlatTopFiniteElementFamily<D, d, R, r>
        • LocalIntersectionBilinearFormAssembler<Matrix, GridView, t_r, t_rC, TR, TGV, AGV, a_r, a_rC, AR>
        • LocalIntersectionBilinearFormIndicatorOperator<I, SV, SGV, s_r, s_rC, SF, RF, IRGV, IRV, ORGV, ORV>
        • LocalIntersectionBilinearFormInterface<Intersection, test_range_dim, test_range_dim_cols, TestRangeField, Field, ansatz_range_dim, ansatz_range_dim_cols, AnsatzRangeField>
        • LocalIntersectionFunctionalAssembler<Vector, GridView, r, rC, R, SpaceGridView>
        • LocalIntersectionFunctionalInterface<Intersection, range_dim, range_dim_cols, RangeField, Field>
        • LocalIntersectionIntegralBilinearForm<I, t_r, t_rC, TR, F, a_r, a_rC, AR>
        • LocalIntersectionIntegralFunctional<I, r, rC, R, F>
        • LocalIntersectionNormalComponentProductIntegrand<I, r, TR, F, AR>
        • LocalIntersectionOperatorFiniteDifferenceJacobianAssembler<M, SGV, s_r, s_rC, F, r_r, r_rC, RGV>
        • LocalIntersectionOperatorInterface<Intersection, SourceVector, SourceGridView, source_range_dim, source_range_dim_cols, SourceField, range_range_dim, range_range_dim_cols, RangeField, InsideRangeGridView, InsideRangeVector, OutsideRangeGridView, OutsideRangeVector>
        • LocalIntersectionProductIntegrand<I, r, TR, F, AR>
        • LocalIntersectionRestrictedIntegralBilinearForm<I, t_r, t_rC, TR, F, a_r, a_rC, AR>
        • LocalIntersectionRestrictedIntegralFunctional<I, r, rC, R, F>
        • LocalL2FiniteElementInterpolation<D, d, R, r>
        • LocalLagrangeFiniteElementFactory<D, d, R, r>
        • LocalLagrangeFiniteElementFamily<D, d, R, r>
        • LocalLaplaceIntegrand<E, r, F>
        • LocalLinearAdvectionIntegrand<E, F>
        • LocalLinearReconstructionOperator<AnalyticalFluxType, BoundaryValueType, GV, TargetSpaceType, TargetVectorType, EigenvectorWrapperType>
        • LocalMassMatrixProvider<GV, r, rC, F, AGV>
        • LocalOrthonormalFiniteElementFactory<D, d, R, r>
        • LocalPointwiseLinearReconstructionOperator<AnalyticalFluxType, BoundaryValueType, GV, EigenvectorWrapperType>
        • LocalPowerFiniteElement<power, D, d, R, r, rC>
        • LocalPowerFiniteElement<1, D, d, R, r, rC>
        • LocalPowerFiniteElement<power, D, d, R, r, 1>
        • LocalPowerFiniteElementBasis<power, D, d, R, r, rC>
        • LocalPowerFiniteElementBasis<power, D, d, R, r, 1>
        • LocalPowerFiniteElementCoefficients<D, d>
        • LocalPowerFiniteElementInterpolation<power, D, d, R, r, rC>
        • LocalPowerFiniteElementInterpolation<power, D, d, R, r, 1>
        • LocalProductIntegrand<E_or_I, r, TR, F, AR>
        • LocalQuaternaryIntersectionIntegrandInterface<Intersection, test_range_dim, test_range_dim_cols, TestRangeField, Field, ansatz_range_dim, ansatz_range_dim_cols, AnsatzRangeField>
        • LocalQuaternaryIntersectionIntegrandSum<I, t_r, t_rC, TF, F, a_r, a_rC, AF>
        • LocalRaviartThomasFiniteElementFactory<D, d, R>
        • LocalRaviartThomasFiniteElementFamily<D, d, R>
        • LocalRaviartThomasInterpolation<D, d, R>
        • LocalSymmetrizedLaplaceIntegrand<E, F>
        • LocalUnaryElementIntegrandInterface<Element, range_dim, range_dim_cols, RangeField, Field>
        • LocalUnaryElementIntegrandSum<E, r, rC, R, F>
        • LocalUnaryIntersectionIntegrandInterface<Intersection, range_dim, range_dim_cols, RangeField, Field>
        • LocalUnaryIntersectionIntegrandSum<I, r, rC, R, F>
        • LocalView<VectorType, ScalarType, SpaceType, Descriptor>
        • LocalZeroOrderLagrangeFiniteElement<D, d, R, r>
        • LocalizableFunctionalBase<GridView, range_dim, range_dim_cols, RangeField, Field>
        • LocalizedGlobalFiniteElementInterface<E, r, rC, R>
        • MapperInterface<GV>
        • MatrixOperator<AGV, s_r, s_rC, r_r, r_rC, F, M, SGV, RGV>
        • McSlope<E, EigenVectorWrapperType>
        • MinDataHandle<GV, r, rD, R, VectorType>
        • MinGatherScatter
        • MinmodSlope<E, EigenVectorWrapperType>
        • NoSlope<E, EigenVectorWrapperType, stencil_size>
        • NumericalEngquistOsherFlux<I, d, m, R>
        • NumericalEngquistOsherFlux<I, d, 1, R>
        • NumericalFluxInterface<Intersection, d, m, R>
        • NumericalLaxFriedrichsFlux<I, d, m, R>
        • NumericalUpwindFlux<I, d, m, R>
        • NumericalUpwindFlux<I, d, 1, R>
        • NumericalVijayasundaramFlux<I, d, m, R>
        • Operator<AGV, s_r, s_rC, r_r, r_rC, F, M, SGV, RGV>
        • OperatorInterface<AssemblyGridView, s_r, s_rC, r_r, r_rC, F, Matrix, SGV, RGV>
        • OswaldInterpolationOperator<AssemblyGridView, r, rC, F, V, SGV, RGV>
        • PointwiseLinearReconstructionOperator<AnalyticalFluxImp, BoundaryValueImp, GV, VectorType, EigenvectorWrapperImp>
        • RaviartThomasGlobalBasis<GL, R>
        • RaviartThomasSpace<GV, R>
        • RightSlope<E, EigenVectorWrapperType, stencil_size>
        • SharedDOFDataHandle<GV, r, rD, R, VectorType>
        • SharedDOFGatherScatter
        • SlopeBase<E, EigenVectorWrapperType, stencil_size>
        • SpaceDataHandle<GV, r, rD, R, VectorType, GatherScatter, CommunicationDescriptor>
        • SpaceInterface<GridView, range_dim, range_dim_columns, RangeField>
        • SpaceNeighborDataHandle<GV, r, rD, R, RankIndex>
        • SpaceTestBase<Space, p>
        • StrangSplittingTimeStepper<FirstStepperImp, SecondStepperImp>
        • SuperbeeSlope<E, EigenVectorWrapperType>
        • ThreadSafeDefaultLocalFiniteElementFamily<D, d, R, r, rC>
        • TimeStepperInterface<DiscreteFunctionImp>
        • VectorBasedFunctional<V, GV, r, rC, F, AssemblyGridView>
        • is_local_finite_element<T>
        • is_local_finite_element<LocalFiniteElementInterface<D, d, R, r, rC>>
        • is_local_finite_element_family<T>
        • is_local_finite_element_family<LocalFiniteElementFamilyInterface<D, d, R, r, rC>>
        • is_space<S, is_candidate>
        • is_space<S, true>
        • H1Product
        • H1SemiProduct
        • L2Product
        • advection_dg_artificial_viscosity_default_alpha_1
        • advection_dg_artificial_viscosity_default_component
        • advection_dg_artificial_viscosity_default_nu_1
        • boundary_interpolation
        • default_interpolation
        • default_newton_solve_options
        • doerfler_marking
        • estimate_combined_inverse_trace_inequality_constant
        • estimate_dt_for_hyperbolic_system
        • estimate_element_to_intersection_equivalence_constant
        • estimate_inverse_inequality_constant
        • h1_norm
        • h1_semi_norm
        • interpolate
        • l2_norm
        • make_adaptation_helper
        • make_advection_dg_operator
        • make_advection_fv_operator
        • make_bilinear_form
        • make_const_lincomb_operator
        • make_constant_forward_operator
        • make_constant_operator
        • make_continuous_flattop_space
        • make_continuous_lagrange_space
        • make_coupling_sparsity_pattern
        • make_cubic_grid
        • make_dirichlet_constraints
        • make_discontinuous_lagrange_space
        • make_discrete_bochner_function
        • make_discrete_function
        • make_element_and_intersection_sparsity_pattern
        • make_element_sparsity_pattern
        • make_finite_volume_skeleton_space
        • make_finite_volume_space
        • make_forward_operator
        • make_generic_numerical_flux
        • make_identity_operator
        • make_intersection_sparsity_pattern
        • make_l2_volume_vector_functional
        • make_laplace_ipdg_flux_reconstruction_operator
        • make_lincomb_operator
        • make_local_element_functional_accumulator
        • make_local_flattop_finite_element
        • make_local_lagrange_finite_element
        • make_local_orthonormal_finite_element
        • make_local_powered_finite_element
        • make_local_raviart_thomas_finite_element
        • make_localizable_functional
        • make_matrix_operator
        • make_mixed_grid
        • make_numerical_engquist_osher_flux
        • make_numerical_lax_friedrichs_flux
        • make_numerical_upwind_flux
        • make_numerical_vijayasundaram_flux
        • make_operator
        • make_oswald_interpolation_operator
        • make_prism_grid
        • make_raviart_thomas_space
        • make_simplicial_grid
        • make_sparsity_pattern
        • make_vector_functional
        • newton_solve
        • prolong
        • raviart_thomas_interpolation
        • reinterpret
        • space_associates_data_with
        • visualize
        • visualize_gradient
        • Operators
        • Types
      • PybindXI
        • ScopedInterpreter
        • GlobalInterpreter
        • interpreter_is_running
      • XT
        • Common
          • Cblas
            • available
            • col_major
            • dgemv
            • dtrsm
            • dtrsv
            • left
            • lower
            • no_trans
            • non_unit
            • right
            • row_major
            • trans
            • unit
            • upper
            • ztrsm
            • ztrsv
          • FloatCmp
            • internal
              • Call<FirstType, SecondType, ToleranceType, style>
              • Call<FirstType, SecondType, ToleranceType, Style::numpy>
              • ConvertStyle<Style::relativeWeak>
              • ConvertStyle<Style::relativeStrong>
              • ConvertStyle<Style::absolute>
              • cmp_type_check<FirstType, SecondType, ToleranceType>
              • cmp_ge
              • cmp_gt
              • cmp_le
              • cmp_lt
              • dune_cmp_ge
              • dune_cmp_le
              • dune_float_cmp_eq
              • float_cmp_eq
            • DefaultEpsilon<T, style, bool>
            • DefaultEpsilon<std::complex<T>, style, false>
            • DefaultEpsilon<T, Style::numpy, false>
            • DefaultEpsilon<std::complex<T>, Style::numpy, false>
            • DefaultEpsilon<T, style, true>
            • DefaultEpsilon<T, Style::numpy, true>
            • MT<V>
            • Types
          • Lapacke
            • available
            • col_major
            • dgeev
            • dgeev_work
            • dgeevx
            • dgeevx_work
            • dgeqp3
            • dgeqp3_work
            • dgesvd
            • dlamch
            • dorgqr
            • dorgqr_work
            • dormqr
            • dormqr_work
            • dpocon
            • dpotrf
            • dpotrf_work
            • dptcon
            • dpttrf
            • dpttrs
            • dsygv
            • dtrcon
            • row_major
            • zgeqp3
            • zungqr
            • zunmqr
          • Mkl
            • available
            • exp
          • Test
            • CurrentPathGuard
            • ScopedEnvVar
            • ScopedTestDir
            • get_unique_test_name
          • TupleProduct
            • Combine<UTypes, VTypes, TestFunc>
            • end_of_recursion_tag
          • bindings
            • guarded_bind
          • internal
            • AbsoluteValue<T, isUnsigned>
            • AbsoluteValue<T, true>
            • Absretval<T, is_enum>
            • Absretval<T, true>
            • AccessByPointer<T>
            • AccessByReference<T>
            • AccessByValue<T>
            • AccessInterface<T>
            • Any<std::size_t>
            • Concat<index_sequence<I1...>, index_sequence<I2...>>
            • ConstAccessByPointer<T>
            • ConstAccessByReference<T>
            • ConstAccessByValue<T>
            • ConstAccessInterface<T>
            • DefaultPrinter<T, use_repr>
            • EnumerableThreadSpecificWrapper<ValueImp>
            • HasSubscriptOperatorForVectorAbstraction<VectorType, ScalarType>
            • Helper<T>
            • Helper<bool>
            • Helper<int>
            • Helper<long>
            • Helper<long long>
            • Helper<unsigned long>
            • Helper<unsigned long long>
            • Helper<float>
            • Helper<double>
            • Helper<long double>
            • Helper<unsigned int>
            • MatrixPrinter<T, use_repr>
            • SimpleDict<ValueType>
            • Typer<T>
            • VectorAbstractionBase<Vector, K>
            • VectorPrinter<T, use_repr>
            • from_tplwrap<B, class>
            • from_tplwrap<tplwrap<B>, T...>
            • get_nth_helper<Is>
            • head_hlp<A>
            • head_hlp<std::tuple<A, B>>
            • hstack_decay<K>
            • hstack_decay<Dune::FieldVector<K, SIZE>>
            • hstack_decay<const Dune::FieldVector<K, SIZE> &>
            • hstack_decay<Dune::XT::Common::FieldVector<K, SIZE>>
            • hstack_decay<const Dune::XT::Common::FieldVector<K, SIZE> &>
            • hstack_helper<Vectors>
            • hstack_helper<L, R, Vectors...>
            • hstack_helper<Dune::FieldVector<K, SIZE>>
            • hstack_helper<Dune::XT::Common::FieldVector<K, SIZE>>
            • hstack_helper<KL, Dune::FieldVector<KR, r>>
            • hstack_helper<KL, Dune::XT::Common::FieldVector<KR, r>>
            • hstack_helper<Dune::FieldVector<KL, l>, KR>
            • hstack_helper<Dune::XT::Common::FieldVector<KL, l>, KR>
            • hstack_helper<Dune::FieldVector<KL, l>, Dune::FieldVector<KR, r>>
            • hstack_helper<Dune::XT::Common::FieldVector<KL, l>, Dune::FieldVector<KR, r>>
            • hstack_helper<Dune::FieldVector<KL, l>, Dune::XT::Common::FieldVector<KR, r>>
            • hstack_helper<Dune::XT::Common::FieldVector<KL, l>, Dune::XT::Common::FieldVector<KR, r>>
            • hstack_helper<Dune::FieldVector<KL, l>, const Dune::FieldVector<KR, r> &>
            • hstack_helper<Dune::FieldVector<KL, l>, const Dune::XT::Common::FieldVector<KR, r> &>
            • is_matrix_helper<M>
            • is_vector_helper<V>
            • require_impl<condition>
            • require_impl<true>
            • tail_hlp<Args>
            • tail_hlp<std::tuple<Args...>>
            • type_help<Templates>
            • type_help<std::tuple<Args...>>
            • wrapper<T>
            • abs
            • complex_from_string
            • convert_from_string
            • convert_safely
            • convert_to_string
            • deduce_seq
            • matrix_from_string
            • trim_copy_safely
            • vector_from_string
            • Types
          • ActiveEnableDebugLoggingForCtors<T>
          • BlockedFieldMatrix<K, num_blocks, block_rows, block_cols>
          • BlockedFieldVector<K, block_num, size_block>
          • CRTPInterface<InterfaceType, TraitsImp>
          • CombinedBuffer
          • Configuration
          • ConfigurationDefaults
          • ConstFixedMapIterator<FixedMapType>
          • ConstSharedStorageProvider<T>
          • ConstStorageProvider<T>
          • ConvergenceStudy
          • DefaultLogger
          • DefaultRNG<T, bool>
          • DefaultRNG<std::complex<T>, false>
          • DefaultRNG<VectorType, true>
          • DefaultRNG<std::string>
          • DualLogStream
          • EmptyBuffer
          • EmptyLogStream
          • Epsilon<T, is_integral>
          • Epsilon<T, true>
          • Epsilon<T, false>
          • Epsilon<std::string, false>
          • FieldMatrix<K, ROWS, COLS>
          • FieldMatrix<K, 1, 1>
          • FieldVector<K, SIZE>
          • FieldVectorFloatLess
          • FieldVectorLess
          • FixedMap<key_imp, T, nin>
          • FixedMapIterator<FixedMapType>
          • FullPattern
          • HexToString<ElemT>
          • IndexSetPartitioner<GridViewType>
          • LogStream
          • Logging
          • MPI_Comm_Wrapper
          • MatrixAbstraction<MatType>
          • MatrixAbstraction<Dune::DynamicMatrix<K>>
          • MatrixAbstraction<Dune::FieldMatrix<K, N, M>>
          • MatrixAbstraction<LA::ConstMatrixView<MatrixImp>>
          • MatrixAbstraction<LA::EigenRowMajorSparseMatrix<T>>
          • MatrixAbstraction<LA::MatrixView<MatrixImp>>
          • MatrixAbstraction<LA::CommonDenseMatrix<T, layout>>
          • MatrixAbstraction<Dune::XT::Common::FieldMatrix<K, N, M>>
          • MatrixAbstraction<LA::EigenDenseMatrix<T>>
          • MatrixAbstraction<Dune::XT::Common::BlockedFieldMatrix<K, num_blocks, block_rows, block_cols>>
          • MatrixAbstraction<LA::IstlRowMajorSparseMatrix<T>>
          • MatrixAbstraction<LA::CommonSparseMatrixCsr<T>>
          • MatrixAbstraction<LA::CommonSparseMatrixCsc<T>>
          • MatrixAbstraction<LA::CommonSparseOrDenseMatrix<DenseMatrixImp, SparseMatrixImp>>
          • MinMaxAvg<ElementType>
          • NoOpEnableDebugLoggingForCtors<T>
          • OstreamBuffer
          • OstreamLogStream
          • OutputScopedTiming
          • Parameter
          • ParameterType
          • ParametricInterface
          • PerThreadValue<ValueImp>
          • PrefixOutputIterator<T>
          • Printer<Dune::Intersection<G, I>, use_repr>
          • Printer<T, use_repr, anything>
          • Printer<Dune::Entity<cd, dim, GridImp, EntityImp>, use_repr>
          • Printer<V, use_repr, std::enable_if_t<is_vector<V>::value>>
          • Printer<M, use_repr, std::enable_if_t<is_matrix<M>::value>>
          • Printer<Configuration, use_repr, anything>
          • Printer<ParameterType, use_repr, anything>
          • Printer<Parameter, use_repr, anything>
          • PtrCaller<T, class>
          • PtrCaller<T, typename std::enable_if<is_smart_ptr<T>::value || std::is_pointer<T>::value>::type>
          • RNG<T, DistributionImp, EngineImp>
          • RNG<std::complex<T>, DistributionImp, EngineImp>
          • RandomStrings
          • ScopedTiming
          • StorageProvider<T>
          • SuspendableStrBuffer
          • ThreadManager
          • ThreadResultPropagator<Imp, Result, Reduction>
          • TimedLogManager
          • TimedLogging
          • TimedPrefixedLogStream
          • TimedPrefixedStreamBuffer
          • TimingData
          • Timings
          • Typename<T>
          • Typename<ValidateAny<T>>
          • Typename<int>
          • Typename<double>
          • Typename<float>
          • Typename<long>
          • Typename<unsigned int>
          • Typename<unsigned long>
          • Typename<char>
          • UniformDistributionSelector<T, bool>
          • UniformDistributionSelector<T, true>
          • UniformDistributionSelector<T, false>
          • UnsafePerThreadValue<ValueImp>
          • ValidateAny<T>
          • ValidateGreater<T>
          • ValidateGreaterOrEqual<T>
          • ValidateInList<T, ListImp>
          • ValidateInterval<T>
          • ValidateInverse<T, Validator>
          • ValidateLess<T>
          • ValidateLessOrEqual<T>
          • ValidateNone<T>
          • ValidatorInterface<T, Derived>
          • ValueInitFieldVector<K, SIZE, value>
          • VectorAbstraction<VecType>
          • VectorAbstraction<std::vector<T, Allocator>>
          • VectorAbstraction<std::array<K, SIZE>>
          • VectorAbstraction<Dune::DynamicVector<K>>
          • VectorAbstraction<Dune::FieldVector<K, SIZE>>
          • VectorAbstraction<Dune::DenseVector<V>>
          • VectorAbstraction<GDT::ConstLocalDofVector<Vector, GridView, Traits>>
          • VectorAbstraction<GDT::LocalDofVector<Vector, GridView>>
          • VectorAbstraction<Dune::XT::Common::FieldVector<K, SIZE>>
          • VectorAbstraction<LA::ConstVectorView<VectorImp>>
          • VectorAbstraction<LA::VectorView<VectorImp>>
          • VectorAbstraction<Dune::XT::Common::BlockedFieldVector<K, num_blocks, block_size>>
          • VectorAbstraction<LA::CommonSparseVector<T>>
          • VectorAbstraction<LA::CommonDenseVector<T>>
          • VectorAbstraction<LA::EigenDenseVector<T>>
          • VectorAbstraction<LA::EigenMappedDenseVector<T>>
          • VectorAbstraction<LA::IstlDenseVector<T>>
          • VectorFloatLess
          • VectorLess
          • WithLogger<T>
          • concatenate_container<T>
          • dependent<T>
          • field_traits<T>
          • field_traits<const T>
          • field_traits<T &>
          • field_traits<const T &>
          • field_traits<std::complex<T>>
          • index_sequence<Is>
          • is_arithmetic<T>
          • is_arithmetic<Dune::bigunsignedint<k>>
          • is_complex<T>
          • is_complex<std::complex<T>>
          • is_field_matrix<T>
          • is_field_matrix<Dune::FieldMatrix<K, ROWS, COLS>>
          • is_field_matrix<Dune::XT::Common::FieldMatrix<K, ROWS, COLS>>
          • is_field_vector<T>
          • is_field_vector<Dune::FieldVector<K, SIZE>>
          • is_field_vector<Dune::XT::Common::FieldVector<K, SIZE>>
          • is_hashable<typename>
          • is_matrix<T, candidate>
          • is_matrix<T, false>
          • is_printable<_Tp, dummy>
          • is_printable<_Tp, typename std::enable_if_t<std::is_same<std::remove_reference_t<decltype(std::cout << std::declval<_Tp>())>, std::ostream>::value>>
          • is_self<Self, Args>
          • is_self<Self, Arg>
          • is_smart_ptr<T>
          • is_vector<T, candidate>
          • is_vector<T, false>
          • list_content<TList>
          • list_content<std::tuple<Head, Tail...>>
          • list_content<std::tuple<T>>
          • list_content<template_tuple<Head, Tail...>>
          • list_content<template_tuple<T>>
          • make_identical_tuple<T, N, I>
          • make_identical_tuple<T, N, index_sequence<Indices...>>
          • make_index_sequence<N>
          • make_index_sequence<1>
          • make_index_sequence<0>
          • multiplication_promotion<L, R>
          • nonmoveable
          • null_type
          • numeric_limits<T, typename>
          • numeric_limits<T, typename std::enable_if<std::numeric_limits<T>::is_specialized>::type>
          • plus_promotion<L, R>
          • suitable_default<K, is_number>
          • suitable_default<K, false>
          • template_tuple<Ms>
          • tplwrap<B>
          • tuple_element<N, Tuple>
          • tuple_element<N, std::tuple<Ts...>>
          • tuple_null_type
          • Config
          • Logger
          • SecondsSinceStartup
          • TimedLogger
          • abs
          • absolute_difference
          • array_length
          • binomial_coefficient
          • clamp
          • conj
          • convert_to
          • create
          • create_directory
          • create_directory_of
          • create_real_or_complex_number
          • cross_product
          • data
          • default_logger_state
          • demangle_typename
          • demangled_type_id
          • dim_to_axis_name
          • directory_only
          • dump_environment
          • factorial
          • file_to_stream_filtered
          • filename_only
          • find_largest_by_bisection
          • from_string
          • get_idx
          • get_matrix_cols
          • get_matrix_entry
          • get_matrix_rows
          • get_template_basename
          • get_typename
          • handle_interrupt
          • hstack
          • imag
          • install_signal_handler
          • is_zero
          • isinf
          • isnan
          • make_array
          • make_const_shared_storage
          • make_const_storage
          • make_field_container
          • make_field_container_ptr
          • make_ifstream
          • make_ofstream
          • make_storage
          • make_string_sequence
          • matrix_to_gnuplot_stream
          • max
          • maxmod
          • mem_usage
          • meminfo
          • min
          • minmod
          • move_if
          • mv
          • numeric_cast
          • output_matrix
          • print
          • real
          • real_type_id
          • reduce
          • repr
          • reset_signal
          • serialize
          • serialize_colwise
          • serialize_rowwise
          • set_matrix_entry
          • signum
          • standard_deviation
          • stringFromTime
          • sup_norm
          • threadManager
          • timings
          • to_camel_case
          • to_lower
          • to_string
          • to_upper
          • tokenize
          • touch
          • transform_reduce
          • transposed
          • trim
          • value_range
          • vector_to_main_args
          • whitespaceify
          • zeros_like
          • Operators
          • Types
          • Constants
        • Functions
          • ESV2007
            • CutoffFunction<E, R>
            • Testcase1ExactSolution<d, r, rC, R>
            • Testcase1ExactSolution<2, 1, 1, R>
            • Testcase1Force<d, r, rC, R>
            • Testcase1Force<2, 1, 1, R>
          • Exceptions
            • combined_error
            • element_function_error
            • flux_function_error
            • function_error
            • grid_function_error
            • not_bound_to_an_element_yet
            • parameter_error
            • reinterpretation_error
            • spe10_data_file_missing
            • wrong_input_given
          • Spe10
            • internal
              • Model1Base<E, r, rC, R>
              • Constants
            • Model1Function<E, r, rC, R>
            • Model1Function<E, r, r, R>
            • Model2Function<E, r, rC, R>
            • Model2Function<E, 3, 3, R>
          • internal
            • CombinedDim<comb, L_r, L_rC, R_r, R_rC>
            • CombinedDim<CombinationType::product, L_r, L_rC, R_r, R_rC>
            • CombinedEval<comb, L_R, R_R, L_r, L_rC, R_r, R_rC>
            • CombinedEval<CombinationType::product, L_R, R_R, L_r, L_rC, R_r, R_rC>
            • CombinedHelper<Left, Right, comb>
            • CombinedJac<comb, L_R, R_R, d, L_r, L_rC, R_r, R_rC, anything>
            • CombinedJac<CombinationType::difference, L_R, R_R, d, L_r, L_rC, L_r, L_rC, a>
            • CombinedJac<CombinationType::sum, L_R, R_R, d, L_r, L_rC, L_r, L_rC, a>
            • CombinedStorageProvider<LeftType, RightType>
            • DerivativeElementFunctionHelper<ElementFunctionType, derivative>
            • ElementFunctionChooser<InnerType, OuterType, OuterGridViewType>
            • ElementFunctionForGlobalChooser<InnerType, OuterType, OuterGridViewType>
            • ElementwiseMinimumFunctionHelper<FunctionType>
            • GeneralElementFunctionChooser<InnerType, OuterType, OuterGridViewType>
            • GridFunctionBase<Derived, E, r, rC, R>
            • InverseFunctionHelper<FunctionType>
            • MathExpressionEngine
            • is_element_function_helper<Tt>
            • is_function_helper<Tt>
            • is_grid_function_helper<Tt>
            • add_gradient_to_vtkwriter
            • add_to_vtkwriter
            • compute_combined_eval
            • compute_combined_order
            • create_vtkwriter
            • make_generic_grid_function
            • make_generic_grid_function_with_jacobian
            • write_visualization
          • CheckerboardFunction<E, r, rC, R>
          • CombinationType
          • CombinedConstElementFunction<LeftType, RightType, comb>
          • CombinedElementFunction<LeftType, RightType, combination>
          • CombinedFunction<LeftType, RightType, comb>
          • CombinedGridFunction<LeftType, RightType, comb>
          • ComponentVisualizer<r, rC, R>
          • CompositionFunction<InnerType, OuterType, OuterGridViewType>
          • ConstDifferenceElementFunction<MinuendType, SubtrahendType>
          • ConstFractionElementFunction<LeftFactorType, RightFactorType>
          • ConstProductElementFunction<LeftFactorType, RightFactorType>
          • ConstSumElementFunction<LeftSummandType, RightSummandType>
          • ConstantFluxFunction<E, stateDim, r, rC, R>
          • ConstantFunction<d, r, rC, R>
          • ConstantGridFunction<E, r, rC, R>
          • DefaultVisualizer<r, rC, R>
          • DerivativeElementFunction<ElementFunctionType, derivative>
          • DerivativeGridFunction<GridFunctionType, derivative>
          • DerivativeRangeTypeSelector<d, R, r, rC>
          • DerivativeRangeTypeSelector<d, R, r, 1>
          • DifferenceElementFunction<MinuendType, SubtrahendType>
          • DifferenceFunction<MinuendType, SubtrahendType>
          • DifferenceGridFunction<MinuendType, SubtrahendType>
          • DivergenceElementFunction<ElementFunctionType>
          • DivergenceGridFunction<GridFunctionType>
          • DynamicMathExpressionBase<D, R, r, max_d>
          • ElementFluxFunctionInterface<Element, state_dim, range_dim, range_dim_cols, RangeField>
          • ElementFluxFunctionSetInterface<Element, stateDim, rangeDim, rangeDimCols, RangeField, StateField>
          • ElementFunctionInterface<Element, range_dim, range_dim_cols, RangeField>
          • ElementFunctionSetInterface<Element, rangeDim, rangeDimCols, RangeField>
          • ElementwiseDiameterFunction<E>
          • ElementwiseMinimumFunction<SomeFunction>
          • ExpressionFunction<d, r, rC, RangeField>
          • ExpressionFunction<d, r, 1, RangeField>
          • FlatTopFunction<d, r, rC, R>
          • FlatTopFunction<d, 1, 1, R>
          • FluxFunctionInterface<Element, stateDim, rangeDim, rangeDimCols, RangeField>
          • FractionElementFunction<LeftFactorType, RightFactorType>
          • FractionFunction<NominatorType, DenominatorType>
          • FractionGridFunction<NominatorType, DenominatorType>
          • FunctionAsGridFunctionWrapper<E, r, rC, R>
          • FunctionInterface<domainDim, rangeDim, rangeDimCols, RangeField>
          • GenericElementFunction<E, r, rC, R>
          • GenericElementFunctionSet<E, r, rC, R>
          • GenericFluxFunction<E, s, r, rC, R>
          • GenericFunction<domain_dim, range_dim, range_dim_cols, RangeField>
          • GenericGridFunction<E, r, rC, R>
          • GenericVisualizer<r, rC, R>
          • GetCombination<CombinationType>
          • GradientElementFunction<ElementFunctionType>
          • GradientGridFunction<GridFunctionType>
          • GradientVisualizationAdapter<GridViewType, range_dim, range_dim_cols, RangeField>
          • GridFunction<E, r, rC, R>
          • GridFunction<E, r, r, R>
          • GridFunction<E, 1, 1, R>
          • GridFunctionInterface<Element, rangeDim, rangeDimCols, RangeField>
          • IndicatorFunction<d, r, rC, R>
          • IndicatorGridFunction<E, r, rC, R>
          • InverseElementFunction<ElementFunctionType>
          • InverseFunction<FunctionType>
          • InverseGridFunction<GridFunctionType>
          • MathExpressionBase<DomainField, domainDim, RangeField, rangeDim>
          • ParametricExpressionFunction<d, r, rC, R>
          • ParametricExpressionFunction<d, r, 1, R>
          • ProductElementFunction<LeftFactorType, RightFactorType>
          • ProductFunction<LeftFactorType, RightFactorType>
          • ProductGridFunction<LeftFactorType, RightFactorType>
          • RangeTypeSelector<R, r, rC>
          • RangeTypeSelector<R, r, 1>
          • ReinterpretLocalizableFunction<SourceGridView, TargetElement, range_dim, range_dim_cols, RangeField>
          • SlicedGridFunction<LF, r, rC>
          • SlicedGridFunction<GF, r, 1>
          • StateFunctionAsFluxFunctionWrapper<E, s, r, rC, R>
          • SumElementFunction<LeftSummandType, RightSummandType>
          • SumFunction<LeftSummandType, RightSummandType>
          • SumGridFunction<LeftSummandType, RightSummandType>
          • SumVisualizer<r, rC, R>
          • TransformedGridFunction<GF, r, rC, R>
          • VisualizationAdapter<GridViewType, range_dim, range_dim_cols, RangeField>
          • VisualizerInterface<r, rC, R>
          • as_element_function_interface<F>
          • as_function_interface<F>
          • as_grid_function_interface<F>
          • is_element_function<T, is_candidate>
          • is_element_function<T, false>
          • is_element_function<T, true>
          • is_function<T, is_candidate>
          • is_function<T, false>
          • is_function<T, true>
          • is_grid_function<T, is_candidate>
          • is_grid_function<T, false>
          • is_grid_function<T, true>
          • default_visualizer
          • divergence
          • get_combination_name
          • get_combination_symbol
          • gradient
          • inverse
          • make_grid_function
          • make_sliced_function
          • make_transformed_function
          • reinterpret
          • visualize
          • visualize_gradient
          • Types
        • Grid
          • ApplyOn
            • AllElements<GL>
            • AllIntersections<GV>
            • AllIntersectionsOnce<GV>
            • BoundaryElements<GL>
            • BoundaryIntersections<GV>
            • CustomBoundaryAndProcessIntersections<GV>
            • CustomBoundaryIntersections<GV>
            • GenericFilteredElements<GL>
            • GenericFilteredIntersections<GV>
            • InnerIntersections<GV>
            • InnerIntersectionsOnce<GV>
            • InnerIntersectionsOnceMap<GV>
            • NoElements<GL>
            • NoIntersections<GV>
            • NonPeriodicBoundaryIntersections<GV>
            • PartitionSetElements<GL, PartitionSetType>
            • PartitionSetInnerIntersectionsOnce<GV, PartitionSetType>
            • PeriodicBoundaryIntersections<GV>
            • PeriodicBoundaryIntersectionsOnce<GV>
            • PeriodicBoundaryIntersectionsOnceMap<GV>
            • ProcessIntersections<GV>
          • DD
            • Exceptions
              • intersection_orientation_is_broken
            • Glued<MacroGridImp, LocalGridImp, layer>
            • GluedVTKWriter<MacroGridType, LocalGridType, layer>
            • check_for_broken_coupling_intersections
          • Exceptions
            • boundary_info_error
            • boundary_type_error
            • functor_error
            • not_bound_to_an_element_yet
            • wrong_codimension
            • wrong_dimension
          • internal
            • CombinedElementFilter<GL>
            • CombinedIntersectionFilter<GL>
            • CompareType<type>
            • CouplingGridViewWrapper<GridGlueImp>
            • CouplingGridViewWrapperTraits<GridGlueImp>
            • CouplingIntersectionWithCorrectNormal<CouplingIntersectionType, MacroIntersectionType>
            • ElementAndIntersectionFunctorWrapper<GL>
            • ElementFunctorWrapper<GL>
            • IndexMapCreator<BaseGridViewType, codim_iters_provided, codim>
            • IntersectionFunctorWrapper<GL>
            • MinMaxCoordinateFunctorReduction<D, d>
            • NegatedElementFilter<GL>
            • NegatedIntersectionFilter<GL>
            • PeriodicGridViewWrapper<BaseGridViewImp, codim_iters_provided>
            • PeriodicGridViewWrapperTraits<BaseGridViewImp, codim_iters_provided>
            • PeriodicIndexSet<BaseGridViewImp>
            • PeriodicIntersectionImp<BaseIntersectionImp>
            • PeriodicIntersectionIterator<BaseGridViewImp>
            • backend_dependent_typename<backend>
            • has_traits_helper<T>
            • layer_dependent_typename<layer>
          • AbsorbingBoundary
          • AllDirichletBoundaryInfo<IntersectionImp>
          • AllNeumannBoundaryInfo<IntersectionImp>
          • AllReflectingBoundaryInfo<IntersectionImp>
          • BoundaryDetectorFunctor<GL>
          • BoundaryInfo<I>
          • BoundaryInfoFactory<I>
          • BoundarySegmentIndexBasedBoundaryInfo<IntersectionImp>
          • BoundaryType
          • CheckInside<codim>
          • CheckInside<0>
          • CouplingGridProvider<CouplingGridViewImp>
          • CouplingGridView<GridGlueImp>
          • CubeGridProviderFactory<GridType>
          • DgfGridProviderFactory<GridType>
          • Dimensions<GridLayerType>
          • DirichletBoundary
          • EOCGridProvider<G>
          • EOCGridProvider<Dune::ALUGrid<2, 2, simplex, conforming, Comm>>
          • ElementAndIntersectionFunctor<GL>
          • ElementBoundObject<Element>
          • ElementFilter<GL>
          • ElementFunctor<GL>
          • ElementVisualization
          • EntityHierarchicSearch<GridLayerType>
          • EntityInlevelSearch<GridLayerType, codim>
          • EntityLess<GV>
          • EntitySearchBase<GridLayerType, codim>
          • ExpectedResults<M, L>
          • FallbackEntityInlevelSearch<GridLayerType, codim>
          • FunctionBasedBoundaryInfo<I>
          • GenericElementAndIntersectionFunctor<GL>
          • GenericElementFunctor<GL>
          • GenericIntersectionFunctor<GL>
          • GluedDdGridTest<GridTuple>
          • GmshGridProviderFactory<GridType>
          • GmshGridProviderFactory<Dune::YaspGrid<dim, Coordinates>>
          • GridProvider<GridImp>
          • GridProviderFactory<GridType>
          • ImpermeableBoundary
          • InflowBoundary
          • InflowOutflowBoundary
          • IntersectionBoundObject<Intersection>
          • IntersectionFilter<GL>
          • IntersectionFunctor<GL>
          • Layer<GridType, layer, backend, periodic>
          • Layer<GridType, Layers::leaf, Backends::view, false>
          • Layer<GridType, Layers::level, Backends::view, false>
          • Layer<GridType, layer, backend, true>
          • LeafBasedEOCGridProvider<GridImp>
          • LevelBasedEOCGridProvider<GridImp>
          • MaximumEntityVolumeRefineFunctor<GridViewType>
          • MinMaxCoordinateFunctor<GV>
          • NeumannBoundary
          • NoBoundary
          • NormalBasedBoundaryInfo<I>
          • OutflowBoundary
          • PeriodicGridView<BaseGridViewImp, codim_iters_provided>
          • PgfCoordWrapper
          • PgfEntityFunctor
          • PgfEntityFunctorIntersections<GridViewType>
          • PgfEntityFunctorIntersectionsWithShift<GridViewType>
          • PgfOutput<GridType>
          • ProcessBoundaryInfo<IntersectionImp>
          • RangedPartitioning<GridView, codim, pit>
          • ReflectingBoundary
          • RobinBoundary
          • StarCDGridProviderFactory<GridType>
          • Statistics
          • StructuredGridFactory<GridType>
          • StructuredGridFactory<UGGrid<dim>>
          • StructuredGridFactory<ALUGrid<dim, dim_world, Dune::cube, refineType, Comm>>
          • StructuredGridFactory<Dune::YaspGrid<dim, Coords>>
          • TemporaryConstView<GridLayerType>
          • TemporaryView<GridLayerType>
          • UnknownBoundary
          • Walker<Gl>
          • extract_collective_communication<T, view, part>
          • extract_collective_communication<T, true, false>
          • extract_collective_communication<T, false, true>
          • extract_entity<T, codim, view, part, grid>
          • extract_entity<T, codim, true, false, false>
          • extract_entity<T, codim, false, true, false>
          • extract_entity<T, codim, false, false, true>
          • extract_geometry<T, codim, view, part>
          • extract_geometry<T, codim, true, false>
          • extract_geometry<T, codim, false, true>
          • extract_grid<T, view, part, intersection, entity>
          • extract_grid<T, true, false, false, false>
          • extract_grid<T, false, true, false, false>
          • extract_grid<T, false, false, true, false>
          • extract_grid<Dune::Entity<cd, dim, GridImp, EntityImp>, false, false, false, true>
          • extract_index_set<T, view, part>
          • extract_index_set<T, true, false>
          • extract_index_set<T, false, true>
          • extract_intersection<T, view, part>
          • extract_intersection<T, true, false>
          • extract_intersection<T, false, true>
          • extract_intersection_iterator<T, view, part>
          • extract_intersection_iterator<T, true, false>
          • extract_intersection_iterator<T, false, true>
          • extract_iterator<T, c, pit, view, part>
          • extract_iterator<T, c, pit, true, false>
          • extract_iterator<T, c, pit, false, true>
          • extract_layer_backend<GridLayerType>
          • extract_local_geometry<T, codim, view, part>
          • extract_local_geometry<T, codim, true, false>
          • extract_local_geometry<T, codim, false, true>
          • has_boundary_id<G>
          • has_boundary_id<UGGrid<dim>>
          • is_alugrid<T>
          • is_alugrid<ALUGrid<dim, dimworld, elType, refineType, Comm>>
          • is_conforming_alugrid<T>
          • is_conforming_alugrid<ALUGrid<dim, dimworld, elType, Dune::conforming, Comm>>
          • is_cube_alugrid<T>
          • is_cube_alugrid<ALUGrid<dim, dimworld, ALUGridElementType::cube, refineType, Comm>>
          • is_entity<T, codim>
          • is_entity<Dune::Entity<cd, dim, GridImp, EntityImp>, cd>
          • is_grid<T>
          • is_grid<const T>
          • is_grid<Dune::OneDGrid>
          • is_grid<Dune::YaspGrid<dim, Coordinates>>
          • is_grid<Dune::ALUGrid<dim, dimworld, elType, refineType, Comm>>
          • is_grid<Dune::ALU3dGrid<dim, dimworld, elType, Comm>>
          • is_grid<Dune::UGGrid<dim>>
          • is_intersection<T>
          • is_intersection<Dune::Intersection<G, I>>
          • is_intersection<Dune::GridGlue::Intersection<P0, P1, I, O>>
          • is_intersection<Dune::XT::Grid::internal::CouplingIntersectionWithCorrectNormal<Dune::GridGlue::Intersection<P0, P1, It, O>, Dune::Intersection<G, I>>>
          • is_layer<T>
          • is_part<T, is_candidate>
          • is_simplex_alugrid<T>
          • is_simplex_alugrid<ALUGrid<dim, dimworld, ALUGridElementType::simplex, refineType, Comm>>
          • is_uggrid<T>
          • is_uggrid<UGGrid<dim>>
          • is_view<T, candidate>
          • is_view<const T, true>
          • is_view<T, true>
          • is_yaspgrid<T>
          • is_yaspgrid<YaspGrid<dim, Coordinates>>
          • alldirichlet_boundaryinfo_default_config
          • allneumann_boundaryinfo_default_config
          • allreflecting_boundaryinfo_default_config
          • boundarysegment_boundaryinfo_default_config
          • contains
          • cube_gridprovider_default_config
          • cube_gridprovider_id
          • default_overlap
          • dgf_gridprovider_default_config
          • dgf_gridprovider_id
          • diameter
          • dimensions
          • element_integral
          • enforce_maximum_entity_volume
          • entity_diameter
          • gmsh_gridprovider_default_config
          • gmsh_gridprovider_id
          • intersection_integral
          • make_alldirichlet_boundaryinfo
          • make_allneumann_boundaryinfo
          • make_allreflecting_boundaryinfo
          • make_boundary_type
          • make_boundarysegment_boundaryinfo
          • make_coupling_grid_view
          • make_cube_grid
          • make_dgf_grid
          • make_entity_hierarchic_search
          • make_entity_in_level_search
          • make_gmsh_grid
          • make_mixed_grid
          • make_normalbased_boundaryinfo
          • make_periodic_grid_layer
          • make_periodic_grid_view
          • make_prism_grid
          • make_tmp_view
          • make_walker
          • max_number_of_neighbors
          • normalbased_boundaryinfo_default_config
          • parallel_size
          • print_entity
          • print_info
          • print_intersection
          • reference_element
          • starcd_gridprovider_default_config
          • starcd_gridprovider_id
          • sub_entity_center
          • sub_entity_index
          • visualize_index_per_level
          • Operators
          • Types
          • Constants
        • LA
          • Exceptions
            • eigen_solver_failed
            • eigen_solver_failed_bc_data_did_not_fulfill_requirements
            • eigen_solver_failed_bc_eigenvalues_are_not_negative_as_requested
            • eigen_solver_failed_bc_eigenvalues_are_not_positive_as_requested
            • eigen_solver_failed_bc_eigenvalues_are_not_real_as_requested
            • eigen_solver_failed_bc_eigenvectors_are_not_real_as_requested
            • eigen_solver_failed_bc_it_was_not_set_up_correctly
            • eigen_solver_failed_bc_result_contained_inf_or_nan
            • eigen_solver_failed_bc_result_is_not_an_eigendecomposition
            • generalized_eigen_solver_failed
            • generalized_eigen_solver_failed_bc_data_did_not_fulfill_requirements
            • generalized_eigen_solver_failed_bc_eigenvalues_are_not_negative_as_requested
            • generalized_eigen_solver_failed_bc_eigenvalues_are_not_positive_as_requested
            • generalized_eigen_solver_failed_bc_eigenvalues_are_not_real_as_requested
            • generalized_eigen_solver_failed_bc_eigenvectors_are_not_real_as_requested
            • generalized_eigen_solver_failed_bc_it_was_not_set_up_correctly
            • generalized_eigen_solver_failed_bc_result_contained_inf_or_nan
            • linear_solver_failed
            • linear_solver_failed_bc_data_did_not_fulfill_requirements
            • linear_solver_failed_bc_it_did_not_converge
            • linear_solver_failed_bc_it_was_not_set_up_correctly
            • linear_solver_failed_bc_the_solution_does_not_solve_the_system
            • matrix_invert_failed
            • matrix_invert_failed_bc_data_did_not_fulfill_requirements
            • matrix_invert_failed_bc_it_was_not_set_up_correctly
            • matrix_invert_failed_bc_result_contained_inf_or_nan
            • matrix_invert_failed_bc_result_is_not_a_left_inverse
            • matrix_invert_failed_bc_result_is_not_a_right_inverse
            • not_available
          • internal
            • CholeskySolver<MatrixType, storage_layout>
            • CommonDenseMatrixBackend<ScalarType, Common::StorageLayout::dense_row_major>
            • CommonDenseMatrixBackend<ScalarType, Common::StorageLayout::dense_column_major>
            • CommonDenseMatrixTraits<ScalarImp, storage_layout>
            • CommonDenseVectorBackend<ScalarImp>
            • CommonDenseVectorTraits<ScalarImp>
            • CommonSparseMatrixTraits<ScalarImp, layout>
            • CommonSparseOrDenseMatrixTraits<DenseMatrixImp, SparseMatrixImp>
            • CommonSparseVectorTraits<ScalarImp>
            • ConstMatrixViewTraits<MatrixImp>
            • ConstVectorViewTraits<VectorImp>
            • EigenDenseMatrixTraits<ScalarImp>
            • EigenDenseVectorTraits<ScalarImp>
            • EigenMappedDenseVectorTraits<ScalarImp>
            • EigenRowMajorSparseMatrixTraits<ScalarImp>
            • EigenSolverBase<MatrixImp, FieldImp, RealMatrixImp, ComplexMatrixImp>
            • GeneralizedEigenSolverBase<MatrixImp, FieldImp, RealMatrixImp, ComplexMatrixImp>
            • IstlDenseVectorTraits<ScalarImp>
            • IstlRowMajorSparseMatrixTraits<ScalarImp>
            • IstlSolverTraits<S, CommunicatorType>
            • IstlSolverTraits<S, SequentialCommunication>
            • LDLTSolver<FirstVectorType, SecondVectorType, RhsType>
            • LockGuard
            • MatrixAbstractionBase<MatrixImp>
            • MatrixBackendBase<ScalarType>
            • MatrixDataProvider<MatrixType, true>
            • MatrixDataProvider<MatrixType, false>
            • MatrixInverterBase<MatrixImp>
            • MatrixTraitsBase<ScalarImp, derived_imp, BackendImp, backend_imp, vector_imp, is_sparse>
            • MatrixViewTraits<MatrixImp>
            • QrHelper<MatrixType, VectorType, IndexVectorType, storage_layout>
            • RealQrEigenSolver<FieldType, MatrixType, VectorType>
            • ScopedPythonContext
            • SolverUtils
            • TriangularSolver<MatrixType, VectorType, triangular_type, transpose, storage_layout>
            • TriangularSolver<CommonSparseOrDenseMatrix<DenseMatrixType, SparseMatrixType>, VectorType, triangular_type, transpose, Common::StorageLayout::other>
            • VectorAbstractionBase<VectorImp>
            • VectorBackendHelper<VectorImp, is_la_vector>
            • VectorBackendHelper<VectorImp, true>
            • VectorInputIterator<Traits, ScalarImp>
            • VectorLockGuard
            • VectorOutputIterator<Traits, ScalarImp>
            • VectorTraitsBase<ScalarImp, derived_imp, BackendImp, backend_imp, dense_matrix_imp, sparse_matrix_imp>
            • VectorViewTraits<VectorImp>
            • generalized_eigenvalues_lapack_helper<MatrixType>
            • is_container_helper<C>
            • is_contiguous_and_mutable<MatrixType>
            • is_eigen_vector_helper<C>
            • is_istl_dense_vector_helper<C>
            • is_matrix_helper<M>
            • is_vector_helper<V>
            • lapack_helper<MatrixType>
            • provides_backend_helper<C>
            • provides_data_access_helper<C>
            • triangular_helper<MatrixType, FirstVectorType, SecondVectorType, triangular_type, transpose, sparse_vector>
            • triangular_helper<MatrixType, FirstVectorType, SecondVectorType, triangular_type, transpose, true>
            • assemble_solver_types
            • backward_solve
            • backward_solve_csc
            • backward_solve_csr
            • cholesky_colwise
            • cholesky_csc
            • cholesky_csr
            • cholesky_rowwise
            • common_eigen_solver_options
            • compute_eigenvalue_groups
            • compute_eigenvalues_and_right_eigenvectors_of_a_fieldmatrix_using_numpy
            • compute_eigenvalues_and_right_eigenvectors_of_a_real_matrix_using_lapack
            • compute_eigenvalues_and_right_eigenvectors_of_a_real_matrix_using_lapack_impl
            • compute_eigenvalues_and_right_eigenvectors_using_eigen
            • compute_eigenvalues_and_right_eigenvectors_using_lapack
            • compute_eigenvalues_of_a_real_matrix_using_lapack
            • compute_eigenvalues_of_a_real_matrix_using_lapack_impl
            • compute_eigenvalues_using_eigen
            • compute_eigenvalues_using_lapack
            • compute_eigenvalues_using_qr
            • compute_generalized_eigenvalues_of_real_matrices_using_lapack
            • compute_generalized_eigenvalues_of_real_matrices_using_lapack_impl
            • compute_generalized_eigenvalues_using_lapack
            • compute_moore_penrose_inverse_using_eigen
            • compute_real_eigenvalues_and_real_right_eigenvectors_using_qr
            • compute_right_eigenvectors_using_eigen
            • copy_from_dynamic_matrix
            • copy_to_dynamic_matrix
            • csr_row_dot_product
            • default_eigen_solver_options
            • default_generalized_eigen_solver_options
            • default_matrix_inverter_options
            • eigen_solver_options_for_type
            • empty_matrix_ref
            • empty_vector_ref
            • ensure_eigen_solver_type
            • ensure_generalized_eigen_solver_type
            • ensure_matrix_inverter_type
            • fmatrix_compute_real_eigenvalues_and_real_right_eigenvectors_using_qr
            • forward_solve
            • forward_solve_csc
            • forward_solve_csr
            • generalized_eigen_solver_options_for_type
            • get_s
            • multiply_householder_from_left
            • multiply_householder_from_right
            • numpy_eigensolver_available
            • partial_dot
            • process_eigenvalue_group
            • qr_decomposition
            • read_matrix_market_array_format
            • read_matrix_market_coordinate_format
            • set_diagonal_to_one
            • solve_tridiag_ldlt
            • solver_options_with_type
            • solver_type_available
            • tridiagonal_ldlt
            • Constants
          • AmgApplicator<S, CommunicatorType>
          • AmgApplicator<S, SequentialCommunication>
          • CommonDenseMatrix<ScalarImp, storage_layout>
          • CommonDenseVector<ScalarImp>
          • CommonSparseMatrix<ScalarImp, layout>
          • CommonSparseMatrix<ScalarImp, Common::StorageLayout::csc>
          • CommonSparseOrDenseMatrix<DenseMatrixImp, SparseMatrixImp>
          • CommonSparseVector<ScalarImp>
          • ConstMatrixView<MatrixImp>
          • ConstVectorView<VectorImp>
          • Container<ScalarType, Backends::common_dense>
          • Container<ScalarType, Backends::common_sparse>
          • Container<ScalarType, Backends::eigen_dense>
          • Container<ScalarType, Backends::eigen_sparse>
          • Container<ScalarType, Backends::istl_dense>
          • Container<ScalarType, Backends::istl_sparse>
          • ContainerInterface<TraitsImp, ScalarImp>
          • EigenBaseVector<ImpTraits, ScalarImp>
          • EigenDenseMatrix<ScalarImp>
          • EigenDenseVector<ScalarImp>
          • EigenMappedDenseVector<T>
          • EigenMatrixInterfaceDynamic
          • EigenRowMajorSparseMatrix<ScalarType>
          • EigenSolver<MatrixImp, true>
          • EigenSolver<EigenDenseMatrix<S>, true>
          • EigenSolver<MatrixImp, is_matrix>
          • EigenSolver<Dune::FieldMatrix<K, SIZE, SIZE>, true>
          • EigenSolver<Dune::XT::Common::FieldMatrix<K, SIZE, SIZE>, true>
          • EigenSolver<Dune::XT::Common::FieldVector<K, 1>, true>
          • EigenSolver<Dune::FieldVector<K, 1>, true>
          • EigenSolverOptions<MatrixType, true>
          • EigenSolverOptions<EigenDenseMatrix<S>, true>
          • EigenSolverOptions<MatrixType, is_matrix>
          • EigenSolverOptions<Dune::FieldMatrix<K, SIZE, SIZE>, true>
          • EigenSolverOptions<Dune::XT::Common::FieldMatrix<K, SIZE, SIZE>, true>
          • EigenSolverOptions<Dune::FieldVector<K, 1>, true>
          • EigenSolverOptions<Dune::XT::Common::FieldVector<K, 1>, true>
          • GeneralizedEigenSolver<MatrixImp, true>
          • GeneralizedEigenSolver<MatrixImp, is_matrix>
          • GeneralizedEigenSolverOptions<MatrixType, true>
          • GeneralizedEigenSolverOptions<MatrixType, is_matrix>
          • IdentityPreconditioner<O>
          • IstlDenseVector<ScalarImp>
          • IstlRowMajorSparseMatrix<ScalarImp>
          • ListVectorArray<Vector>
          • MatrixInterface<TraitsImp, ScalarImp>
          • MatrixInverter<MatrixImp, true>
          • MatrixInverter<EigenDenseMatrix<S>, true>
          • MatrixInverter<FieldMatrix<K, ROWS, COLS>, true>
          • MatrixInverter<MatrixType, is_matrix>
          • MatrixInverter<Common::FieldMatrix<K, ROWS, COLS>, true>
          • MatrixInverterOptions<MatrixType, true>
          • MatrixInverterOptions<EigenDenseMatrix<S>, true>
          • MatrixInverterOptions<MatrixType, is_matrix>
          • MatrixInverterOptions<FieldMatrix<K, ROWS, COLS>, true>
          • MatrixInverterOptions<Common::FieldMatrix<K, ROWS, COLS>, true>
          • MatrixView<MatrixImp>
          • ProvidesBackend<Traits>
          • ProvidesConstContainer<Traits>
          • ProvidesContainer<Traits>
          • ProvidesDataAccess<Traits>
          • SaddlePointSolver<VectorType, MatrixType, CommunicatorType>
          • SchurComplementOperator<VectorType, MatrixType, CommunicatorType>
          • Solver<MatrixView<MatrixImp>, CommunicatorType>
          • Solver<Matrix, std::enable_if_t<XT::Common::is_matrix<Matrix>::value && !is_matrix<Matrix>::value, SequentialCommunication>>
          • Solver<CommonDenseMatrix<S>, CommunicatorType>
          • Solver<MatrixImp, CommunicatorType>
          • Solver<EigenDenseMatrix<S>, CommunicatorType>
          • Solver<IstlRowMajorSparseMatrix<S>, CommunicatorType>
          • Solver<EigenRowMajorSparseMatrix<S>, CommunicatorType>
          • SolverOptions<Matrix, std::enable_if_t<XT::Common::is_matrix<Matrix>::value && !is_matrix<Matrix>::value, SequentialCommunication>>
          • SolverOptions<MatrixView<MatrixImp>, CommunicatorType>
          • SolverOptions<CommonDenseMatrix<S>, CommunicatorType>
          • SolverOptions<MatrixType, CommunicatorType>
          • SolverOptions<EigenDenseMatrix<S>, CommunicatorType>
          • SolverOptions<IstlRowMajorSparseMatrix<S>, CommunicatorType>
          • SolverOptions<EigenRowMajorSparseMatrix<S>, CommunicatorType>
          • SparsityPatternDefault
          • VectorArrayInterface<TraitsImp>
          • VectorInterface<Traits, ScalarImp>
          • VectorView<VectorImp>
          • extract_matrix<V, bool>
          • extract_matrix<V, false>
          • extract_matrix<V, true>
          • extract_vector<M, bool>
          • extract_vector<M, false>
          • extract_vector<M, true>
          • is_container<C, candidate>
          • is_container<C, false>
          • is_eigen_vector<V, candidate>
          • is_eigen_vector<V, false>
          • is_istl_dense_vector<V, candidate>
          • is_istl_dense_vector<V, false>
          • is_matrix<M, candidate>
          • is_matrix<M, false>
          • is_vector<V, candidate>
          • is_vector<V, false>
          • provides_backend<C, candidate>
          • provides_backend<C, false>
          • provides_data_access<C, candidate>
          • provides_data_access<C, false>
          • apply_q_from_qr
          • calculate_q_from_qr
          • cholesky
          • convert_to
          • create
          • dense_pattern
          • diagonal_pattern
          • eigen_solver_check_dense_matrix_for_inf_nan
          • eigen_solver_check_sparse_matrix_for_inf_nan
          • eigen_solver_check_sparse_matrix_symmetry
          • eigen_solver_options
          • eigen_solver_types
          • eye_matrix
          • from_file
          • generalized_eigen_solver_options
          • generalized_eigen_solver_types
          • get_permutation_matrix
          • invert_matrix
          • make_eigen_solver
          • make_generalized_eigen_solver
          • make_matrix_inverter
          • make_solver
          • matrix_inverter_options
          • matrix_inverter_types
          • multiplication_pattern
          • qr
          • read_matrix_market
          • solve
          • solve_by_qr_decomposition
          • solve_cholesky_factorized
          • solve_lower_triangular
          • solve_lower_triangular_transposed
          • solve_qr_factorized
          • solve_sym_tridiag_posdef
          • solve_tridiagonal_ldlt_factorized
          • solve_upper_triangular
          • solve_upper_triangular_transposed
          • to_file
          • triangular_pattern
          • tridiagonal_ldlt
          • tridiagonal_pattern
          • write_matrix_market
          • Operators
          • Types
          • Constants
        • Test
          • internal
            • convert_to_scientific
          • FunctionInterfaceTestBase
          • check_eoc_study_for_success
          • expect_derivative_eq
          • expect_dynamic_derivative_eq
          • expect_dynamic_range_eq
          • expect_range_eq
          • expected_derivative
          • expected_value
          • filled_derivative
          • filled_range
          • grid_elements
          • init_bound
          • inside_point
          • multiindex
          • outside_point
        • SequentialCommunication
        • UseParallelCommunication<GridCommImp>
        • abort_all_mpi_processes
      • FieldTraits<XT::Common::FieldVector<K, SIZE>>
      • rightmultiply
      • Operators
      • Types
    • Namespace std
      • hash<Dune::FieldVector<K, SIZE>>
      • hash<Dune::XT::Common::FieldVector<K, SIZE>>
      • less<Dune::ParameterTree>
      • less<Dune::XT::Common::Configuration>
      • tuple_size<Dune::XT::Common::template_tuple<Types...>>
      • Operators
    • Class template ContainerFactory<ContainerImp>
    • Class template ContainerFactory<Dune::XT::LA::CommonDenseVector<S>>
    • Class template ContainerFactory<Dune::DynamicVector<S>>
    • Class template ContainerFactory<Dune::XT::Common::FieldVector<S, 4>>
    • Class template ContainerFactory<Dune::XT::Common::FieldVector<S, 10>>
    • Class template ContainerFactory<Dune::XT::LA::CommonSparseVector<S>>
    • Class template ContainerFactory<Dune::XT::Common::FieldMatrix<S, 10, 10>>
    • Class template ContainerFactory<Dune::XT::LA::CommonDenseMatrix<S>>
    • Class template ContainerFactory<Dune::XT::LA::CommonSparseMatrixCsr<S>>
    • Class template ContainerFactory<Dune::XT::LA::CommonSparseMatrixCsc<S>>
    • Class template ContainerFactory<Dune::XT::LA::CommonSparseOrDenseMatrixCsr<S>>
    • Class template ContainerFactory<Dune::XT::LA::CommonSparseOrDenseMatrixCsc<S>>
    • Class template ContainerFactory<Dune::XT::LA::IstlDenseVector<S>>
    • Class template ContainerFactory<Dune::XT::LA::IstlRowMajorSparseMatrix<S>>
    • Class template ContainerFactory<Dune::XT::LA::EigenDenseVector<S>>
    • Class template ContainerFactory<Dune::XT::LA::EigenMappedDenseVector<S>>
    • Class template ContainerFactory<Dune::XT::LA::EigenDenseMatrix<S>>
    • Class template ContainerFactory<Dune::XT::LA::EigenRowMajorSparseMatrix<S>>
    • Class template EigenSolverTest<MatrixImp, F, C, R>
    • Class template EigenSolverTestForMatricesWithRealEigenvaluesAndVectors<M, F, C, R>
    • Class template GeneralizedEigenSolverTest<MatrixImp, F, C, R>
    • Class template GeneralizedEigenSolverTestForMatricesWithRealEigenvaluesAndVectors<M, F, C, R>
    • Class template GridProviderBase<GridType>
    • Class template Int<i>
    • Class template MatrixInverterTest<MatrixImp>
    • Class template RightTrimTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, Size>
    • Class template RightTrimTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, 9>
    • Class template RightTrimTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, 8>
    • Class template RightTrimTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, 7>
    • Class template RightTrimTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, 6>
    • Class template RightTrimTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, 5>
    • Class template RightTrimTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, 4>
    • Class template RightTrimTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, 3>
    • Class template RightTrimTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, 2>
    • Class template RightTrimTuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, 1>
    • Class template TestRunner<Test>
    • Function DXTC_CONFIG_GET
    • Function DXTC_CONFIG_GETV
    • Function DXTC_TEST_CONFIG_GET
    • Function DXTC_TEST_CONFIG_HAS_SUB
    • Function DXTC_TEST_CONFIG_SET
    • Function DXTC_TEST_CONFIG_SUB
    • Function busywait
    • Function charcopy
    • Function convert_to_initializer_list_str
    • Operators in the global namespace
    • Types in the global namespace
    • Constants in the global namespace
    • Latex
    • ´´These methods allow to merge trees.``
    • ´´These methods allow to set key: value pairs.``
    • ´´These methods replace or override those from Dune::ParameterTree.``
Back to top

Namespace Dune¶

No documentation provided.

  • FloatCmp
  • GDT
  • PybindXI
  • XT
  • FieldTraits<XT::Common::FieldVector<K, SIZE>>
  • rightmultiply
  • Operators
  • Types
Next
Namespace Dune::FloatCmp
Previous
API Reference
Copyright © 2013-2021 dune-gdt developers and contributors
Made with Sphinx and @pradyunsg's Furo
Last updated on Oct 24, 2026