G4ArrayOps Namespace Reference

Functions
template<class T >
void	Set (G4int Elements, T *To, T Value)
template<class T >
void	Copy (G4int Elements, T *To, T *From)
template<class T >
void	Add (G4int Elements, T *To, T *A1, T *A2=nullptr)
template<class T >
void	Add (G4int Elements, T *To, T A1, T *A2=NULL)
template<class T >
void	Subtract (G4int Elements, T *To, T *Minuend, T *Subtrahend=NULL)
template<class T >
void	Multiply (G4int Elements, T *To, T *M1, T *M2=nullptr)
template<class T >
void	Multiply (G4int Elements, T *To, T M1, T *M2=NULL)
template<class T >
void	Divide (G4int Elements, T *To, T *Numerator, T *Denominator=NULL)
template<class T >
void	Divide (G4int Elements, T *To, T Numerator, T *Denominator=NULL)
template<class T >
void	DeleteVectorOfPointers (std::vector< T > &Vector)

Detailed Description

G4ArrayOps is a namespace that provides template functions for performing basic arithmatic operations on any data type that is accessed with the [] operator.

Function Documentation

Add() [1/2]

template<class T >

void G4ArrayOps::Add	(	G4int	Elements,
		T *	To,
		T *	A1,
		T *	A2 = nullptr )

Add two arrays together. If the second array is NULL then the 'To' array is used as if the function were the += operator.

Definition at line 71 of file G4ArrayOps.hh.

{
  if (A2 == nullptr) {
    A2 = To;
  }
 
  for (G4int position = 0; position < Elements; position++) {
    To[position] = A2[position] + A1[position];
  }
}

Referenced by G4FissionProductYieldDist::Renormalize(), and G4FissionProductYieldDist::SortProbability().

Add() [2/2]

template<class T >

void G4ArrayOps::Add	(	G4int	Elements,
		T *	To,
		T	A1,
		T *	A2 = NULL )

Add a constant to an array. If the second array is NULL then the 'To' array is used as if the function were the += operator.

Definition at line 86 of file G4ArrayOps.hh.

{
  if (A2 == NULL) {
    A2 = To;
  }
 
  for (G4int position = 0; position < Elements; position++) {
    To[position] = A1 + A2[position];
  }
}

Copy()

template<class T >

void G4ArrayOps::Copy	(	G4int	Elements,
		T *	To,
		T *	From )

Copy values from one array to another

Definition at line 60 of file G4ArrayOps.hh.

{
  for (G4int position = 0; position < Elements; position++) {
    To[position] = From[position];
  }
}

Referenced by G4FissionProductYieldDist::ReadProbabilities(), G4FissionProductYieldDist::Renormalize(), G4ENDFYieldDataContainer::SetYieldError(), G4ENDFYieldDataContainer::SetYieldProbability(), and G4FissionProductYieldDist::SortProbability().

DeleteVectorOfPointers()

template<class T >

void G4ArrayOps::DeleteVectorOfPointers

(

std::vector< T > &

Vector

)

Definition at line 175 of file G4ArrayOps.hh.

{
  for (unsigned int i = 0; i < Vector.size(); i++) {
    delete Vector[i];
  }
 
  delete &Vector;
}

Referenced by G4FissionProductYieldDist::G4GetFission().

Divide() [1/2]

template<class T >

void G4ArrayOps::Divide	(	G4int	Elements,
		T *	To,
		T *	Numerator,
		T *	Denominator = NULL )

Divide an array by another. If the second array is NULL then the 'To' array is used as if the function were the /= operator.

Definition at line 147 of file G4ArrayOps.hh.

{
  if (Denominator == NULL) {
    Denominator = Numerator;
    Numerator = To;
  }
 
  for (G4int position = 0; position < Elements; position++) {
    To[position] = Numerator[position] / Denominator[position];
  }
}

Referenced by G4FissionProductYieldDist::ReadProbabilities().

Divide() [2/2]

template<class T >

void G4ArrayOps::Divide	(	G4int	Elements,
		T *	To,
		T	Numerator,
		T *	Denominator = NULL )

Divide a constant by an array. If the second array is NULL then the 'To' array is used as if the function were the /= operator.

Definition at line 163 of file G4ArrayOps.hh.

{
  if (Denominator == nullptr) {
    Denominator = To;
  }
 
  for (G4int position = 0; position < Elements; position++) {
    To[position] = Numerator / Denominator[position];
  }
}

Multiply() [1/2]

template<class T >

void G4ArrayOps::Multiply	(	G4int	Elements,
		T *	To,
		T *	M1,
		T *	M2 = nullptr )

Multiply two arrays together. If the second array is NULL then the 'To' array is used as if the function were the *= operator.

Definition at line 117 of file G4ArrayOps.hh.

{
  if (M2 == nullptr) {
    M2 = To;
  }
 
  for (G4int position = 0; position < Elements; position++) {
    To[position] = M2[position] * M1[position];
  }
}

Referenced by G4FissionProductYieldDist::Renormalize().

Multiply() [2/2]

template<class T >

void G4ArrayOps::Multiply	(	G4int	Elements,
		T *	To,
		T	M1,
		T *	M2 = NULL )

Multiply an array by a constant. If the second array is NULL then the 'To' array is used as if the function were the *= operator.

Definition at line 132 of file G4ArrayOps.hh.

{
  if (M2 == NULL) {
    M2 = To;
  }
 
  for (G4int position = 0; position < Elements; position++) {
    To[position] = M2[position] * M1;
  }
}

Set()

template<class T >

void G4ArrayOps::Set	(	G4int	Elements,
		T *	To,
		T	Value )

Set's all the values in an array to a constant

Definition at line 51 of file G4ArrayOps.hh.

{
  for (G4int position = 0; position < Elements; position++) {
    To[position] = Value;
  }
}

Referenced by G4FissionProductYieldDist::ReadProbabilities().

Subtract()

template<class T >

void G4ArrayOps::Subtract	(	G4int	Elements,
		T *	To,
		T *	Minuend,
		T *	Subtrahend = NULL )

Subtract an array from another. If the second array is NULL then the 'To' array is used as if the function were the -= operator.

Definition at line 101 of file G4ArrayOps.hh.

{
  if (Subtrahend == NULL) {
    Subtrahend = Minuend;
    Minuend = To;
  }
 
  for (G4int position = 0; position < Elements; position++) {
    To[position] = Minuend[position] - Subtrahend[position];
  }
}