LLData< T > Class Template Reference

Collaboration diagram for LLData< T >:

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

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

Private Attributes
size_t	m_rank
int *	m_dims
T *	m_data_array

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 27 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 87 of file LLData.h.

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

References LLData< T >::allocate().

Here is the call graph for this function:

LLData() [2/2]

template<class T >

LLData< T >::LLData

(

const LLData< T > &

right

)

Definition at line 92 of file LLData.h.

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

References LLData< T >::allocate(), LLData< T >::getDimensions(), LLData< T >::getRank(), LLData< T >::getTotalSize(), and LLData< T >::m_data_array.

Here is the call graph for this function:

~LLData()

template<class T >

LLData< T >::~LLData

Definition at line 100 of file LLData.h.

{
    clear();
}

Member Function Documentation

operator=()

template<class T >

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

(

const LLData< T > &

right

)

Definition at line 105 of file LLData.h.

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

meanValues()

template<class T >

LLData<double> LLData< T >::meanValues

(

)

const

operator[]() [1/2]

template<class T >

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

inline

Definition at line 114 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 119 of file LLData.h.

{
    return m_data_array[i];
}

atCoordinate() [1/2]

template<class T >

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

inline

Definition at line 124 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 129 of file LLData.h.

{
    return m_data_array[convertCoordinate(coordinate)];
}

operator+=()

template<class T >

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

(

const LLData< T > &

right

)

Definition at line 134 of file LLData.h.

{
    if (!HaveSameDimensions(*this, right))
        throw Exceptions::RuntimeErrorException(
            "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 145 of file LLData.h.

{
    if (!HaveSameDimensions(*this, right))
        throw Exceptions::RuntimeErrorException(
            "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 156 of file LLData.h.

{
    if (!HaveSameDimensions(*this, right))
        throw Exceptions::RuntimeErrorException(
            "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 167 of file LLData.h.

{
    if (!HaveSameDimensions(*this, right))
        throw Exceptions::RuntimeErrorException(
            "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:

setAll()

template<class T >

void LLData< T >::setAll

(

const T &

value

)

Definition at line 187 of file LLData.h.

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

scaleAll()

template<class T >

void LLData< T >::scaleAll

(

const T &

factor

)

Definition at line 192 of file LLData.h.

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

getTotalSize()

template<class T >

size_t LLData< T >::getTotalSize

inline

Definition at line 198 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().

getRank()

template<class T >

size_t LLData< T >::getRank ( ) const

inline

Definition at line 56 of file LLData.h.

{ return m_rank; }

References LLData< T >::m_rank.

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

getDimensions()

template<class T >

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

inline

Definition at line 57 of file LLData.h.

{ return m_dims; }

References LLData< T >::m_dims.

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

getTotalSum()

template<class T >

T LLData< T >::getTotalSum

Definition at line 204 of file LLData.h.

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

allocate()

template<class T >

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

private

Definition at line 209 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().

clear()

template<class T >

void LLData< T >::clear

private

Definition at line 225 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;
    }
}

checkDimensions()

template<class T >

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

inlineprivate

Definition at line 238 of file LLData.h.

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

convertCoordinate()

template<class T >

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

inlineprivate

Definition at line 244 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;
}

swapContents()

template<class T >

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

private

Definition at line 255 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:

getZeroElement() [1/3]

template<class T >

T LLData< T >::getZeroElement

private

Definition at line 262 of file LLData.h.

{
    T result = 0;
    return result;
}

getZeroElement() [2/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() [3/3]

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

private

Member Data Documentation

m_rank

template<class T >

size_t LLData< T >::m_rank

private

Definition at line 68 of file LLData.h.

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

m_dims

template<class T >

int* LLData< T >::m_dims

private

Definition at line 69 of file LLData.h.

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

m_data_array

template<class T >

T* LLData< T >::m_data_array

private

Definition at line 70 of file LLData.h.

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

---

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

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