LLData< T > Class Template Reference

Template class to store data of any type in multi-dimensional space (low-level). More...

Public Member Functions
	LLData (const LLData< T > &right)
	LLData (size_t rank, const int *dimensions)
	~LLData ()
T &	atCoordinate (int *coordinate)
const T &	atCoordinate (int *coordinate) const
const int *	dimensions () const
size_t	getTotalSize () const
T	getTotalSum () const
LLData< double >	meanValues () const
LLData< T > &	operator*= (const LLData< T > &right)
LLData< T > &	operator+= (const LLData< T > &right)
LLData< T > &	operator-= (const LLData< T > &right)
LLData< T > &	operator/= (const LLData< T > &right)
LLData< T > &	operator= (const LLData< T > &right)
T &	operator[] (size_t i)
const T &	operator[] (size_t i) const
size_t	rank () const
void	scaleAll (const T &factor)
void	setAll (const T &value)

Private Member Functions
void	allocate (size_t rank, const int *dimensions)
bool	checkDimensions (size_t rank, const int *dimensions) const
void	clear ()
size_t	convertCoordinate (int *coordinate) const
Eigen::Matrix2d	getZeroElement () const
T	getZeroElement () const
Eigen::Matrix2d	getZeroElement () const
void	swapContents (LLData< T > &other)

Private Attributes
T *	m_data_array
int *	m_dims
size_t	m_rank

Detailed Description

template<class T>
class LLData< T >

Template class to store data of any type in multi-dimensional space (low-level).

Definition at line 31 of file LLData.h.

Constructor & Destructor Documentation

LLData() [1/2]

template<class T >

LLData< T >::LLData ( size_t  rank, const int *  dimensions  )

inline

Definition at line 90 of file LLData.h.

                                                           : m_rank(0), m_dims(0), m_data_array(0)
{
    allocate(rank, dimensions);
}

References LLData< T >::allocate(), LLData< T >::dimensions(), and LLData< T >::rank().

Here is the call graph for this function:

LLData() [2/2]

template<class T >

LLData< T >::LLData

(

const LLData< T > &

right

)

Definition at line 95 of file LLData.h.

                                                           : m_rank(0), m_dims(0), m_data_array(0)
{
    allocate(right.rank(), right.dimensions());
    for (size_t i = 0; i < getTotalSize(); ++i) {
        m_data_array[i] = right[i];
    }
}

References LLData< T >::allocate(), LLData< T >::dimensions(), LLData< T >::getTotalSize(), LLData< T >::m_data_array, and LLData< T >::rank().

Here is the call graph for this function:

~LLData()

template<class T >

LLData< T >::~LLData

Definition at line 103 of file LLData.h.

{
    clear();
}

Member Function Documentation

allocate()

template<class T >

void LLData< T >::allocate ( size_t  rank, const int *  dimensions  )

private

Definition at line 212 of file LLData.h.

{
    clear();
    if (!checkDimensions(rank, dimensions)) {
        throw std::runtime_error("LLData<T>::allocate error: dimensions must be > 0");
    }
    m_rank = rank;
    if (m_rank) {
        m_dims = new int[m_rank];
        std::copy(dimensions, dimensions + rank, m_dims);
        m_data_array = new T[getTotalSize()];
    } else {
        m_data_array = new T[1];
    }
}

Referenced by LLData< T >::LLData().

atCoordinate() [1/2]

template<class T >

T & LLData< T >::atCoordinate ( int *  coordinate )

inline

Definition at line 127 of file LLData.h.

{
    return m_data_array[convertCoordinate(coordinate)];
}

atCoordinate() [2/2]

template<class T >

const T & LLData< T >::atCoordinate ( int *  coordinate ) const

inline

Definition at line 132 of file LLData.h.

{
    return m_data_array[convertCoordinate(coordinate)];
}

checkDimensions()

template<class T >

bool LLData< T >::checkDimensions ( size_t  rank, const int *  dimensions  ) const

inlineprivate

Definition at line 241 of file LLData.h.

{
    return std::all_of(dimensions, dimensions + rank,
                       [](const int& dim) -> bool { return dim > 0; });
}

clear()

template<class T >

void LLData< T >::clear

private

Definition at line 228 of file LLData.h.

{
    if (m_rank > 0) {
        m_rank = 0;
        delete[] m_data_array;
        delete[] m_dims;
        m_data_array = nullptr;
        m_dims = nullptr;
    } else {
        delete[] m_data_array;
    }
}

convertCoordinate()

template<class T >

size_t LLData< T >::convertCoordinate ( int *  coordinate ) const

inlineprivate

Definition at line 247 of file LLData.h.

{
    size_t offset = 1;
    size_t result = 0;
    for (size_t i = m_rank; i > 0; --i) {
        result += offset * coordinate[i - 1];
        offset *= m_dims[i - 1];
    }
    return result;
}

dimensions()

template<class T >

const int* LLData< T >::dimensions ( ) const

inline

Definition at line 60 of file LLData.h.

{ return m_dims; }

References LLData< T >::m_dims.

Referenced by LLData< T >::LLData(), and HaveSameDimensions().

getTotalSize()

template<class T >

size_t LLData< T >::getTotalSize

inline

Definition at line 201 of file LLData.h.

{
    int result = std::accumulate(m_dims, m_dims + m_rank, 1, std::multiplies<int>{});
    return static_cast<size_t>(result);
}

Referenced by LLData< T >::LLData().

getTotalSum()

template<class T >

T LLData< T >::getTotalSum

Definition at line 207 of file LLData.h.

{
    return std::accumulate(m_data_array, m_data_array + getTotalSize(), getZeroElement());
}

getZeroElement() [1/3]

Eigen::Matrix2d LLData< Eigen::Matrix2d >::getZeroElement ( ) const

private

Definition at line 17 of file LLData.cpp.

{
    Eigen::Matrix2d result = Eigen::Matrix2d::Zero();
    return result;
}

getZeroElement() [2/3]

template<class T >

T LLData< T >::getZeroElement

private

Definition at line 265 of file LLData.h.

{
    T result = 0;
    return result;
}

getZeroElement() [3/3]

Eigen::Matrix2d LLData< Eigen::Matrix2d >::getZeroElement ( ) const

private

meanValues()

template<class T >

LLData<double> LLData< T >::meanValues

(

)

const

operator*=()

template<class T >

LLData< T > & LLData< T >::operator*=

(

const LLData< T > &

right

)

Definition at line 159 of file LLData.h.

{
    if (!HaveSameDimensions(*this, right))
        throw std::runtime_error(
            "Operation *= on LLData requires both operands to have the same dimensions");
    for (size_t i = 0; i < getTotalSize(); ++i) {
        m_data_array[i] *= right[i];
    }
    return *this;
}

References HaveSameDimensions().

Here is the call graph for this function:

operator+=()

template<class T >

LLData< T > & LLData< T >::operator+=

(

const LLData< T > &

right

)

Definition at line 137 of file LLData.h.

{
    if (!HaveSameDimensions(*this, right))
        throw std::runtime_error(
            "Operation += on LLData requires both operands to have the same dimensions");
    for (size_t i = 0; i < getTotalSize(); ++i) {
        m_data_array[i] += right[i];
    }
    return *this;
}

References HaveSameDimensions().

Here is the call graph for this function:

operator-=()

template<class T >

LLData< T > & LLData< T >::operator-=

(

const LLData< T > &

right

)

Definition at line 148 of file LLData.h.

{
    if (!HaveSameDimensions(*this, right))
        throw std::runtime_error(
            "Operation -= on LLData requires both operands to have the same dimensions");
    for (size_t i = 0; i < getTotalSize(); ++i) {
        m_data_array[i] -= right[i];
    }
    return *this;
}

References HaveSameDimensions().

Here is the call graph for this function:

operator/=()

template<class T >

LLData< T > & LLData< T >::operator/=

(

const LLData< T > &

right

)

Definition at line 170 of file LLData.h.

{
    if (!HaveSameDimensions(*this, right))
        throw std::runtime_error(
            "Operation /= on LLData requires both operands to have the same dimensions");
    for (size_t i = 0; i < getTotalSize(); ++i) {
        double ratio;
        if (std::abs(m_data_array[i] - right[i])
            <= std::numeric_limits<double>::epsilon() * std::abs(right[i])) {
            ratio = 1.0;
        } else if (std::abs(right[i]) <= std::numeric_limits<double>::min()) {
            ratio = double(m_data_array[i]) / std::numeric_limits<double>::min();
        } else {
            ratio = double(m_data_array[i] / right[i]);
        }
        m_data_array[i] = (T)ratio;
    }
    return *this;
}

References HaveSameDimensions().

Here is the call graph for this function:

operator=()

template<class T >

LLData< T > & LLData< T >::operator=

(

const LLData< T > &

right

)

Definition at line 108 of file LLData.h.

{
    if (this != &right) {
        LLData<T> copy(right);
        swapContents(copy);
    }
    return *this;
}

operator[]() [1/2]

template<class T >

T & LLData< T >::operator[] ( size_t  i )

inline

Definition at line 117 of file LLData.h.

{
    return m_data_array[i];
}

operator[]() [2/2]

template<class T >

const T & LLData< T >::operator[] ( size_t  i ) const

inline

Definition at line 122 of file LLData.h.

{
    return m_data_array[i];
}

rank()

template<class T >

size_t LLData< T >::rank ( ) const

inline

Definition at line 59 of file LLData.h.

{ return m_rank; }

References LLData< T >::m_rank.

Referenced by LLData< T >::LLData(), and HaveSameDimensions().

scaleAll()

template<class T >

void LLData< T >::scaleAll

(

const T &

factor

)

Definition at line 195 of file LLData.h.

{
    std::transform(m_data_array, m_data_array + getTotalSize(), m_data_array,
                   [&factor](const T& value) -> T { return value * factor; });
}

setAll()

template<class T >

void LLData< T >::setAll

(

const T &

value

)

Definition at line 190 of file LLData.h.

{
    std::fill(m_data_array, m_data_array + getTotalSize(), value);
}

swapContents()

template<class T >

void LLData< T >::swapContents ( LLData< T > &  other )

private

Definition at line 258 of file LLData.h.

{
    std::swap(this->m_rank, other.m_rank);
    std::swap(this->m_dims, other.m_dims);
    std::swap(this->m_data_array, other.m_data_array);
}

References LLData< T >::m_data_array, LLData< T >::m_dims, LLData< T >::m_rank, and swap().

Here is the call graph for this function:

Member Data Documentation

m_data_array

template<class T >

T* LLData< T >::m_data_array

private

Definition at line 73 of file LLData.h.

Referenced by LLData< T >::LLData(), and LLData< T >::swapContents().

m_dims

template<class T >

int* LLData< T >::m_dims

private

Definition at line 72 of file LLData.h.

Referenced by LLData< T >::dimensions(), and LLData< T >::swapContents().

m_rank

template<class T >

size_t LLData< T >::m_rank

private

Definition at line 71 of file LLData.h.

Referenced by LLData< T >::rank(), and LLData< T >::swapContents().

---

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

• /home/www/ba/Device/Data/LLData.h