level1_impl.h File Reference

#include "common.h"

Go to the source code of this file.

Functions
if incx	make_vector (y, *n)+
else if incx	make_vector (y, *n, *incy)+ = alpha * make_vector(x, *n, -*incx).reverse()
else if incx	make_vector (y, *n, - *incy).reverse()+ = alpha * make_vector(x, *n, -*incx).reverse()
EIGEN_BLAS_FUNC()	copy (int *n, RealScalar *px, int *incx, RealScalar *py, int *incy)
EIGEN_BLAS_FUNC()	rotg (RealScalar *pa, RealScalar *pb, RealScalar *pc, RealScalar *ps)
EIGEN_BLAS_FUNC()	scal (int *n, RealScalar *palpha, RealScalar *px, int *incx)
EIGEN_BLAS_FUNC()	swap (int *n, RealScalar *px, int *incx, RealScalar *py, int *incy)

Variables
const int *	n
const int const RealScalar *	palpha
const int const RealScalar const RealScalar *	px
const int const RealScalar const RealScalar const int *	incx
const int const RealScalar const RealScalar const int RealScalar *	py
const int const RealScalar const RealScalar const int RealScalar const int *	incy
Scalar *	y = reinterpret_cast<Scalar *>(py)
Scalar	alpha = *reinterpret_cast<const Scalar *>(palpha)
if n	return

Function Documentation

copy()

EIGEN_BLAS_FUNC() copy	(	int *	n,
		RealScalar *	px,
		int *	incx,
		RealScalar *	py,
		int *	incy
	)

                                                                                    {
  if (*n <= 0) return;
 
  Scalar *x = reinterpret_cast<Scalar *>(px);
  Scalar *y = reinterpret_cast<Scalar *>(py);
 
  // be careful, *incx==0 is allowed !!
  if (*incx == 1 && *incy == 1)
    make_vector(y, *n) = make_vector(x, *n);
  else {
    if (*incx < 0) x = x - (*n - 1) * (*incx);
    if (*incy < 0) y = y - (*n - 1) * (*incy);
    for (int i = 0; i < *n; ++i) {
      *y = *x;
      x += *incx;
      y += *incy;
    }
  }
}

References i, incx, incy, make_vector(), n, px, py, plotDoE::x, and y.

Referenced by Eigen::BlockSparseMatrix< Scalar_, _BlockAtCompileTime, Options_, StorageIndex_ >::BlockSparseMatrix(), oomph::DoubleVector::build(), construct_vector(), oomph::CRDoubleMatrix::CRDoubleMatrix(), oomph::CRDoubleMatrixHelpers::deep_copy(), eiToGmm(), Eigen::internal::kissfft_impl< Scalar_ >::fwd(), oomph::RefineableQElement< 2 >::get_boundaries(), oomph::DoubleVector::initialise(), Eigen::internal::kissfft_impl< Scalar_ >::inv(), main(), SmallMatrix< numberOfRows, numberOfColumns >::operator=(), SmallVector< numberOfRows >::operator=(), Eigen::internal::smart_copy_helper< T, false >::run(), Eigen::internal::smart_memmove_helper< T, false >::run(), SmallMatrix< numberOfRows, numberOfColumns >::SmallMatrix(), SmallVector< numberOfRows >::SmallVector(), rapidjson::GenericDocument< Encoding, Allocator >::String(), rapidjson::PrettyWriter< Stream, Encoding, Allocator >::String(), rapidjson::Writer< Stream, Encoding, Allocator >::String(), test_0d(), test_1d(), and test_empty_slice().

make_vector() [1/3]

if incx make_vector	(	y	,
		*	n
	)

Referenced by copy(), scal(), and swap().

make_vector() [2/3]

else if incx make_vector	(	y	,
		*	n,
		*	incy
	)		= alpha * make_vector(x, *n, -*incx).reverse()

make_vector() [3/3]

else if incx make_vector	(	y	,
		*	n,
		- *	incy
	)		= alpha * make_vector(x, *n, -*incx).reverse()

rotg()

EIGEN_BLAS_FUNC() rotg	(	RealScalar *	pa,
		RealScalar *	pb,
		RealScalar *	pc,
		RealScalar *	ps
	)

                                                                                      {
  using std::abs;
  using std::sqrt;
 
  Scalar &a = *reinterpret_cast<Scalar *>(pa);
  Scalar &b = *reinterpret_cast<Scalar *>(pb);
  RealScalar *c = pc;
  Scalar *s = reinterpret_cast<Scalar *>(ps);
 
#if !ISCOMPLEX
  Scalar r, z;
  Scalar aa = abs(a);
  Scalar ab = abs(b);
  if ((aa + ab) == Scalar(0)) {
    *c = 1;
    *s = 0;
    r = 0;
    z = 0;
  } else {
    r = sqrt(a * a + b * b);
    Scalar amax = aa > ab ? a : b;
    r = amax > 0 ? r : -r;
    *c = a / r;
    *s = b / r;
    z = 1;
    if (aa > ab) z = *s;
    if (ab > aa && *c != RealScalar(0)) z = Scalar(1) / *c;
  }
  *pa = r;
  *pb = z;
#else
  Scalar alpha;
  RealScalar norm, scale;
  if (abs(a) == RealScalar(0)) {
    *c = RealScalar(0);
    *s = Scalar(1);
    a = b;
  } else {
    scale = abs(a) + abs(b);
    norm = scale * sqrt((Eigen::numext::abs2(a / scale)) + (Eigen::numext::abs2(b / scale)));
    alpha = a / abs(a);
    *c = abs(a) / norm;
    *s = alpha * Eigen::numext::conj(b) / norm;
    a = alpha * norm;
  }
#endif
 
  //   JacobiRotation<Scalar> r;
  //   r.makeGivens(a,b);
  //   *c = r.c();
  //   *s = r.s();
}

References a, abs(), Eigen::numext::abs2(), alpha, amax, b, calibrate::c, conj(), pa, pb, pc, ps, UniformPSDSelfTest::r, s, and sqrt().

scal()

EIGEN_BLAS_FUNC() scal	(	int *	n,
		RealScalar *	palpha,
		RealScalar *	px,
		int *	incx
	)

                                                                             {
  if (*n <= 0) return;
 
  Scalar *x = reinterpret_cast<Scalar *>(px);
  Scalar alpha = *reinterpret_cast<Scalar *>(palpha);
 
  if (*incx == 1)
    make_vector(x, *n) *= alpha;
  else
    make_vector(x, *n, std::abs(*incx)) *= alpha;
}

References abs(), alpha, incx, make_vector(), n, palpha, px, and plotDoE::x.

swap()

EIGEN_BLAS_FUNC() swap	(	int *	n,
		RealScalar *	px,
		int *	incx,
		RealScalar *	py,
		int *	incy
	)

                                                                                    {
  if (*n <= 0) return;
 
  Scalar *x = reinterpret_cast<Scalar *>(px);
  Scalar *y = reinterpret_cast<Scalar *>(py);
 
  if (*incx == 1 && *incy == 1)
    make_vector(y, *n).swap(make_vector(x, *n));
  else if (*incx > 0 && *incy > 0)
    make_vector(y, *n, *incy).swap(make_vector(x, *n, *incx));
  else if (*incx > 0 && *incy < 0)
    make_vector(y, *n, -*incy).reverse().swap(make_vector(x, *n, *incx));
  else if (*incx < 0 && *incy > 0)
    make_vector(y, *n, *incy).swap(make_vector(x, *n, -*incx).reverse());
  else if (*incx < 0 && *incy < 0)
    make_vector(y, *n, -*incy).reverse().swap(make_vector(x, *n, -*incx).reverse());
}

References incx, incy, make_vector(), n, px, py, reverse(), plotDoE::x, and y.

Referenced by IcoSphere::_subdivide(), Eigen::BDCSVD< MatrixType_, Options_ >::allocate(), Eigen::PermutationBase< Derived >::applyTranspositionOnTheRight(), Eigen::internal::swap_assign_op< Scalar >::assignCoeff(), Eigen::JacobiSVD< MatrixType_, Options_ >::compute_impl(), Eigen::ColPivHouseholderQR< MatrixType_, PermutationIndex_ >::computeInPlace(), Eigen::BDCSVD< MatrixType_, Options_ >::computeSingVals(), Eigen::BDCSVD< MatrixType_, Options_ >::computeSVDofM(), SCoupling< M, O >::createDPMWallsFromFiniteElems(), Eigen::BDCSVD< MatrixType_, Options_ >::deflation(), Eigen::DynamicSGroup::DynamicSGroup(), EIGEN_DECLARE_TEST(), Eigen::SparseQR< MatrixType_, OrderingType_ >::factorize(), Eigen::IncompleteLUT< Scalar_, StorageIndex_ >::factorize(), oomph::QuadTree::gteq_edge_neighbour(), initSparse(), Eigen::internal::matrix_function_permute_schur(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::operator=(), Eigen::DynamicSGroup::operator=(), Eigen::internal::permute_symm_to_fullsymm(), Eigen::internal::permute_symm_to_symm(), Eigen::internal::SparseLUImpl< Scalar, StorageIndex >::pivotL(), Eigen::internal::SparseLUImpl< MatrixType_::Scalar, MatrixType_::StorageIndex >::pruneL(), Eigen::internal::QuickSplit(), Eigen::randomPermutationVector(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::reserveInnerVectors(), Eigen::TensorEvaluator< const TensorFFTOp< FFT, ArgType, FFTResultType, FFTDir >, Device >::scramble_FFT(), Eigen::ComplexEigenSolver< MatrixType_ >::sortEigenvalues(), Eigen::internal::sortWithPermutation(), Eigen::internal::CompressedStorage< Scalar_, StorageIndex_ >::swap(), Eigen::PlainObjectBase< Derived >::swap(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::swap(), Eigen::SparseVector< Scalar_, Options_, StorageIndex_ >::swap(), test_shuffle_unshuffle(), test_stl_iterators(), test_tensor_randacc(), testVectorType(), Eigen::internal::ldlt_inplace< Lower >::unblocked(), SCoupling< M, O >::updateDPMWallsFromFiniteElems(), and Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::updateList().

Variable Documentation

alpha

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

Referenced by rotg(), and scal().

incx

const int const RealScalar const RealScalar const int* incx

Referenced by copy(), scal(), and swap().

incy

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

Initial value:

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

Referenced by copy(), and swap().

n

const int* n

Referenced by copy(), scal(), and swap().

palpha

const int const RealScalar* palpha

Referenced by scal().

px

const int const RealScalar const RealScalar* px

Referenced by copy(), scal(), and swap().

py

const int const RealScalar const RealScalar const int RealScalar* py

Referenced by copy(), and swap().

return

if n return

y

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

Referenced by copy(), and swap().