Classes
struct	Inverter

struct	Inverter< M1, M2, 1 >

struct	Inverter< M1, M2, 2 >

struct	Inverter< M1, M2, 3 >

struct	Inverter< M1, M2, 4 >

struct	Inverter< M1, M2, 5 >

struct	Inverter< M1, M2, 6 >

Functions
template<typename M1 , typename M2 >
constexpr void	__attribute__ ((always_inline)) invert11(M1 const &src

	dst (0, 0)

	dst (1, 0)

	dst (1, 1)

	dst (2, 0)

	dst (2, 1)

	dst (2, 2)

	dst (3, 0)

	dst (3, 1)

	dst (3, 2)

	dst (3, 3)

	dst (4, 0)

	dst (4, 1)

	dst (4, 2)

	dst (4, 3)

	dst (4, 4)

	dst (5, 0)

	dst (5, 1)

	dst (5, 2)

	dst (5, 3)

	dst (5, 4)

	dst (5, 5)

template<typename M1 , typename M2 , int N = M2::ColsAtCompileTime>
constexpr void	invertNN (M1 const &src, M2 &dst)

else	invertNN (src, dst)

template<typename M >
constexpr void	symmetrize11 (M &dst)

template<typename M >
constexpr void	symmetrize22 (M &dst)

template<typename M >
constexpr void	symmetrize33 (M &dst)

template<typename M >
constexpr void	symmetrize44 (M &dst)

template<typename M >
constexpr void	symmetrize55 (M &dst)

template<typename M >
constexpr void	symmetrize66 (M &dst)

Variables
constexpr void M2 &	dst

auto	li21 = luc1 * luc0 * luc2

auto	li31 = (luc1 * (luc2 * luc4) - luc3) * luc0

auto	li32 = -(luc2 * luc4)

auto	li41 = (-luc1 * (luc2 * luc4) * (luc8 * luc5) + luc1 * (luc2 * luc7) + luc3 * (luc8 * luc5) - luc6) * luc0

auto	li42 = (luc4 * luc8 * luc5 - luc7) * luc2

auto	li43 = -(luc8 * luc5)

auto	li51

auto	li52 = (-luc4 * luc8 * luc13 * luc5 * luc9 + luc4 * luc12 * luc5 + luc7 * luc13 * luc9 - luc11) * luc2

auto	li53 = (luc13 * luc8 * luc9 - luc12) * luc5

auto	li54 = -luc13 * luc9

auto	li61

auto	li62

auto	li63

auto	li64 = (luc19 * luc14 * luc13 - luc18) * luc9

auto	li65 = -luc19 * luc14

auto	luc0 = F(1.0) / src(0, 0)

auto	luc1 = src(1, 0) * src(1, 0) * luc0

auto	luc10 = src(4, 0)

auto	luc11 = (src(4, 1) - luc0 * luc1 * luc10)

auto	luc12 = (src(4, 2) - luc0 * luc3 * luc10 - luc2 * luc4 * luc11)

auto	luc13 = (src(4, 3) - luc0 * luc6 * luc10 - luc2 * luc7 * luc11 - luc5 * luc8 * luc12)

auto	luc14

auto	luc15 = src(5, 0)

auto	luc16 = (src(5, 1) - luc0 * luc1 * luc15)

auto	luc17 = (src(5, 2) - luc0 * luc3 * luc15 - luc2 * luc4 * luc16)

auto	luc18 = (src(5, 3) - luc0 * luc6 * luc15 - luc2 * luc7 * luc16 - luc5 * luc8 * luc17)

auto	luc19

auto	luc2 = F(1.0) / (src(1, 1) - luc1)

auto	luc20

auto	luc3 = src(2, 0)

auto	luc4 = (src(2, 1) - luc0 * luc1 * luc3)

auto	luc5 = src(2, 2) - (luc0 * luc3 * luc3 + (luc2 * luc4) * luc4)

auto	luc6 = src(3, 0)

auto	luc7 = (src(3, 1) - luc0 * luc1 * luc6)

auto	luc8 = (src(3, 2) - luc0 * luc3 * luc6 - luc2 * luc4 * luc7)

auto	luc9 = src(3, 3) - (luc0 * luc6 * luc6 + luc2 * luc7 * luc7 + luc8 * (luc8 * luc5))

Function Documentation

◆ attribute()

template<typename M1 , typename M2 >

constexpr void math::cholesky::__attribute__ ( (always_inline) ) const &

inline

fully inlined specialized code to perform the inversion of a positive defined matrix of rank up to 6.

adapted from ROOT::Math::CholeskyDecomp originally by

Author: Manuel Schiller

Date: Aug 29 2008

◆ dst() [1/21]

math::cholesky::dst	(	0	,
		0
	)

◆ dst() [2/21]

math::cholesky::dst	(	1	,
		0
	)

◆ dst() [3/21]

math::cholesky::dst	(	1	,
		1
	)

◆ dst() [4/21]

math::cholesky::dst	(	2	,
		0
	)

◆ dst() [5/21]

math::cholesky::dst	(	2	,
		1
	)

◆ dst() [6/21]

math::cholesky::dst	(	2	,
		2
	)

◆ dst() [7/21]

math::cholesky::dst	(	3	,
		0
	)

◆ dst() [8/21]

math::cholesky::dst	(	3	,
		1
	)

◆ dst() [9/21]

math::cholesky::dst	(	3	,
		2
	)

◆ dst() [10/21]

math::cholesky::dst	(	3	,
		3
	)

◆ dst() [11/21]

math::cholesky::dst	(	4	,
		0
	)

◆ dst() [12/21]

math::cholesky::dst	(	4	,
		1
	)

◆ dst() [13/21]

math::cholesky::dst	(	4	,
		2
	)

◆ dst() [14/21]

math::cholesky::dst	(	4	,
		3
	)

◆ dst() [15/21]

math::cholesky::dst	(	4	,
		4
	)

◆ dst() [16/21]

math::cholesky::dst	(	5	,
		0
	)

◆ dst() [17/21]

math::cholesky::dst	(	5	,
		1
	)

◆ dst() [18/21]

math::cholesky::dst	(	5	,
		2
	)

◆ dst() [19/21]

math::cholesky::dst	(	5	,
		3
	)

◆ dst() [20/21]

math::cholesky::dst	(	5	,
		4
	)

◆ dst() [21/21]

math::cholesky::dst	(	5	,
		5
	)

◆ invertNN() [1/2]

template<typename M1 , typename M2 , int N = M2::ColsAtCompileTime>

constexpr void math::cholesky::invertNN	(	M1 const &	src,
		M2 &	dst
	)

inline

Definition at line 17 of file choleskyInversion.h.

References a, ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), dst, mps_fire::i, dqmiolumiharvest::j, isotrackApplyRegressor::k, MainPageGenerator::l, N, and TrackRefitter_38T_cff::src.

                                          {
 
       // origin: CERNLIB
 
       using T = typename M2::Scalar;
 
       T a[N][N];
       for (int i = 0; i < N; ++i) {
         a[i][i] = src(i, i);
         for (int j = i + 1; j < N; ++j)
           a[j][i] = src(i, j);
       }
 
       for (int j = 0; j < N; ++j) {
         a[j][j] = T(1.) / a[j][j];
         int jp1 = j + 1;
         for (int l = jp1; l < N; ++l) {
           a[j][l] = a[j][j] * a[l][j];
           T s1 = -a[l][jp1];
           for (int i = 0; i < jp1; ++i)
             s1 += a[l][i] * a[i][jp1];
           a[l][jp1] = -s1;
         }
       }
 
       if constexpr (N == 1) {
         dst(0, 0) = a[0][0];
         return;
       }
       a[0][1] = -a[0][1];
       a[1][0] = a[0][1] * a[1][1];
       for (int j = 2; j < N; ++j) {
         int jm1 = j - 1;
         for (int k = 0; k < jm1; ++k) {
           T s31 = a[k][j];
           for (int i = k; i < jm1; ++i)
             s31 += a[k][i + 1] * a[i + 1][j];
           a[k][j] = -s31;
           a[j][k] = -s31 * a[j][j];
         }
         a[jm1][j] = -a[jm1][j];
         a[j][jm1] = a[jm1][j] * a[j][j];
       }
 
       int j = 0;
       while (j < N - 1) {
         T s33 = a[j][j];
         for (int i = j + 1; i < N; ++i)
           s33 += a[j][i] * a[i][j];
         dst(j, j) = s33;
 
         ++j;
         for (int k = 0; k < j; ++k) {
           T s32 = 0;
           for (int i = j; i < N; ++i)
             s32 += a[k][i] * a[i][j];
           dst(k, j) = dst(j, k) = s32;
         }
       }
       dst(j, j) = a[j][j];
     }

◆ invertNN() [2/2]

else math::cholesky::invertNN	(	src	,
		dst
	)

◆ symmetrize11()

template<typename M >

constexpr void math::cholesky::symmetrize11 ( M & dst )

inline

Definition at line 316 of file choleskyInversion.h.

316 {}

◆ symmetrize22()

template<typename M >

constexpr void math::cholesky::symmetrize22 ( M & dst )

inline

Definition at line 319 of file choleskyInversion.h.

References dst.

Referenced by symmetrize33().

                                                {
       dst(0, 1) = dst(1, 0);
     }

◆ symmetrize33()

template<typename M >

constexpr void math::cholesky::symmetrize33 ( M & dst )

inline

Definition at line 324 of file choleskyInversion.h.

References dst, and symmetrize22().

Referenced by symmetrize44().

                                                {
       symmetrize22(dst);
       dst(0, 2) = dst(2, 0);
       dst(1, 2) = dst(2, 1);
     }

◆ symmetrize44()

template<typename M >

constexpr void math::cholesky::symmetrize44 ( M & dst )

inline

Definition at line 331 of file choleskyInversion.h.

References dst, and symmetrize33().

Referenced by symmetrize55().

                                                {
       symmetrize33(dst);
       dst(0, 3) = dst(3, 0);
       dst(1, 3) = dst(3, 1);
       dst(2, 3) = dst(3, 2);
     }

◆ symmetrize55()

template<typename M >

constexpr void math::cholesky::symmetrize55 ( M & dst )

inline

Definition at line 339 of file choleskyInversion.h.

References dst, and symmetrize44().

Referenced by symmetrize66().

                                                {
       symmetrize44(dst);
       dst(0, 4) = dst(4, 0);
       dst(1, 4) = dst(4, 1);
       dst(2, 4) = dst(4, 2);
       dst(3, 4) = dst(4, 3);
     }

◆ symmetrize66()

template<typename M >

constexpr void math::cholesky::symmetrize66 ( M & dst )

inline

Definition at line 348 of file choleskyInversion.h.

References dst, and symmetrize55().

                                                {
       symmetrize55(dst);
       dst(0, 5) = dst(5, 0);
       dst(1, 5) = dst(5, 1);
       dst(2, 5) = dst(5, 2);
       dst(3, 5) = dst(5, 3);
       dst(4, 5) = dst(5, 4);
     }

Variable Documentation

◆ dst

constexpr void M2 & math::cholesky::dst

Initial value:

{

using F = decltype(src(0, 0))

TrackRefitter_38T_cff.src

src

Definition: TrackRefitter_38T_cff.py:24

F

static uInt32 F(BLOWFISH_CTX *ctx, uInt32 x)

Definition: blowfish.cc:163

Definition at line 92 of file choleskyInversion.h.

Referenced by cms::cuda::copyAsync(), cms::alpakatools::CopyToHost< PortableDeviceCollection< portabletest::TestSoAWithPtr, TDev > >::copyAsync(), L1GtTriggerMenuXmlParser::countConditionChildMaxBits(), math::cholesky::Inverter< M1, M2, N >::eval(), math::cholesky::Inverter< M1, M2, 1 >::eval(), L1GtTriggerMenuXmlParser::getConditionChildValues(), SiStripConfigDb::getDcuDetIds(), L1GtTriggerMenuXmlParser::getXMLHexTextValue(), invertNN(), cms::alpakatools::CopyToHost< PortableDeviceCollection< portabletest::TestSoAWithPtr, TDev > >::postCopy(), l1tpf_calo::FlatCaloLinker::run(), l1tpf_calo::CombinedCaloLinker::run(), symmetrize22(), symmetrize33(), symmetrize44(), symmetrize55(), symmetrize66(), and DAClusterizerInZT_vect::update().

◆ li21

auto math::cholesky::li21 = luc1 * luc0 * luc2

Definition at line 104 of file choleskyInversion.h.

Referenced by fastInvertPDM2().

◆ li31

auto math::cholesky::li31 = (luc1 * (luc2 * luc4) - luc3) * luc0

Definition at line 125 of file choleskyInversion.h.

◆ li32

auto math::cholesky::li32 = -(luc2 * luc4)

Definition at line 124 of file choleskyInversion.h.

◆ li41

auto math::cholesky::li41 = (-luc1 * (luc2 * luc4) * (luc8 * luc5) + luc1 * (luc2 * luc7) + luc3 * (luc8 * luc5) - luc6) * luc0

Definition at line 157 of file choleskyInversion.h.

◆ li42

auto math::cholesky::li42 = (luc4 * luc8 * luc5 - luc7) * luc2

Definition at line 156 of file choleskyInversion.h.

◆ li43

auto math::cholesky::li43 = -(luc8 * luc5)

Definition at line 155 of file choleskyInversion.h.

◆ li51

auto math::cholesky::li51

Initial value:

= (luc1 * luc4 * luc8 * luc13 * luc2 * luc5 * luc9 - luc13 * luc8 * luc3 * luc9 * luc5 -
                   luc12 * luc4 * luc1 * luc2 * luc5 - luc13 * luc7 * luc1 * luc9 * luc2 + luc11 * luc1 * luc2 +
                   luc12 * luc3 * luc5 + luc13 * luc6 * luc9 - luc10) *
                  luc0

Definition at line 204 of file choleskyInversion.h.

◆ li52

auto math::cholesky::li52 = (-luc4 * luc8 * luc13 * luc5 * luc9 + luc4 * luc12 * luc5 + luc7 * luc13 * luc9 - luc11) * luc2

Definition at line 203 of file choleskyInversion.h.

◆ li53

auto math::cholesky::li53 = (luc13 * luc8 * luc9 - luc12) * luc5

Definition at line 202 of file choleskyInversion.h.

◆ li54

auto math::cholesky::li54 = -luc13 * luc9

Definition at line 201 of file choleskyInversion.h.

◆ li61

auto math::cholesky::li61

Initial value:

=
          (-luc19 * luc13 * luc8 * luc4 * luc1 * luc2 * luc5 * luc9 * luc14 +
           luc18 * luc8 * luc4 * luc1 * luc2 * luc5 * luc9 + luc19 * luc12 * luc4 * luc1 * luc2 * luc5 * luc14 +
           luc19 * luc13 * luc7 * luc1 * luc2 * luc9 * luc14 + luc19 * luc13 * luc8 * luc3 * luc5 * luc9 * luc14 -
           luc17 * luc4 * luc1 * luc2 * luc5 - luc18 * luc7 * luc1 * luc2 * luc9 - luc19 * luc11 * luc1 * luc2 * luc14 -
           luc18 * luc8 * luc3 * luc5 * luc9 - luc19 * luc12 * luc3 * luc5 * luc14 -
           luc19 * luc13 * luc6 * luc9 * luc14 + luc16 * luc1 * luc2 + luc17 * luc3 * luc5 + luc18 * luc6 * luc9 +
           luc19 * luc10 * luc14 - luc15) *
          luc0

Definition at line 281 of file choleskyInversion.h.

◆ li62

auto math::cholesky::li62

Initial value:

= (luc4 * (luc8 * luc9) * luc13 * luc5 * (luc19 * luc14) - luc18 * luc4 * (luc8 * luc9) * luc5 -
                   luc19 * luc12 * luc4 * luc14 * luc5 - luc19 * luc13 * luc7 * luc14 * luc9 + luc17 * luc4 * luc5 +
                   luc18 * luc7 * luc9 + luc19 * luc11 * luc14 - luc16) *
                  luc2