G4ErrorSymMatrix.cc File Reference

#include "globals.hh"
#include <iostream>
#include <cmath>
#include "G4ErrorSymMatrix.hh"
#include "G4ErrorMatrix.hh"

Go to the source code of this file.

Macros
#define	A00   0
#define	A01   1
#define	A02   3
#define	A03   6
#define	A04   10
#define	A05   15
#define	A10   1
#define	A11   2
#define	A12   4
#define	A13   7
#define	A14   11
#define	A15   16
#define	A20   3
#define	A21   4
#define	A22   5
#define	A23   8
#define	A24   12
#define	A25   17
#define	A30   6
#define	A31   7
#define	A32   8
#define	A33   9
#define	A34   13
#define	A35   18
#define	A40   10
#define	A41   11
#define	A42   12
#define	A43   13
#define	A44   14
#define	A45   19
#define	A50   15
#define	A51   16
#define	A52   17
#define	A53   18
#define	A54   19
#define	A55   20
#define	CHK_DIM_1(c1, r2, fun)
#define	CHK_DIM_2(r1, r2, c1, c2, fun)
#define	SIMPLE_BOP(OPER)
#define	SIMPLE_TOP(OPER)
#define	SIMPLE_UOP(OPER)

Functions
G4ErrorSymMatrix	dsum (const G4ErrorSymMatrix &mat1, const G4ErrorSymMatrix &mat2)
G4ErrorMatrix	operator* (const G4ErrorMatrix &mat1, const G4ErrorSymMatrix &mat2)
G4ErrorMatrix	operator* (const G4ErrorSymMatrix &mat1, const G4ErrorMatrix &mat2)
G4ErrorMatrix	operator* (const G4ErrorSymMatrix &mat1, const G4ErrorSymMatrix &mat2)
G4ErrorSymMatrix	operator* (const G4ErrorSymMatrix &mat1, G4double t)
G4ErrorSymMatrix	operator* (G4double t, const G4ErrorSymMatrix &mat1)
G4ErrorMatrix	operator+ (const G4ErrorMatrix &mat1, const G4ErrorSymMatrix &mat2)
G4ErrorMatrix	operator+ (const G4ErrorSymMatrix &mat1, const G4ErrorMatrix &mat2)
G4ErrorSymMatrix	operator+ (const G4ErrorSymMatrix &mat1, const G4ErrorSymMatrix &mat2)
G4ErrorMatrix	operator- (const G4ErrorMatrix &mat1, const G4ErrorSymMatrix &mat2)
G4ErrorMatrix	operator- (const G4ErrorSymMatrix &mat1, const G4ErrorMatrix &mat2)
G4ErrorSymMatrix	operator- (const G4ErrorSymMatrix &mat1, const G4ErrorSymMatrix &mat2)
G4ErrorSymMatrix	operator/ (const G4ErrorSymMatrix &mat1, G4double t)
std::ostream &	operator<< (std::ostream &os, const G4ErrorSymMatrix &q)

Macro Definition Documentation

A00

#define A00   0

Definition at line 1348 of file G4ErrorSymMatrix.cc.

A01

#define A01   1

Definition at line 1349 of file G4ErrorSymMatrix.cc.

A02

#define A02   3

Definition at line 1350 of file G4ErrorSymMatrix.cc.

A03

#define A03   6

Definition at line 1351 of file G4ErrorSymMatrix.cc.

A04

#define A04   10

Definition at line 1352 of file G4ErrorSymMatrix.cc.

A05

#define A05   15

Definition at line 1353 of file G4ErrorSymMatrix.cc.

A10

#define A10   1

Definition at line 1355 of file G4ErrorSymMatrix.cc.

A11

#define A11   2

Definition at line 1356 of file G4ErrorSymMatrix.cc.

A12

#define A12   4

Definition at line 1357 of file G4ErrorSymMatrix.cc.

A13

#define A13   7

Definition at line 1358 of file G4ErrorSymMatrix.cc.

A14

#define A14   11

Definition at line 1359 of file G4ErrorSymMatrix.cc.

A15

#define A15   16

Definition at line 1360 of file G4ErrorSymMatrix.cc.

A20

#define A20   3

Definition at line 1362 of file G4ErrorSymMatrix.cc.

A21

#define A21   4

Definition at line 1363 of file G4ErrorSymMatrix.cc.

A22

#define A22   5

Definition at line 1364 of file G4ErrorSymMatrix.cc.

A23

#define A23   8

Definition at line 1365 of file G4ErrorSymMatrix.cc.

A24

#define A24   12

Definition at line 1366 of file G4ErrorSymMatrix.cc.

A25

#define A25   17

Definition at line 1367 of file G4ErrorSymMatrix.cc.

A30

#define A30   6

Definition at line 1369 of file G4ErrorSymMatrix.cc.

A31

#define A31   7

Definition at line 1370 of file G4ErrorSymMatrix.cc.

A32

#define A32   8

Definition at line 1371 of file G4ErrorSymMatrix.cc.

A33

#define A33   9

Definition at line 1372 of file G4ErrorSymMatrix.cc.

A34

#define A34   13

Definition at line 1373 of file G4ErrorSymMatrix.cc.

A35

#define A35   18

Definition at line 1374 of file G4ErrorSymMatrix.cc.

A40

#define A40   10

Definition at line 1376 of file G4ErrorSymMatrix.cc.

A41

#define A41   11

Definition at line 1377 of file G4ErrorSymMatrix.cc.

A42

#define A42   12

Definition at line 1378 of file G4ErrorSymMatrix.cc.

A43

#define A43   13

Definition at line 1379 of file G4ErrorSymMatrix.cc.

A44

#define A44   14

Definition at line 1380 of file G4ErrorSymMatrix.cc.

A45

#define A45   19

Definition at line 1381 of file G4ErrorSymMatrix.cc.

A50

#define A50   15

Definition at line 1383 of file G4ErrorSymMatrix.cc.

A51

#define A51   16

Definition at line 1384 of file G4ErrorSymMatrix.cc.

A52

#define A52   17

Definition at line 1385 of file G4ErrorSymMatrix.cc.

A53

#define A53   18

Definition at line 1386 of file G4ErrorSymMatrix.cc.

A54

#define A54   19

Definition at line 1387 of file G4ErrorSymMatrix.cc.

A55

#define A55   20

Definition at line 1388 of file G4ErrorSymMatrix.cc.

CHK_DIM_1

#define CHK_DIM_1	(		c1,
			r2,
			fun
	)

Value:

  if(c1 != r2)                                                                 \
  {                                                                            \
    G4ErrorMatrix::error("Range error in Matrix function " #fun "(2).");       \
  }

Definition at line 67 of file G4ErrorSymMatrix.cc.

CHK_DIM_2

#define CHK_DIM_2	(		r1,
			r2,
			c1,
			c2,
			fun
	)

Value:

  if(r1 != r2 || c1 != c2)                                                     \
  {                                                                            \
    G4ErrorMatrix::error("Range error in Matrix function " #fun "(1).");       \
  }

Definition at line 61 of file G4ErrorSymMatrix.cc.

SIMPLE_BOP

#define SIMPLE_BOP

(

OPER

)

Value:

  G4ErrorMatrixIter a      = m.begin();                                        \
  G4ErrorMatrixConstIter b = mat2.m.begin();                                   \
  G4ErrorMatrixConstIter e = m.begin() + num_size();                           \
  for(; a < e; a++, b++)                                                       \
    (*a) OPER(*b);

Definition at line 46 of file G4ErrorSymMatrix.cc.

SIMPLE_TOP

#define SIMPLE_TOP

(

OPER

)

Value:

  G4ErrorMatrixConstIter a = mat1.m.begin();                                   \
  G4ErrorMatrixConstIter b = mat2.m.begin();                                   \
  G4ErrorMatrixIter t      = mret.m.begin();                                   \
  G4ErrorMatrixConstIter e = mat1.m.begin() + mat1.num_size();                 \
  for(; a < e; a++, b++, t++)                                                  \
    (*t) = (*a) OPER(*b);

Definition at line 53 of file G4ErrorSymMatrix.cc.

SIMPLE_UOP

#define SIMPLE_UOP

(

OPER

)

Value:

  G4ErrorMatrixIter a = m.begin();                                             \
  G4ErrorMatrixIter e = m.begin() + num_size();                                \
  for(; a < e; a++)                                                            \
    (*a) OPER t;

Definition at line 40 of file G4ErrorSymMatrix.cc.

Function Documentation

dsum()

G4ErrorSymMatrix dsum	(	const G4ErrorSymMatrix &	mat1,
		const G4ErrorSymMatrix &	mat2
	)

Definition at line 195 of file G4ErrorSymMatrix.cc.

{
  G4ErrorSymMatrix mret(mat1.num_row() + mat2.num_row(), 0);
  mret.sub(1, mat1);
  mret.sub(mat1.num_row() + 1, mat2);
  return mret;
}

References G4ErrorSymMatrix::num_row(), and G4ErrorSymMatrix::sub().

operator*() [1/5]

G4ErrorMatrix operator*	(	const G4ErrorMatrix &	mat1,
		const G4ErrorSymMatrix &	mat2
	)

Definition at line 302 of file G4ErrorSymMatrix.cc.

{
  G4ErrorMatrix mret(mat1.num_row(), mat2.num_col());
  CHK_DIM_1(mat1.num_col(), mat2.num_row(), *);
  G4ErrorMatrixConstIter mit1, mit2, sp, snp;  // mit2=0
  G4double temp;
  G4ErrorMatrixIter mir = mret.m.begin();
  for(mit1 = mat1.m.begin();
      mit1 < mat1.m.begin() + mat1.num_row() * mat1.num_col(); mit1 = mit2)
  {
    snp = mat2.m.begin();
    for(int step = 1; step <= mat2.num_row(); ++step)
    {
      mit2 = mit1;
      sp   = snp;
      snp += step;
      temp = 0;
      while(sp < snp)  // Loop checking, 06.08.2015, G.Cosmo
      {
        temp += *(sp++) * (*(mit2++));
      }
      if(step < mat2.num_row())
      {  // only if we aren't on the last row
        sp += step - 1;
        for(int stept = step + 1; stept <= mat2.num_row(); stept++)
        {
          temp += *sp * (*(mit2++));
          if(stept < mat2.num_row())
            sp += stept;
        }
      }  // if(step
      *(mir++) = temp;
    }  // for(step
  }    // for(mit1
  return mret;
}

operator*() [2/5]

G4ErrorMatrix operator*	(	const G4ErrorSymMatrix &	mat1,
		const G4ErrorMatrix &	mat2
	)

Definition at line 339 of file G4ErrorSymMatrix.cc.

{
  G4ErrorMatrix mret(mat1.num_row(), mat2.num_col());
  CHK_DIM_1(mat1.num_col(), mat2.num_row(), *);
  G4int step, stept;
  G4ErrorMatrixConstIter mit1, mit2, sp, snp;
  G4double temp;
  G4ErrorMatrixIter mir = mret.m.begin();
  for(step = 1, snp = mat1.m.begin(); step <= mat1.num_row(); snp += step++)
  {
    for(mit1 = mat2.m.begin(); mit1 < mat2.m.begin() + mat2.num_col(); mit1++)
    {
      mit2 = mit1;
      sp   = snp;
      temp = 0;
      while(sp < snp + step)  // Loop checking, 06.08.2015, G.Cosmo
      {
        temp += *mit2 * (*(sp++));
        mit2 += mat2.num_col();
      }
      sp += step - 1;
      for(stept = step + 1; stept <= mat1.num_row(); stept++)
      {
        temp += *mit2 * (*sp);
        mit2 += mat2.num_col();
        sp += stept;
      }
      *(mir++) = temp;
    }
  }
  return mret;
}

operator*() [3/5]

G4ErrorMatrix operator*	(	const G4ErrorSymMatrix &	mat1,
		const G4ErrorSymMatrix &	mat2
	)

Definition at line 372 of file G4ErrorSymMatrix.cc.

{
  G4ErrorMatrix mret(mat1.num_row(), mat1.num_row());
  CHK_DIM_1(mat1.num_col(), mat2.num_row(), *);
  G4int step1, stept1, step2, stept2;
  G4ErrorMatrixConstIter snp1, sp1, snp2, sp2;
  G4double temp;
  G4ErrorMatrixIter mr = mret.m.begin();
  for(step1 = 1, snp1 = mat1.m.begin(); step1 <= mat1.num_row();
      snp1 += step1++)
  {
    for(step2 = 1, snp2 = mat2.m.begin(); step2 <= mat2.num_row();)
    {
      sp1 = snp1;
      sp2 = snp2;
      snp2 += step2;
      temp = 0;
      if(step1 < step2)
      {
        while(sp1 < snp1 + step1)  // Loop checking, 06.08.2015, G.Cosmo
        {
          temp += (*(sp1++)) * (*(sp2++));
        }
        sp1 += step1 - 1;
        for(stept1 = step1 + 1; stept1 != step2 + 1; sp1 += stept1++)
        {
          temp += (*sp1) * (*(sp2++));
        }
        sp2 += step2 - 1;
        for(stept2 = ++step2; stept2 <= mat2.num_row();
            sp1 += stept1++, sp2 += stept2++)
        {
          temp += (*sp1) * (*sp2);
        }
      }
      else
      {
        while(sp2 < snp2)  // Loop checking, 06.08.2015, G.Cosmo
        {
          temp += (*(sp1++)) * (*(sp2++));
        }
        sp2 += step2 - 1;
        for(stept2 = ++step2; stept2 != step1 + 1; sp2 += stept2++)
        {
          temp += (*(sp1++)) * (*sp2);
        }
        sp1 += step1 - 1;
        for(stept1 = step1 + 1; stept1 <= mat1.num_row();
            sp1 += stept1++, sp2 += stept2++)
        {
          temp += (*sp1) * (*sp2);
        }
      }
      *(mr++) = temp;
    }
  }
  return mret;
}

operator*() [4/5]

G4ErrorSymMatrix operator*	(	const G4ErrorSymMatrix &	mat1,
		G4double	t
	)

Definition at line 288 of file G4ErrorSymMatrix.cc.

{
  G4ErrorSymMatrix mret(mat1);
  mret *= t;
  return mret;
}

operator*() [5/5]

G4ErrorSymMatrix operator*	(	G4double	t,
		const G4ErrorSymMatrix &	mat1
	)

Definition at line 295 of file G4ErrorSymMatrix.cc.

{
  G4ErrorSymMatrix mret(mat1);
  mret *= t;
  return mret;
}

operator+() [1/3]

G4ErrorMatrix operator+	(	const G4ErrorMatrix &	mat1,
		const G4ErrorSymMatrix &	mat2
	)

Definition at line 222 of file G4ErrorSymMatrix.cc.

{
  G4ErrorMatrix mret(mat1);
  CHK_DIM_2(mat1.num_row(), mat2.num_row(), mat1.num_col(), mat2.num_col(), +);
  mret += mat2;
  return mret;
}

References CHK_DIM_2, G4ErrorMatrix::num_col(), G4ErrorSymMatrix::num_col(), G4ErrorMatrix::num_row(), and G4ErrorSymMatrix::num_row().

operator+() [2/3]

G4ErrorMatrix operator+	(	const G4ErrorSymMatrix &	mat1,
		const G4ErrorMatrix &	mat2
	)

Definition at line 230 of file G4ErrorSymMatrix.cc.

{
  G4ErrorMatrix mret(mat2);
  CHK_DIM_2(mat1.num_row(), mat2.num_row(), mat1.num_col(), mat2.num_col(), +);
  mret += mat1;
  return mret;
}

References CHK_DIM_2, G4ErrorMatrix::num_col(), G4ErrorSymMatrix::num_col(), G4ErrorMatrix::num_row(), and G4ErrorSymMatrix::num_row().

operator+() [3/3]

G4ErrorSymMatrix operator+	(	const G4ErrorSymMatrix &	mat1,
		const G4ErrorSymMatrix &	mat2
	)

Definition at line 238 of file G4ErrorSymMatrix.cc.

{
  G4ErrorSymMatrix mret(mat1.nrow);
  CHK_DIM_1(mat1.nrow, mat2.nrow, +);
  SIMPLE_TOP(+)
  return mret;
}

operator-() [1/3]

G4ErrorMatrix operator-	(	const G4ErrorMatrix &	mat1,
		const G4ErrorSymMatrix &	mat2
	)

Definition at line 251 of file G4ErrorSymMatrix.cc.

{
  G4ErrorMatrix mret(mat1);
  CHK_DIM_2(mat1.num_row(), mat2.num_row(), mat1.num_col(), mat2.num_col(), -);
  mret -= mat2;
  return mret;
}

References CHK_DIM_2, G4ErrorMatrix::num_col(), G4ErrorSymMatrix::num_col(), G4ErrorMatrix::num_row(), and G4ErrorSymMatrix::num_row().

operator-() [2/3]

G4ErrorMatrix operator-	(	const G4ErrorSymMatrix &	mat1,
		const G4ErrorMatrix &	mat2
	)

Definition at line 259 of file G4ErrorSymMatrix.cc.

{
  G4ErrorMatrix mret(mat1);
  CHK_DIM_2(mat1.num_row(), mat2.num_row(), mat1.num_col(), mat2.num_col(), -);
  mret -= mat2;
  return mret;
}

References CHK_DIM_2, G4ErrorMatrix::num_col(), G4ErrorSymMatrix::num_col(), G4ErrorMatrix::num_row(), and G4ErrorSymMatrix::num_row().

operator-() [3/3]

G4ErrorSymMatrix operator-	(	const G4ErrorSymMatrix &	mat1,
		const G4ErrorSymMatrix &	mat2
	)

Definition at line 267 of file G4ErrorSymMatrix.cc.

{
  G4ErrorSymMatrix mret(mat1.num_row());
  CHK_DIM_1(mat1.num_row(), mat2.num_row(), -);
  SIMPLE_TOP(-)
  return mret;
}

operator/()

G4ErrorSymMatrix operator/	(	const G4ErrorSymMatrix &	mat1,
		G4double	t
	)

Definition at line 281 of file G4ErrorSymMatrix.cc.

{
  G4ErrorSymMatrix mret(mat1);
  mret /= t;
  return mret;
}

operator<<()

std::ostream & operator<<	(	std::ostream &	os,
		const G4ErrorSymMatrix &	q
	)

Definition at line 564 of file G4ErrorSymMatrix.cc.

{
  os << G4endl;
 
  // Fixed format needs 3 extra characters for field,
  // while scientific needs 7
 
  G4int width;
  if(os.flags() & std::ios::fixed)
  {
    width = os.precision() + 3;
  }
  else
  {
    width = os.precision() + 7;
  }
  for(G4int irow = 1; irow <= q.num_row(); irow++)
  {
    for(G4int icol = 1; icol <= q.num_col(); icol++)
    {
      os.width(width);
      os << q(irow, icol) << " ";
    }
    os << G4endl;
  }
  return os;
}

References G4endl, G4ErrorSymMatrix::num_col(), and G4ErrorSymMatrix::num_row().