auryn::SimpleMatrix< T > Class Template Reference

Template for a sparse matrix with row major ordering and fast access of rows. More...

#include <SimpleMatrix.h>

Public Member Functions
	SimpleMatrix ()
	SimpleMatrix (SimpleMatrix *mat)
	SimpleMatrix (NeuronID rows, NeuronID cols)
	SimpleMatrix (NeuronID rows, NeuronID cols, AurynLong size)
virtual	~SimpleMatrix ()
void	clear ()
void	resize_buffer (AurynLong newsize)
void	resize_buffer_and_clear (AurynLong size)
void	prune ()
void	push_back (const NeuronID i, const NeuronID j, const T value)
void	copy (SimpleMatrix *mat)
void	set_data (AurynLong i, T value)
void	scale_data (AurynLong i, T value)
T *	get_data_ptr (const AurynLong i)
T	get_data (const AurynLong i)
T *	get_data_ptr (const NeuronID *ind_ptr)
T	get_data (const NeuronID *ind_ptr)
void	fill_zeros ()
	Same as fill_na. More...
void	fill_na ()
	Marks the remainder of buffers non-existing connections. More...
AurynDouble	get_fill_level ()
T	get (NeuronID i, NeuronID j)
bool	exists (NeuronID i, NeuronID j)
T *	get_ptr (NeuronID i, NeuronID j)
T *	get_ptr (AurynLong data_index)
T	get_value (AurynLong data_index)
void	add_value (AurynLong data_index, T value)
NeuronID	get_colind (AurynLong data_index)
bool	set (NeuronID i, NeuronID j, T value)
void	set_all (T value)
void	set_row (NeuronID i, T value)
void	scale_row (NeuronID i, T value)
void	scale_all (T value)
void	set_col (NeuronID j, T value)
void	scale_col (NeuronID j, T value)
double	sum_col (NeuronID j)
AurynLong	get_datasize ()
AurynLong	get_nonzero ()
void	print ()
double	mean ()
NeuronID *	get_ind_begin ()
NeuronID *	get_row_begin (NeuronID i)
AurynLong	get_row_begin_index (NeuronID i)
NeuronID *	get_row_end (NeuronID i)
AurynLong	get_row_end_index (NeuronID i)
NeuronID	get_m_rows ()
NeuronID	get_n_cols ()
NeuronID **	get_rowptrs ()
T *	get_data_begin ()
T *	get_data_end ()
	Returns value behind last element in data array corresponding to a nonzero value. More...
T	get_value (NeuronID i)
T	get_value (NeuronID *r)
T *	get_value_ptr (NeuronID i)
T *	get_value_ptr (NeuronID *r)
NeuronID	get_data_offset (NeuronID *r)

Protected Member Functions
void	init (NeuronID m, NeuronID n, AurynLong size=256)
void	free ()

Protected Attributes
NeuronID **	rowptrs
NeuronID *	colinds
T *	coldata

Friends
class	boost::serialization::access

Detailed Description

template<typename T>
class auryn::SimpleMatrix< T >

Template for a sparse matrix with row major ordering and fast access of rows.

This matrix class implements a sparse matrix that allows fast access of all elements of one row. It provides row interators to efficiently propagate spikes. Memory has to be reserved when the class is defined and elements can only be inserted row by row starting from "left to right". This scheme enables related data fields to reside in memory next to each other.

Constructor & Destructor Documentation

SimpleMatrix() [1/4]

template<typename T >

auryn::SimpleMatrix< T >::SimpleMatrix

(

)

{
        init(1,1);
}

Here is the call graph for this function:

SimpleMatrix() [2/4]

template<typename T >

auryn::SimpleMatrix< T >::SimpleMatrix

(

SimpleMatrix< T > *

mat

)

{
        init(mat->get_m_rows(),mat->get_n_cols(),mat->get_nonzero());
        copy(mat);
}

Here is the call graph for this function:

SimpleMatrix() [3/4]

template<typename T >

auryn::SimpleMatrix< T >::SimpleMatrix	(	NeuronID	rows,
		NeuronID	cols
	)

{
        init(rows,cols);
}

Here is the call graph for this function:

SimpleMatrix() [4/4]

template<typename T >

auryn::SimpleMatrix< T >::SimpleMatrix	(	NeuronID	rows,
		NeuronID	cols,
		AurynLong	size
	)

{
        init(rows,cols,datasize);
}

Here is the call graph for this function:

~SimpleMatrix()

template<typename T >

auryn::SimpleMatrix< T >::~SimpleMatrix ( )

virtual

{
        free();
}

Here is the call graph for this function:

Member Function Documentation

add_value()

template<typename T >

void auryn::SimpleMatrix< T >::add_value	(	AurynLong	data_index,
		T	value
	)

{
        coldata[data_index] += value;
}

clear()

template<typename T >

void auryn::SimpleMatrix< T >::clear

(

)

{
        current_row = 0;
        current_col = 0;
        n_nonzero = 0;
        rowptrs[0] = colinds;
        rowptrs[1] = colinds;
}

copy()

template<typename T >

void auryn::SimpleMatrix< T >::copy

(

SimpleMatrix< T > *

mat

)

{
        if ( get_m_rows() != mat->get_m_rows() || get_n_cols() != mat->get_n_cols() )
                throw AurynMatrixDimensionalityException();

        clear();

        for ( NeuronID i = 0 ; i < mat->get_m_rows() ; ++i ) {
                for ( NeuronID * r = mat->get_row_begin(i) ; r != mat->get_row_end(i) ; ++r ) {
                        push_back(i,*r,mat->get_value(r));
                }
        }
}

Here is the call graph for this function:

exists()

template<typename T >

bool auryn::SimpleMatrix< T >::exists	(	NeuronID	i,
		NeuronID	j
	)

{
        if ( get_ptr(i,j) == NULL )
                return false;
        else 
                return true;
}

Here is the call graph for this function:

fill_na()

template<typename T >

void auryn::SimpleMatrix< T >::fill_na

(

)

Marks the remainder of buffers non-existing connections.

Should be called by finalize before using the matrix.

{
        for ( NeuronID i = current_row ; i < m_rows-1 ; ++i )
        {
                rowptrs[i+2] = rowptrs[i+1];  // save value of last element
        }
        current_row = get_m_rows();
}

Here is the call graph for this function:

fill_zeros()

template<typename T >

void auryn::SimpleMatrix< T >::fill_zeros

(

)

Same as fill_na.

Deprecated:

Because it does not really fill zeros, but NA.

{
        fill_na();
}

Here is the call graph for this function:

free()

template<typename T >

void auryn::SimpleMatrix< T >::free ( )

protected

{
        delete [] rowptrs;
        delete [] colinds;
        delete [] coldata;
}

get()

template<typename T >

T auryn::SimpleMatrix< T >::get	(	NeuronID	i,
		NeuronID	j
	)

{
        return *get_ptr(i,j);
}

Here is the call graph for this function:

get_colind()

template<typename T >

NeuronID auryn::SimpleMatrix< T >::get_colind

(

AurynLong

data_index

)

{
        return colinds[data_index];
}

get_data() [1/2]

template<typename T >

T auryn::SimpleMatrix< T >::get_data

(

const AurynLong

i

)

Gets the matching data entry for a given index i

{
        return coldata[i];
}

get_data() [2/2]

template<typename T >

T auryn::SimpleMatrix< T >::get_data

(

const NeuronID *

ind_ptr

)

Gets the matching data value for a given index pointer

{
        return *(get_data_ptr(ind_ptr));
}

Here is the call graph for this function:

get_data_begin()

template<typename T >

T * auryn::SimpleMatrix< T >::get_data_begin

(

)

{
        return coldata;
}

get_data_end()

template<typename T >

T * auryn::SimpleMatrix< T >::get_data_end

(

)

Returns value behind last element in data array corresponding to a nonzero value.

{
        return coldata+get_nonzero();
}

Here is the call graph for this function:

get_data_offset()

template<typename T >

NeuronID auryn::SimpleMatrix< T >::get_data_offset

(

NeuronID *

r

)

{
        return r-get_ind_begin();
}

Here is the call graph for this function:

get_data_ptr() [1/2]

template<typename T >

T * auryn::SimpleMatrix< T >::get_data_ptr

(

const AurynLong

i

)

Gets the matching data ptr for a given index i

{
        return coldata+i;
}

get_data_ptr() [2/2]

template<typename T >

T * auryn::SimpleMatrix< T >::get_data_ptr

(

const NeuronID *

ind_ptr

)

Gets the matching data ptr for a given index pointer

{
        size_t ptr_offset = ind_ptr-get_ind_begin();
        return coldata+ptr_offset;
}

Here is the call graph for this function:

get_datasize()

template<typename T >

AurynLong auryn::SimpleMatrix< T >::get_datasize

(

)

{
        return datasize;
}

get_fill_level()

template<typename T >

AurynDouble auryn::SimpleMatrix< T >::get_fill_level

(

)

{
        return 1.*n_nonzero/datasize;
}

get_ind_begin()

template<typename T >

NeuronID * auryn::SimpleMatrix< T >::get_ind_begin

(

)

{
        return rowptrs[0];
}

get_m_rows()

template<typename T >

NeuronID auryn::SimpleMatrix< T >::get_m_rows

(

)

{
        return m_rows;
}

get_n_cols()

template<typename T >

NeuronID auryn::SimpleMatrix< T >::get_n_cols

(

)

{
        return n_cols;
}

get_nonzero()

template<typename T >

AurynLong auryn::SimpleMatrix< T >::get_nonzero

(

)

{
        return n_nonzero;
}

get_ptr() [1/2]

template<typename T >

T * auryn::SimpleMatrix< T >::get_ptr	(	NeuronID	i,
		NeuronID	j
	)

Returns the pointer to a particular element

{
        // check bounds
        if ( !(i < m_rows && j < n_cols) ) return NULL;

#ifdef DEBUG
        std::cout << "enter search" << std::endl;
#endif // DEBUG
        // perform binary search
        NeuronID * lo = rowptrs[i];
        NeuronID * hi = rowptrs[i+1];

        if ( lo >= hi ) // no elements/targets in this row
                return NULL; 
        
        while ( lo < hi ) {
                NeuronID * c = lo + (hi-lo)/2;
                if ( *c < j ) lo = c+1;
                else hi = c;
#ifdef DEBUG
                std::cout << i << ":" << j << "   " << *lo << ":" << *hi << std::endl;
#endif // DEBUG
        }
        
        if ( *lo == j ) {
                return coldata+(lo-colinds);
        }

        return NULL; 
}

get_ptr() [2/2]

template<typename T >

T * auryn::SimpleMatrix< T >::get_ptr

(

AurynLong

data_index

)

Returns the pointer to a particular element given its position in the data array.

{
        return &coldata[data_index];
}

get_row_begin()

template<typename T >

NeuronID * auryn::SimpleMatrix< T >::get_row_begin

(

NeuronID

i

)

{
        return rowptrs[i];
}

get_row_begin_index()

template<typename T >

AurynLong auryn::SimpleMatrix< T >::get_row_begin_index

(

NeuronID

i

)

{
        return rowptrs[i]-rowptrs[0];
}

get_row_end()

template<typename T >

NeuronID * auryn::SimpleMatrix< T >::get_row_end

(

NeuronID

i

)

{
        return rowptrs[i+1];
}

get_row_end_index()

template<typename T >

AurynLong auryn::SimpleMatrix< T >::get_row_end_index

(

NeuronID

i

)

{
        return rowptrs[i+1]-rowptrs[0];
}

get_rowptrs()

template<typename T >

NeuronID ** auryn::SimpleMatrix< T >::get_rowptrs

(

)

{
        return rowptrs;
}

get_value() [1/3]

template<typename T >

T auryn::SimpleMatrix< T >::get_value

(

AurynLong

data_index

)

{
        return coldata[data_index];
}

get_value() [2/3]

template<typename T >

T auryn::SimpleMatrix< T >::get_value

(

NeuronID

i

)

Returns the data value to an item that is i-th in the colindex array

{
        return get_data_begin()[i];
}

Here is the call graph for this function:

get_value() [3/3]

template<typename T >

T auryn::SimpleMatrix< T >::get_value

(

NeuronID *

r

)

Returns the data value to an item that for pointer r pointing to the respective element in the index array

{
        return get_data_begin()[r-get_ind_begin()];
}

Here is the call graph for this function:

get_value_ptr() [1/2]

template<typename T >

T * auryn::SimpleMatrix< T >::get_value_ptr

(

NeuronID

i

)

Returns pointer to the the data value to an item that is i-th in the colindex array

{
        return &get_data_begin()[i];
}

Here is the call graph for this function:

get_value_ptr() [2/2]

template<typename T >

T * auryn::SimpleMatrix< T >::get_value_ptr

(

NeuronID *

r

)

Returns the pointer to the data value to an item that for pointer r pointing to the respective element in the index array

{
        return &get_data_begin()[r-get_ind_begin()];
}

Here is the call graph for this function:

init()

template<typename T >

void auryn::SimpleMatrix< T >::init ( NeuronID  m, NeuronID  n, AurynLong  size = 256  )

protected

Default initializiation called by the constructor.

{
        m_rows = m;
        n_cols = n;
        datasize = size;
        rowptrs = new NeuronID * [m_rows+1];
        colinds = new NeuronID [datasize];
        coldata = new T [datasize];
        clear();
}

Here is the call graph for this function:

mean()

template<typename T >

double auryn::SimpleMatrix< T >::mean

(

)

{
        double sum = 0;
        for (NeuronID i = 0 ; i < get_nonzero() ; ++i) {
                sum += coldata[i];
        }
        return sum/get_nonzero();
}

Here is the call graph for this function:

print()

template<typename T >

void auryn::SimpleMatrix< T >::print

(

)

{
        for (NeuronID i = 0 ; i < m_rows ; ++i) {
                for (NeuronID * r = get_row_begin(i) ; r != get_row_end(i) ; ++r ) {
                        std::cout << i << " " << *r << " " << coldata[r-colinds] << "\n";
                }
        }
}

Here is the call graph for this function:

prune()

template<typename T >

void auryn::SimpleMatrix< T >::prune

(

)

Prunes the reserved memory such that datasize=get_nonzero() Note that this is an expensive operation because it uses resize_buffer(size) and it should be used sparsely.

{
        if ( get_datasize() > get_nonzero() )
                resize_buffer(get_nonzero());
}

Here is the call graph for this function:

push_back()

template<typename T >

void auryn::SimpleMatrix< T >::push_back	(	const NeuronID	i,
		const NeuronID	j,
		const T	value
	)

Add non-zero element in row/col order.

Parameters

i	row index where to insert element
j	col index where to insert element
value	to insert

Exceptions

AurynMatrixBufferException

{   
        if ( i >= m_rows || j >= n_cols ) throw AurynMatrixDimensionalityException();
        while ( i > current_row )
        {
                rowptrs[current_row+2] = rowptrs[current_row+1];  // save value of last element
                current_col = 0;
                current_row++;
        } 
        current_col = j;
        if (i >= current_row && j >= current_col) {
                if ( n_nonzero >= datasize ) throw AurynMatrixBufferException();
                *(rowptrs[i+1]) = j; // write last j to end of index array
                coldata[rowptrs[i+1]-colinds] = value; // write value to end of data array
                ++rowptrs[i+1]; //increment end by one
                rowptrs[m_rows] = rowptrs[i+1]; // last (m_row+1) marks end of last row
                n_nonzero++;
        } else {
                throw AurynMatrixPushBackException();
        }
}

resize_buffer()

template<typename T >

void auryn::SimpleMatrix< T >::resize_buffer

(

AurynLong

newsize

)

Resize buffer Allocates a new buffer of size and copies the old buffers before freeing the memory

{
        const AurynLong oldsize = datasize;
        if ( oldsize == newsize ) return;
        const AurynLong copysize = std::min(oldsize,newsize);

        // std::cout << " copy colinds " << std::endl;

        NeuronID * new_colinds = new NeuronID [newsize];
        std::copy(colinds, colinds+copysize, new_colinds);

        // std::cout << " update rowptrs " << std::endl;

        // update rowpointers
        ptrdiff_t offset = new_colinds-colinds;
        for ( NeuronID i = 0 ; i < m_rows+1 ; ++i ) {
                rowptrs[i] += offset;
        }
        
        // std::cout << " delete old colinds " << std::endl;
        // FIXME I get regular crashes in this line:
        //  invalid pointer: 0x0000000001d954c0 ***
        delete [] colinds;

        // std::cout << " replace colinds " << std::endl;
        colinds = new_colinds;

        // std::cout << " create new data array " << std::endl;
        T * new_coldata = new T [newsize];
        std::copy(coldata, coldata+copysize, new_coldata);
        delete [] coldata;
        coldata = new_coldata;

        datasize = newsize;
        // std::cout << " done " << std::endl;
}

resize_buffer_and_clear()

template<typename T >

void auryn::SimpleMatrix< T >::resize_buffer_and_clear

(

AurynLong

size

)

Resizes buffer and clears the matrix. This saves to copy all the data.

{
        // free();
        // init(m_rows, n_cols, size);
        resize_buffer(size);
        clear();
}

Here is the call graph for this function:

scale_all()

template<typename T >

void auryn::SimpleMatrix< T >::scale_all

(

T

value

)

Scales all non-zero elements

{
        for ( AurynLong i = 0 ; i < n_nonzero ; ++i ) 
                scale_data( i , value );
}

Here is the call graph for this function:

scale_col()

template<typename T >

void auryn::SimpleMatrix< T >::scale_col	(	NeuronID	j,
		T	value
	)

Scales all non-zero elements in col j to value. Due to ordering this is slow and the use of this functions is discouraged.

{
        for ( AurynLong i = 0 ; i < n_nonzero ; ++i ) {
                if ( colinds[i] == j ) scale_data(i,value);
        }
}

Here is the call graph for this function:

scale_data()

template<typename T >

void auryn::SimpleMatrix< T >::scale_data	(	AurynLong	i,
		T	value
	)

{
        if (i<datasize)
                coldata[i] *= value;
}

scale_row()

template<typename T >

void auryn::SimpleMatrix< T >::scale_row	(	NeuronID	i,
		T	value
	)

Scales all non-zero elements in row i to value

{
        NeuronID * rowbegin = rowptrs[i];
        NeuronID * rowend = rowptrs[i+1]--;

        for (NeuronID * c = rowbegin ; c <= rowend ; ++c) 
        {
                coldata[c-colinds] *= value;
        }
}

set()

template<typename T >

bool auryn::SimpleMatrix< T >::set	(	NeuronID	i,
		NeuronID	j,
		T	value
	)

{
        T * ptr = get_ptr(i,j);
        if ( ptr != NULL) {
                *ptr = value;
                return true;
        }
        else
                return false;
}

Here is the call graph for this function:

set_all()

template<typename T >

void auryn::SimpleMatrix< T >::set_all

(

T

value

)

Sets all non-zero elements to value

{
        for ( AurynLong i = 0 ; i < n_nonzero ; ++i ) 
                set_data( i , value );
}

Here is the call graph for this function:

set_col()

template<typename T >

void auryn::SimpleMatrix< T >::set_col	(	NeuronID	j,
		T	value
	)

Sets all non-zero elements in col j to value. Due to ordering this is slow and the use of this functions is discouraged.

{
        for ( AurynLong i = 0 ; i < n_nonzero ; ++i ) {
                if ( colinds[i] == j ) set_data(i,value);
        }
}

Here is the call graph for this function:

set_data()

template<typename T >

void auryn::SimpleMatrix< T >::set_data	(	AurynLong	i,
		T	value
	)

{
        if (i<datasize)
                coldata[i] = value;
}

set_row()

template<typename T >

void auryn::SimpleMatrix< T >::set_row	(	NeuronID	i,
		T	value
	)

Sets all non-zero elements in row i to value

{
        NeuronID * rowbegin = rowptrs[i];
        NeuronID * rowend = rowptrs[i+1]--;

        for (NeuronID * c = rowbegin ; c <= rowend ; ++c) 
        {
                coldata[c-colinds] = value;
        }
}

sum_col()

template<typename T >

double auryn::SimpleMatrix< T >::sum_col

(

NeuronID

j

)

{
        double sum = 0;
        for ( AurynLong i = 0 ; i < n_nonzero ; ++i ) {
                if ( colinds[i] == j ) 
                        sum += *(get_data_begin()+i);
        }
        return sum;
}

Here is the call graph for this function:

Friends And Related Function Documentation

boost::serialization::access

template<typename T >

friend class boost::serialization::access

friend

Member Data Documentation

coldata

template<typename T >

T* auryn::SimpleMatrix< T >::coldata

protected

Array that holds the data values of the non-zero elements

colinds

template<typename T >

NeuronID* auryn::SimpleMatrix< T >::colinds

protected

Array that holds the column indices of non-zero elements

rowptrs

template<typename T >

NeuronID** auryn::SimpleMatrix< T >::rowptrs

protected

Array that holds the begin addresses of column indices

---

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

• /home/zenke/auryn/src/auryn/SimpleMatrix.h