level3_impl.h File Reference

#include <iostream>
#include "common.h"

Go to the source code of this file.

Typedefs
typedef void(*	functype) (DenseIndex, DenseIndex, DenseIndex, const Scalar *, DenseIndex, const Scalar *, DenseIndex, Scalar *, DenseIndex, DenseIndex, Scalar, Eigen::internal::level3_blocking< Scalar, Scalar > &, Eigen::internal::GemmParallelInfo< DenseIndex > *)

Functions
	if (OP(*opa)==INVALID) info
else if *	lda (1,(OP(*opa)==NOTR) ? *m :*k)) info=8;else if(*ldb< std::max(1,(OP(*opb)==NOTR) ? *k :*n)) info=10;else if(*ldc< std::max(1, *m)) info=13;if(info) return xerbla_(SCALAR_SUFFIX_UP "GEMM ", &info
	if (beta !=Scalar(1))
	if (SIDE(*side)==INVALID) info = 1
else	if (UPLO(*uplo)==INVALID) info
else	if (DIAG(*diag)==INVALID) info
else if *	lda (1,(SIDE(*side)==LEFT) ? *m :*n)) info=9;else if(*ldb< std::max(1, *m)) info=11;if(info) return xerbla_(SCALAR_SUFFIX_UP "TRSM ", &info
	if (alpha !=Scalar(1)) matrix(b
	matrix (b, *m, *n, *ldb).setZero()
Eigen::Matrix< Scalar, Dynamic, Dynamic, ColMajor >	matA (size, size)
else if *	lda (1,(OP(*op)==NOTR) ? *n :*k)) info=7;else if(*ldc< std::max(1, *n)) info=10;if(info) return xerbla_(SCALAR_SUFFIX_UP "SYRK ", &info
else	matrix (c, *n, *n, *ldc).triangularView< Lower >()+
	if (beta==Scalar(0)) matrix(c
*ldc	setZero ()
else	if ((OP(*op)==INVALID)||(OP(*op)==TR)) info = 2
if *	k (0)

Variables
const char *	opa
const char const char *	opb
const char const char const int *	m
const char const char const int const int *	n
const char const char const int const int const int *	k
const char const char const int const int const int const RealScalar *	palpha
const char const char const int const int const int const RealScalar const RealScalar *	pa
const char const char const int const int const int const RealScalar const RealScalar const int *	lda
const char const char const int const int const int const RealScalar const RealScalar const int const RealScalar *	pb
const char const char const int const int const int const RealScalar const RealScalar const int const RealScalar const int *	ldb
const char const char const int const int const int const RealScalar const RealScalar const int const RealScalar const int const RealScalar *	pbeta
const char const char const int const int const int const RealScalar const RealScalar const int const RealScalar const int const RealScalar RealScalar *	pc
const char const char const int const int const int const RealScalar const RealScalar const int const RealScalar const int const RealScalar RealScalar const int *	ldc
static const functype	func [12]
const Scalar *	a = reinterpret_cast<const Scalar *>(pa)
const Scalar *	b = reinterpret_cast<const Scalar *>(pb)
Scalar *	c = reinterpret_cast<Scalar *>(pc)
Scalar	alpha = *reinterpret_cast<const Scalar *>(palpha)
Scalar	beta = *reinterpret_cast<const Scalar *>(pbeta)
int	info = 0
if m	return = beta
int	code = OP(*opa) | (OP(*opb) << 2)
const char *	side = alpha
const char const char *	uplo
const char const char const char const char *	diag
	else
Eigen::Matrix< Scalar, Dynamic, Dynamic, ColMajor >	tmp = matrix(b, *m, *n, *ldb)
int	size = (SIDE(*side) == LEFT) ? (*m) : (*n)
const char const char *	op

Typedef Documentation

functype

typedef void(* functype)(DenseIndex, DenseIndex, const Scalar *, DenseIndex, const Scalar *, DenseIndex, Scalar *, DenseIndex, DenseIndex, const Scalar &, Eigen::internal::level3_blocking< Scalar, Scalar > &)

Function Documentation

if() [1/8]

else if

(

(OP(*op)==INVALID)||(OP(*op)==TR)

)

= 2

if() [2/8]

if

(

alpha !

= Scalar(1)

)

if() [3/8]

if

(

beta !

= Scalar(1)

)

                         {
    if (beta == Scalar(0))
      matrix(c, *m, *n, *ldc).setZero();
    else
      matrix(c, *m, *n, *ldc) *= beta;
  }

References beta, c, ldc, m, matrix(), and n.

if() [4/8]

if

(

beta

= = Scalar(0)

)

if() [5/8]

else if

(

DIAG *

diag = =INVALID

)

if() [6/8]

if

(

OP *

opa = = INVALID

)

                       {
    if (UPLO(*uplo) == UP) {
      matrix(c, *n, *n, *ldc).triangularView<Upper>() +=
          alpha * matrix(a, *n, *k, *lda) * matrix(b, *n, *k, *ldb).transpose() +
          alpha * matrix(b, *n, *k, *ldb) * matrix(a, *n, *k, *lda).transpose();
    } else if (UPLO(*uplo) == LO)
      matrix(c, *n, *n, *ldc).triangularView<Lower>() +=
          alpha * matrix(a, *n, *k, *lda) * matrix(b, *n, *k, *ldb).transpose() +
          alpha * matrix(b, *n, *k, *ldb) * matrix(a, *n, *k, *lda).transpose();
  } else if (OP(*op) == TR || OP(*op) == ADJ) {

References a, alpha, b, c, k, lda, ldb, ldc, LO, Eigen::Lower, matrix(), n, UP, UPLO, uplo, and Eigen::Upper.

if() [7/8]

else if

(

SIDE *

side = = INVALID

)

= 1

                           {
    Eigen::internal::gemm_blocking_space<ColMajor, Scalar, Scalar, Dynamic, Dynamic, Dynamic, 4> blocking(*m, *n, *m, 1,
                                                                                                          false);
    func[code](*m, *n, a, *lda, b, 1, *ldb, blocking);
  } else {

References a, b, code, lda, ldb, LEFT, m, and n.

if() [8/8]

else if

(

UPLO *

uplo = =INVALID

)

                         {
    matA.triangularView<Upper>() = matrix(a, size, size, *lda);
    matA.triangularView<Lower>() = matrix(a, size, size, *lda).transpose();
  } else if (UPLO(*uplo) == LO) {

References a, lda, Eigen::Lower, matA(), matrix(), size, and Eigen::Upper.

Referenced by blas.Blas::__init__(), lapack.Lapack::__init__(), framework.Frame::__init__(), blacs.Blacs::check_blacs(), blas.Blas::check_blas(), lapack.Lapack::check_lapack(), framework.Frame::check_linking(), framework.Frame::check_mpicc(), framework.Frame::check_mpif77(), Eigen::Serializer< DenseBase< Derived >, void >::deserialize(), Eigen::Serializer< SparseMatrix< Scalar, Options, StorageIndex >, void >::deserialize(), Eigen::Serializer< SparseVector< Scalar, Options, StorageIndex >, void >::deserialize(), scalapack.Scalapack::down_install(), blacs.Blacs::down_install_blacs(), blas.Blas::down_install_blas(), lapack.Lapack::down_install_lapack(), utils::downloader(), utils::fixpaths(), fpdiff::fpdiff_helper(), utils::killfiles(), framework.Frame::look_for_mpibinaries(), framework.Frame::look_for_mpih(), Eigen::SluMatrix::Map(), framework.Frame::parse_args(), fpdiff::read_file(), framework.Frame::set_download(), lapack.Lapack::set_etime(), framework.Frame::set_mangling(), blacs.Blacs::set_transcomm(), and test_empty_runqueue().

k()

if* k

(

0

)

                                        {
    Eigen::internal::gemm_blocking_space<ColMajor, Scalar, Scalar, Dynamic, Dynamic, Dynamic> blocking(*n, *n, *k, 1,
                                                                                                       false);
    func[code](*n, *k, a, *lda, a, *lda, c, 1, *ldc, alpha, blocking);
    matrix(c, *n, *n, *ldc).diagonal().imag().setZero();
  }

References a, alpha, c, code, k, lda, ldc, matrix(), and n.

lda() [1/3]

else if* lda	(	1	,
		(OP(*op)==NOTR) ? *n :*	k
	)		&

lda() [2/3]

else if* lda	(	1	,
		(OP(*opa)==NOTR) ? *m :*	k
	)		&

lda() [3/3]

else if* lda	(	1	,
		(SIDE(*side)==LEFT) ? *m :*	n
	)		&

References LEFT.

matA()

Eigen::Matrix<Scalar, Dynamic, Dynamic, ColMajor> matA	(	size	,
		size
	)

Referenced by Eigen::HessenbergDecomposition< MatrixType_ >::_compute(), cholesky_bug241(), Eigen::GeneralizedSelfAdjointEigenSolver< MatrixType_ >::compute(), Eigen::GeneralizedSelfAdjointEigenSolver< MatrixType_ >::GeneralizedSelfAdjointEigenSolver(), if(), and Eigen::internal::tridiagonalization_inplace().

matrix() [1/2]

matrix	(	b	,
		*	m,
		*	n,
		*	ldb
	)

References a, alpha, b, code, Eigen::PlainObjectBase< Derived >::data(), lda, ldb, m, n, Eigen::Matrix< Scalar_, Rows_, Cols_, Options_, MaxRows_, MaxCols_ >::outerStride(), and tmp.

Referenced by if(), and k().

matrix() [2/2]

else matrix	(	c	,
		*	n,
		*	n,
		*	ldc
	)

setZero()

* ldc setZero

(

)

References LEFT.

Variable Documentation

a

const Scalar* a = reinterpret_cast<const Scalar *>(pa)

Referenced by if(), k(), and matrix().

alpha

Scalar alpha = *reinterpret_cast<const Scalar *>(palpha)

Referenced by if(), k(), and matrix().

b

const Scalar* b = reinterpret_cast<const Scalar *>(pb)

Referenced by if(), and matrix().

beta

RealScalar beta = *reinterpret_cast<const Scalar *>(pbeta)

Referenced by if().

c

Scalar* c = reinterpret_cast<Scalar *>(pc)

Referenced by if(), and k().

code

int code = OP(*opa) | (OP(*opb) << 2)

Referenced by if(), k(), and matrix().

diag

* ldb* const char const char const char const char* diag

else

else

Initial value:

{
    Eigen::internal::gemm_blocking_space<ColMajor, Scalar, Scalar, Dynamic, Dynamic, Dynamic, 4> blocking(*m, *n, *n, 1,
                                                                                                          false)

func

static const functype func

static

info

else if k info = 0

k

const char const char const int const int* k

Referenced by if(), and k().

lda

const char const char const int const int const RealScalar const RealScalar const int* lda

Referenced by if(), k(), and matrix().

ldb

const char const char const int const int const RealScalar const RealScalar const int const RealScalar const int * ldb

Initial value:

{
  
  
  using Eigen::ColMajor

Referenced by if(), and matrix().

ldc

const char const char const int const int const RealScalar const RealScalar const int const RealScalar const int const RealScalar RealScalar const int* ldc

Initial value:

{
  
  
  using Eigen::ColMajor

Referenced by if(), and k().

m

Eigen::internal::gemm_blocking_space<ColMajor, Scalar, Scalar, Dynamic, Dynamic, Dynamic> blocking* m

Referenced by if(), and matrix().

n

const char const char const int* n

Referenced by if(), k(), and matrix().

op

const char const char* op

opa

* ldb* const char const char const char* opa

opb

const char const char* opb

pa

const char const char const int const int const RealScalar const RealScalar* pa

palpha

const char const char const int const int const RealScalar* palpha

pb

const char const char const int const int const RealScalar const RealScalar const int const RealScalar* pb

pbeta

const char const char const int const int const RealScalar const RealScalar const int const RealScalar const int const RealScalar* pbeta

pc

const char const char const int const int const RealScalar const RealScalar const int const RealScalar const int const RealScalar RealScalar* pc

return

if k return = beta

side

const char * side = alpha

Referenced by check_side(), Eigen::internal::SimpleTensorContractionMapper< Scalar, Index, side, Tensor, nocontract_t, contract_t, packet_size, inner_dim_contiguous, Alignment, MakePointer_ >::computeIndex(), Eigen::internal::SimpleTensorContractionMapper< Scalar, Index, side, Tensor, nocontract_t, contract_t, packet_size, inner_dim_contiguous, Alignment, MakePointer_ >::computeIndexPair(), Eigen::internal::SimpleTensorContractionMapper< Scalar, Index, side, Tensor, nocontract_t, contract_t, packet_size, inner_dim_contiguous, Alignment, MakePointer_ >::firstAligned(), Eigen::internal::BaseTensorContractionMapper< Scalar, Index, side, Tensor, nocontract_t, contract_t, packet_size, inner_dim_contiguous, inner_dim_reordered, Alignment, MakePointer_ >::load(), RotatingDrumBidisperseInitialise::RotatingDrumBidisperseInitialise(), Drum::setupInitialConditions(), and Eigen::internal::SimpleTensorContractionMapper< Scalar, Index, side, Tensor, nocontract_t, contract_t, packet_size, inner_dim_contiguous, Alignment, MakePointer_ >::stride().

size

int size = (SIDE(*side) == LEFT) ? (*m) : (*n)

Referenced by if().

tmp

Eigen::Matrix<Scalar, Dynamic, Dynamic, ColMajor> tmp = matrix(b, *m, *n, *ldb)

Referenced by Eigen::PardisoImpl< Derived >::_solve_impl(), Eigen::SVDBase< Derived >::_solve_impl(), Eigen::SVDBase< Derived >::_solve_impl_transposed(), Eigen::IterativeSolverBase< Derived >::_solve_with_guess_impl(), Eigen::internal::gebp_traits< std::complex< RealScalar >, std::complex< RealScalar >, ConjLhs_, ConjRhs_, Arch, PacketSize_ >::acc(), oomph::SpineAxisymmetricMarangoniSurfactantFluidInterfaceElement< ELEMENT >::add_additional_residual_contributions_interface(), Eigen::SimplicialCholeskyBase< Derived >::analyzePattern(), Eigen::internal::apply_block_householder_on_the_left(), Eigen::MatrixBase< Derived >::applyHouseholderOnTheLeft(), Eigen::MatrixBase< Derived >::applyHouseholderOnTheRight(), array_real(), oomph::Problem::assign_eqn_numbers(), Eigen::internal::triangular_dense_assignment_kernel< UpLo, SelfAdjoint, SetOpposite, DstEvaluatorTypeT, SrcEvaluatorTypeT, Functor, Version >::assignCoeff(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::assignDiagonal(), Eigen::internal::generic_dense_assignment_kernel< DstEvaluatorTypeT, SrcEvaluatorTypeT, swap_assign_op< typename DstEvaluatorTypeT::Scalar >, Specialized >::assignPacket(), basic_tuple_test(), Eigen::Spline< Scalar_, Dim_, Degree_ >::BasisFunctions(), Eigen::internal::bicgstab(), oomph::HelmholtzMGPreconditioner< DIM >::block_preconditioner_self_test(), bug1684_job3(), Eigen::TensorEvaluator< const TensorFFTOp< FFT, ArgType, FFTResultType, FFTDir >, Device >::butterfly_2(), Eigen::TensorEvaluator< const TensorFFTOp< FFT, ArgType, FFTResultType, FFTDir >, Device >::butterfly_4(), Eigen::internal::simpl_chol_helper< Scalar, StorageIndex >::calc_etree(), Eigen::internal::simpl_chol_helper< Scalar, StorageIndex >::calc_hadj_inner(), Eigen::internal::call_assignment(), call_ref(), oomph::checked_dynamic_cast(), cholesky_verify_assert(), cod_verify_assert(), Eigen::SimplicialCholeskyBase< Derived >::compute(), Eigen::ThreadPoolTempl< Environment >::ComputeCoprimes(), Eigen::internal::conjugate_gradient(), copy_matrix(), diagonalmatrices(), Eigen::BDCSVD< MatrixType_, Options_ >::divide(), oomph::MemoryUsage::doc_total_memory_usage(), dont_over_optimize(), GpuHelper::drawVector(), GpuHelper::drawVectorBox(), eigen33(), EIGEN_DECLARE_TEST(), eiToGmm(), Eigen::MatrixExponentialReturnValue< Derived >::evalTo(), Eigen::MatrixSquareRootReturnValue< Derived >::evalTo(), Eigen::TensorEvaluator< const TensorFFTOp< FFT, ArgType, FFTResultType, FFTDir >, Device >::evalToBuf(), oomph::DenseLU::factorise(), Eigen::SimplicialCholeskyBase< Derived >::factorize(), Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::factorize(), oomph::AdvectionDiffusionEquations< DIM >::fill_in_generic_residual_contribution_adv_diff(), oomph::RefineableAdvectionDiffusionEquations< DIM >::fill_in_generic_residual_contribution_adv_diff(), oomph::AdvectionDiffusionReactionEquations< NREAGENT, DIM >::fill_in_generic_residual_contribution_adv_diff_react(), oomph::RefineableAdvectionDiffusionReactionEquations< NREAGENT, DIM >::fill_in_generic_residual_contribution_adv_diff_react(), oomph::RefineableGeneralisedAdvectionDiffusionEquations< DIM >::fill_in_generic_residual_contribution_cons_adv_diff(), oomph::RefineableGeneralisedAxisymAdvectionDiffusionEquations::fill_in_generic_residual_contribution_cons_axisym_adv_diff(), oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::fill_in_generic_residual_contribution_nst(), oomph::RefineableGeneralisedNewtonianNavierStokesEquations< DIM >::fill_in_generic_residual_contribution_nst(), oomph::NavierStokesEquations< DIM >::fill_in_generic_residual_contribution_nst(), oomph::RefineableNavierStokesEquations< DIM >::fill_in_generic_residual_contribution_nst(), oomph::RefineableUnsteadyHeatEquations< DIM >::fill_in_generic_residual_contribution_ust_heat(), oomph::WomersleyEquations< DIM >::fill_in_generic_residual_contribution_womersley(), oomph::FSIDiagHermiteShellElement::fluid_load_rate_of_work(), generalized_eigensolver_real(), oomph::AxisymmetricNavierStokesEquations::get_dresidual_dnodal_coordinates(), oomph::RefineableAxisymmetricNavierStokesEquations::get_dresidual_dnodal_coordinates(), oomph::GeneralisedNewtonianAxisymmetricNavierStokesEquations::get_dresidual_dnodal_coordinates(), oomph::RefineableGeneralisedNewtonianAxisymmetricNavierStokesEquations::get_dresidual_dnodal_coordinates(), oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::get_dresidual_dnodal_coordinates(), oomph::RefineableGeneralisedNewtonianNavierStokesEquations< DIM >::get_dresidual_dnodal_coordinates(), oomph::NavierStokesEquations< DIM >::get_dresidual_dnodal_coordinates(), oomph::RefineableNavierStokesEquations< DIM >::get_dresidual_dnodal_coordinates(), oomph::SpaceTimeNavierStokesEquations< DIM >::get_dresidual_dnodal_coordinates(), oomph::RefineableSpaceTimeNavierStokesEquations< DIM >::get_dresidual_dnodal_coordinates(), householder(), householder_update(), oomph::QTaylorHoodElement< 2 >::identify_load_data(), Eigen::internal::IndexMapper< Index, InputDims, NumKernelDims, Layout >::IndexMapper(), Eigen::KdBVH< Scalar_, Dim_, _Object >::init(), oomph::MemoryUsage::insert_comment_to_continous_top(), Eigen::internal::kissfft_impl< Scalar_ >::inv(), Eigen::internal::least_square_conjugate_gradient(), Eigen::internal::gebp_traits< std::complex< RealScalar >, RealScalar, ConjLhs_, false, Arch, PacketSize_ >::loadRhsQuad_impl(), lu_verify_assert(), oomph::DenseComplexMatrix::ludecompose(), Eigen::internal::gebp_traits< LhsScalar_, RhsScalar_, ConjLhs_, ConjRhs_, Arch, PacketSize_ >::madd(), Eigen::internal::gebp_traits< std::complex< RealScalar >, RealScalar, ConjLhs_, false, Arch, PacketSize_ >::madd(), Eigen::internal::gebp_traits< RealScalar, std::complex< RealScalar >, false, ConjRhs_, Arch, PacketSize_ >::madd(), Eigen::internal::gebp_traits< std::complex< RealScalar >, std::complex< RealScalar >, ConjLhs_, ConjRhs_, Arch, PacketSize_ >::madd(), Eigen::internal::gebp_traits< std::complex< RealScalar >, RealScalar, ConjLhs_, false, Arch, PacketSize_ >::madd_impl(), Eigen::internal::gebp_traits< RealScalar, std::complex< RealScalar >, false, ConjRhs_, Arch, PacketSize_ >::madd_impl(), main(), Eigen::MatrixMarketIterator< Scalar >::matrix(), matrix(), Eigen::internal::matrix_exp_pade13(), Eigen::internal::matrix_exp_pade3(), Eigen::internal::matrix_exp_pade5(), Eigen::internal::matrix_exp_pade7(), Eigen::internal::matrix_exp_pade9(), Eigen::internal::matrix_sqrt_quasi_triangular_1x1_off_diagonal_block(), Eigen::matrix_sqrt_triangular(), move_matrix(), Eigen::TensorSycl::internal::TensorContractionKernel< OutScalar, LhsScalar, RhsScalar, OutAccessor, LhsMapper, RhsMapper, StorageIndex, Properties, TripleDim, Vectorizable, input_mapper_properties, IsFinal, contraction_tp >::operator()(), Eigen::TensorSycl::internal::ScanKernelFunctor< Evaluator, CoeffReturnType, OutAccessor, Op, Index, stp >::operator()(), Eigen::TensorSycl::internal::ScanAdjustmentKernelFunctor< CoeffReturnType, InAccessor, OutAccessor, Op, Index >::operator()(), Eigen::internal::GaussianGenerator< T, Index, NumDims >::operator()(), Eigen::internal::operator/(), Eigen::TensorStorage< T, DSizes< IndexType, NumIndices_ >, Options_ >::operator=(), Eigen::internal::sparse_matrix_block_impl< SparseMatrixType, BlockRows, BlockCols >::operator=(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::operator=(), Eigen::SparseVector< Scalar_, Options_, StorageIndex_ >::operator=(), oomph::GeneralisedAdvectionDiffusionEquations< 2 >::output_fct(), oomph::UnsteadyHeatEquations< 2 >::output_fct(), Eigen::internal::pcast< Packet4f, Packet2l >(), Eigen::internal::pcast< Packet4f, Packet2ul >(), Eigen::internal::pcast< Packet8s, Packet2d >(), Eigen::internal::pcast< Packet8us, Packet2d >(), Eigen::internal::pcmp_eq(), Eigen::internal::pconj(), Eigen::internal::permutation_matrix_product< ExpressionType, Side, Transposed, SparseShape >::permute_inner(), Eigen::internal::permutation_matrix_product< ExpressionType, Side, Transposed, SparseShape >::permute_outer(), Eigen::BDCSVD< MatrixType_, Options_ >::perturbCol0(), Eigen::internal::pexp_double(), Eigen::internal::pgather< std::complex< double >, Packet1cd >(), Eigen::internal::pgather< std::complex< float >, Packet1cf >(), Eigen::internal::ploaddup< Packet16b >(), Eigen::internal::ploaddup< Packet16c >(), Eigen::internal::ploaddup< Packet16uc >(), Eigen::internal::ploaddup< Packet4d >(), Eigen::internal::ploaddup< Packet4i >(), Eigen::internal::ploaddup< Packet4ui >(), Eigen::internal::ploaddup< Packet8d >(), Eigen::internal::ploaddup< Packet8f >(), Eigen::internal::ploaddup< Packet8i >(), Eigen::internal::ploaddup< Packet8l >(), Eigen::internal::ploaddup< Packet8s >(), Eigen::internal::ploaddup< Packet8ui >(), Eigen::internal::ploaddup< Packet8us >(), Eigen::internal::ploadquad< Packet16b >(), Eigen::internal::ploadquad< Packet16c >(), Eigen::internal::ploadquad< Packet16f >(), Eigen::internal::ploadquad< Packet16i >(), Eigen::internal::ploadquad< Packet16uc >(), Eigen::internal::ploadquad< Packet4i >(), Eigen::internal::ploadquad< Packet4ui >(), Eigen::internal::ploadquad< Packet8d >(), Eigen::internal::ploadquad< Packet8f >(), Eigen::internal::ploadquad< Packet8l >(), Eigen::internal::ploadquad< Packet8s >(), Eigen::internal::ploadquad< Packet8us >(), Eigen::internal::plog_impl_double(), Eigen::internal::plog_impl_float(), Eigen::internal::predux< Packet16b >(), Eigen::internal::predux< Packet4ui >(), Eigen::internal::predux_max< Packet4d >(), Eigen::internal::predux_max< Packet4ui >(), Eigen::internal::predux_max< Packet8f >(), Eigen::internal::predux_min< Packet4d >(), Eigen::internal::predux_min< Packet4ui >(), Eigen::internal::predux_min< Packet8f >(), Eigen::internal::predux_mul< Packet16b >(), Eigen::internal::predux_mul< Packet4d >(), Eigen::internal::predux_mul< Packet4ui >(), Eigen::internal::predux_mul< Packet8f >(), Eigen::internal::preverse(), product_extra(), product_notemporary(), Eigen::internal::psignbit(), Eigen::internal::ptranspose(), qr(), qr_verify_assert(), Eigen::SparseSelfAdjointView< MatrixType, Mode_ >::rankUpdate(), oomph::Problem::read(), Eigen::internal::real_2x2_jacobi_svd(), helpers::removeFromCommandline(), Eigen::TensorEvaluator< const TensorRollOp< RollDimensions, ArgType >, Device >::roll(), Eigen::internal::simplicial_cholesky_grab_input< CholMatrixType, InputMatrixType >::run(), Eigen::internal::sparse_solve_triangular_selector< Lhs, Rhs, Mode, Lower, RowMajor >::run(), Eigen::internal::sparse_solve_triangular_selector< Lhs, Rhs, Mode, Upper, RowMajor >::run(), Eigen::internal::sparse_solve_triangular_selector< Lhs, Rhs, Mode, Lower, ColMajor >::run(), Eigen::internal::sparse_solve_triangular_selector< Lhs, Rhs, Mode, Upper, ColMajor >::run(), Eigen::internal::generic_reciprocal_newton_step< Packet, Steps >::run(), Eigen::internal::conservative_resize_like_impl< Derived, OtherDerived, IsVector >::run(), Eigen::internal::direct_selfadjoint_eigenvalues< SolverType, 3, false >::run(), Eigen::internal::Assignment< DstXprType, SrcXprType, Functor, SparseSelfAdjoint2Sparse >::run(), Eigen::internal::Assignment< DstXprType, SparseSymmetricPermutationProduct< MatrixType, Mode >, internal::assign_op< Scalar, typename MatrixType::Scalar >, Sparse2Sparse >::run(), oomph::MemoryUsage::run_continous_top(), rvalue_copyassign(), Eigen::internal::set_from_triplets(), oomph::SimpleTwoDofOnly< MATRIX >::setup(), oomph::SimpleOneDofOnly< MATRIX >::setup(), oomph::CoarseTwoIntoOne< MATRIX >::setup(), oomph::TwoPlusThree< MATRIX >::setup(), oomph::TwoPlusThreeUpperTriangular< MATRIX >::setup(), oomph::TwoPlusThreeUpperTriangularWithOneLevelSubsidiary< MATRIX >::setup(), oomph::TwoPlusOneUpperTriangularPreconditioner< MATRIX >::setup(), oomph::TwoPlusThreeUpperTriangularWithTwoLevelSubsidiary< MATRIX >::setup(), oomph::TwoPlusThreeUpperTriangularWithReplace< MATRIX >::setup(), oomph::CoarseTwoPlusTwoPlusOne< MATRIX >::setup(), oomph::OnePlusFourWithTwoCoarse< MATRIX >::setup(), oomph::LineVisualiser::setup_from_file(), oomph::HelmholtzMGPreconditioner< DIM >::setup_mg_structures(), Eigen::Transform< Scalar_, Dim_, Mode_, Options_ >::shear(), Eigen::Rotation2D< Scalar_ >::smallestAngle(), Eigen::Rotation2D< Scalar_ >::smallestPositiveAngle(), oomph::HSL_MA42::solve(), oomph::HelmholtzGMRESMG< MATRIX >::solve(), oomph::HelmholtzFGMRESMG< MATRIX >::solve(), Eigen::internal::solve_sparse_through_dense_panels(), sparse_vector(), Eigen::internal::stable_norm_kernel(), Eigen::RealQZ< MatrixType_ >::step(), oomph::MemoryUsage::stop_continous_top(), Eigen::BDCSVD< MatrixType_, Options_ >::structured_update(), svd_min_norm(), svd_preallocate(), test_conj_helper(), test_stl_iterators(), Eigen::AngleAxis< Scalar_ >::toRotationMatrix(), Eigen::SelfAdjointView< MatrixType_, UpLo >::transpose(), Eigen::TriangularView< MatrixType_, Mode_ >::transpose(), Eigen::umeyama(), Eigen::internal::ldlt_inplace< Lower >::unblocked(), Eigen::internal::ldlt_inplace< Lower >::update(), Eigen::internal::ldlt_inplace< Upper >::update(), Eigen::internal::upperbidiagonalization_blocked_helper(), vectorwiseop_matrix(), Eigen::internal::detail::zip_in_place< Packet16c >(), Eigen::internal::detail::zip_in_place< Packet16uc >(), Eigen::internal::detail::zip_in_place< Packet2f >(), Eigen::internal::detail::zip_in_place< Packet2i >(), Eigen::internal::detail::zip_in_place< Packet2ui >(), Eigen::internal::detail::zip_in_place< Packet4bf >(), Eigen::internal::detail::zip_in_place< Packet4f >(), Eigen::internal::detail::zip_in_place< Packet4i >(), Eigen::internal::detail::zip_in_place< Packet4s >(), Eigen::internal::detail::zip_in_place< Packet4ui >(), Eigen::internal::detail::zip_in_place< Packet4us >(), Eigen::internal::detail::zip_in_place< Packet8c >(), Eigen::internal::detail::zip_in_place< Packet8s >(), Eigen::internal::detail::zip_in_place< Packet8uc >(), Eigen::internal::detail::zip_in_place< Packet8us >(), and Eigen::RandomSetter< SparseMatrixType, MapTraits, OuterPacketBits >::~RandomSetter().

uplo

const char* uplo

Referenced by if().