MeteoIODoc 2.11.0
mio::Array1D< T > Class Template Reference

Detailed Description

template<class T>
class mio::Array1D< T >

The template class Array1D is a 1D array (vector) able to hold any type of object as datatype. If the compilation flag NOSAFECHECKS is used, bounds check is turned off (leading to increased performances).

Author
Thomas Egger
Date
2009-05-02

#include <Array1D.h>

Public Member Functions

 Array1D (const size_t &asize=0)
 
 Array1D (const size_t &asize, const T &init)
 
void setKeepNodata (const bool i_keep_nodata)
 set how to process nodata values (ie: as nodata or as normal numbers) More...
 
bool getKeepNodata ()
 get how to process nodata values (ie: as nodata or as normal numbers) More...
 
void size (size_t &nx) const
 
size_t size () const
 
size_t getNx () const
 
void resize (const size_t &asize)
 
void resize (const size_t &asize, const T &init)
 
void clear ()
 
bool empty () const
 
void insertAt (const int &index, T e)
 
void removeAt (const size_t &index)
 
getMin () const
 returns the minimum value contained in the grid More...
 
getMax () const
 returns the maximum value contained in the grid More...
 
getMean () const
 returns the mean value contained in the grid More...
 
size_t getCount () const
 returns the number of points contained in the grid. If setNodataHandling(IOUtils::RAW_NODATA), then the number of points is the size of the grid. If setNodataHandling(IOUtils::PARSE_NODATA), then it is the number of non-nodata values in the grid More...
 
const Array1D< T > getAbs () const
 returns the grid of the absolute value of values contained in the grid More...
 
void abs ()
 
const std::string toString () const
 
bool checkEpsilonEquality (const Array1D< double > &rhs, const double &epsilon) const
 
T & operator[] (const size_t &index)
 
const T operator[] (const size_t &index) const
 
T & operator() (const size_t &index)
 
const T operator() (const size_t &index) const
 
Array1D< T > & operator= (const T &value)
 
Array1D< T > & operator+= (const T &rhs)
 
const Array1D< T > operator+ (const T &rhs) const
 
Array1D< T > & operator+= (const Array1D< T > &rhs)
 
const Array1D< T > operator+ (const Array1D< T > &rhs) const
 
Array1D< T > & operator-= (const T &rhs)
 
const Array1D< T > operator- (const T &rhs) const
 
Array1D< T > & operator-= (const Array1D< T > &rhs)
 
const Array1D< T > operator- (const Array1D< T > &rhs) const
 
Array1D< T > & operator*= (const T &rhs)
 
const Array1D< T > operator* (const T &rhs) const
 
Array1D< T > & operator*= (const Array1D< T > &rhs)
 
const Array1D< T > operator* (const Array1D< T > &rhs) const
 
Array1D< T > & operator/= (const T &rhs)
 
const Array1D< T > operator/ (const T &rhs) const
 
Array1D< T > & operator/= (const Array1D< T > &rhs)
 
const Array1D< T > operator/ (const Array1D< T > &rhs) const
 
bool operator== (const Array1D< T > &) const
 Operator that tests for equality. More...
 
bool operator!= (const Array1D< T > &) const
 Operator that tests for inequality. More...
 

Static Public Member Functions

static bool checkEpsilonEquality (const Array1D< double > &rhs1, const Array1D< double > &rhs2, const double &epsilon)
 

Protected Attributes

std::vector< T > vecData
 the actual data structure, that holds the objects of type T More...
 
size_t nx
 this is introduced to omit the costly vecData.size() More...
 
bool keep_nodata
 

Friends

template<class P >
std::ostream & operator<< (std::ostream &os, const Array1D< P > &array)
 
template<class P >
std::istream & operator>> (std::istream &is, Array1D< P > &array)
 

Constructor & Destructor Documentation

◆ Array1D() [1/2]

template<class T >
mio::Array1D< T >::Array1D ( const size_t &  asize = 0)

◆ Array1D() [2/2]

template<class T >
mio::Array1D< T >::Array1D ( const size_t &  asize,
const T &  init 
)

A constructor that creates an array filled with constant values

Parameters
asizesize of the new array
initinitial value to fill the array with

Member Function Documentation

◆ abs()

template<class T >
void mio::Array1D< T >::abs

◆ checkEpsilonEquality() [1/2]

template<class T >
bool mio::Array1D< T >::checkEpsilonEquality ( const Array1D< double > &  rhs,
const double &  epsilon 
) const

◆ checkEpsilonEquality() [2/2]

template<class T >
bool mio::Array1D< T >::checkEpsilonEquality ( const Array1D< double > &  rhs1,
const Array1D< double > &  rhs2,
const double &  epsilon 
)
static

◆ clear()

template<class T >
void mio::Array1D< T >::clear

◆ empty()

template<class T >
bool mio::Array1D< T >::empty

◆ getAbs()

template<class T >
const Array1D< T > mio::Array1D< T >::getAbs

returns the grid of the absolute value of values contained in the grid

Returns
grid of abs(grid)

◆ getCount()

template<class T >
size_t mio::Array1D< T >::getCount

returns the number of points contained in the grid. If setNodataHandling(IOUtils::RAW_NODATA), then the number of points is the size of the grid. If setNodataHandling(IOUtils::PARSE_NODATA), then it is the number of non-nodata values in the grid

Returns
count

◆ getKeepNodata()

template<class T >
bool mio::Array1D< T >::getKeepNodata

get how to process nodata values (ie: as nodata or as normal numbers)

Returns
true means that NODATA is interpreted as NODATA, false means that it is a normal number

◆ getMax()

template<class T >
T mio::Array1D< T >::getMax

returns the maximum value contained in the grid

Returns
maximum value

◆ getMean()

template<class T >
T mio::Array1D< T >::getMean

returns the mean value contained in the grid

Returns
mean value

◆ getMin()

template<class T >
T mio::Array1D< T >::getMin

returns the minimum value contained in the grid

Returns
minimum value

◆ getNx()

template<class T >
size_t mio::Array1D< T >::getNx

◆ insertAt()

template<class T >
void mio::Array1D< T >::insertAt ( const int &  index,
e 
)

◆ operator!=()

template<class T >
bool mio::Array1D< T >::operator!= ( const Array1D< T > &  in) const

Operator that tests for inequality.

◆ operator()() [1/2]

template<class T >
T & mio::Array1D< T >::operator() ( const size_t &  index)
inline

◆ operator()() [2/2]

template<class T >
const T mio::Array1D< T >::operator() ( const size_t &  index) const
inline

◆ operator*() [1/2]

template<class T >
const Array1D< T > mio::Array1D< T >::operator* ( const Array1D< T > &  rhs) const

◆ operator*() [2/2]

template<class T >
const Array1D< T > mio::Array1D< T >::operator* ( const T &  rhs) const

◆ operator*=() [1/2]

template<class T >
Array1D< T > & mio::Array1D< T >::operator*= ( const Array1D< T > &  rhs)

◆ operator*=() [2/2]

template<class T >
Array1D< T > & mio::Array1D< T >::operator*= ( const T &  rhs)

◆ operator+() [1/2]

template<class T >
const Array1D< T > mio::Array1D< T >::operator+ ( const Array1D< T > &  rhs) const

◆ operator+() [2/2]

template<class T >
const Array1D< T > mio::Array1D< T >::operator+ ( const T &  rhs) const

◆ operator+=() [1/2]

template<class T >
Array1D< T > & mio::Array1D< T >::operator+= ( const Array1D< T > &  rhs)

◆ operator+=() [2/2]

template<class T >
Array1D< T > & mio::Array1D< T >::operator+= ( const T &  rhs)

◆ operator-() [1/2]

template<class T >
const Array1D< T > mio::Array1D< T >::operator- ( const Array1D< T > &  rhs) const

◆ operator-() [2/2]

template<class T >
const Array1D< T > mio::Array1D< T >::operator- ( const T &  rhs) const

◆ operator-=() [1/2]

template<class T >
Array1D< T > & mio::Array1D< T >::operator-= ( const Array1D< T > &  rhs)

◆ operator-=() [2/2]

template<class T >
Array1D< T > & mio::Array1D< T >::operator-= ( const T &  rhs)

◆ operator/() [1/2]

template<class T >
const Array1D< T > mio::Array1D< T >::operator/ ( const Array1D< T > &  rhs) const

◆ operator/() [2/2]

template<class T >
const Array1D< T > mio::Array1D< T >::operator/ ( const T &  rhs) const

◆ operator/=() [1/2]

template<class T >
Array1D< T > & mio::Array1D< T >::operator/= ( const Array1D< T > &  rhs)

◆ operator/=() [2/2]

template<class T >
Array1D< T > & mio::Array1D< T >::operator/= ( const T &  rhs)

◆ operator=()

template<class T >
Array1D< T > & mio::Array1D< T >::operator= ( const T &  value)

◆ operator==()

template<class T >
bool mio::Array1D< T >::operator== ( const Array1D< T > &  in) const

Operator that tests for equality.

◆ operator[]() [1/2]

template<class T >
T & mio::Array1D< T >::operator[] ( const size_t &  index)
inline

◆ operator[]() [2/2]

template<class T >
const T mio::Array1D< T >::operator[] ( const size_t &  index) const
inline

◆ removeAt()

template<class T >
void mio::Array1D< T >::removeAt ( const size_t &  index)

◆ resize() [1/2]

template<class T >
void mio::Array1D< T >::resize ( const size_t &  asize)

◆ resize() [2/2]

template<class T >
void mio::Array1D< T >::resize ( const size_t &  asize,
const T &  init 
)

◆ setKeepNodata()

template<class T >
void mio::Array1D< T >::setKeepNodata ( const bool  i_keep_nodata)

set how to process nodata values (ie: as nodata or as normal numbers)

Parameters
i_keep_nodatatrue means that NODATA is interpreted as NODATA, false means that it is a normal number By default, arrays keep nodata.

◆ size() [1/2]

template<class T >
size_t mio::Array1D< T >::size

◆ size() [2/2]

template<class T >
void mio::Array1D< T >::size ( size_t &  nx) const

◆ toString()

template<class T >
const std::string mio::Array1D< T >::toString

Friends And Related Function Documentation

◆ operator<<

template<class T >
template<class P >
std::ostream & operator<< ( std::ostream &  os,
const Array1D< P > &  array 
)
friend

◆ operator>>

template<class T >
template<class P >
std::istream & operator>> ( std::istream &  is,
Array1D< P > &  array 
)
friend

Member Data Documentation

◆ keep_nodata

template<class T >
bool mio::Array1D< T >::keep_nodata
protected

◆ nx

template<class T >
size_t mio::Array1D< T >::nx
protected

this is introduced to omit the costly vecData.size()

◆ vecData

template<class T >
std::vector<T> mio::Array1D< T >::vecData
protected

the actual data structure, that holds the objects of type T


The documentation for this class was generated from the following file: