Logo Search packages:      
Sourcecode: feel++ version File versions  Download package

Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
gdb::printers::EigenMatrixPrinter::_iterator
gdb::printers::EigenQuaternionPrinter::_iterator
Feel::_Q< IMORDER >
A
Feel::AboutDataHolds information needed by the "About" box and other classes
Feel::AboutDataPrivate
Feel::AboutPerson
gmm::abstract_dense
gmm::abstract_indirect
gmm::abstract_matrix
gmm::abstract_null_type
gmm::abstract_skyline
gmm::abstract_sparse
gmm::abstract_vector
Action_aat_product< Interface >
Action_ata_product< Interface >
Action_atv_product< Interface >
Action_axpby< Interface >
Action_axpy< Interface >
Action_cholesky< Interface >
Action_ger< Interface >
Action_hessenberg< Interface >
Action_lu_decomp< Interface >
Action_lu_solve< Interface >
Action_matrix_matrix_product< Interface >
Action_matrix_matrix_product_bis< Interface >
Action_matrix_vector_product< Interface >
Action_partial_lu< Interface >
Action_rot< Interface >
Action_symv< Interface >
Action_syr2< Interface >
Action_tridiagonalization< Interface >
Action_trisolve< Interface >
Action_trisolve_matrix< Interface >
Action_trmm< Interface >
gmm::actual_precond< P, local_solver, Matrix >
Feel::ADBinaryAdd< L, R >
Feel::ADBinaryDivide< L, R >
AdBinaryFunctionsBrief description
Feel::ADBinaryMultiply< L, R >
Feel::ADBinaryPow< L, R >
Feel::ADBinaryPow< ADCst< typename R::value_type >, R >
Feel::ADBinaryPow< L, ADCst< int > >
Feel::ADBinaryPow< L, ADCst< typename L::value_type > >
Feel::ADBinarySubtract< L, R >
Feel::ADCst< T >
gmm::add_schwarz_mat< Matrix1, Matrix2, Precond, local_solver >
AddIfNull< Scalar >
Feel::ADExpr< Expr >Brief description
Feel::ADOfstream
Feel::ADType< T, Nvar, Order, Var >Automatically Diffentiated Numerical Type
Feel::ADType< T, Nvar, 0, Var >
Feel::ADType< T, Nvar, 1, Var >
Feel::ADType< T, Nvar, 2, Var >
Feel::ADUnaryMinus< T >
Feel::ADUnaryPlus< T >
Feel::ADVariable< var_ >
Feel::Advection< Dim, Order, Cont, Entity >
Feel::AdvReact< Space, imOrder, Entity >Advection-Reaction solver
Feel::AirAir material
Feel::Aitken< fs_type >Aitken relaxation method for fixed point iterations
Feel::ALE< Convex >
aligned_allocator< T >STL compatible allocator to use with with 16 byte aligned types
Eigen::aligned_allocator_indirection< T >
AlignedBox< _Scalar, _AmbientDim >An axis aligned box
alt_prod< M, N, K >
AmbiVector< _Scalar, _Index >
AngleAxis< _Scalar >Represents a 3D rotation as a rotation angle around an arbitrary 3D axis
interface::app
Feel::ApplicationInformation about the Application
Feel::ApplicationXMLXML application
Feel::Continuous::apply< MeshType, DofType >
Feel::CrouzeixRaviart< Order, PolySetType, Pts >::apply< N, T, Convex >
Feel::Discontinuous::apply< MeshType, DofType >
Feel::Hermite< Order, PolySetType, Pts >::apply< N, T, Convex >
Feel::IM< DIM, IMORDER, T, Entity >::apply< DIM1, T1, Entity1 >
Feel::DiscontinuousInterfaces< A0 >::apply< MeshType, DofType >
Feel::_Q< IMORDER >::apply< DIM, T, Entity >
Feel::Lagrange< Order, PolySetType, ContinuityType, Pts >::apply< N, T, Convex >
Feel::Field< M >::apply< Nvar >
Feel::RaviartThomas< Order >::apply< N, T, Convex >
Feel::_Q< IMORDER >::applyContext< ContextType >
dal::approx_greater< T >
dal::approx_less< T >
Array< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols >General-purpose arrays with easy API for coefficient-wise operations
ArrayBase< Derived >Base class for all 1D and 2D array, and related expressions
ArrayWrapper< ExpressionType >Expression of a mathematical vector or matrix as an array object
ArrayXpr
Feel::Assert
Feel::AssertContextDetails about a failed assertion
Eigen::AutoDiffJacobian< Functor >
Eigen::AutoDiffScalar< _DerType >A scalar type replacement with automatic differentation capability
Eigen::AutoDiffVector< ValueType, JacobianType >
B
Feel::Backend< T >!
Feel::BackendAdaptiveReusePC< BackendBase >
Feel::BackendAdaptiveReusePCdefaults
Feel::BackendGmm< T >
Feel::BackendGmmDefaults
Ball< Dim >
BallPointStuff< Dim >
BandMatrix< _Scalar, Rows, Cols, Supers, Subs, Options >Represents a rectangular matrix with a banded storage
Feel::BareEdgeThe Edge basis class It contains the attributes common to all Edges In particular, it contains the two size_type's (first and second) of the points at the two ends of the edge
Feel::BareFaceThe base Face class
BareItemHandlerBare Items Handler
Feel::BareItemsHandler< BareItem >
Feel::BarePointThe Point basis class It contains the attributes common to all Points In particular, it contains the one size_type's (first) of the point
bases
Feel::bases< A0, A1, A2, A3 >Classes that store sequences of basis functions to define function spaces
Feel::detail::bases_base
gmm::basic_index
Feel::FunctionSpace< A0, A1, A2, A3, A4 >::Basis< N >
Feel::Basis< tag, T >Base class for basis
Feel::Bdf< SpaceType >Backward differencing formula time discretization
Feel::BdfBase
Feel::BdfBaseMetadata
Feel::Beam< nDim, nOrder >
Feel::Bench1Benchmark for assembly performance in 1D, 2D and 3D
bench_impl< Transformation, N >
bench_impl< Transformation, 0 >
Eigen::BenchTimer
Bennett5_functor
gmm::bfgs_invhessian< VECTOR >
Feel::BFGSInvHessian< VECTOR >
BICGSTAB
blitz_interface< real >
blitz_LU_solve_interface< real >
Block< XprType, BlockRows, BlockCols, InnerPanel, HasDirectAccess >Expression of a fixed-size or dynamic-size block
Block< XprType, BlockRows, BlockCols, InnerPanel, true >
gmm::block_matrix< MAT >
Feel::BoundaryAdapted< Dim, Degree, T, StoragePolicy >BoundaryAdapted Basis on simplex
Feel::BoundaryAdaptedTag< D, O >
Feel::BoundaryAdaptedTraits< Dim, Degree, T, StoragePolicy >
Feel::BoundingBox< T >Bounding box for a matrix of points
Feel::RegionTree::box_index_type
BoxBOD_functor
Feel::Bratu< Dim, Order, Entity >
BtlConfig
BtlString
C
C_BLAS_interface< real >
C_BLAS_interface< float >
C_interface< real >
C_Map_MatrixXd
C_MatrixXd
gmm::c_mult
Camera
gmm::cast_char_type< T >
gmm::cast_char_type< signed char >
gmm::cast_char_type< unsigned char >
Feel::CastIronCast iron material
CG
Feel::FunctionSpace< A0, A1, A2, A3, A4 >::ChangeBasis< BasisType >
Feel::FunctionSpace< A0, A1, A2, A3, A4 >::ChangeBasisToComponentBasis< BasisType >
Feel::FunctionSpace< A0, A1, A2, A3, A4 >::Element< T, Cont >::ChangeElement< BasisType >
Feel::BoundaryAdaptedTraits< Dim, Degree, T, StoragePolicy >::ChangeOrder< NewOrder >
Feel::DubinerTraits< Dim, Degree, NormalizationPolicy, T, StoragePolicy >::ChangeOrder< NewOrder >
Feel::LegendreTraits< Dim, Degree, NormalizationPolicy, T, StoragePolicy >::ChangeOrder< NewOrder >
Feel::BoundaryAdaptedTraits< Dim, Degree, T, StoragePolicy >::ChangeValueType< NewT >
Feel::DubinerTraits< Dim, Degree, NormalizationPolicy, T, StoragePolicy >::ChangeValueType< NewT >
Feel::LegendreTraits< Dim, Degree, NormalizationPolicy, T, StoragePolicy >::ChangeValueType< NewT >
checkTransposeAliasing_impl< Derived, OtherDerived, MightHaveTransposeAliasing >
checkTransposeAliasing_impl< Derived, OtherDerived, false >
gmm::cholesky_precond< Matrix >
gmm::choleskyt_precond< Matrix >
chwirut2_functor
Feel::clear_value< Contextv, Value >
cmp_eval< T >
Feel::cmpBareItem< BareEdge >< The actual comparison operator
Feel::cmpBareItem< BareFace >
Feel::cmpBareItem< BarePoint >< The actual comparison operator
codeCalcul::CodeCalcul
codeCalculParaview::CodeCalculParaview
CoeffBasedProduct< LhsNested, RhsNested, NestingFlags >
gmm::col_and_row
gmm::col_major
gmm::col_matrix< V >
ColPivHouseholderQR< _MatrixType >Householder rank-revealing QR decomposition of a matrix with column-pivoting
CommaInitializer< XprType >Helper class used by the comma initializer operator
ComplexEigenSolver< _MatrixType >Computes eigenvalues and eigenvectors of general complex matrices
ComplexSchur< _MatrixType >Performs a complex Schur decomposition of a real or complex square matrix
Feel::Component< T >
Feel::functional< Data >::ComponentPointEvaluation< Space >Generate the functional associated with a point evaluation associated with a component
Feel::FunctionSpace< A0, A1, A2, A3, A4 >::ComponentSpace
Feel::functional< Data >::ComponentsPointsEvaluation< Space >Generate the functionals associated with point set
CompressedStorage< _Scalar, _Index >
Feel::compute_opInterpolation_return< Args >
gmm::conjugated_col_const_iterator< M >
gmm::conjugated_col_matrix_const_ref< M >
gmm::conjugated_const_iterator< IT >
gmm::conjugated_return< L >
gmm::conjugated_return_< L, T, LT >
gmm::conjugated_return_< L, std::complex< T >, abstract_vector >
gmm::conjugated_return_< L, T, abstract_matrix >
gmm::conjugated_return__< L, SO >
gmm::conjugated_return__< L, col_major >
gmm::conjugated_row_const_iterator< M >
gmm::conjugated_row_matrix_const_ref< M >
gmm::conjugated_vector_const_ref< V >
gmm::const_pointer< const P * >
gmm::const_pointer< P * >
Feel::math::Constant< Tag, Rep >Structure that holds a constant with different numerical representation
Feel::ConstrainedPolynomialSet< Poly >
Feel::ContextContext class
Feel::GeoMap< Dim, Order, T, Entity, PP >::Context< context_v, ElementType >
Feel::PolynomialSet< Poly, PolySetType >::Context< context_v, Basis_t, Geo_t, ElementType, context_g >
Feel::detail::continuity_base
Feel::ContinuousDescribe continuous functions
contributor
Convection< Order_s, Order_p, Order_t >
mpfr::conversion_overflow
Feel::Convex< Dim, Order, RDim >Convex base class
Feel::BoundaryAdaptedTraits< Dim, Degree, T, StoragePolicy >::Convex< order, V >
Feel::DubinerTraits< Dim, Degree, NormalizationPolicy, T, StoragePolicy >::Convex< order, V >
Feel::LegendreTraits< Dim, Degree, NormalizationPolicy, T, StoragePolicy >::Convex< order, V >
Feel::TensorisedBoundaryAdapted< Dim, Degree, T, StoragePolicy >::Convex< order >
Feel::ConvexBase
Feel::SolverConstrained< Data, Problem >::COptionsHolds the options for the SolverConstrained
Feel::SolverUnconstrained< Data, Problem >::COptionsParameters for the solver
Feel::core_data< Data, Id >
ei_member_redux< BinaryOp, Scalar >::Cost< _Scalar, Size >
gmm::cref_type< L >
gmm::cref_type_< L, R >
gmm::cref_type_< L, linalg_modifiable >
gmm::crmult
Feel::fem::CrouzeixRaviart< N, PolySetType, T, Convex >CrouzeixRaviart Finite Element
Feel::CrouzeixRaviart< Order, PolySetType, Pts >
Feel::fem::detail::CrouzeixRaviartDual< Basis, PointSetType >
gmm::cs_vector_ref< PT1, PT2, shift >
gmm::cs_vector_ref_iterator< PT1, PT2, shift >
gmm::csc_matrix< T, shift >
gmm::csc_matrix_ref< PT1, PT2, PT3, shift >
gmm::csr_matrix< T, shift >
gmm::csr_matrix_ref< PT1, PT2, PT3, shift >
Feel::detail::Curl< T, N >
Cwise< ExpressionType >Pseudo expression providing additional coefficient-wise operations
CwiseBinaryOp< BinaryOp, Lhs, Rhs >Generic expression where a coefficient-wise binary operator is applied to two expressions
CwiseBinaryOpImpl< BinaryOp, Lhs, Rhs, Dense >
CwiseBinaryOpImpl< BinaryOp, Lhs, Rhs, Sparse >
CwiseClampOp< Scalar >
CwiseNullaryOp< NullaryOp, PlainObjectType >Generic expression of a matrix where all coefficients are defined by a functor
CwiseUnaryOp< UnaryOp, XprType >Generic expression where a coefficient-wise unary operator is applied to an expression
CwiseUnaryOpImpl< UnaryOp, MatrixType, Sparse >
CwiseUnaryOpImpl< UnaryOp, XprType, Dense >
CwiseUnaryView< ViewOp, MatrixType >Generic lvalue expression of a coefficient-wise unary operator of a matrix or a vector
CwiseUnaryViewImpl< ViewOp, MatrixType, Dense >
CwiseUnaryViewImpl< ViewOp, MatrixType, Sparse >
D
Feel::detail::D< T, N >
Feel::Dar< Dim, Order, Cont, Entity >
DataData for the Turek benchmark
Feel::DataMapData layout in a multi-processor environnement
Feel::detail::DD< T >
DebugArea debugging tool
Feel::DebugStream
Default_t
Dense
gmm::dense_compressed_iterator< ITER, MIT, PT >
gmm::dense_matrix< T >
gmm::dense_vector_type< T >
DenseBase< Derived >Base class for all dense matrices, vectors, and arrays
DenseCoeffsBase
DenseCoeffsBase< Derived, DirectAccessors >Base class providing direct coefficient access to matrices and arrays
DenseCoeffsBase< Derived, ReadOnlyAccessors >Base class providing read-only coefficient access to matrices and arrays
DenseCoeffsBase< Derived, WriteAccessors >Base class providing read/write coefficient access to matrices and arrays
DenseSparseProductReturnType< Lhs, Rhs, InnerSize >
DenseSparseProductReturnType< Lhs, Rhs, 1 >
DenseStorageBase< Derived >Dense storage base class for matrices and arrays
DenseTimeSparseProduct< Lhs, Rhs >
DenseTimeSparseSelfAdjointProduct< Lhs, Rhs, UpLo >
Depends< Align >
std::deque< T, EIGEN_ALIGNED_ALLOCATOR< T > >
Diagonal< MatrixType, DiagIndex >Expression of a diagonal/subdiagonal/superdiagonal in a matrix
gmm::diagonal_precond< Matrix >
DiagonalBase< Derived >
BandMatrix< _Scalar, Rows, Cols, Supers, Subs, Options >::DiagonalIntReturnType< Index >
DiagonalMatrix< _Scalar, SizeAtCompileTime, MaxSizeAtCompileTime >Represents a diagonal matrix with its storage
DiagonalProduct< MatrixType, DiagonalType, ProductOrder >
DiagonalWrapper< _DiagonalVectorType >Expression of a diagonal matrix
Feel::functional< Data >::diff< Data >
Feel::inequalities< Data >::diff< Diff >
Feel::equalities< Data >::diff< Diff >
Feel::diff_order< O >
dal::dimension_error
Feel::DimFromShape< sh >
Feel::functional< Data >::DirectionalComponentPointEvaluation< Space >Functional associate with directional component point evaluation
Feel::functional< Data >::DirectionalComponentPointsEvaluation< Space >Functional associate with directional component point evaluation
Feel::DirScalingMatrix< NumType >Implements the directional Scaling Matrix for directionally-scaled trust region
Feel::Discontinuous
Feel::DiscontinuousInterfaces< A0 >Describes discontinuous interfaces and provide dof creation
Feel::detail::Div< T >
interface::dlgCmd
dal::dna_const_iterator< T, pks >Constant iterator class for dynamic array
dal::dna_iterator< T, pks >Iterator class for dynamic array
Feel::DofClass that represents a degree of freedom
Feel::DofCompositeCompositing of degree of freedom table
Feel::DofTable< MeshType, FEType, PeriodicityType >Local-to-global Degree of Freedom table
Feel::OperatorLinear< DomainSpace, DualImageSpace >::domain_element< T, Storage >
ei_gebp_traits< std::complex< RealScalar >, std::complex< RealScalar >, _ConjLhs, _ConjRhs >::DoublePacket
Feel::DualBasis< Primal >Basis of a space P' dual of some space P
Feel::Dubiner< Dim, Degree, NormalizationPolicy, T, StoragePolicy >Dubiner polynomial orthonormal basis
Feel::DubinerTag< D, O >
Feel::DubinerTraits< Dim, Degree, NormalizationPolicy, T, StoragePolicy >
Feel::dummy_data< N >Dummy data type
dal::dynamic_array< T, pks >
DynamicSparseMatrix< _Scalar, _Flags, _Index >A sparse matrix class designed for matrix assembly purpose
E
eckerle4_functor
ei_abs2_impl< Scalar >
ei_abs2_impl< std::complex< RealScalar > >
ei_abs2_retval< Scalar >
ei_abs_impl< Scalar >
ei_abs_retval< Scalar >
ei_all_unroller< Derived, UnrollCount >
ei_all_unroller< Derived, 1 >
ei_all_unroller< Derived, Dynamic >
ei_always_void< T >
ei_any_unroller< Derived, UnrollCount >
ei_any_unroller< Derived, 1 >
ei_any_unroller< Derived, Dynamic >
ei_are_flags_consistent< Flags >
Eigen::ei_assert_exception
ei_assign_DefaultTraversal_CompleteUnrolling< Derived1, Derived2, Index, Stop >
ei_assign_DefaultTraversal_CompleteUnrolling< Derived1, Derived2, Stop, Stop >
ei_assign_DefaultTraversal_InnerUnrolling< Derived1, Derived2, Index, Stop >
ei_assign_DefaultTraversal_InnerUnrolling< Derived1, Derived2, Stop, Stop >
ei_assign_impl< Derived1, Derived2, DefaultTraversal, CompleteUnrolling >
ei_assign_impl< Derived1, Derived2, DefaultTraversal, InnerUnrolling >
ei_assign_impl< Derived1, Derived2, DefaultTraversal, NoUnrolling >
ei_assign_impl< Derived1, Derived2, InnerVectorizedTraversal, CompleteUnrolling >
ei_assign_impl< Derived1, Derived2, InnerVectorizedTraversal, InnerUnrolling >
ei_assign_impl< Derived1, Derived2, InnerVectorizedTraversal, NoUnrolling >
ei_assign_impl< Derived1, Derived2, InvalidTraversal, Unrolling >
ei_assign_impl< Derived1, Derived2, LinearTraversal, CompleteUnrolling >
ei_assign_impl< Derived1, Derived2, LinearTraversal, NoUnrolling >
ei_assign_impl< Derived1, Derived2, LinearVectorizedTraversal, CompleteUnrolling >
ei_assign_impl< Derived1, Derived2, LinearVectorizedTraversal, NoUnrolling >
ei_assign_impl< Derived1, Derived2, SliceVectorizedTraversal, NoUnrolling >
ei_assign_innervec_CompleteUnrolling< Derived1, Derived2, Index, Stop >
ei_assign_innervec_CompleteUnrolling< Derived1, Derived2, Stop, Stop >
ei_assign_innervec_InnerUnrolling< Derived1, Derived2, Index, Stop >
ei_assign_innervec_InnerUnrolling< Derived1, Derived2, Stop, Stop >
ei_assign_LinearTraversal_CompleteUnrolling< Derived1, Derived2, Index, Stop >
ei_assign_LinearTraversal_CompleteUnrolling< Derived1, Derived2, Stop, Stop >
ei_assign_selector< Derived, OtherDerived, false, false >
ei_assign_selector< Derived, OtherDerived, false, true >
ei_assign_selector< Derived, OtherDerived, true, false >
ei_assign_selector< Derived, OtherDerived, true, true >
ei_assign_traits< Derived, OtherDerived >
ei_atan2_default_impl< Scalar, IsInteger >
ei_atan2_default_impl< Scalar, true >
ei_atan2_impl< Scalar >
ei_atan2_retval< Scalar >
Eigen::ei_auto_diff_special_op< _DerType, false >
Eigen::ei_auto_diff_special_op< _DerType, true >
ei_binary_result_of_select< Func, ArgType0, ArgType1, SizeOf >
ei_binary_result_of_select< Func, ArgType0, ArgType1, sizeof(ei_has_std_result_type)>
ei_binary_result_of_select< Func, ArgType0, ArgType1, sizeof(ei_has_tr1_result)>
ei_blas_data_mapper< Scalar, Index, StorageOrder >
ei_blas_traits< XprType >
ei_blas_traits< CwiseUnaryOp< ei_scalar_conjugate_op< Scalar >, NestedXpr > >
ei_blas_traits< CwiseUnaryOp< ei_scalar_multiple_op< Scalar >, NestedXpr > >
ei_blas_traits< CwiseUnaryOp< ei_scalar_opposite_op< Scalar >, NestedXpr > >
ei_blas_traits< SelfCwiseBinaryOp< BinOp, NestedXpr, Rhs > >
ei_blas_traits< Transpose< NestedXpr > >
ei_cast_impl
ei_cast_return_type< XprType, CastType >
ei_check_transpose_aliasing_compile_time_selector< DestIsTransposed, OtherDerived >
ei_check_transpose_aliasing_compile_time_selector< DestIsTransposed, CwiseBinaryOp< BinOp, DerivedA, DerivedB > >
ei_check_transpose_aliasing_run_time_selector< Scalar, DestIsTransposed, OtherDerived >
ei_check_transpose_aliasing_run_time_selector< Scalar, DestIsTransposed, CwiseBinaryOp< BinOp, DerivedA, DerivedB > >
ei_cleantype< T >
ei_cleantype< const T & >
ei_cleantype< const T * >
ei_cleantype< const T >
ei_cleantype< T & >
ei_cleantype< T * >
ei_coeff_visitor< Derived >Base class to implement min and max visitors
ei_companion< _Scalar, _Deg >
ei_complex_schur_reduce_to_hessenberg< MatrixType, IsComplex >
ei_complex_schur_reduce_to_hessenberg< MatrixType, false >
ei_compute_inverse< MatrixType, ResultType, Size >
ei_compute_inverse< MatrixType, ResultType, 1 >
ei_compute_inverse< MatrixType, ResultType, 2 >
ei_compute_inverse< MatrixType, ResultType, 3 >
ei_compute_inverse< MatrixType, ResultType, 4 >
ei_compute_inverse_and_det_with_check< MatrixType, ResultType, Size >
ei_compute_inverse_and_det_with_check< MatrixType, ResultType, 1 >
ei_compute_inverse_and_det_with_check< MatrixType, ResultType, 2 >
ei_compute_inverse_and_det_with_check< MatrixType, ResultType, 3 >
ei_compute_inverse_and_det_with_check< MatrixType, ResultType, 4 >
ei_compute_inverse_size4< Arch, Scalar, MatrixType, ResultType >
ei_compute_inverse_size4< Architecture::SSE, double, MatrixType, ResultType >
ei_compute_inverse_size4< Architecture::SSE, float, MatrixType, ResultType >
ei_compute_matrix_flags< Scalar, Rows, Cols, Options, MaxRows, MaxCols >
ei_conj_expr_if< Cond, T >
ei_conj_helper< Packet1cd, Packet1cd, false, true >
ei_conj_helper< Packet1cd, Packet1cd, true, false >
ei_conj_helper< Packet1cd, Packet1cd, true, true >
ei_conj_helper< Packet1cd, Packet2d, false, false >
ei_conj_helper< Packet2cf, Packet2cf, false, true >
ei_conj_helper< Packet2cf, Packet2cf, true, false >
ei_conj_helper< Packet2cf, Packet2cf, true, true >
ei_conj_helper< Packet2cf, Packet4f, false, false >
ei_conj_helper< Packet2d, Packet1cd, false, false >
ei_conj_helper< Packet4f, Packet2cf, false, false >
ei_conj_helper< RealScalar, std::complex< RealScalar >, false, Conj >
ei_conj_helper< Scalar, Scalar, false, false >
ei_conj_helper< std::complex< RealScalar >, RealScalar, Conj, false >
ei_conj_helper< std::complex< RealScalar >, std::complex< RealScalar >, false, true >
ei_conj_helper< std::complex< RealScalar >, std::complex< RealScalar >, true, false >
ei_conj_helper< std::complex< RealScalar >, std::complex< RealScalar >, true, true >
ei_conj_if< false >
ei_conj_if< true >
ei_conj_impl< Scalar >
ei_conj_impl< std::complex< RealScalar > >
ei_conj_retval< Scalar >
ei_conservative_resize_like_impl< Derived, OtherDerived, IsVector >
ei_conservative_resize_like_impl< Derived, OtherDerived, true >
ei_const_blas_data_mapper< Scalar, Index, StorageOrder >
ei_constructor_without_unaligned_array_assert
ei_cos_default_impl< Scalar, IsInteger >
ei_cos_default_impl< Scalar, true >
ei_cos_impl< Scalar >
ei_cos_retval< Scalar >
ei_cross3_impl< Arch, VectorLhs, VectorRhs, Scalar, Vectorizable >
ei_cross3_impl< Architecture::SSE, VectorLhs, VectorRhs, float, true >
ei_decrement_if_fixed_size< Size >
ei_decrement_size< n >
ei_default_packet_traits
ei_dense_xpr_base< Derived, XprKind >
ei_dense_xpr_base< Derived, ArrayXpr >
ei_dense_xpr_base< Derived, MatrixXpr >
ei_determinant_impl< Derived, DeterminantType >
ei_determinant_impl< Derived, 1 >
ei_determinant_impl< Derived, 2 >
ei_determinant_impl< Derived, 3 >
ei_determinant_impl< Derived, 4 >
ei_dot_nocheck< T, U, NeedToTranspose >
ei_dot_nocheck< T, U, true >
ei_eigenvalues_selector< Derived, IsComplex >
ei_eigenvalues_selector< Derived, false >
ei_enable_if< true, T >
ei_eval< Array< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols >, Dense >
ei_eval< Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols >, Dense >
ei_eval< T, Dense >
ei_eval< T, IsSkyline >
ei_eval< T, Sparse >
ei_exp_default_impl< Scalar, IsInteger >
ei_exp_default_impl< Scalar, true >
ei_exp_impl< Scalar >
ei_exp_retval< Scalar >
ei_extract_data_selector< T, HasUsableDirectAccess >
ei_extract_data_selector< T, false >
ei_fftw_impl< _Scalar >
ei_fftw_plan< T >
ei_fftw_plan< double >
ei_fftw_plan< float >
ei_fftw_plan< long double >
ei_first_aligned_impl< Derived, JustReturnZero >
ei_first_aligned_impl< Derived, false >
ei_functor_allows_mixing_real_and_complex< Functor >
ei_functor_allows_mixing_real_and_complex< ei_scalar_product_op< LhsScalar, RhsScalar > >
ei_functor_has_linear_access< Functor >
ei_functor_has_linear_access< ei_scalar_identity_op< Scalar > >
ei_functor_traits< T >
ei_functor_traits< ei_linspaced_op< Scalar, RandomAccess > >
ei_functor_traits< ei_max_coeff_visitor< Scalar > >
ei_functor_traits< ei_min_coeff_visitor< Scalar > >
ei_functor_traits< ei_scalar_abs2_op< Scalar > >
ei_functor_traits< ei_scalar_abs_op< Scalar > >
ei_functor_traits< ei_scalar_add_op< Scalar > >
ei_functor_traits< ei_scalar_cast_op< Scalar, NewType > >
ei_functor_traits< ei_scalar_conj_product_op< Scalar > >
ei_functor_traits< ei_scalar_conjugate_op< Scalar > >
ei_functor_traits< ei_scalar_constant_op< Scalar > >
ei_functor_traits< ei_scalar_cos_op< Scalar > >
ei_functor_traits< ei_scalar_cube_op< Scalar > >
ei_functor_traits< ei_scalar_difference_op< Scalar > >
ei_functor_traits< ei_scalar_exp_op< Scalar > >
ei_functor_traits< ei_scalar_hypot_op< Scalar > >
ei_functor_traits< ei_scalar_identity_op< Scalar > >
ei_functor_traits< ei_scalar_imag_op< Scalar > >
ei_functor_traits< ei_scalar_imag_ref_op< Scalar > >
ei_functor_traits< ei_scalar_inverse_op< Scalar > >
ei_functor_traits< ei_scalar_log_op< Scalar > >
ei_functor_traits< ei_scalar_max_op< Scalar > >
ei_functor_traits< ei_scalar_min_op< Scalar > >
ei_functor_traits< ei_scalar_multiple2_op< Scalar1, Scalar2 > >
ei_functor_traits< ei_scalar_multiple_op< Scalar > >
ei_functor_traits< ei_scalar_opposite_op< Scalar > >
ei_functor_traits< ei_scalar_pow_op< Scalar > >
ei_functor_traits< ei_scalar_product_op< LhsScalar, RhsScalar > >
ei_functor_traits< ei_scalar_quotient1_impl< Scalar, false > >
ei_functor_traits< ei_scalar_quotient1_impl< Scalar, true > >
ei_functor_traits< ei_scalar_quotient1_op< Scalar > >
ei_functor_traits< ei_scalar_quotient_op< Scalar > >
ei_functor_traits< ei_scalar_random_op< Scalar > >
ei_functor_traits< ei_scalar_real_op< Scalar > >
ei_functor_traits< ei_scalar_real_ref_op< Scalar > >
ei_functor_traits< ei_scalar_sin_op< Scalar > >
ei_functor_traits< ei_scalar_sqrt_op< Scalar > >
ei_functor_traits< ei_scalar_square_op< Scalar > >
ei_functor_traits< ei_scalar_sum_op< Scalar > >
ei_functor_traits< std::binary_negate< T > >
ei_functor_traits< std::binder1st< T > >
ei_functor_traits< std::binder2nd< T > >
ei_functor_traits< std::divides< T > >
ei_functor_traits< std::equal_to< T > >
ei_functor_traits< std::greater< T > >
ei_functor_traits< std::greater_equal< T > >
ei_functor_traits< std::less< T > >
ei_functor_traits< std::less_equal< T > >
ei_functor_traits< std::logical_and< T > >
ei_functor_traits< std::logical_not< T > >
ei_functor_traits< std::logical_or< T > >
ei_functor_traits< std::minus< T > >
ei_functor_traits< std::multiplies< T > >
ei_functor_traits< std::negate< T > >
ei_functor_traits< std::not_equal_to< T > >
ei_functor_traits< std::plus< T > >
ei_functor_traits< std::unary_negate< T > >
ei_gebp_kernel< LhsScalar, RhsScalar, Index, mr, nr, ConjugateLhs, ConjugateRhs >
ei_gebp_madd_selector< CJ, A, B, C, T >
ei_gebp_madd_selector< CJ, T, T, T, T >
ei_gebp_traits< _LhsScalar, _RhsScalar, _ConjLhs, _ConjRhs >
ei_gebp_traits< RealScalar, std::complex< RealScalar >, false, _ConjRhs >
ei_gebp_traits< std::complex< RealScalar >, RealScalar, _ConjLhs, false >
ei_gebp_traits< std::complex< RealScalar >, std::complex< RealScalar >, _ConjLhs, _ConjRhs >
ei_gemm_blocking_space< StorageOrder, _LhsScalar, _RhsScalar, MaxRows, MaxCols, MaxDepth, false >
ei_gemm_blocking_space< StorageOrder, _LhsScalar, _RhsScalar, MaxRows, MaxCols, MaxDepth, true >
ei_gemm_functor< Scalar, Index, Gemm, Lhs, Rhs, Dest, BlockingType >
ei_gemm_pack_lhs< Scalar, Index, Pack1, Pack2, StorageOrder, Conjugate, PanelMode >
ei_gemm_pack_rhs< Scalar, Index, nr, ColMajor, Conjugate, PanelMode >
ei_gemm_pack_rhs< Scalar, Index, nr, RowMajor, Conjugate, PanelMode >
ei_gemv_selector< OnTheLeft, StorageOrder, BlasCompatible >
ei_gemv_selector< OnTheRight, ColMajor, false >
ei_gemv_selector< OnTheRight, ColMajor, true >
ei_gemv_selector< OnTheRight, RowMajor, false >
ei_gemv_selector< OnTheRight, RowMajor, true >
ei_general_matrix_matrix_product< Index, LhsScalar, LhsStorageOrder, ConjugateLhs, RhsScalar, RhsStorageOrder, ConjugateRhs, ColMajor >
ei_general_matrix_matrix_product< Index, LhsScalar, LhsStorageOrder, ConjugateLhs, RhsScalar, RhsStorageOrder, ConjugateRhs, RowMajor >
ei_general_matrix_vector_product< Index, LhsScalar, ColMajor, ConjugateLhs, RhsScalar, ConjugateRhs >
ei_general_matrix_vector_product< Index, LhsScalar, RowMajor, ConjugateLhs, RhsScalar, ConjugateRhs >
ei_get_boxes_helper< ObjectList, VolumeList, BoxIter >
ei_get_boxes_helper< ObjectList, VolumeList, int >
ei_get_factor< From, To >
ei_get_factor< Scalar, typename NumTraits< Scalar >::Real >
ei_global_math_functions_filtering_base< T, dummy >
ei_global_math_functions_filtering_base< T, typename ei_always_void< typename T::Eigen_BaseClassForSpecializationOfGlobalMathFuncImpl >::type >
ei_has_direct_access< Derived >
ei_has_none
ei_has_std_result_type
ei_has_tr1_result
ei_homogeneous_left_product_impl< Homogeneous< MatrixType, Vertical >, Lhs >
ei_homogeneous_right_product_impl< Homogeneous< MatrixType, Horizontal >, Rhs >
ei_hseq_side_dependent_impl< VectorsType, CoeffsType, Side >
ei_hseq_side_dependent_impl< VectorsType, CoeffsType, OnTheRight >
ei_hypot_impl< Scalar >
ei_hypot_retval< Scalar >
ei_imag_impl< Scalar >
ei_imag_impl< std::complex< RealScalar > >
ei_imag_ref_default_impl< Scalar, IsComplex >
ei_imag_ref_default_impl< Scalar, false >
ei_imag_ref_impl< Scalar >
ei_imag_ref_retval< Scalar >
ei_imag_retval< Scalar >
ei_image_retval< FullPivLU< _MatrixType > >
ei_image_retval_base< _DecompositionType >
ei_increment_if_fixed_size< Size >
ei_inner_stride_at_compile_time< Derived, HasDirectAccess >
ei_inner_stride_at_compile_time< Derived, false >
ei_inplace_transpose_selector< MatrixType, false >
ei_inplace_transpose_selector< MatrixType, true >
ei_intersector_helper1< Volume1, Object1, Object2, Intersector >
ei_intersector_helper2< Volume2, Object2, Object1, Intersector >
ei_inverse_impl< MatrixType >
ei_is_arithmetic< T >
ei_is_arithmetic< __m128 >
ei_is_arithmetic< __m128d >
ei_is_arithmetic< __m128i >
ei_is_arithmetic< bool >
ei_is_arithmetic< char >
ei_is_arithmetic< double >
ei_is_arithmetic< float >
ei_is_arithmetic< long double >
ei_is_arithmetic< signed char >
ei_is_arithmetic< signed int >
ei_is_arithmetic< signed long >
ei_is_arithmetic< signed long long >
ei_is_arithmetic< signed short >
ei_is_arithmetic< unsigned char >
ei_is_arithmetic< unsigned int >
ei_is_arithmetic< unsigned long >
ei_is_arithmetic< unsigned long long >
ei_is_arithmetic< unsigned short >
ei_is_diagonal< T >
ei_is_diagonal< DiagonalBase< T > >
ei_is_diagonal< DiagonalMatrix< T, S > >
ei_is_diagonal< DiagonalWrapper< T > >
ei_is_reference< T >
ei_is_reference< T & >
ei_is_same_type< T, U >
ei_is_same_type< T, T >
ei_kernel_retval< FullPivLU< _MatrixType > >
ei_kernel_retval_base< _DecompositionType >
ei_kiss_cpx_fft< _Scalar >
ei_kissfft_impl< _Scalar >
ei_ldlt_inplace< Lower >
ei_ldlt_inplace< Upper >
ei_level3_blocking< _LhsScalar, _RhsScalar >
ei_linspaced_op< Scalar, RandomAccess >
ei_linspaced_op_impl< Scalar, false >
ei_linspaced_op_impl< Scalar, true >
ei_llt_inplace< Lower >
ei_llt_inplace< Upper >
ei_log_default_impl< Scalar, IsInteger >
ei_log_default_impl< Scalar, true >
ei_log_impl< Scalar >
ei_log_retval< Scalar >
ei_lpNorm_selector< Derived, p >
ei_lpNorm_selector< Derived, 1 >
ei_lpNorm_selector< Derived, 2 >
ei_lpNorm_selector< Derived, Infinity >
Eigen::ei_make_coherent_impl< A, B >
Eigen::ei_make_coherent_impl< A, Matrix< B_Scalar, B_Rows, B_Cols, B_Options, B_MaxRows, B_MaxCols > >
Eigen::ei_make_coherent_impl< Matrix< A_Scalar, A_Rows, A_Cols, A_Options, A_MaxRows, A_MaxCols >, B >
Eigen::ei_make_coherent_impl< Matrix< A_Scalar, A_Rows, A_Cols, A_Options, A_MaxRows, A_MaxCols >, Matrix< B_Scalar, B_Rows, B_Cols, B_Options, B_MaxRows, B_MaxCols > >
ei_make_proper_matrix_type< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols >
ei_makeconst< T >
ei_makeconst< const T & >
ei_makeconst< const T * >
ei_makeconst< const T >
ei_makeconst< T & >
ei_makeconst< T * >
ei_makeconst_return_type< T >
ei_matrix_array< T, Size, MatrixOptions, Alignment >
ei_matrix_array< T, 0, MatrixOptions, Alignment >
ei_matrix_array< T, Size, MatrixOptions, 16 >
ei_matrix_storage< T, Size, _Rows, _Cols, _Options >Stores the data of a matrix
ei_matrix_storage< T, 0, _Rows, _Cols, _Options >
ei_matrix_storage< T, Dynamic, _Rows, Dynamic, _Options >
ei_matrix_storage< T, Dynamic, Dynamic, _Cols, _Options >
ei_matrix_storage< T, Dynamic, Dynamic, Dynamic, _Options >
ei_matrix_storage< T, Size, _Rows, Dynamic, _Options >
ei_matrix_storage< T, Size, Dynamic, _Cols, _Options >
ei_matrix_storage< T, Size, Dynamic, Dynamic, _Options >
ei_matrix_swap_impl< MatrixTypeA, MatrixTypeB, SwapPointers >
ei_matrix_swap_impl< MatrixTypeA, MatrixTypeB, true >
ei_matrix_type_times_scalar_type< OtherScalarType, MatrixType >
ei_max_coeff_visitor< Derived >Visitor computing the max coefficient with its value and coordinates
ei_member_redux< BinaryOp, Scalar >
ei_meta_false
ei_meta_if< Condition, Then, Else >
ei_meta_if< false, Then, Else >
ei_meta_sqrt< Y, InfX, SupX, Done >
ei_meta_sqrt< Y, InfX, SupX, true >
ei_meta_true
ei_min_coeff_visitor< Derived >Visitor computing the min coefficient with its value and coordinates
ei_minimizer_helper1< Volume1, Object1, Object2, Minimizer >
ei_minimizer_helper2< Volume2, Object2, Object1, Minimizer >
ei_must_nest_by_value< T >
ei_nested< T, n, PlainObject >
ei_nested< CoeffBasedProduct< Lhs, Rhs, EvalBeforeNestingBit|EvalBeforeAssigningBit >, N, PlainObject >
ei_nested< GeneralProduct< Lhs, Rhs, Mode >, N, PlainObject >
ei_nested< ReturnByValue< Derived >, n, PlainObject >
ei_no_assignment_operator
ei_norm1_default_impl< Scalar, IsComplex >
ei_norm1_default_impl< Scalar, false >
ei_norm1_impl< Scalar >
ei_norm1_retval< Scalar >
ei_outer_product_selector< ColMajor >
ei_outer_product_selector< RowMajor >
ei_outer_stride_at_compile_time< Derived, HasDirectAccess >
ei_outer_stride_at_compile_time< Derived, false >
ei_packet_traits< T >
ei_packet_traits< double >
ei_packet_traits< float >
ei_packet_traits< int >
ei_packet_traits< std::complex< double > >
ei_packet_traits< std::complex< float > >
ei_palign_impl< Offset, PacketType >
ei_palign_impl< Offset, Packet1cd >
ei_palign_impl< Offset, Packet2cf >
ei_palign_impl< Offset, Packet2d >
ei_palign_impl< Offset, Packet4f >
ei_palign_impl< Offset, Packet4i >
ei_partial_lu_impl< Scalar, StorageOrder >
ei_permut_matrix_product_retval< PermutationType, MatrixType, Side, Transposed >
ei_plain_col_type< MatrixType, Scalar >
ei_plain_diag_type< MatrixType, Scalar >
ei_plain_matrix_type< T, Dense >
ei_plain_matrix_type< T, Sparse >
ei_plain_matrix_type_column_major< T >
ei_plain_matrix_type_dense< T, ArrayXpr >
ei_plain_matrix_type_dense< T, MatrixXpr >
ei_plain_matrix_type_row_major< T >
ei_plain_row_type< MatrixType, Scalar >
ei_pow_default_impl
ei_pow_default_impl< Scalar, true >
ei_pow_impl< Scalar >
ei_pow_retval< Scalar >
ei_product_coeff_impl< DefaultTraversal, 0, Lhs, Rhs, RetScalar >
ei_product_coeff_impl< DefaultTraversal, Dynamic, Lhs, Rhs, RetScalar >
ei_product_coeff_impl< DefaultTraversal, UnrollingIndex, Lhs, Rhs, RetScalar >
ei_product_coeff_impl< InnerVectorizedTraversal, Dynamic, Lhs, Rhs, RetScalar >
ei_product_coeff_impl< InnerVectorizedTraversal, UnrollingIndex, Lhs, Rhs, RetScalar >
ei_product_coeff_vectorized_dyn_selector< Lhs, Rhs, LhsRows, RhsCols >
ei_product_coeff_vectorized_dyn_selector< Lhs, Rhs, 1, 1 >
ei_product_coeff_vectorized_dyn_selector< Lhs, Rhs, 1, RhsCols >
ei_product_coeff_vectorized_dyn_selector< Lhs, Rhs, LhsRows, 1 >
ei_product_coeff_vectorized_unroller< UnrollingIndex, Lhs, Rhs, Packet >
ei_product_coeff_vectorized_unroller< 0, Lhs, Rhs, Packet >
ei_product_packet_impl< ColMajor, 0, Lhs, Rhs, Packet, LoadMode >
ei_product_packet_impl< ColMajor, Dynamic, Lhs, Rhs, Packet, LoadMode >
ei_product_packet_impl< ColMajor, UnrollingIndex, Lhs, Rhs, Packet, LoadMode >
ei_product_packet_impl< RowMajor, 0, Lhs, Rhs, Packet, LoadMode >
ei_product_packet_impl< RowMajor, Dynamic, Lhs, Rhs, Packet, LoadMode >
ei_product_packet_impl< RowMajor, UnrollingIndex, Lhs, Rhs, Packet, LoadMode >
ei_product_selfadjoint_matrix< Scalar, Index, LhsStorageOrder, false, ConjugateLhs, RhsStorageOrder, true, ConjugateRhs, ColMajor >
ei_product_selfadjoint_matrix< Scalar, Index, LhsStorageOrder, LhsSelfAdjoint, ConjugateLhs, RhsStorageOrder, RhsSelfAdjoint, ConjugateRhs, RowMajor >
ei_product_selfadjoint_matrix< Scalar, Index, LhsStorageOrder, true, ConjugateLhs, RhsStorageOrder, false, ConjugateRhs, ColMajor >
ei_product_triangular_matrix_matrix< Scalar, Index, Mode, false, LhsStorageOrder, ConjugateLhs, RhsStorageOrder, ConjugateRhs, ColMajor >
ei_product_triangular_matrix_matrix< Scalar, Index, Mode, LhsIsTriangular, LhsStorageOrder, ConjugateLhs, RhsStorageOrder, ConjugateRhs, RowMajor >
ei_product_triangular_matrix_matrix< Scalar, Index, Mode, true, LhsStorageOrder, ConjugateLhs, RhsStorageOrder, ConjugateRhs, ColMajor >
ei_product_triangular_vector_selector< false, Lhs, Rhs, Result, Mode, ConjLhs, ConjRhs, StorageOrder >
ei_product_triangular_vector_selector< true, Lhs, Rhs, Result, Mode, ConjLhs, ConjRhs, ColMajor >
ei_product_triangular_vector_selector< true, Lhs, Rhs, Result, Mode, ConjLhs, ConjRhs, RowMajor >
ei_product_type< Lhs, Rhs >
ei_product_type_selector< 1, 1, 1 >
ei_product_type_selector< 1, 1, Depth >
ei_product_type_selector< 1, Large, Large >
ei_product_type_selector< 1, Large, Small >
ei_product_type_selector< 1, Small, Large >
ei_product_type_selector< 1, Small, Small >
ei_product_type_selector< Large, 1, Large >
ei_product_type_selector< Large, 1, Small >
ei_product_type_selector< Large, Large, Large >
ei_product_type_selector< Large, Large, Small >
ei_product_type_selector< Large, Small, 1 >
ei_product_type_selector< Large, Small, Large >
ei_product_type_selector< Large, Small, Small >
ei_product_type_selector< M, N, 1 >
ei_product_type_selector< Small, 1, Large >
ei_product_type_selector< Small, 1, Small >
ei_product_type_selector< Small, Large, 1 >
ei_product_type_selector< Small, Large, Large >
ei_product_type_selector< Small, Large, Small >
ei_product_type_selector< Small, Small, 1 >
ei_product_type_selector< Small, Small, Large >
ei_product_type_selector< Small, Small, Small >
ei_projective_transform_inverse< TransformType, Mode >
ei_projective_transform_inverse< TransformType, Projective >
ei_promote_index_type< I1, I2 >
ei_promote_storage_type< A, A >
ei_promote_storage_type< Dense, Sparse >
ei_promote_storage_type< Sparse, Dense >
ei_quat_product< Arch, Derived1, Derived2, Scalar, PacketAccess >
ei_quat_product< Architecture::SSE, Derived, OtherDerived, double, Aligned >
ei_quat_product< Architecture::SSE, Derived, OtherDerived, float, Aligned >
ei_quaternionbase_assign_impl< Other, 3, 3 >
ei_quaternionbase_assign_impl< Other, 4, 1 >
ei_random_default_impl
ei_random_default_impl< Scalar, false, false >
ei_random_default_impl< Scalar, false, true >
ei_random_default_impl< Scalar, true, false >
ei_random_impl< Scalar >
ei_random_impl< bool >
ei_random_retval< Scalar >
ei_real_impl< Scalar >
ei_real_impl< std::complex< RealScalar > >
ei_real_ref_impl< Scalar >
ei_real_ref_retval< Scalar >
ei_real_retval< Scalar >
ei_redux_impl< Func, Derived, DefaultTraversal, CompleteUnrolling >
ei_redux_impl< Func, Derived, DefaultTraversal, NoUnrolling >
ei_redux_impl< Func, Derived, LinearVectorizedTraversal, CompleteUnrolling >
ei_redux_impl< Func, Derived, LinearVectorizedTraversal, NoUnrolling >
ei_redux_impl< Func, Derived, SliceVectorizedTraversal, NoUnrolling >
ei_redux_novec_unroller< Func, Derived, Start, Length >
ei_redux_novec_unroller< Func, Derived, Start, 0 >
ei_redux_novec_unroller< Func, Derived, Start, 1 >
ei_redux_traits< Func, Derived >
ei_redux_vec_unroller< Func, Derived, Start, Length >
ei_redux_vec_unroller< Func, Derived, Start, 1 >
ei_ref_selector< T >
ei_result_of< T >
ei_result_of< Func(ArgType)>
ei_result_of< Func(ArgType0, ArgType1)>
ei_reverse_packet_cond< PacketScalar, ReversePacket >
ei_reverse_packet_cond< PacketScalar, false >
ei_rotation_base_generic_product_selector< RotationDerived, DiagonalMatrix< Scalar, Dim, MaxDim >, false >
ei_rotation_base_generic_product_selector< RotationDerived, MatrixType, false >
ei_rotation_base_generic_product_selector< RotationDerived, OtherVectorType, true >
ei_scalar_abs2_op< Scalar >Template functor to compute the squared absolute value of a scalar
ei_scalar_abs_op< Scalar >Template functor to compute the absolute value of a scalar
ei_scalar_add_op< Scalar >Template functor to add a scalar to a fixed other one
ei_scalar_cast_op< Scalar, NewType >Template functor to cast a scalar to another type
ei_scalar_conj_product_op< Scalar >Template functor to compute the conjugate product of two scalars
ei_scalar_conjugate_op< Scalar >Template functor to compute the conjugate of a complex value
ei_scalar_constant_op< Scalar >
ei_scalar_cos_op< Scalar >Template functor to compute the cosine of a scalar
ei_scalar_cube_op< Scalar >Template functor to compute the cube of a scalar
ei_scalar_difference_op< Scalar >Template functor to compute the difference of two scalars
ei_scalar_exp_op< Scalar >Template functor to compute the exponential of a scalar
ei_scalar_fuzzy_default_impl
ei_scalar_fuzzy_default_impl< Scalar, false, false >
ei_scalar_fuzzy_default_impl< Scalar, false, true >
ei_scalar_fuzzy_default_impl< Scalar, true, false >
ei_scalar_fuzzy_impl< Scalar >
ei_scalar_fuzzy_impl< bool >
ei_scalar_hypot_op< Scalar >Template functor to compute the hypot of two scalars
ei_scalar_identity_op< Scalar >
ei_scalar_imag_op< Scalar >Template functor to extract the imaginary part of a complex
ei_scalar_imag_ref_op< Scalar >Template functor to extract the imaginary part of a complex as a reference
ei_scalar_inverse_op< Scalar >Template functor to compute the inverse of a scalar
ei_scalar_log_op< Scalar >Template functor to compute the logarithm of a scalar
ei_scalar_max_op< Scalar >Template functor to compute the max of two scalars
ei_scalar_min_op< Scalar >Template functor to compute the min of two scalars
ei_scalar_multiple2_op< Scalar1, Scalar2 >
ei_scalar_multiple_op< Scalar >Template functor to multiply a scalar by a fixed other one
ei_scalar_opposite_op< Scalar >Template functor to compute the opposite of a scalar
ei_scalar_pow_op< Scalar >Template functor to raise a scalar to a power
ei_scalar_product_op< LhsScalar, RhsScalar >Template functor to compute the product of two scalars
Eigen::ei_scalar_product_traits< A_Scalar, Matrix< A_Scalar, A_Rows, A_Cols, A_Options, A_MaxRows, A_MaxCols > >
Eigen::ei_scalar_product_traits< AutoDiffScalar< DerType >, T >
Eigen::ei_scalar_product_traits< Matrix< A_Scalar, A_Rows, A_Cols, A_Options, A_MaxRows, A_MaxCols >, A_Scalar >
ei_scalar_product_traits< std::complex< T >, T >
ei_scalar_product_traits< T, std::complex< T > >
ei_scalar_product_traits< T, T >
ei_scalar_quotient1_impl< Scalar, IsInteger >
ei_scalar_quotient1_impl< Scalar, true >
ei_scalar_quotient1_op< Scalar >Template functor to divide a scalar by a fixed other one
ei_scalar_quotient_op< Scalar >Template functor to compute the quotient of two scalars
ei_scalar_random_op< Scalar >
ei_scalar_real_op< Scalar >Template functor to extract the real part of a complex
ei_scalar_real_ref_op< Scalar >Template functor to extract the real part of a complex as a reference
ei_scalar_sin_op< Scalar >Template functor to compute the sine of a scalar
ei_scalar_sqrt_op< Scalar >Template functor to compute the square root of a scalar
ei_scalar_square_op< Scalar >Template functor to compute the square of a scalar
ei_scalar_sum_op< Scalar >Template functor to compute the sum of two scalars
ei_selfadjoint_product< Scalar, Index, MatStorageOrder, ColMajor, AAT, UpLo >
ei_selfadjoint_product< Scalar, Index, MatStorageOrder, RowMajor, AAT, UpLo >
ei_selfadjoint_rank2_update_selector< Scalar, Index, UType, VType, Lower >
ei_selfadjoint_rank2_update_selector< Scalar, Index, UType, VType, Upper >
ei_setIdentity_impl< Derived, Big >
ei_setIdentity_impl< Derived, true >
ei_significant_decimals_default_impl< Scalar, IsInteger >
ei_significant_decimals_default_impl< Scalar, true >
ei_significant_decimals_impl< Scalar >
ei_sin_default_impl< Scalar, IsInteger >
ei_sin_default_impl< Scalar, true >
ei_sin_impl< Scalar >
ei_sin_retval< Scalar >
ei_size_at_compile_time< _Rows, _Cols >
ei_skyline_product_selector< Lhs, Rhs, ResultType, ColMajor >
ei_skyline_product_selector< Lhs, Rhs, ResultType, RowMajor >
ei_solve_retval< ColPivHouseholderQR< _MatrixType >, Rhs >
ei_solve_retval< FullPivHouseholderQR< _MatrixType >, Rhs >
ei_solve_retval< FullPivLU< _MatrixType >, Rhs >
ei_solve_retval< HouseholderQR< _MatrixType >, Rhs >
ei_solve_retval< LDLT< _MatrixType, _UpLo >, Rhs >
ei_solve_retval< LLT< _MatrixType, UpLo >, Rhs >
ei_solve_retval< PartialPivLU< _MatrixType >, Rhs >
ei_solve_retval< SVD< _MatrixType >, Rhs >
ei_solve_retval_base< _DecompositionType, Rhs >
ei_sparse_cwise_binary_op_inner_iterator_selector< BinaryOp, Lhs, Rhs, Derived, Sparse, Sparse >
ei_sparse_cwise_binary_op_inner_iterator_selector< ei_scalar_product_op< T >, Lhs, Rhs, Derived, Dense, Sparse >
ei_sparse_cwise_binary_op_inner_iterator_selector< ei_scalar_product_op< T >, Lhs, Rhs, Derived, Sparse, Dense >
ei_sparse_cwise_binary_op_inner_iterator_selector< ei_scalar_product_op< T >, Lhs, Rhs, Derived, Sparse, Sparse >
ei_sparse_diagonal_product_inner_iterator_selector< Lhs, Rhs, SparseDiagonalProductType, SDP_IsDiagonal, SDP_IsSparseColMajor >
ei_sparse_diagonal_product_inner_iterator_selector< Lhs, Rhs, SparseDiagonalProductType, SDP_IsDiagonal, SDP_IsSparseRowMajor >
ei_sparse_diagonal_product_inner_iterator_selector< Lhs, Rhs, SparseDiagonalProductType, SDP_IsSparseColMajor, SDP_IsDiagonal >
ei_sparse_diagonal_product_inner_iterator_selector< Lhs, Rhs, SparseDiagonalProductType, SDP_IsSparseRowMajor, SDP_IsDiagonal >
ei_sparse_product_selector2< Lhs, Rhs, ResultType, ColMajor, ColMajor, ColMajor >
ei_sparse_product_selector2< Lhs, Rhs, ResultType, ColMajor, ColMajor, RowMajor >
ei_sparse_product_selector2< Lhs, Rhs, ResultType, ColMajor, RowMajor, ColMajor >
ei_sparse_product_selector2< Lhs, Rhs, ResultType, ColMajor, RowMajor, RowMajor >
ei_sparse_product_selector2< Lhs, Rhs, ResultType, RowMajor, ColMajor, ColMajor >
ei_sparse_product_selector2< Lhs, Rhs, ResultType, RowMajor, ColMajor, RowMajor >
ei_sparse_product_selector2< Lhs, Rhs, ResultType, RowMajor, RowMajor, ColMajor >
ei_sparse_product_selector2< Lhs, Rhs, ResultType, RowMajor, RowMajor, RowMajor >
ei_sparse_product_selector< Lhs, Rhs, ResultType, ColMajor, ColMajor, ColMajor >
ei_sparse_product_selector< Lhs, Rhs, ResultType, ColMajor, ColMajor, RowMajor >
ei_sparse_product_selector< Lhs, Rhs, ResultType, RowMajor, RowMajor, ColMajor >
ei_sparse_product_selector< Lhs, Rhs, ResultType, RowMajor, RowMajor, RowMajor >
ei_sparse_solve_triangular_selector< Lhs, Rhs, Mode, Lower, ColMajor >
ei_sparse_solve_triangular_selector< Lhs, Rhs, Mode, Lower, RowMajor >
ei_sparse_solve_triangular_selector< Lhs, Rhs, Mode, Upper, ColMajor >
ei_sparse_solve_triangular_selector< Lhs, Rhs, Mode, Upper, RowMajor >
ei_sparse_solve_triangular_sparse_selector< Lhs, Rhs, Mode, UpLo, ColMajor >
ei_special_scalar_op_base< Derived, Scalar, OtherScalar, EnableIt >
ei_special_scalar_op_base< Derived, Scalar, OtherScalar, true >
ei_sqrt_default_impl< Scalar, IsInteger >
ei_sqrt_default_impl< Scalar, true >
ei_sqrt_impl< Scalar >
ei_sqrt_retval< Scalar >
ei_static_assert< condition >
ei_static_assert< true >
ei_stem_function< Scalar >
ei_svd_precondition_2x2_block_to_be_real< MatrixType, Options, IsComplex >
ei_svd_precondition_2x2_block_to_be_real< MatrixType, Options, false >
ei_svd_precondition_2x2_block_to_be_real< MatrixType, Options, true >
ei_svd_precondition_if_more_cols_than_rows< MatrixType, Options, PossiblyMoreColsThanRows >
ei_svd_precondition_if_more_cols_than_rows< MatrixType, Options, true >
ei_svd_precondition_if_more_rows_than_cols< MatrixType, Options, PossiblyMoreRowsThanCols >
ei_svd_precondition_if_more_rows_than_cols< MatrixType, Options, true >
ei_sybb_kernel< Scalar, Index, mr, nr, ConjLhs, ConjRhs, UpLo >
ei_symm_pack_lhs< Scalar, Index, Pack1, Pack2, StorageOrder >
ei_symm_pack_rhs< Scalar, Index, nr, StorageOrder >
ei_traits< AngleAxis< _Scalar > >
ei_traits< Array< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols > >
ei_traits< ArrayWrapper< ExpressionType > >
ei_traits< BandMatrix< _Scalar, Rows, Cols, Supers, Subs, Options > >
ei_traits< Block< XprType, BlockRows, BlockCols, InnerPanel, HasDirectAccess > >
ei_traits< CoeffBasedProduct< LhsNested, RhsNested, NestingFlags > >
ei_traits< CwiseBinaryOp< BinaryOp, Lhs, Rhs > >
ei_traits< CwiseNullaryOp< NullaryOp, PlainObjectType > >
ei_traits< CwiseUnaryOp< UnaryOp, XprType > >
ei_traits< CwiseUnaryView< ViewOp, MatrixType > >
ei_traits< DenseTimeSparseProduct< Lhs, Rhs > >
ei_traits< DenseTimeSparseSelfAdjointProduct< Lhs, Rhs, UpLo > >
ei_traits< Diagonal< MatrixType, DiagIndex > >
ei_traits< DiagonalMatrix< _Scalar, SizeAtCompileTime, MaxSizeAtCompileTime > >
ei_traits< DiagonalProduct< MatrixType, DiagonalType, ProductOrder > >
ei_traits< DiagonalWrapper< _DiagonalVectorType > >
ei_traits< DynamicSparseMatrix< _Scalar, _Flags, _Index > >
ei_traits< ei_homogeneous_left_product_impl< Homogeneous< MatrixType, Vertical >, Lhs > >
ei_traits< ei_homogeneous_right_product_impl< Homogeneous< MatrixType, Horizontal >, Rhs > >
ei_traits< ei_image_retval_base< DecompositionType > >
ei_traits< ei_inverse_impl< MatrixType > >
ei_traits< ei_kernel_retval_base< DecompositionType > >
ei_traits< ei_permut_matrix_product_retval< PermutationType, MatrixType, Side, Transposed > >
ei_traits< ei_solve_retval_base< DecompositionType, Rhs > >
ei_traits< ei_transposition_matrix_product_retval< TranspositionType, MatrixType, Side, Transposed > >
ei_traits< Flagged< ExpressionType, Added, Removed > >
ei_traits< ForceAlignedAccess< ExpressionType > >
ei_traits< GeneralProduct< Lhs, Rhs, GemmProduct > >
ei_traits< GeneralProduct< Lhs, Rhs, GemvProduct > >
ei_traits< GeneralProduct< Lhs, Rhs, InnerProduct > >
ei_traits< GeneralProduct< Lhs, Rhs, OuterProduct > >
ei_traits< HessenbergDecompositionMatrixHReturnType< MatrixType > >
ei_traits< Homogeneous< MatrixType, Direction > >
ei_traits< HouseholderSequence< VectorsType, CoeffsType, Side > >
ei_traits< Map< PlainObjectType, MapOptions, StrideType > >
ei_traits< Map< Quaternion< _Scalar >, _PacketAccess > >
ei_traits< MappedSparseMatrix< _Scalar, _Flags, _Index > >
ei_traits< Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols > >
ei_traits< MatrixExponentialReturnValue< Derived > >
ei_traits< MatrixFunctionReturnValue< Derived > >
ei_traits< MatrixWrapper< ExpressionType > >
ei_traits< Minor< MatrixType > >
ei_traits< NestByValue< ExpressionType > >
ei_traits< PartialReduxExpr< MatrixType, MemberOp, Direction > >
ei_traits< PermutationMatrix< SizeAtCompileTime, MaxSizeAtCompileTime > >
ei_traits< ProductBase< Derived, _Lhs, _Rhs > >
ei_traits< Quaternion< _Scalar > >
ei_traits< Replicate< MatrixType, RowFactor, ColFactor > >
ei_traits< ReturnByValue< Derived > >
ei_traits< Reverse< MatrixType, Direction > >
ei_traits< Rotation2D< _Scalar > >
ei_traits< ScaledProduct< NestedProduct > >
ei_traits< Select< ConditionMatrixType, ThenMatrixType, ElseMatrixType > >
ei_traits< SelfadjointProductMatrix< Lhs, 0, true, Rhs, RhsMode, false > >
ei_traits< SelfadjointProductMatrix< Lhs, LhsMode, false, Rhs, 0, true > >
ei_traits< SelfadjointProductMatrix< Lhs, LhsMode, false, Rhs, RhsMode, false > >
ei_traits< SelfAdjointView< MatrixType, UpLo > >
ei_traits< SelfCwiseBinaryOp< BinaryOp, Lhs, Rhs > >
ei_traits< SkylineMatrix< _Scalar, _Options > >
ei_traits< SkylineProduct< LhsNested, RhsNested, ProductMode > >
ei_traits< SparseDenseOuterProduct< Lhs, Rhs, Tr > >
ei_traits< SparseDiagonalProduct< Lhs, Rhs > >
ei_traits< SparseInnerVectorSet< MatrixType, Size > >
ei_traits< SparseMatrix< _Scalar, _Options, _Index > >
ei_traits< SparseSelfAdjointTimeDenseProduct< Lhs, Rhs, UpLo > >
ei_traits< SparseSparseProduct< LhsNested, RhsNested > >
ei_traits< SparseTimeDenseProduct< Lhs, Rhs > >
ei_traits< SparseTriangularView< MatrixType, Mode > >
ei_traits< SparseVector< _Scalar, _Options, _Index > >
ei_traits< SparseView< MatrixType > >
ei_traits< SwapWrapper< ExpressionType > >
ei_traits< Transpose< MatrixType > >
ei_traits< Transpose< PermutationMatrix< SizeAtCompileTime, MaxSizeAtCompileTime > > >
ei_traits< TriangularProduct< Mode, LhsIsTriangular, Lhs, false, Rhs, false > >
ei_traits< TriangularProduct< Mode, LhsIsTriangular, Lhs, false, Rhs, true > >
ei_traits< TriangularProduct< Mode, LhsIsTriangular, Lhs, true, Rhs, false > >
ei_traits< TriangularView< MatrixType, _Mode > >
ei_traits< VectorBlock< VectorType, Size > >
ei_transform_construct_from_matrix< Other, AffineCompact, Dim, HDim, HDim, HDim >
ei_transform_construct_from_matrix< Other, Mode, Dim, HDim, Dim, Dim >
ei_transform_construct_from_matrix< Other, Mode, Dim, HDim, Dim, HDim >
ei_transform_construct_from_matrix< Other, Mode, Dim, HDim, HDim, HDim >
ei_transform_left_product_impl< Other, AffineCompact, Dim, HDim, Dim, HDim >
ei_transform_left_product_impl< Other, AffineCompact, Dim, HDim, HDim, HDim >
ei_transform_left_product_impl< Other, Mode, Dim, HDim, Dim, Dim >
ei_transform_left_product_impl< Other, Mode, Dim, HDim, Dim, HDim >
ei_transform_left_product_impl< Other, Mode, Dim, HDim, HDim, HDim >
ei_transform_product_result< LhsMode, RhsMode >
ei_transform_right_product_impl< TransformType, MatrixType, false >
ei_transform_right_product_impl< TransformType, MatrixType, true >
ei_transform_take_affine_part< TransformType >
ei_transform_take_affine_part< Transform< Scalar, Dim, AffineCompact > >
ei_transform_traits< Transform >
ei_transform_transform_product_impl< Transform< Scalar, Dim, LhsMode >, Transform< Scalar, Dim, RhsMode >, false >
ei_transform_transform_product_impl< Transform< Scalar, Dim, LhsMode >, Transform< Scalar, Dim, RhsMode >, true >
ei_TransposeImpl_base< MatrixType, HasDirectAccess >
ei_TransposeImpl_base< MatrixType, false >
ei_transposition_matrix_product_retval< TranspositionType, MatrixType, Side, Transposed >
ei_triangular_assignment_selector< Derived1, Derived2, Mode, UnrollCount, ClearOpposite >
ei_triangular_assignment_selector< Derived1, Derived2, Lower, Dynamic, ClearOpposite >
ei_triangular_assignment_selector< Derived1, Derived2, Mode, 0, ClearOpposite >
ei_triangular_assignment_selector< Derived1, Derived2, SelfAdjoint|Lower, 0, ClearOpposite >
ei_triangular_assignment_selector< Derived1, Derived2, SelfAdjoint|Lower, Dynamic, ClearOpposite >
ei_triangular_assignment_selector< Derived1, Derived2, SelfAdjoint|Upper, 0, ClearOpposite >
ei_triangular_assignment_selector< Derived1, Derived2, SelfAdjoint|Upper, Dynamic, ClearOpposite >
ei_triangular_assignment_selector< Derived1, Derived2, StrictlyLower, Dynamic, ClearOpposite >
ei_triangular_assignment_selector< Derived1, Derived2, StrictlyUpper, Dynamic, ClearOpposite >
ei_triangular_assignment_selector< Derived1, Derived2, UnitLower, Dynamic, ClearOpposite >
ei_triangular_assignment_selector< Derived1, Derived2, UnitUpper, Dynamic, ClearOpposite >
ei_triangular_assignment_selector< Derived1, Derived2, Upper, Dynamic, ClearOpposite >
ei_triangular_assignment_selector< Derived1, Derived2,(SelfAdjoint|Lower), UnrollCount, ClearOpposite >
ei_triangular_assignment_selector< Derived1, Derived2,(SelfAdjoint|Upper), UnrollCount, ClearOpposite >
ei_triangular_solve_matrix< Scalar, Index, OnTheLeft, Mode, Conjugate, TriStorageOrder, ColMajor >
ei_triangular_solve_matrix< Scalar, Index, OnTheRight, Mode, Conjugate, TriStorageOrder, ColMajor >
ei_triangular_solve_matrix< Scalar, Index, Side, Mode, Conjugate, TriStorageOrder, RowMajor >
ei_triangular_solver_selector< Lhs, Rhs, OnTheLeft, Mode, CompleteUnrolling, StorageOrder, 1 >
ei_triangular_solver_selector< Lhs, Rhs, OnTheLeft, Mode, NoUnrolling, ColMajor, 1 >
ei_triangular_solver_selector< Lhs, Rhs, OnTheLeft, Mode, NoUnrolling, RowMajor, 1 >
ei_triangular_solver_selector< Lhs, Rhs, OnTheRight, Mode, Unrolling, StorageOrder, 1 >
ei_triangular_solver_selector< Lhs, Rhs, Side, Mode, NoUnrolling, StorageOrder, Dynamic >
ei_triangular_solver_unroller< Lhs, Rhs, Mode, Index, Size, false >
ei_triangular_solver_unroller< Lhs, Rhs, Mode, Index, Size, true >
ei_tridiagonalization_inplace_selector< MatrixType, Size, IsComplex >
ei_tridiagonalization_inplace_selector< MatrixType, 1, IsComplex >
ei_tridiagonalization_inplace_selector< MatrixType, 3, false >
ei_trsolve_traits< Lhs, Rhs, Side >
ei_unaligned_assign_impl< IsAligned >
ei_unaligned_assign_impl< false >
ei_unary_result_of_select< Func, ArgType, SizeOf >
ei_unary_result_of_select< Func, ArgType, sizeof(ei_has_std_result_type)>
ei_unary_result_of_select< Func, ArgType, sizeof(ei_has_tr1_result)>
ei_unconst< T >
ei_unconst< const T >
ei_unconst< T const & >
ei_unconst< T const * >
ei_unitOrthogonal_selector< Derived, Size >
ei_unitOrthogonal_selector< Derived, 2 >
ei_unitOrthogonal_selector< Derived, 3 >
ei_unpacket_traits< T >
ei_unpacket_traits< Packet1cd >
ei_unpacket_traits< Packet2cf >
ei_unpacket_traits< Packet2d >
ei_unpacket_traits< Packet4f >
ei_unpacket_traits< Packet4i >
ei_unpointer< T >
ei_unpointer< T * >
ei_unpointer< T *const >
ei_unref< T >
ei_unref< T & >
ei_variable_if_dynamic< T, Value >
ei_variable_if_dynamic< T, Dynamic >
ei_vector_int_pair< Scalar, Dim >
ei_visitor_impl< Visitor, Derived, UnrollCount >
ei_visitor_impl< Visitor, Derived, 1 >
ei_visitor_impl< Visitor, Derived, Dynamic >
eigen2_interface< real, SIZE >
EigenBase< Derived >
gdb::printers::EigenMatrixPrinter
gdb::printers::EigenQuaternionPrinter
EigenSolver< _MatrixType >Computes eigenvalues and eigenvectors of general matrices
Feel::Elaxi< Order, Entity >
Feel::FunctionSpace< A0, A1, A2, A3, A4 >::Element< T, Cont >
Feel::SubFaceOf< ElementType >::Element< ET >
Feel::SubFaceOfNone::Element< ET >
Feel::DofTable< MeshType, FEType, PeriodicityType >::element_access
Feel::meta::elements< MeshType >
gmm::elt_rsvector_< T >
gmm::elt_rsvector_value_less_< T >
Feel::Entity< ShapeE, T >
Feel::Entity< SHAPE_HEXA, T >
Feel::Entity< SHAPE_LINE, T >
Feel::Entity< SHAPE_QUAD, T >
Feel::Entity< SHAPE_TETRA, T >
Feel::Entity< SHAPE_TRIANGLE, T >
Feel::EnvironmentInitialize, finalize, and query the Feel++ environment
Feel::equalities< Data >Define the equalities type
equality_comparable
Feel::EthierSteinman
EulerAngles< _Scalar >
Feel::ExactSolution< Dim >
Feel::ExactSolution< 1 >
Feel::ExactSolution< 2 >
Feel::ExactSolution< 3 >
Feel::FactoryDefaultError< IdentifierType, AbstractProduct >::Exception
dal::exception_callback
dal::exception_callback_debug
Feel::Exporter< MeshType, N >Export Feel generated data to some file formatsUse the visitor and factory pattern
Feel::ExporterEnsight< MeshType, N >Exporter to Ensight format
Feel::ExporterGmsh< MeshType, N >Exporter to GMSH format
Feel::ExporterGnuplot< MeshType >Exporter to GNUPLOT format
Feel::ExporterQuick< MeshType >Simple interface to exporter
Feel::ExprBaseBase class for expression
VectorwiseOp< ExpressionType, Direction >::ExtendedType< OtherDerived >
Feel::detail::extract_all_poly_indices< T >
EyeReturn an identity matrix
F
f77_interface< real >
f77_interface< float >
f77_interface_base< real >
Feel::f_Nx
Feel::f_Ny
Feel::f_Px
Feel::f_sinPx
Feel::PointSetQuadrature< Convex, Integration_Degree, T >::Face
Feel::DofTable< MeshType, FEType, PeriodicityType >::face_access
Feel::GeoMap< Dim, Order, T, Entity, PP >::face_gm< N >
Feel::Simplex< Dim, Order, RDim >::faces_t< rdim >
Feel::Hypercube< Dim, Order, RDim >::faces_t< rdim >
Feel::Exporter< MeshType, N >::Factory
Feel::Gmsh::Factory
Feel::Factory< AbstractProduct, IdentifierType, ProductCreator, FactoryErrorPolicy >Implements a generic object Factory
Feel::Partitioner< Mesh >::Factory
Feel::FactoryClone< AbstractProduct, ProductCreator, FactoryErrorPolicy >Implements a generic cloning object Factory
Feel::FactoryDefaultError< IdentifierType, AbstractProduct >
dal::failure_error
FancySpheres
Fekete
Feel::detail::Field< N, M >
Feel::Field< M >
dal::file_not_found_error
Feel::FilterFromVtk< MeshType >
Feel::FilterFromVtk3D< MeshType >
Feel::FiniteElement< P, PDual, Pts >Finite element following Ciarlet framework
Flagged< ExpressionType, Added, Removed >Expression with modified flags
ForceAlignedAccess< ExpressionType >Enforce aligned packet loads and stores regardless of what is requested
Frame
Feel::FsFunctional< Space >
Feel::FsFunctionalLinear< Space >
FullPivHouseholderQR< _MatrixType >Householder rank-revealing QR decomposition of a matrix with full pivoting
FullPivLU< _MatrixType >LU decomposition of a matrix with complete pivoting, and related features
Feel::Functional< Space >Linear functional
Feel::functional< Data >Defines the functional type
Feel::FunctionalSet< Space >Set of functionals
Feel::FunctionSpace< A0, A1, A2, A3, A4 >
Feel::FunctionSpaceBase
Functor< _Scalar, NX, NY >
gmm::g_mult
Feel::Gauss< Convex, Integration_Degree, T >Gauss quadrature points
Feel::Gauss< Simplex< 0, 1 >, Integration_Degree, T >
Feel::GaussLobatto< Convex, Integration_Degree, T >Gauss quadrature points
GemmParallelInfo< Index >
gmm::gen_col_vector< PT >
gmm::gen_col_vector_iterator< PT >
gmm::gen_row_vector< PT >
gmm::gen_row_vector_iterator< PT >
gmm::gen_sub_col_matrix< PT, SUBI1, SUBI2 >
gmm::gen_sub_col_matrix_iterator< PT, SUBI1, SUBI2 >
gmm::gen_sub_row_matrix< PT, SUBI1, SUBI2 >
gmm::gen_sub_row_matrix_iterator< PT, SUBI1, SUBI2 >
GeneralizedSelfAdjointEigenSolver< _MatrixType >Computes eigenvalues and eigenvectors of the generalized selfadjoint eigen problem
GeneralProductExpression of the product of two general matrices or vectors
GeneralProduct< Lhs, Rhs, GemmProduct >
GeneralProduct< Lhs, Rhs, GemvProduct >
GeneralProduct< Lhs, Rhs, InnerProduct >
GeneralProduct< Lhs, Rhs, OuterProduct >
GenericNumTraits< T >
Feel::Geo0D< Dim, T >
Feel::GeoElement0D< Dim, SubFace, T >
Feel::GeoElement1D< Dim, GEOSHAPE, SubFace, T >Class for 1D elements
Feel::GeoElement2D< Dim, GEOSHAPE, SubFace, T >Class for 2D elements
Feel::GeoElement3D< Dim, GEOSHAPE, T >Class for 3D elements
Feel::GeoEntity< Entity >Base class for all geometric entities
Feel::GeoTool::GeoGMSHTool
Feel::GeoMap< Dim, Order, T, Entity, PP >Structure for the geometrical mapping
Feel::GeomapInverse
Feel::GeoMapInverse< Dim, Order, T, Entity >Handles the geometric inversion for a given (supposedly quite large) set of points
Feel::GeoMap< Dim, Order, T, Entity, PP >::Inverse::GeomapInverseConvex
Feel::GeoND< Dim, GEOSHAPE, T, POINTTYPE >Base class for Multi-dimensional basis Geometrical Entities
GEOSHAPE
get_dim< T >
get_dim< Matrix< S, R, C, O, MR, MC > >
Feel::FunctionSpace< A0, A1, A2, A3, A4 >::GetComponentBasis< BasisType >
GetDifferentType< double >
GetDifferentType< float >
GetDifferentType< std::complex< T > >
Feel::FunctionSpace< A0, A1, A2, A3, A4 >::GetNComponents< BasisType >
GlMatrixHelper< false, _Flags >
GlMatrixHelper< true, _Flags >
Feel::Mesh< GeoShape, T >::gmc< ContextID >
gmm_interface< real >
GMRES
Feel::GmshGmsh Mesh Generator
Feel::GmshEllipsoidDomainN-Ellipsoid Domain description for gmsh mesh generation
Feel::GmshHypercubeDomainTensorized Domain description for gmsh mesh generation
Feel::GmshOrdering< ConvexType >
Feel::GmshSimplexDomainSimplex Domain description for gmsh mesh generation
GpuHelper
displayGraphics::graphBuilder
Feel::GraphCSRGraph representation of the Compressed Sparse Row format
dal::greater< T >
dal::greater< char >
dal::greater< int >
dal::greater< short >
dal::greater< unsigned char >
Eigen::GslTraits< Scalar, IsComplex >
Eigen::GslTraits< Scalar, true >
Feel::GT_Lagrange< Dim, Order, Entity, T >
Feel::GT_QK< Dim, Order, T >
Feel::detail::H< T >
hahn1_functor
hand_vec_interface< real >
gmm::HarwellBoeing_IO
Feel::vm::has_curl< Context >
Feel::vm::has_div< Context >
Feel::vm::has_first_derivative< Context >
Feel::vm::has_first_derivative_normal< Context >
Feel::vm::has_grad< Context >
Feel::vm::has_hessian< Context >
Feel::vm::has_jacobian< Context >
Feel::vm::has_kb< Context >
Feel::vm::has_kb2< Context >
Feel::vm::has_mass< Context >
Feel::vm::has_normal< Context >
Feel::vm::has_point< Context >
Feel::vm::has_second_derivative< Context >
Feel::vm::has_stifness< Context >
Feel::vm::has_symm< Context >
Feel::vm::has_tangent< Context >
Feel::vm::has_unsymm< Context >
Feel::has_value< Contextv, Value >
Feel::Hermite< Order, PolySetType, Pts >
Feel::fem::Hermite< N, O, PolySetType, T, Convex, Pts >Hermite polynomial set
HessenbergDecomposition< _MatrixType >Reduces a square matrix to Hessenberg form by an orthogonal similarity transformation
HessenbergDecompositionMatrixHReturnType< MatrixType >Expression type for return value of HessenbergDecomposition::matrixH()
HNormalizedReturnType< ExpressionType >
Homogeneous< MatrixType, _Direction >Expression of one (or a set of) homogeneous vector(s)
HouseholderQR< _MatrixType >Householder QR decomposition of a matrix
HouseholderSequence< VectorsType, CoeffsType, Side >Represents a sequence of householder reflections with decreasing size
hybrd_functor
HybridNonLinearSolver< FunctorType, Scalar >Finds a zero of a system of n nonlinear functions in n variables by a modification of the Powell hybrid method ("dogleg")
hybrj_functor
Feel::Hypercube< Dim, Order, RDim >
Hyperplane< _Scalar, _AmbientDim >A hyperplane
IcoSphere
Feel::detail::ID< T >
gmm::identity_matrix
gmm::ildlt_precond< Matrix >
gmm::ildltt_precond< Matrix >
gmm::ilu_precond< Matrix >
gmm::ilut_precond< Matrix >
gmm::ilutp_precond< Matrix >
Feel::IM< DIM, IMORDER, T, Entity >Integration method interface class
Feel::Oseen< Space, imOrder, Entity >::im< Order >
Feel::imesh< T, Dim, Order >
imesh< Dim, Order, RDim >
Feel::IMExact< T >Exact integration method
Feel::IMGeneral< Dim, Order, T, Entity, QPS, DegreePolicy >
Feel::Importer< MeshType >
Feel::ImporterGambit< MeshType >Gambit(fluent mesh generator) importer class
Feel::ImporterGmsh< MeshType >Gmsh importer class
Feel::PolynomialSet< Poly, PolySetType >::Context< context_v, Basis_t, Geo_t, ElementType, context_g >::Index< TheRank >
gmm::index_generator
gmm::index_is_sorted< SUBI >
gmm::index_is_sorted< unsorted_sub_index >
Feel::inequalities< Data >Define the inequalities type
Feel::mpfr::InexactFlag
Data::Inflow
Feel::InfoInformation provider for versioning and installation directories
Feel::detail::InitializeSpace< MeshType >
SparseVector< _Scalar, _Options, _Index >::InnerIterator
InnerIteratorAn InnerIterator allows to loop over the element of a sparse (or dense) matrix or expression
DenseBase< Derived >::InnerIterator
DynamicSparseMatrix< _Scalar, _Flags, _Index >::InnerIterator
SparseView< MatrixType >::InnerIterator
SparseTriangularView< MatrixType, Mode >::InnerIterator
MappedSparseMatrix< _Scalar, _Flags, _Index >::InnerIterator
SparseInnerVectorSet< MatrixType, Size >::InnerIterator
SparseInnerVectorSet< DynamicSparseMatrix< _Scalar, _Options >, Size >::InnerIterator
SparseInnerVectorSet< SparseMatrix< _Scalar, _Options, _Index >, Size >::InnerIterator
CwiseBinaryOpImpl< BinaryOp, Lhs, Rhs, Sparse >::InnerIterator
CwiseUnaryOpImpl< UnaryOp, MatrixType, Sparse >::InnerIterator
CwiseUnaryViewImpl< ViewOp, MatrixType, Sparse >::InnerIterator
SparseDenseOuterProduct< Lhs, Rhs, Tr >::InnerIterator
SparseMatrix< _Scalar, _Options, _Index >::InnerIterator
TransposeImpl< MatrixType, Sparse >::InnerIterator
SkylineMatrix< _Scalar, _Options >::InnerLowerIterator
InnerStride< Value >Convenience specialization of Stride to specify only an inner stride See class Map for some examples
SkylineMatrix< _Scalar, _Options >::InnerUpperIterator
Feel::detail::integer< bit_size >
Feel::functional< Data >::IntegralMoment< Space, Poly >Functional that returns $\ell_u (v) = \int_\Omega( u\, v )$
Feel::functional< Data >::IntegralMomentOfDerivative< Space >Functional that returns $\ell_u^i (v) = \int_\Omega( \frac{d u}{d x_i} \, v )$
Feel::functional< Data >::IntegralMomentOfDivergence< Space, Poly >Functional that returns $\ell_u^i (v) = \int_\Omega( \frac{d u}{d x_i} \, v )$
Feel::functional< Data >::IntegralMomentOnFace< Space >Functional that returns $\ell_u (v) = \int_{\Gamma} ( u\, v )$ where $\Gamma \subset \partial \Omega$
Feel::functional< Data >::IntegralMomentsOnFace< Space, BasisType >Functional that returns $\ell_u (v) = \int_{\Gamma} ( u\, v )$ where $\Gamma \subset \partial \Omega$
Feel::IntegrationDegree< N >
dal::internal_error
Feel::GeoMap< Dim, Order, T, Entity, PP >::Inverse
Feel::Mesh< GeoShape, T >::Inverse
IOFormatStores a set of parameters controlling the way matrices are printed
gmm::is_a_reference< L >
gmm::is_a_reference_< R >
gmm::is_a_reference_< linalg_false >
Feel::detail::is_function_space_ptr< FuncSpaceType >
Feel::detail::is_function_space_ptr< boost::shared_ptr< FuncSpaceType > >
Feel::detail::is_matrix_ptr< MatrixType >
Feel::detail::is_matrix_ptr< boost::shared_ptr< MatrixType > >
Feel::is_shared_ptr< T >
Feel::is_shared_ptr< boost::shared_ptr< T > >
Feel::detail::is_vector_ptr< VectorType >
Feel::detail::is_vector_ptr< boost::shared_ptr< VectorType > >
Feel::Private::isNullFinder< T >
Feel::Private::isNullFinder< char * >
Feel::Private::isNullFinder< const char * >
gmm::iteration
Feel::Iteration< Real >Brief description
IterationControllerControls the iterations of the iterative solvers
AmbiVector< _Scalar, _Index >::Iterator
iters_before_test< T >
iters_before_test< double >
Feel::dyna::Jacobi< T >1D Jacobi polynomial
Feel::Jacobi< N, T >1D Jacobi polynomial
Feel::JacobiDegree< N >
JacobiSVD< MatrixType, Options >Jacobi SVD decomposition of a square matrix
dal::just_for_the_fine_cxx
KdBVH< _Scalar, _Dim, _Object >A simple bounding volume hierarchy based on AlignedBox
Feel::KDTreeKDTree class
Feel::Kovasznay< _OrderU, _OrderP, Entity >Solves the stokes equations
la_stat
gmm::lag_precond< Matrix >
Feel::Lagrange< Order, PolySetType, ContinuityType, Pts >
Feel::fem::Lagrange< N, O, PolySetType, ContinuityType, T, Convex, Pts >Lagrange polynomial set
lanczos1_functor
Laplacian< Dim, Order, RDim, ContinuityType, Entity >
Feel::Laplacian< Dim, Order, RDim, Entity >
Feel::LaplacianML< Dim, Order >
LaplacianV< Dim, Order, RDim >
LazyProductReturnType< Lhs, Rhs >
Feel::glas::ldl< T >
LDLT< _MatrixType, _UpLo >Robust Cholesky decomposition of a matrix with pivoting
LDLT_Traits< MatrixType, Lower >
LDLT_Traits< MatrixType, Upper >
Feel::Legendre< Dim, Degree, NormalizationPolicy, T, StoragePolicy >Legendre polynomial orthonormal basis
Feel::LegendreTag< D, O >
Feel::LegendreTraits< Dim, Degree, NormalizationPolicy, T, StoragePolicy >
dal::less< T >
dal::less< char >
dal::less< int >
dal::less< short >
dal::less< unsigned char >
less_than_comparable
LevenbergMarquardt< FunctorType, Scalar >Performs non linear optimization over a non-linear function, using a variant of the Levenberg Marquardt algorithm
dal::lexicographical_greater< CONT, COMP >
dal::lexicographical_less< CONT, COMP >
Lib_Mean
gmm::linalg_and< V, W >
gmm::linalg_and< linalg_false, linalg_false >
gmm::linalg_and< linalg_true, linalg_true >
gmm::linalg_const
gmm::linalg_false
gmm::linalg_imag_part
gmm::linalg_modifiable
gmm::linalg_or< V, W >
gmm::linalg_real_part
gmm::linalg_traits< V >
gmm::linalg_traits< bgeot::PT< VECT > >
gmm::linalg_traits< bgeot::small_vector< T > >
gmm::linalg_traits< bgeot::vsvector< T > >
gmm::linalg_traits< block_matrix< MAT > >
gmm::linalg_traits< col_matrix< V > >
gmm::linalg_traits< conjugated_col_matrix_const_ref< M > >
gmm::linalg_traits< conjugated_row_matrix_const_ref< M > >
gmm::linalg_traits< conjugated_vector_const_ref< V > >
gmm::linalg_traits< cs_vector_ref< PT1, PT2, shift > >
gmm::linalg_traits< csc_matrix< T, shift > >
gmm::linalg_traits< csc_matrix_ref< PT1, PT2, PT3, shift > >
gmm::linalg_traits< csr_matrix< T, shift > >
gmm::linalg_traits< csr_matrix_ref< PT1, PT2, PT3, shift > >
gmm::linalg_traits< dense_matrix< T > >
gmm::linalg_traits< gen_col_vector< PT > >
gmm::linalg_traits< gen_row_vector< PT > >
gmm::linalg_traits< gen_sub_col_matrix< PT, SUBI1, SUBI2 > >
gmm::linalg_traits< gen_sub_row_matrix< PT, SUBI1, SUBI2 > >
gmm::linalg_traits< part_col_ref< PT, PART > >
gmm::linalg_traits< part_row_ref< PT, PART > >
gmm::linalg_traits< part_vector< PT, PART > >
gmm::linalg_traits< row_matrix< V > >
gmm::linalg_traits< rsvector< T > >
gmm::linalg_traits< scaled_col_matrix_const_ref< M, S > >
gmm::linalg_traits< scaled_row_matrix_const_ref< M, S > >
gmm::linalg_traits< scaled_vector_const_ref< V, S > >
gmm::linalg_traits< simple_vector_ref< PT > >
gmm::linalg_traits< skyline_sub_vector< PT, SUBI > >
gmm::linalg_traits< slvector< T > >
gmm::linalg_traits< sparse_sub_vector< PT, SUBI > >
gmm::linalg_traits< std::vector< T, alloc > >
gmm::linalg_traits< tab_ref_index_ref_with_origin< IT, ITINDEX, V > >
gmm::linalg_traits< tab_ref_reg_spaced_with_origin< IT, V > >
gmm::linalg_traits< tab_ref_with_origin< IT, V > >
gmm::linalg_traits< transposed_col_ref< PT > >
gmm::linalg_traits< transposed_row_ref< PT > >
gmm::linalg_traits< wsvector< T > >
gmm::linalg_true
Feel::Line< Dim >
std::list< T, EIGEN_ALIGNED_ALLOCATOR< T > >
AmbiVector< _Scalar, _Index >::ListEl
Feel::ListReturnTypes< Dim >
LLT< _MatrixType, _UpLo >Standard Cholesky decomposition (LL^T) of a matrix and associated features
LLT_Traits< MatrixType, Lower >
LLT_Traits< MatrixType, Upper >
lmder_functor
lmdif_functor
lmstr_functor
Feel::Mesh< GeoShape, T >::Localization
Feel::GeoTool::Loop
loop_on_k< M, N, K >
loop_on_k< M, N, END >
loop_on_m< M, N, K >
loop_on_m< END, N, K >
loop_on_n< M, N, K, Scalar, Mode >
loop_on_n< M, END, K, Scalar, Mode >
Feel::TimeSet< MeshType, N >::ltstep
Feel::LU< MatrixType >
MakeComplexOp< Scalar >
MandelbrotThread
MandelbrotWidget
Map< PlainObjectType, MapOptions, StrideType >A matrix or vector expression mapping an existing array of data
Map< Quaternion< _Scalar >, PacketAccess >Expression of a quaternion from a memory buffer
map_size< S >
map_size< 10 >
map_size< 11 >
map_size< 12 >
map_size< 13 >
MapBase< Derived >Base class for Map and Block expression with direct access
MappedSparseMatrix< _Scalar, _Flags, _Index >Sparse matrix
Feel::meta::marked2elements< MeshType >
Feel::meta::marked3elements< MeshType >
Feel::meta::markedelements< MeshType >
Feel::MaterialMaterial base class
Feel::MaterialLibMaterial library
Feel::matrix< ordering >
Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols >The matrix class, also used for vectors and row-vectors
Feel::matrix_node< T, S >
MatrixBase< Derived >Base class for all dense matrices, vectors, and expressions
Feel::MatrixBlock< NR, NC, MatrixType >Block of matrices
MatrixExponential< MatrixType >Class for computing the matrix exponential
MatrixExponentialReturnValue< Derived >Proxy for the matrix exponential of some matrix (expression)
MatrixFunction< MatrixType, IsComplex >Class for computing matrix exponentials
MatrixFunction< MatrixType, 0 >Partial specialization of MatrixFunction for real matrices
MatrixFunction< MatrixType, 1 >Partial specialization of MatrixFunction for complex matrices
MatrixFunctionAtomic< MatrixType >Helper class for computing matrix functions of atomic matrices
MatrixFunctionReturnValue< Derived >Proxy for the matrix function of some matrix (expression)
Feel::MatrixGmm< T, LayoutType >Interface to gmm sparse matrix
gmm::MatrixMarket_IO
Feel::MatrixMass< ordering >
Feel::MatrixShell< T >Matrices that define its action against a vector
Feel::MatrixShellSparse< T >Allow all sparse matrices to be shell matrices
Feel::MatrixSparse< T >
Feel::MatrixTriplet< T >Brief description
Feel::MatrixUBlas< T, LayoutType >Interface to ublas sparse matrix
Feel::MatrixValue< T >Interface to matrix
MatrixWrapper< ExpressionType >Expression of an array as a mathematical vector or matrix
MatrixXpr
meshUnifying mesh class
Feel::Mesh< GeoShape, T >
Feel::Mesh1D< Shape >1D mesh class
Feel::Mesh2D< Shape >2D mesh class
Feel::Mesh3D< Shape >3D mesh class
Feel::MeshBaseBase mesh class
Feel::MeshHighOrder< Convex >
Feel::MeshMover< MeshType >Move mesh according to a given map
Feel::MeshTraits< MeshType >Traits for meshes
MGH09_functor
MGH10_functor
MGH17_functor
Minor< MatrixType >Expression of a minor
misra1a_functor
misra1d_functor
Mixed_Perf_Analyzer< Action >
gmm::modifiable_pointer< const P * >
gmm::modifiable_pointer< P * >
gmm::modified_gram_schmidt< T >
Feel::Moment< Dim, Degree, T, StoragePolicy >Moment polynomial basis
mpfr_group_t
mpfr_save_expo_t
mpfr_size_limb_t
Feel::mpfr::MpfrClass
mpfr::mpreal
gmm::mr_approx_inverse_precond< Matrix >
gmm::mref_type< PT >
gmm::mref_type_< PT, R >
gmm::mref_type_< const L *, linalg_const >
gmm::mref_type_< const L *, linalg_modifiable >
gmm::mref_type_< const L *, R >
gmm::mref_type_< L *, linalg_const >
gmm::mref_type_< L *, linalg_modifiable >
gmm::mref_type_< L *, R >
mtl4_interface< real >
my_functor
MyApp
Feel::ALE< Convex >::MyBasis< i >
MyClassA
Feel::ALE< Convex >::MyConvex< i >
MyFunctionSpace< Dim, Order >
TestImPK< D, N, T, QPS >::MyIm< IMORDER >
Feel::StokesStabilized< Order >::MyIm< i >
Feel::LaplacianML< Dim, Order >::MyIM< IMORDER >
MyIntegrals< Dim >
MyMesh< Dim >
MyMpiApp
Feel::ALE< Convex >::MyPointSet< i >
MyStruct
mytag< A, i >
Feel::mytag< A, i >
Feel::detail::NAME< Expr1, Expr2 >
NAME< Expr >
Feel::detail::NbDof
NColsBlockXpr< N >
DenseBase< Derived >::NColsBlockXpr< N >
Feel::NdebugStream
NestByValue< ExpressionType >Expression which must be nested by value
gmm::NewtonAS_struct< Matrixt, MatrixBi >
Feel::detail::NLocalDof
Feel::detail::no_int< bit_size >
NoAlias< ExpressionType, StorageBase >Pseudo expression providing an operator = assuming no aliasing
NoChange_t
Feel::node< T, S >
Feel::GeoTool::Node
Feel::NonLinearPow< Dim, Order, Entity >
Feel::noop< T, int >
Feel::NoPeriodicityNoPeriodicity class holder
Feel::norm_inf_adaptor
Feel::Normalized< normalized >
dal::not_linear_error
DenseBase< Derived >::NRowsBlockXpr< N >
NRowsBlockXpr< N >
gmm::number_traits< T >
gmm::number_traits< std::complex< T > >
NumericalDiff< _Functor, mode >
NumTraits< T >Holds information about the various numeric (i.e. scalar) types allowed by Eigen
NumTraits< Array< Scalar, Rows, Cols, Options, MaxRows, MaxCols > >
Eigen::NumTraits< AutoDiffScalar< DerType > >
NumTraits< double >
NumTraits< float >
NumTraits< long double >
NumTraits< std::complex< _Real > >
OnesReturn a matrix expression or N-dimensional array whose elements are all 1
Feel::Operator< DomainSpace, DualImageSpace >Operator between function spaces
Feel::OperatorInterpolation< DomainSpaceType, ImageSpaceType, IteratorRange >Global interpolation operator
Feel::OperatorLagrangeP1< SpaceType >
Feel::OperatorLinear< DomainSpace, DualImageSpace >Linear Operator between function spaces, represented by a matrix
Feel::Order< PN, GN >
Feel::OrthogonalPolynomialSet< Dim, Order, PolySetType, T, Convex >Set of orthogonal polynomials over a convex
Feel::OrthogonalPolynomialSet< Dim, Order, PolySetType, T, Hypercube >
Feel::OrthogonalPolynomialSet< Dim, Order, PolySetType, T, Simplex >
Feel::Oseen< Space, imOrder, Entity >
Feel::OseenDefaultsOseen Default Data
other_matrix_type< T >
other_matrix_type< Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols > >
OuputOutput class to describe code outputs
OuterStride< Value >Convenience specialization of Stride to specify only an outer stride See class Map for some examples
util::Output
Feel::Output
Feel::Output_impl
P2N< T >
P3N< T >
Packet1cd
Packet2cf
packet_helper< Cond, Packet >
packet_helper< false, Packet >
Feel::ParameterParameter class to describe code inputs
util::Parameter
Feel::Parameter_impl
HybridNonLinearSolver< FunctorType, Scalar >::Parameters
LevenbergMarquardt< FunctorType, Scalar >::Parameters
ParametrizedLine< _Scalar, _AmbientDim >A parametrized line
gmm::part_col_ref< PT, PART >
gmm::part_return< PT, PART >
gmm::part_return_< TYPE, PART, PT >
gmm::part_return_< col_major, PART, PT >
gmm::part_return_< row_major, PART, PT >
gmm::part_return__< PT, PART, LT >
gmm::part_return__< PT, PART, abstract_matrix >
gmm::part_return__< PT, PART, abstract_vector >
gmm::part_row_ref< PT, PART >
gmm::part_vector< PT, PART >
gmm::part_vector_iterator< IT, MIT, PART >
PartialPivLU< _MatrixType >LU decomposition of a matrix with partial pivoting, and related features
PartialReduxExpr< MatrixType, MemberOp, Direction >Generic expression of a partially reduxed matrix
Feel::Partitioner< Mesh >
Feel::PartitionerMetis< Mesh >
Feel::PartitionerParmetis< Mesh >
Feel::Periodic< Tag1, Tag2, T >Periodic class holder
Feel::detail::periodicity_base
Feel::PeriodicLaplacian< Dim, Order >
PermutationMatrix< SizeAtCompileTime, MaxSizeAtCompileTime >Permutation matrix
Feel::math::pi_tag
PlanarRotation< Scalar >Represents a rotation in the plane from a cosine-sine pair
Feel::functional< Data >::PointDerivative< Space >Generate the functional associated with a point derivative
Feel::functional< Data >::PointEvaluation< Space >Generate the functional associated with a point evaluation
PointPointMinimizer
Feel::functional< Data >::PointsDerivative< Space >Generate the functionals associated with point set
Feel::PointSet< Convex, T >Class of all PointSet on a Convex
Feel::PointSetElectrostatic< Convex, Order, T >
Feel::PointSetEquiSpaced< Convex, Order, T >
Feel::PointSetFekete< Convex, Order, T >
Feel::PointSetFeketeSimplex< Convex, Order, T >
Feel::PointSetGaussLobatto< Convex, Order, T >
Feel::PointSetInterpolation< Dim, Order, T, Convex >Good interpolation point sets on a convex
Feel::PointSetMapped< element_type, Convex, Order, T, PointSetType >
Feel::PointSetQuadrature< Convex, Integration_Degree, T >Quadrature point set base class
Feel::PointSetToMesh< Convex, T >Transform a point set to a mesh data structure using a Delaunay
Feel::PointSetWarpBlend< Convex, Order, T >
Feel::functional< Data >::PointsEvaluation< Space >Generate the functionals associated with point set
Feel::functional< Data >::PointsGradient< Space >Generate the functionals associated with point set
Feel::Poisson< N, T >
Feel::PolicyCreationUsingNew< T >
Feel::PolicyFeelTimeDefault< T >
Feel::Hypercube< Dim, Order, RDim >::PolyDims< N >
Feel::PolynomialSet< Poly, PolySetType >Set of polynomials
PolynomialSolver< _Scalar, _Deg >A polynomial solver
PolynomialSolver< _Scalar, 1 >
PolynomialSolverBase< _Scalar, _Deg >Defined to be inherited by polynomial solvers: it provides convenient methods such as

  • real roots,
  • greatest, smallest complex roots,
  • real roots with greatest, smallest absolute real value,
  • greatest, smallest real roots
Feel::Polyvis< A0, A1, A2, A3, A4 >Class for polynomial visualisation
Polyvis
PolyvisApp
Feel::PolyvisBasePolynomial visualisation base class
Portable_Perf_Analyzer< Action >
Portable_Timer
Feel::PolynomialSet< Poly, PolySetType >::PreCompute
Feel::Principal< Degree, T, StoragePolicy >Principal modified functions
gmm::principal_orientation_type< T >
gmm::principal_orientation_type< col_and_row >
gmm::principal_orientation_type< col_major >
gmm::principal_orientation_type< row_and_col >
gmm::principal_orientation_type< row_major >
print_n< N >
print_n< END >
Feel::DebugStream::Private
Feel::problem< Data >Optimization problem specifications
Feel::functional::detail::prod< P1, P2 >
ProductBase< Derived, Lhs, Rhs >
ProductReturnType< Lhs, Rhs, ProductType >Helper class to get the correct and optimized returned type of operator*
ProductReturnType< Lhs, Rhs, CoeffBasedProductMode >
ProductReturnType< Lhs, Rhs, LazyCoeffBasedProductMode >
gmm::project2nd< T >
PsLogger
Feel::PointSetEquiSpaced< Convex, Order, T >::pt_to_edge< shape >
Feel::Reference< Hypercube< Dim, Order, RDim >, Dim, Order, RDim, T >::pt_to_edge< shape >
Feel::Reference< Simplex< Dim, Order, RDim >, Dim, Order, RDim, T >::pt_to_edge< shape >
Feel::PointSetGaussLobatto< Convex, Order, T >::pt_to_edge< shape >
Feel::PointSetEquiSpaced< Convex, Order, T >::pt_to_element< shape >
Feel::Reference< Hypercube< Dim, Order, RDim >, Dim, Order, RDim, T >::pt_to_element< shape >
Feel::Reference< Simplex< Dim, Order, RDim >, Dim, Order, RDim, T >::pt_to_element< shape >
Feel::PointSetGaussLobatto< Convex, Order, T >::pt_to_element< shape >
Feel::Reference< Simplex< Dim, Order, RDim >, Dim, Order, RDim, T >::pt_to_entity< shape, topo_dim >
Feel::Reference< Hypercube< Dim, Order, RDim >, Dim, Order, RDim, T >::pt_to_entity< shape, topo_dim >
Feel::PointSetEquiSpaced< Convex, Order, T >::pt_to_entity_hexahedron< shape, topo_dim >
Feel::PointSetGaussLobatto< Convex, Order, T >::pt_to_entity_hexahedron< shape, topo_dim >
Feel::PointSetEquiSpaced< Convex, Order, T >::pt_to_entity_tetrahedron< shape, topo_dim >
Feel::Reference< Simplex< Dim, Order, RDim >, Dim, Order, RDim, T >::pt_to_face< shape >
Feel::Reference< Hypercube< Dim, Order, RDim >, Dim, Order, RDim, T >::pt_to_face< shape >
Feel::PointSetEquiSpaced< Convex, Order, T >::pt_to_face_hexahedron< shape >
Feel::PointSetGaussLobatto< Convex, Order, T >::pt_to_face_hexahedron< shape >
Feel::PointSetEquiSpaced< Convex, Order, T >::pt_to_face_tetrahedron< shape >
dal::ptr_collection< T >
QMR
Feel::QuadMapped< PsetType >
Quaternion< _Scalar >The quaternion class used to represent 3D orientations and rotations
QuaternionBase< Derived >
QuaternionDemo
gmm::r_mult
randomMatrixWithImagEivals< MatrixType, IsComplex >
randomMatrixWithImagEivals< MatrixType, 0 >
randomMatrixWithImagEivals< MatrixType, 1 >
RandomSetter< SparseMatrixType, MapTraits, OuterPacketBits >The RandomSetter is a wrapper object allowing to set/update a sparse matrix with random access
Feel::VectorUblas< T, Storage >::range
Feel::RankDown< T >
Feel::RankSame< T >
Feel::RankUp< T >
Feel::RankUp2< T >
rat42_functor
rat43_functor
Feel::RaviartThomas< Order >
Feel::fem::RaviartThomas< N, O, T, Convex >RaviartThomas Finite Element
Feel::fem::detail::RaviartThomasDual< Basis, PointSetType >
Feel::RaviartThomasPolynomialSet< N, O, T, Convex >
gmm::rcmult
Feel::detail::real< bit_size >
RealSchur< _MatrixType >Performs a real Schur decomposition of a square matrix
Feel::RealToReference< Elem, Entity, T >
Eigen::aligned_allocator_indirection< T >::rebind< U >
aligned_allocator< T >::rebind< U >
VectorwiseOp< ExpressionType, Direction >::ReduxReturnType< BinaryOp >
gmm::ref_elt_vector< T, V >
gmm::ref_elt_vector< T, which_part< R, PART > >
gmm::ref_or_value_type< reference >
gmm::ref_or_value_type< ref_elt_vector< U, which_part< R, PART > > >
Feel::mpfr::RefCounter
Feel::Reference< Geo, Dim, Order, RDim, T >Reference convex
Feel::Reference< Hypercube< Dim, Order, RDim >, Dim, Order, RDim, T >
Feel::Reference< Simplex< Dim, Order, RDim >, Dim, Order, RDim, T >
Feel::GeoEntity< Entity >::reference_convex< T >
Feel::RegionTreeImplements a region-tree for point search in a set of boxes
Feel::remove_shared_ptr< T >
Feel::remove_shared_ptr< boost::shared_ptr< T > >
RenderingWidget
Replicate< MatrixType, RowFactor, ColFactor >Expression of the multiple replication of a matrix or vector
ResidualEstimator< Dim, Order >
Feel::ResistanceLaplacian< Dim, Order >
Feel::detail::DD< T >::result
Feel::detail::ID< T >::result
Feel::detail::Div< T >::result
Feel::detail::Curl< T, N >::result
Feel::detail::D< T, N >::result
Feel::detail::H< T >::result
Feel::detail::NbDof::result< NbDof(T, S)>
Feel::detail::NLocalDof::result< NLocalDof(T, S)>
Feel::detail::searchIndicesBySpace< map_type >::result< searchIndicesBySpace(T, M)>
ReturnByValue< Derived >
Feel::ReturnSelect< T1, T2 >
VectorwiseOp< ExpressionType, Direction >::ReturnType< Functor, Scalar >
Reverse< MatrixType, Direction >Expression of the reverse of a vector or matrix
TransposeImpl< MatrixType, Sparse >::ReverseInnerIterator
Rotation2D< _Scalar >Represents a rotation/orientation in a 2 dimensional space
RotationBase< Derived, _Dim >Common base class for compact rotation representations
gmm::row_and_col
gmm::row_major
gmm::row_matrix< V >
gmm::rsvector< T >
gmm::rsvector_const_iterator< T >
gmm::rsvector_iterator< T >
Feel::Scalar< Dim >
RandomSetter< SparseMatrixType, MapTraits, OuterPacketBits >::ScalarWrapper
gmm::scaled_col_const_iterator< M, S >
gmm::scaled_col_matrix_const_ref< M, S >
gmm::scaled_const_iterator< IT, S >
gmm::scaled_return< L, S >
gmm::scaled_return_< L, S, LT >
gmm::scaled_return_< L, S, abstract_matrix >
gmm::scaled_return_< L, S, abstract_vector >
gmm::scaled_return__< L, S, R >
gmm::scaled_return__< L, S, col_major >
gmm::scaled_return__< L, S, row_major >
gmm::scaled_row_const_iterator< M, S >
gmm::scaled_row_matrix_const_ref< M, S >
gmm::scaled_vector_const_ref< V, S >
ScaledProduct< NestedProduct >
ScalingRepresents a generic uniform scaling transformation
gmm::schwarz_additif_matrix< Matrix1, Matrix2, Matrix3, SUBI >
Feel::detail::searchIndicesBySpace< map_type >
Select< ConditionMatrixType, ThenMatrixType, ElseMatrixType >Expression of a coefficient wise version of the C++ ternary operator ?:
gmm::select_orientation< C1, C2, L >
gmm::select_orientation_< C1, C2, R >
gmm::select_orientation_< C1, C2, col_major >
gmm::select_orientation_< C1, C2, row_major >
gmm::select_ref< C1, C2, PT >
gmm::select_ref< C1, C2, const L * >
gmm::select_ref_< C1, C2, REF >
gmm::select_ref_< C1, C2, const L & >
gmm::select_ref_< C1, C2, L & >
gmm::select_return< C1, C2, PT >
gmm::select_return_< C1, C2, REF >
gmm::select_return_< C1, C2, const L & >
gmm::select_return_< C1, C2, L & >
Feel::detail::SpaceToLagrangeP1Space< SpaceType >::SelectConvex< PsetType >
SelfAdjointEigenSolver< _MatrixType >Computes eigenvalues and eigenvectors of selfadjoint matrices
SelfadjointProductMatrix< Lhs, 0, true, Rhs, RhsMode, false >
SelfadjointProductMatrix< Lhs, LhsMode, false, Rhs, 0, true >
SelfadjointProductMatrix< Lhs, LhsMode, false, Rhs, RhsMode, false >
SelfAdjointView< MatrixType, UpLo >Expression of a selfadjoint matrix from a triangular part of a dense matrix
SelfCwiseBinaryOp< BinaryOp, Lhs, Rhs >Internal helper class for optimizing operators like +=, -=
dal::sequence_iterator< T >
Sequential_t
Feel::set_value< Contextv, Value >
Feel::Simplex< Dim, Order, RDim >::shape< shape_dim, O, R >
Feel::Hypercube< Dim, Order, RDim >::shape< shape_dim, O, R >
Feel::sim
Feel::SimgetSimulation Object
gmm::simple_vector_ref< PT >
Feel::Simplex< Dim, Order, RDim >Simplex of dimension Dim
Feel::Singleton< T >Implement the Singleton pattern
gmm::skyline_sub_vector< PT, SUBI >
gmm::skyline_sub_vector_iterator< IT, MIT, SUBI >
SkylineInplaceLU< MatrixType >Inplace LU decomposition of a skyline matrix and associated features
SkylineMatrix< _Scalar, _Options >The main skyline matrix class
SkylineMatrixBase< Derived >Base class of any skyline matrices or skyline expressions
SkylineProduct< LhsNested, RhsNested, ProductMode >
SkylineProductReturnType< Lhs, Rhs, ProductMode >
SkylineStorage< Scalar >
Feel::VectorUblas< T, Storage >::slice
Feel::SListGenerator< N, T >
Feel::SListGenerator< 0, T >
SluMatrix
SluMatrixMapHelper< Matrix< Scalar, Rows, Cols, Options, MRows, MCols > >
SluMatrixMapHelper< SparseMatrixBase< Derived > >
gmm::slvector< T >
gmm::slvector_const_iterator< T >
gmm::slvector_iterator< T >
Feel::SNumericalTraits< A, B >
Feel::SNumericalTraits< T, T >
Feel::SolverBaseAbstract base class for wrapped (linear) solvers
Feel::SolverConstrained< Data, Problem >
Feel::SolverEigen< T >Base class for eigen solvers
Feel::SolverLinear< T >
Feel::SolverNonLinear< T >Non linear solver base interface
Feel::SolverNonLinearTrilinosInterface
Feel::SolverUMFPACKInterface for the UMFPACK Solver
Feel::SolverUnconstrained< Data, Problem >
some_non_vectorizable_type
STL_algo_interface< real >::somme
dal::sorted_indexes_aux< VEC >
Feel::SOrth< MatrixA >
Feel::Sound< Dim, Order, Entity >
Feel::Wave< Dim, Order, Cont, Entity, FType >::space< Conti >
Feel::Bratu< Dim, Order, Entity >::space< Conti >
Feel::Advection< Dim, Order, Cont, Entity >::space< Conti >
Feel::Laplacian< Dim, Order, RDim, Entity >::space< Conti >
Feel::Dar< Dim, Order, Cont, Entity >::space< Conti >
Feel::detail::SpaceToLagrangeP1Space< SpaceType >
gmm::sparse_compressed_iterator< PT1, PT2, PT3, shift >
gmm::sparse_sub_vector< PT, SUBI >
gmm::sparse_sub_vector_iterator< IT, MIT, SUBI >
gmm::sparse_vector_type< T >
SparseDenseOuterProduct< Lhs, Rhs, Tr >
SparseDenseProductReturnType< Lhs, Rhs, InnerSize >
SparseDenseProductReturnType< Lhs, Rhs, 1 >
SparseDiagonalProduct< Lhs, Rhs >
SparseInnerVectorSet< MatrixType, Size >
SparseInnerVectorSet< DynamicSparseMatrix< _Scalar, _Options >, Size >
SparseInnerVectorSet< SparseMatrix< _Scalar, _Options, _Index >, Size >
SparseLDLT< MatrixType, Backend >LDLT Cholesky decomposition of a sparse matrix and associated features
SparseLLT< MatrixType, Backend >LLT Cholesky decomposition of a sparse matrix and associated features
SparseLLT< MatrixType, Cholmod >
SparseLLT< MatrixType, Taucs >
SparseLU< MatrixType, Backend >LU decomposition of a sparse matrix and associated features
SparseLU< MatrixType, SuperLU >
SparseLU< MatrixType, UmfPack >
SparseMatrix< _Scalar, _Options, _Index >The main sparse matrix class
SparseMatrixBase< Derived >Base class of any sparse matrices or sparse expressions
SparseSelfAdjointTimeDenseProduct< Lhs, Rhs, UpLo >
SparseSelfAdjointView< MatrixType, UpLo >Pseudo expression to manipulate a triangular sparse matrix as a selfadjoint matrix
SparseSparseProduct< LhsNested, RhsNested >
SparseSparseProductReturnType< Lhs, Rhs >
SparseTimeDenseProduct< Lhs, Rhs >
SparseTriangularView< MatrixType, Mode >
SparseVector< _Scalar, _Options, _Index >Sparse vector class
SparseView< MatrixType >
Feel::Sphere
static_size_generator< SIZE, Perf_Analyzer, Action, Interface >
static_size_generator< 1, Perf_Analyzer, Action, Interface >
Feel::SolverConstrained< Data, Problem >::StatsHolds the statistics for SolverConstrained
Feel::SolverUnconstrained< Data, Problem >::StatsStatistics holder for the solver
StdMapTraits< Scalar >
StdStemFunctions< Scalar >Stem functions corresponding to standard mathematical functions
Feel::TimeSet< MeshType, N >::StepStep in a time set
STL_algo_interface< real >
STL_interface< real >
STL_Perf_Analyzer< ACTION >
STL_Timer
Feel::Stokes< Dim, BasisU, BasisP, Entity >Solves the stokes equations
Feel::StokesStabilized< Order >
Feel::StorageUBlas< T >
Stride< _OuterStrideAtCompileTime, _InnerStrideAtCompileTime >Holds strides information for Map
Feel::strongest_numeric_type< T1, T2, T3, T4, T5 >
gmm::strongest_numeric_type< T1, T2 >
gmm::strongest_numeric_type< double, long >
gmm::strongest_numeric_type< float, int >
gmm::strongest_numeric_type< float, long >
gmm::strongest_numeric_type< int, float >
gmm::strongest_numeric_type< long, double >
gmm::strongest_numeric_type< long, float >
Feel::strongest_numeric_type< std::complex< T1 >, std::complex< T2 > >
gmm::strongest_numeric_type< std::complex< T1 >, std::complex< T2 > >
Feel::strongest_numeric_type< std::complex< T1 >, T2 >
gmm::strongest_numeric_type< std::complex< T1 >, T2 >
Feel::strongest_numeric_type< T1, std::complex< T2 > >
gmm::strongest_numeric_type< T1, std::complex< T2 > >
gmm::strongest_numeric_type_aux< T1, T2, c >
gmm::strongest_numeric_type_aux< T1, T2, false >
gmm::strongest_value_type< V1, V2 >
gmm::strongest_value_type3< V1, V2, V3 >
Feel::StructureApp
Feel::StructureBaseBase class for structure models
Feel::StructuredGrid< Dim, Order >Class to represent a Structured Grid
Feel::StVenantKirchhoff< Dim, Order >
Feel::FunctionSpace< A0, A1, A2, A3, A4 >::Element< T, Cont >::sub_element< i >
Feel::FunctionSpace< A0, A1, A2, A3, A4 >::sub_functionspace< i >
gmm::sub_index
gmm::sub_interval
gmm::sub_matrix_type< PT, SUBI1, SUBI2 >
gmm::sub_matrix_type_< PT, SUBI1, SUBI2, ST >
gmm::sub_matrix_type_< PT, SUBI1, SUBI2, col_major >
gmm::sub_matrix_type_< PT, SUBI1, SUBI2, row_major >
gmm::sub_slice
gmm::sub_vector_type< PT, SUBI >
Feel::SubFaceOf< ElementType >
Feel::SubFaceOfNone
Feel::Surface
Feel::SVD< MatrixA >Singular Value Decomposition of a rectangular matrix
SVD< _MatrixType >Standard SVD decomposition of a matrix and associated features
gmm::svrt_ir< PT, SUBI, st_type >
gmm::svrt_ir< PT, sub_index, abstract_dense >
gmm::svrt_ir< PT, sub_index, abstract_skyline >
gmm::svrt_ir< PT, sub_interval, abstract_dense >
gmm::svrt_ir< PT, sub_slice, abstract_dense >
gmm::svrt_ir< PT, SUBI, abstract_skyline >
gmm::svrt_ir< PT, SUBI, abstract_sparse >
gmm::svrt_ir< PT, unsorted_sub_index, abstract_dense >
gmm::svrt_ir< PT, unsorted_sub_index, abstract_skyline >
SwapWrapper< ExpressionType >Internal helper class for swapping two expressions
Feel::System< SpaceType >System of PDE associated to a function space
Feel::SystemExplicit< SpaceType >Describes an explicit system
Feel::SystemImplicit< SpaceType >Describes an implicit system
Feel::SystemImplicitLinear< SpaceType >Brief description
Feel::SystemImplicitNonLinear< SpaceType >Describes nonlinear implicit systems
dal::tab_ref< ITER >
dal::tab_ref_index_ref< ITER, ITER_INDEX >
dal::tab_ref_index_ref_iterator_< ITER, ITER_INDEX >
gmm::tab_ref_index_ref_with_origin< IT, ITINDEX, V >
dal::tab_ref_reg_spaced< ITER >
dal::tab_ref_reg_spaced_iterator_< ITER >
gmm::tab_ref_reg_spaced_with_origin< IT, V >
gmm::tab_ref_with_origin< IT, V >
dal::tab_ref_with_selection< ITER, COND >
dal::tab_ref_with_selection_iterator_< ITER, COND >
Feel::Tagged< A, i >
gmm::temporary_col_matrix< V >
gmm::temporary_col_matrix_< S, L, V >
gmm::temporary_col_matrix_< abstract_dense, L, V >
gmm::temporary_col_matrix_< abstract_skyline, L, V >
gmm::temporary_col_matrix_< abstract_sparse, L, V >
gmm::temporary_dense_vector< V >
gmm::temporary_dense_vector_< R, S, V >
gmm::temporary_dense_vector_< linalg_false, abstract_dense, V >
gmm::temporary_dense_vector_< linalg_false, abstract_skyline, V >
gmm::temporary_dense_vector_< linalg_false, abstract_sparse, V >
gmm::temporary_dense_vector_< linalg_true, S, V >
gmm::temporary_matrix< V >
gmm::temporary_matrix_< R, S, L, V >
gmm::temporary_matrix_< linalg_false, S, abstract_matrix, V >
gmm::temporary_matrix_< linalg_true, abstract_dense, L, V >
gmm::temporary_matrix_< linalg_true, abstract_skyline, L, V >
gmm::temporary_matrix_< linalg_true, abstract_sparse, L, V >
gmm::temporary_row_matrix< V >
gmm::temporary_row_matrix_< S, L, V >
gmm::temporary_row_matrix_< abstract_dense, L, V >
gmm::temporary_row_matrix_< abstract_skyline, L, V >
gmm::temporary_row_matrix_< abstract_sparse, L, V >
gmm::temporary_skyline_vector_< R, S, V >
gmm::temporary_skyline_vector_< linalg_false, abstract_dense, V >
gmm::temporary_skyline_vector_< linalg_false, abstract_skyline, V >
gmm::temporary_skyline_vector_< linalg_false, abstract_sparse, V >
gmm::temporary_skyline_vector_< linalg_true, S, V >
gmm::temporary_skylines_vector< V >
gmm::temporary_sparse_vector< V >
gmm::temporary_sparse_vector_< R, S, V >
gmm::temporary_sparse_vector_< linalg_false, abstract_dense, V >
gmm::temporary_sparse_vector_< linalg_false, abstract_skyline, V >
gmm::temporary_sparse_vector_< linalg_false, abstract_sparse, V >
gmm::temporary_sparse_vector_< linalg_true, S, V >
gmm::temporary_vector< V >
gmm::temporary_vector_< R, S, L, V >
gmm::temporary_vector_< linalg_false, abstract_dense, abstract_matrix, V >
gmm::temporary_vector_< linalg_false, abstract_sparse, abstract_matrix, V >
gmm::temporary_vector_< linalg_false, S, abstract_vector, V >
gmm::temporary_vector_< linalg_true, abstract_dense, L, V >
gmm::temporary_vector_< linalg_true, abstract_skyline, L, V >
gmm::temporary_vector_< linalg_true, abstract_sparse, L, V >
Feel::Tensor2< Dim >
Feel::Tensor3< Dim >
Feel::TensorisedBoundaryAdapted< Dim, Degree, T, StoragePolicy >TensorisedBoundaryAdapted Basis on simplex products
Test_AOI
Feel::test_disc< value_type, Dim, Order >
Feel::test_integration_boundary< value_type >
Feel::test_integration_circle< value_type >
test_integration_circle< Order, value_type >
Feel::test_integration_composite_functions< Order, value_type >
Feel::test_integration_domain< value_type >
Feel::test_integration_functions< Order, value_type >
Feel::test_integration_internal_faces_lf< value_type, Dim >
Feel::test_integration_internal_faces_v< value_type, Dim >
Feel::test_integration_simplex< value_type >
test_integration_sin< Order, value_type >
Feel::test_integration_vectorial_functions< Order, value_type >
test_interpolation< Dim, Order, GeoOrder >
test_interpolation_op< Dim, Order, RDim, GeoOrder, value_type >
test_interpolation_op_2< DimDomain, OrderDomain, RealDimDomain, DimImage, OrderImage, RealDimImage >
test_lagrange< FE >
test_lagrange_p1_op< Dim, Order, GeoOrder, value_type >
test_mesh_filters
Test_Mixed
Feel::test_submesh< value_type, Dim >
Feel::TestALE< N >
Feel::TestBASpace< Dim, N, T >
Feel::TestConvergence< value_type, Basis, gtOrder, imOrder >
TestDubiner< N, T >
TestFunc1< _Scalar, NX, NY >
TestHermite< FE >Test Hermite Polynomials
TestImPK< D, N, T, QPS >
TestImQK< D, N, T >
TestInterp< Dim, Entity >
TestJacobi< N, T >
TestLagrange< FE >Test Lagrange Polynomials
Feel::TestMixed< Dim, Order >
TestNew1
TestNew2
TestNew3
TestNew4
TestNew5
TestNew6
Feel::TestSpace1< Dim, N, T >
Feel::TestSpace2< Dim, T >
Feel::TestSpaceRT< Dim >
Feel::Tetrahedron< Dim >
Feel::ThermalFin
thurber_functor
Feel::TimerMapTimers map
Feel::TimerPair
Feel::detail::times_x< P >
Feel::TimeSet< MeshType, N >Data TimeSet
tiny_blitz_interface< real, SIZE >
dal::to_be_done_error
ToRotationMatrixWrapper< T >
Trackball
Transform< _Scalar, _Dim, _Mode >Represents an homogeneous transformation in a N dimensional space
Translation< _Scalar, _Dim >Represents a translation transformation
Transpose< MatrixType >Expression of the transpose of a matrix
Transpose< PermutationMatrix< SizeAtCompileTime, MaxSizeAtCompileTime > >
Transpose< Transpositions< SizeAtCompileTime, MaxSizeAtCompileTime > >
gmm::transposed_col_ref< PT >
gmm::transposed_return< PT >
gmm::transposed_return_< TYPE, PT >
gmm::transposed_return_< col_major, PT >
gmm::transposed_return_< row_major, PT >
gmm::transposed_row_ref< PT >
gmm::transposed_type< col_and_row >
gmm::transposed_type< col_major >
gmm::transposed_type< row_and_col >
gmm::transposed_type< row_major >
TransposeImpl< MatrixType, Dense >
TransposeImpl< MatrixType, Sparse >
Transpositions< SizeAtCompileTime, MaxSizeAtCompileTime >Represents a sequence of transpositions (row/column interchange)
TreeTest< Dim >
Feel::Triangle< Dim >
TriangularBase< Derived >Base class for triangular part in a matrix
TriangularProduct< Mode, false, Lhs, true, Rhs, false >
TriangularProduct< Mode, LhsIsTriangular, Lhs, false, Rhs, false >
TriangularProduct< Mode, true, Lhs, false, Rhs, true >
TriangularView< _MatrixType, _Mode >Base class for triangular part in a matrix
Tridiagonalization< _MatrixType >Tridiagonal decomposition of a selfadjoint matrix
TridiagonalMatrix< Scalar, Size, Options >Represents a tridiagonal matrix
Feel::GeoND< Dim, GEOSHAPE, T, POINTTYPE >::tt
Feel::Turek< Dim, Order, GeoOrder >
Feel::TurekApp
tvmet_interface< real, SIZE >
type
type
type
Feel::type_traits< T >
Feel::TypeInfoWrapper for std::type_info
ublas_interface< real >
view::Ui_Main
UniformScaling< _Scalar >
Feel::detail::unsigned_integer< bit_size >
gmm::unsorted_sub_index
ReturnByValue< Derived >::Unusable
UpperBidiagonalization< _MatrixType >
gmm::using_bicgstab
gmm::using_cg
gmm::using_gmres
gmm::using_qmr
Feel::problem< Data >::value< Order >Compute the value of the functionals, equalities and inequalities associated with the problem
NAME< Expr >::Value< isFundamental, Expr_ >
Feel::ADBinaryPow< L, ADCst< int > >::Value< isFundamental, L_, R_ >
Feel::detail::NAME< Expr1, Expr2 >::Value< isFundamental, Expr1_, Expr2_ >
Feel::ADBinaryPow< L, ADCst< int > >::Value< 1, L_, R_ >
Feel::detail::NAME< Expr1, Expr2 >::Value< true, Expr1_, Expr2_ >
NAME< Expr >::Value< true, Expr_ >
gmm::vect_ref_type< const P *, V >
gmm::vect_ref_type< P *, V >
Feel::Vector< T >
std::vector< T, EIGEN_ALIGNED_ALLOCATOR< T > >
STL_algo_interface< real >::vector_generator
Feel::detail::vector_plus< T >
VectorBlock< VectorType, Size >Expression of a fixed-size or dynamic-size sub-vector
KdBVH< _Scalar, _Dim, _Object >::VectorComparator
Feel::Vectorial< Dim >
vectorization_logic< Scalar, Enable >
vectorization_logic< Scalar, false >
VectorType< EigenVectorContainer, Scalar >
VectorType< StdVectorContainer, Scalar >
Feel::VectorUblas< T, Storage >Interface to vector
Feel::VectorValue< T >Interface to vector
VectorwiseOp< ExpressionType, Direction >Pseudo expression providing partial reduction operations
Feel::VisitableBase< R, CatchAll >
Feel::VisitableCatchAllDefault< R, Visited >
Feel::Visitor< T, R >
Feel::VisitorBaseThe base class of any Acyclic Visitor
VisitorBaseImplImplements non-strict visitation (you can implement only part of the Visit functions)
Feel::VisitorBaseImpl< mpl::list< Head >, R >
Feel::VisitorBaseImpl< mpl::list< Head, Tail >, R >
Feel::VisitorCyclic< R, TList >
Feel::VisitorList< TList, R >
dal::warning_level
Feel::Wave< Dim, Order, Cont, Entity, FType >
gmm::which_part< R, PART >
gmm::which_reference< PT >
gmm::which_reference< const PT * >
gmm::which_reference< PT * >
WithFormat< ExpressionType >Pseudo expression providing matrix output with given format
Feel::Wrapper1App
gmm::wsvector< T >
gmm::wsvector_const_iterator< T >
gmm::wsvector_iterator< T >
x2
X86_Perf_Analyzer< ACTION >
X86_Timer
Feel::xmlParser

Generated by  Doxygen 1.6.0   Back to index