Class to accommodate arrays of one-dimensional grid. More...

#include <ArrayOfOneDGrids.h>

Public Member Functions
Constructor/Destructor methods
	ArrayOfOneDGrids (const char *prefix, const VectorSpace< V, M > &rowSpace)
	Default constructor. More...

	~ArrayOfOneDGrids ()
	Destructor. More...

Property methods
const VectorSpace< V, M > &	rowSpace () const
	Returns the (vector) space to which the row belongs to. More...

const V &	sizes () const
	Returns an array with the sizes of the grids. More...

const V &	minPositions () const
	Returns an array with the minimum position of each grid. More...

const V &	maxPositions () const
	Returns an array with the maximum position of each grid. More...

Math methods
void	setUniformGrids (const V &sizesVec, const V &minPositionsVec, const V &maxPositionsVec)
	Sets an array of uniform grids. More...

Accessor methods
const BaseOneDGrid< double > &	grid (unsigned int rowId) const
	Returns the grid stored in the `rowId`-th position of the array of grids. More...

Private Attributes
const BaseEnvironment &	m_env

std::string	m_prefix

const VectorSpace< V, M > &	m_rowSpace

DistArray< BaseOneDGrid < double > * >	m_oneDGrids

V *	m_sizes

V *	m_minPositions

V *	m_maxPositions

I/O methods
void	print (std::ostream &os) const
	Prints the values of the array of grids (points). More...

std::ostream &	operator<< (std::ostream &os, const ArrayOfOneDGrids< V, M > &obj)

Detailed Description

template<class V = GslVector, class M = GslMatrix>
class QUESO::ArrayOfOneDGrids< V, M >

Class to accommodate arrays of one-dimensional grid.

Arrays of one-dimensional grids are necessary in the calculation, for instance, of CDFs and MDF of vector functions (refer to BaseVectorCdf, BaseVectorMdf, and derived classes).

Definition at line 47 of file ArrayOfOneDGrids.h.

Constructor & Destructor Documentation

template<class V, class M>

QUESO::ArrayOfOneDGrids< V, M >::ArrayOfOneDGrids	(	const char *	prefix,
		const VectorSpace< V, M > &	rowSpace
	)

Default constructor.

Definition at line 35 of file ArrayOfOneDGrids.C.

References QUESO::ArrayOfOneDGrids< V, M >::m_oneDGrids.

   :
   m_env         (rowSpace.env()    ),
   m_prefix      ((std::string)(prefix)+""),
   m_rowSpace    (rowSpace          ),
   m_oneDGrids   (m_rowSpace.map(),1),
   m_sizes       (NULL),
   m_minPositions(NULL),
   m_maxPositions(NULL)
 {
   for (unsigned int i = 0; i < (unsigned int) m_oneDGrids.MyLength(); ++i) {
     m_oneDGrids(i,0) = NULL;
   }
 }

template<class V , class M >

QUESO::ArrayOfOneDGrids< V, M >::~ArrayOfOneDGrids ( )

Destructor.

Definition at line 54 of file ArrayOfOneDGrids.C.

 {
   if (m_maxPositions) delete m_maxPositions;
   if (m_minPositions) delete m_minPositions;
   if (m_sizes       ) delete m_sizes;
 
   for (unsigned int i = 0; i < (unsigned int) m_oneDGrids.MyLength(); ++i) {
     if (m_oneDGrids(i,0)) delete m_oneDGrids(i,0);
   }
 }

Member Function Documentation

template<class V , class M >

const BaseOneDGrid< double > & QUESO::ArrayOfOneDGrids< V, M >::grid ( unsigned int rowId ) const

Returns the grid stored in the rowId-th position of the array of grids.

Definition at line 131 of file ArrayOfOneDGrids.C.

Referenced by QUESO::SampledVectorCdf< V, M >::SampledVectorCdf().

 {
   queso_require_less_msg(rowId, m_rowSpace.dimLocal(), "rowId is out of range");
 
   ArrayOfOneDGrids<V,M>* tmp = const_cast<ArrayOfOneDGrids<V,M>*>(this);
   return *(tmp->m_oneDGrids(rowId,0));
 }

template<class V , class M >

const V & QUESO::ArrayOfOneDGrids< V, M >::maxPositions ( ) const

Returns an array with the maximum position of each grid.

Definition at line 93 of file ArrayOfOneDGrids.C.

 {
   queso_require_msg(m_maxPositions, "maxPositions is still NULL");
 
   return *m_maxPositions;
 }

template<class V , class M >

const V & QUESO::ArrayOfOneDGrids< V, M >::minPositions ( ) const

Returns an array with the minimum position of each grid.

Definition at line 84 of file ArrayOfOneDGrids.C.

 {
   queso_require_msg(m_minPositions, "minPositions is still NULL");
 
   return *m_minPositions;
 }

template<class V , class M >

void QUESO::ArrayOfOneDGrids< V, M >::print ( std::ostream & os ) const

Prints the values of the array of grids (points).

Definition at line 142 of file ArrayOfOneDGrids.C.

References QUESO::ArrayOfOneDGrids< V, M >::m_oneDGrids.

 {
   ArrayOfOneDGrids<V,M>* tmp = const_cast<ArrayOfOneDGrids<V,M>*>(this);
   for (unsigned int i = 0; i < (unsigned int) m_oneDGrids.MyLength(); ++i) {
     os << *(tmp->m_oneDGrids(i,0))
        << std::endl;
   }
 
   return;
 }

template<class V , class M >

const VectorSpace< V, M > & QUESO::ArrayOfOneDGrids< V, M >::rowSpace ( ) const

Returns the (vector) space to which the row belongs to.

Definition at line 68 of file ArrayOfOneDGrids.C.

 {
   return m_rowSpace;
 }

template<class V, class M >

void QUESO::ArrayOfOneDGrids< V, M >::setUniformGrids	(	const V &	sizesVec,
		const V &	minPositionsVec,
		const V &	maxPositionsVec
	)

Sets an array of uniform grids.

Definition at line 102 of file ArrayOfOneDGrids.C.

Referenced by QUESO::SequenceOfVectors< V, M >::subUniformlySampledCdf(), QUESO::SequenceOfVectors< V, M >::subUniformlySampledMdf(), QUESO::SequenceOfVectors< V, M >::unifiedUniformlySampledCdf(), and QUESO::ArrayOfSequences< V, M >::uniformlySampledCdf().

 {
   if (m_sizes        == NULL) m_sizes        = new V(sizesVec);
   else                       *m_sizes        = sizesVec;
 
   if (m_minPositions == NULL) m_minPositions = new V(minPositionsVec);
   else                       *m_minPositions = minPositionsVec;
 
   if (m_maxPositions == NULL) m_maxPositions = new V(maxPositionsVec);
   else                       *m_maxPositions = maxPositionsVec;
 
   char strI[65];
   for (unsigned int i = 0; i < (unsigned int) m_oneDGrids.MyLength(); ++i) {
     sprintf(strI,"%u_",i);
     m_oneDGrids(i,0) = new UniformOneDGrid<double>(m_env,
                                                           (m_prefix+strI).c_str(),
                                                           (unsigned int) sizesVec[i],
                                                           minPositionsVec[i],
                                                           maxPositionsVec[i]);
   }
 
   return;
 }

template<class V , class M >

const V & QUESO::ArrayOfOneDGrids< V, M >::sizes ( ) const

Returns an array with the sizes of the grids.

Definition at line 75 of file ArrayOfOneDGrids.C.

 {
   queso_require_msg(m_sizes, "sizes is still NULL");
 
   return *m_sizes;
 }