#include "common.h"

Functions
	if (UPLO(*uplo)==INVALID) info = 1

else if *	lda (1, n)) info=5;else if(incx==0) info=7;else if(*incy==0) info=10;if(info) return xerbla_(SCALAR_SUFFIX_UP "HEMV ", &info

	if (beta !=Scalar(1))

	if (alpha !=Scalar(0))

	if (actual_x !=x) delete[] actual_x

	if (actual_y !=y) delete[] copy_back(actual_y

EIGEN_BLAS_FUNC()	hpr (char uplo, int n, RealScalar palpha, RealScalar px, int incx, RealScalar pap)

	if (info) return xerbla_(SCALAR_SUFFIX_UP "HPR2 "

	if (alpha==Scalar(0)) return

	if (code >=2\|\|func[code]==0) return

	if (x_cpy !=x) delete[] x_cpy

	if (y_cpy !=y) delete[] y_cpy

EIGEN_BLAS_FUNC()	her (char uplo, int n, RealScalar palpha, RealScalar px, int incx, RealScalar pa, int *lda)

	matrix (a, n, n, *lda).diagonal().imag().setZero()

Variables
const char *	uplo

const char const int *	n

const char const int const RealScalar *	palpha

const char const int const RealScalar const RealScalar *	pa

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

const char const int const RealScalar const RealScalar const int const RealScalar *	px

const char const int const RealScalar const RealScalar const int const RealScalar const int *	incx

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

const char const int const RealScalar const RealScalar const int const RealScalar const int const RealScalar RealScalar *	py

const char const int const RealScalar const RealScalar const int const RealScalar const int const RealScalar RealScalar const int *	incy

static const functype	func [2]

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

const Scalar *	x = reinterpret_cast<const Scalar *>(px)

Scalar *	y = reinterpret_cast<Scalar *>(py)

Scalar	alpha = reinterpret_cast<const Scalar >(palpha)

Scalar	beta = reinterpret_cast<const Scalar >(pbeta)

int	info = 0

if n	return

const Scalar *	actual_x = get_compact_vector(x, n, incx)

Scalar *	actual_y = get_compact_vector(y, n, incy)

char int RealScalar RealScalar int RealScalar int RealScalar *	pap

Scalar *	ap = reinterpret_cast<Scalar *>(pap)

Scalar *	x_cpy = get_compact_vector(x, n, incx)

Scalar *	y_cpy = get_compact_vector(y, n, incy)

int	code = UPLO(*uplo)

int *	m

Function Documentation

◆ her()

EIGEN_BLAS_FUNC() her	(	char *	uplo,
		int *	n,
		RealScalar *	palpha,
		RealScalar *	px,
		int *	incx,
		RealScalar *	pa,
		int *	lda
	)

ZHER performs the hermitian rank 1 operation

A := alpha*x*conjg( x' ) + A,

where alpha is a real scalar, x is an n element vector and A is an n by n hermitian matrix.

                                                                                                                   {
   typedef void (*functype)(int, Scalar *, int, const Scalar *, const Scalar *, const Scalar &);
   static const functype func[2] = {
       // array index: UP
       (Eigen::selfadjoint_rank1_update<Scalar, int, Eigen::ColMajor, Eigen::Upper, false, Conj>::run),
       // array index: LO
       (Eigen::selfadjoint_rank1_update<Scalar, int, Eigen::ColMajor, Eigen::Lower, false, Conj>::run),
   };
  
   Scalar *x = reinterpret_cast<Scalar *>(px);
   Scalar *a = reinterpret_cast<Scalar *>(pa);
   RealScalar alpha = *reinterpret_cast<RealScalar *>(palpha);
  
   int info = 0;
   if (UPLO(*uplo) == INVALID)
     info = 1;
   else if (*n < 0)
     info = 2;
   else if (*incx == 0)
     info = 5;
   else if (*lda < std::max(1, *n))
     info = 7;
   if (info) return xerbla_(SCALAR_SUFFIX_UP "HER  ", &info);
  
   if (alpha == RealScalar(0)) return;
  
   Scalar *x_cpy = get_compact_vector(x, *n, *incx);
  
   int code = UPLO(*uplo);
   if (code >= 2 || func[code] == 0) return;
  
   func[code](*n, a, *lda, x_cpy, x_cpy, alpha);
  
   matrix(a, *n, *n, *lda).diagonal().imag().setZero();
  
   if (x_cpy != x) delete[] x_cpy;
 }

References a, alpha, code, get_compact_vector(), incx, info, int(), INVALID, lda, matrix(), max, n, pa, palpha, px, SCALAR_SUFFIX_UP, UPLO, uplo, x, x_cpy, and xerbla_().

◆ hpr()

EIGEN_BLAS_FUNC() hpr	(	char *	uplo,
		int *	n,
		RealScalar *	palpha,
		RealScalar *	px,
		int *	incx,
		RealScalar *	pap
	)

ZHBMV performs the matrix-vector operation

y := alpha*A*x + beta*y,

where alpha and beta are scalars, x and y are n element vectors and A is an n by n hermitian band matrix, with k super-diagonals. ZHPMV performs the matrix-vector operation

y := alpha*A*x + beta*y,

where alpha and beta are scalars, x and y are n element vectors and A is an n by n hermitian matrix, supplied in packed form. ZHPR performs the hermitian rank 1 operation

A := alpha*x*conjg( x' ) + A,

where alpha is a real scalar, x is an n element vector and A is an n by n hermitian matrix, supplied in packed form.

                                                                                                          {
   typedef void (*functype)(int, Scalar *, const Scalar *, RealScalar);
   static const functype func[2] = {
       // array index: UP
       (Eigen::internal::selfadjoint_packed_rank1_update<Scalar, int, Eigen::ColMajor, Eigen::Upper, false, Conj>::run),
       // array index: LO
       (Eigen::internal::selfadjoint_packed_rank1_update<Scalar, int, Eigen::ColMajor, Eigen::Lower, false, Conj>::run),
   };
  
   Scalar *x = reinterpret_cast<Scalar *>(px);
   Scalar *ap = reinterpret_cast<Scalar *>(pap);
   RealScalar alpha = *palpha;
  
   int info = 0;
   if (UPLO(*uplo) == INVALID)
     info = 1;
   else if (*n < 0)
     info = 2;
   else if (*incx == 0)
     info = 5;
   if (info) return xerbla_(SCALAR_SUFFIX_UP "HPR  ", &info);
  
   if (alpha == Scalar(0)) return;
  
   Scalar *x_cpy = get_compact_vector(x, *n, *incx);
  
   int code = UPLO(*uplo);
   if (code >= 2 || func[code] == 0) return;
  
   func[code](*n, ap, x_cpy, alpha);
  
   if (x_cpy != x) delete[] x_cpy;
 }

References alpha, ap, code, get_compact_vector(), incx, info, int(), INVALID, n, palpha, pap, px, SCALAR_SUFFIX_UP, UPLO, uplo, x, x_cpy, and xerbla_().

◆ if() [1/10]

if ( actual_x ! = x )

◆ if() [2/10]

if ( actual_y ! = y )

◆ if() [3/10]

if ( alpha ! = Scalar(0) )

                           {
     int code = UPLO(*uplo);
     if (code >= 2 || func[code] == 0) return;
  
     func[code](*n, a, *lda, actual_x, actual_y, alpha);
   }

References a, actual_x, actual_y, alpha, code, lda, n, UPLO, and uplo.

◆ if() [4/10]

if ( alpha = =Scalar(0) )

◆ if() [5/10]

if ( beta ! = Scalar(1) )

                          {
     if (beta == Scalar(0))
       make_vector(actual_y, *n).setZero();
     else
       make_vector(actual_y, *n) *= beta;
   }

References actual_y, beta, make_vector(), and n.

◆ if() [6/10]

if ( code >=2|| func[code] = =0 )

◆ if() [7/10]

if ( info )

◆ if() [8/10]

if ( UPLO * uplo = =INVALID ) = 1

                          {
     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.

◆ if() [9/10]

if ( x_cpy ! = x )

◆ if() [10/10]

if ( y_cpy ! = y )

◆ lda()

else if* lda	(	1	,
		*	n
	)		&

◆ matrix()

matrix	(	a	,
		*	n,
		*	n,
		*	lda
	)

Referenced by her().

Variable Documentation

◆ a

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

◆ actual_x

const Scalar* actual_x = get_compact_vector(x, *n, *incx)

Referenced by if().

◆ actual_y

Scalar* actual_y = get_compact_vector(y, *n, *incy)

Referenced by if().

◆ alpha

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

Referenced by her(), hpr(), and if().

◆ ap

Scalar* ap = reinterpret_cast<Scalar *>(pap)

Referenced by Eigen::SimplicialCholeskyBase< Derived >::analyzePattern_preordered(), Eigen::internal::simpl_chol_helper< Scalar, StorageIndex >::calc_etree(), Eigen::internal::simpl_chol_helper< Scalar, StorageIndex >::calc_hadj_inner(), Eigen::internal::simpl_chol_helper< Scalar, StorageIndex >::calc_hadj_outer(), Eigen::SimplicialCholeskyBase< Derived >::factorize_preordered(), hpr(), Eigen::SimplicialCholeskyBase< Derived >::ordering(), Eigen::internal::simpl_chol_helper< Scalar, StorageIndex >::run(), test_autodiff_vector(), tpmv(), and tpsv().

◆ beta

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

Referenced by Eigen::HessenbergDecomposition< MatrixType_ >::_compute(), Eigen::internal::bicgstab(), Eigen::internal::bicgstabl(), Eigen::internal::cm_factorize_p(), Eigen::internal::cm_factorize_p< SuiteSparse_long >(), oomph::ComplexGMRES< MATRIX >::complex_solve_helper(), Eigen::GeneralizedEigenSolver< MatrixType_ >::compute(), helpers::computeDisptFromCollisionTimeAndRestitutionCoefficientAndTangentialRestitutionCoefficientAndEffectiveMass(), Eigen::ColPivHouseholderQR< MatrixType_, PermutationIndex_ >::computeInPlace(), Eigen::CompleteOrthogonalDecomposition< MatrixType_, PermutationIndex_ >::computeInPlace(), Eigen::FullPivHouseholderQR< MatrixType_, PermutationIndex_ >::computeInPlace(), Eigen::internal::conjugate_gradient(), Multipole::convertMultipoleToLocal(), Eigen::DGMRES< MatrixType_, Preconditioner_ >::dgmres(), Eigen::DGMRES< MatrixType_, Preconditioner_ >::dgmresCycle(), Eigen::internal::erf_over_x_double_small(), eulerangles_manual(), Eigen::TensorContractionEvaluatorBase< Derived >::evalGemmPartial(), Eigen::SparseQR< MatrixType_, OrderingType_ >::factorize(), oomph::DisplacementBasedFoepplvonKarmanEquations::fill_in_contribution_to_residuals(), oomph::YoungLaplaceContactAngleElement< ELEMENT >::fill_in_contribution_to_residuals(), oomph::SteadyAxisymAdvectionDiffusionFluxElement< ELEMENT >::fill_in_generic_residual_contribution_adv_diff_flux(), oomph::SphericalAdvectionDiffusionFluxElement< ELEMENT >::fill_in_generic_residual_contribution_spherical_adv_diff_flux(), oomph::RefineableSpaceTimeUnsteadyHeatEquations< SPATIAL_DIM >::fill_in_generic_residual_contribution_ust_heat(), oomph::SpaceTimeUnsteadyHeatEquations< SPATIAL_DIM >::fill_in_generic_residual_contribution_ust_heat(), oomph::SpaceTimeUnsteadyHeatMixedOrderEquations< SPATIAL_DIM >::fill_in_generic_residual_contribution_ust_heat(), oomph::RefineableSpaceTimeUnsteadyHeatMixedOrderEquations< SPATIAL_DIM >::fill_in_generic_residual_contribution_ust_heat(), oomph::RefineableUnsteadyHeatEquations< DIM >::fill_in_generic_residual_contribution_ust_heat(), oomph::UnsteadyHeatEquations< DIM >::fill_in_generic_residual_contribution_ust_heat(), oomph::LAPACK_QZ::find_eigenvalues(), oomph::SphericalAdvectionDiffusionFluxElement< ELEMENT >::get_beta(), oomph::SteadyAxisymAdvectionDiffusionFluxElement< ELEMENT >::get_beta(), RachelsAdvectionDiffusion::get_exact_u(), InfiniteWall::getFurthestPointSuperQuadric(), Eigen::internal::gmres(), householder(), Eigen::internal::householder_qr_inplace_update(), Eigen::internal::idrs(), Eigen::internal::idrstabl(), if(), Eigen::internal::TensorContractionKernel< ResScalar, LhsScalar, RhsScalar, StorageIndex, OutputMapper, LhsMapper, RhsMapper >::invoke(), oomph::Orthpoly::jacobi(), LawinenBox::LawinenBox(), Eigen::internal::least_square_conjugate_gradient(), Eigen::internal::llt_rank_update_lower(), main(), Eigen::MatrixBase< Derived >::makeHouseholder(), Eigen::MatrixBase< Derived >::makeHouseholderInPlace(), Eigen::internal::minres(), Anasazi::MultiVecTraits< double, oomph::DoubleMultiVector >::MvAddMv(), Anasazi::MultiVecTraits< double, oomph::DoubleMultiVector >::MvTimesMatAddMv(), HertzianBSHPInteractionTwoParticleElasticCollision::padeCoefficientOfRestitution(), Eigen::internal::patanh_double(), Eigen::RealSchur< MatrixType_ >::performFrancisQRStep(), Eigen::internal::plog_impl_float(), oomph::GMRESBlockPreconditioner::preconditioner_solve(), TanhSolnForSteadyAxisymAdvectionDiffusion::prescribed_beta_on_fixed_r_boundary(), Global_Physical_Variables::prescribed_beta_on_fixed_r_boundary(), Eigen::internal::ptanh_double(), Eigen::internal::ptanh_float(), Eigen::internal::patan_reduced< Scalar >::run(), Eigen::internal::generic_fast_erf< Scalar >::run(), Eigen::general_product_to_triangular_selector< MatrixType, ProductType, UpLo, true >::run(), Eigen::general_product_to_triangular_selector< MatrixType, ProductType, UpLo, false >::run(), Eigen::internal::tridiagonalization_inplace_selector< MatrixType, 3, false >::run(), ParhamiMcMeekingSinterSpecies::set(), SilbertPeriodic::set_study(), SuperQuadricParticle::setBoundingRadius(), SlidingFrictionSpecies::setCollisionTimeAndNormalAndTangentialRestitutionCoefficient(), SlidingFrictionSpecies::setCollisionTimeAndNormalAndTangentialRestitutionCoefficientNoDispt(), SinterNormalSpecies::setParhamiMcKeeping(), oomph::SpineAxisymmetricMarangoniSurfactantFluidInterfaceElement< ELEMENT >::sigma(), oomph::SpineLineMarangoniSurfactantFluidInterfaceElement< ELEMENT >::sigma(), SilbertPeriodic::SilbertPeriodic(), oomph::LAPACK_QZ::solve_eigenproblem(), oomph::CG< MATRIX >::solve_helper(), oomph::BiCGStab< MATRIX >::solve_helper(), oomph::GMRES< MATRIX >::solve_helper(), oomph::AugmentedProblemGMRES::solve_helper(), oomph::HelmholtzGMRESMG< MATRIX >::solve_helper(), oomph::HelmholtzFGMRESMG< MATRIX >::solve_helper(), Eigen::RealQZ< MatrixType_ >::step(), test_scalar_sugar_add_mul(), test_scalar_sugar_sub_div(), LocalExpansion::translateLocalExpansion(), Multipole::TranslateMultipoleExpansionTo(), and Eigen::internal::tridiagonalization_inplace().

◆ code

int code = UPLO(*uplo)

Referenced by her(), hpr(), and if().

◆ func

func

static

Initial value:

= {
      
      (Eigen::internal::selfadjoint_matrix_vector_product<Scalar, int, Eigen::ColMajor, Eigen::Upper, false,
                                                          false>::run),
      
      (Eigen::internal::selfadjoint_matrix_vector_product<Scalar, int, Eigen::ColMajor, Eigen::Lower, false,
                                                          false>::run),
  }