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=NULL)
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=NULL)
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 = NULL
	)

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 77 of file G4ArrayOps.hh.

    {
        if(A2 == NULL)
        {
            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 97 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 63 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 216 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 178 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 199 of file G4ArrayOps.hh.

    {
        if(Denominator == NULL)
        {
            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 = NULL
	)

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 138 of file G4ArrayOps.hh.

    {
        if(M2 == NULL)
        {
            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 158 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 117 of file G4ArrayOps.hh.

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