level2_real_impl.h File Reference

#include "common.h"

Go to the source code of this file.

Functions
	if (UPLO(*uplo)==INVALID) info
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 "SYMV ", &info
	if (beta !=Scalar(1))
	if (code >=2||func[code]==0) return
	if (actual_x !=x) delete[] actual_x
	if (actual_y !=y) delete[] copy_back(actual_y
else if *	ldc (1, *n)) info=7;if(info) return xerbla_(SCALAR_SUFFIX_UP "SYR ", &info
if *	n (0)) return;const Scalar *x_cpy=get_compact_vector(x, *n, *incx
	if (x_cpy !=x) delete[] x_cpy
	if (alpha==Scalar(0)) return
	if (y_cpy !=y) delete[] y_cpy
EIGEN_BLAS_FUNC()	spr (char *uplo, int *n, Scalar *palpha, Scalar *px, int *incx, Scalar *pap)
	if (info) return xerbla_(SCALAR_SUFFIX_UP "SPR2 "

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)
int	code = UPLO(*uplo)
const char const int const RealScalar const RealScalar const int RealScalar *	pc
const char const int const RealScalar const RealScalar const int RealScalar const int *	ldc
Scalar *	c = reinterpret_cast<Scalar *>(pc)
const Scalar *	x_cpy = get_compact_vector(x, *n, *incx)
const Scalar *	y_cpy = get_compact_vector(y, *n, *incy)
char int RealScalar RealScalar int RealScalar int RealScalar *	pap
Scalar *	ap = reinterpret_cast<Scalar *>(pap)
int *	m

Function Documentation

if() [1/9]

if

(

actual_x !

= x

)

if() [2/9]

if

(

actual_y !

= y

)

if() [3/9]

if

(

alpha

= =Scalar(0)

)

if() [4/9]

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() [5/9]

if

(

code >=2||

func[code] = =0

)

if() [6/9]

if

(

info

)

if() [7/9]

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

if() [8/9]

if

(

x_cpy !

= x

)

if() [9/9]

if

(

y_cpy !

= y

)

lda()

else if* lda	(	1	,
		*	n
	)		&

ldc()

else if* ldc	(	1	,
		*	n
	)		&

n()

if* n

(

0

)

const

spr()

EIGEN_BLAS_FUNC() spr	(	char *	uplo,
		int *	n,
		Scalar *	palpha,
		Scalar *	px,
		int *	incx,
		Scalar *	pap
	)

DSBMV 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 symmetric band matrix, with k super-diagonals. DSPMV 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 symmetric matrix, supplied in packed form. DSPR performs the symmetric rank 1 operation

A := alpha*x*x' + A,

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

                                                                                             {
  typedef void (*functype)(int, Scalar *, const Scalar *, Scalar);
  static const functype func[2] = {
      // array index: UP
      (Eigen::internal::selfadjoint_packed_rank1_update<Scalar, int, Eigen::ColMajor, Eigen::Upper, false, false>::run),
      // array index: LO
      (Eigen::internal::selfadjoint_packed_rank1_update<Scalar, int, Eigen::ColMajor, Eigen::Lower, false, false>::run),
  };
 
  Scalar *x = reinterpret_cast<Scalar *>(px);
  Scalar *ap = reinterpret_cast<Scalar *>(pap);
  Scalar alpha = *reinterpret_cast<Scalar *>(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 "SPR  ", &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_().

Variable Documentation

a

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

actual_x

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

actual_y

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

Referenced by if().

alpha

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

Referenced by spr().

ap

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

Referenced by spr().

beta

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

Referenced by if().

c

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

code

int code = UPLO(*uplo)

Referenced by spr().

func

func

static

Initial value:

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

incx

int int Scalar Scalar int* incx

Referenced by spr().

incy

int int Scalar Scalar int Scalar int* incy

Initial value:

{
  typedef void (*functype)(int, const Scalar *, int, const Scalar *, Scalar *, Scalar)

info

else if incy info = 0

Referenced by spr().

lda

int int Scalar Scalar int Scalar int Scalar int* lda

Initial value:

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

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:

{
  typedef void (*functype)(int, Scalar *, int, const Scalar *, const Scalar *, const Scalar &)

Referenced by Eigen::internal::gemm_kern_avx512().

m

Eigen::internal::general_rank1_update<Scalar, int, Eigen::ColMajor, false, false>::run* m

DGER performs the rank 1 operation

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

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

n

int int* n

Referenced by if(), and spr().

pa

int int Scalar Scalar int Scalar int Scalar* pa

palpha

int int Scalar* palpha

Referenced by spr().

pap

char int RealScalar RealScalar int RealScalar int RealScalar* pap

Initial value:

{
  typedef void (*functype)(int, Scalar *, const Scalar *, const Scalar *, Scalar)

Referenced by spr().

pbeta

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

pc

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

px

int int Scalar Scalar* px

Referenced by spr().

py

int int Scalar Scalar int Scalar* py

return

if n return

uplo

char* uplo

DSPR2 performs the symmetric rank 2 operation

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

where alpha is a scalar, x and y are n element vectors and A is an n by n symmetric matrix, supplied in packed form.

Referenced by spr().

x

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

Referenced by spr().

x_cpy

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

Referenced by spr().

y

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

y_cpy

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