auryn::ComplexMatrix< T > Class Template Reference

Template for a sparse matrix with row major ordering and fast access of rows and capability to store float values per matrix entry. More...

#include <ComplexMatrix.h>

Collaboration diagram for auryn::ComplexMatrix< T >:

Public Member Functions
	ComplexMatrix ()
	Empty constructor. More...
	ComplexMatrix (ComplexMatrix *mat)
	Copy constructor. More...
	ComplexMatrix (NeuronID rows, NeuronID cols, AurynLong size=256, StateID n_values=1)
	Default constructor. More...
virtual	~ComplexMatrix ()
	Default destructor. More...
void	clear ()
	Clears matrix. More...
AurynVector< T, AurynLong > *	get_synaptic_state_vector (StateID z=0)
	Returns pointer to statevector which is an AurynVector of specified synaptic state. More...
AurynVector< T, AurynLong > *	get_state_vector (StateID z=0)
	Sames as get_synaptic_state_vector(StateID z) More...
void	resize_buffers (AurynLong size)
	Resize buffer. More...
void	resize_buffer_and_clear (AurynLong size)
	Resizes buffer and clears the matrix. This saves to copy all the data. More...
void	prune ()
	Prunes the reserved memory such that datasize=get_nonzero() Note that this is an expensive operation because it uses resize_buffers(size) and it should be used sparsely. More...
void	push_back (const NeuronID i, const NeuronID j, const T value)
void	copy (ComplexMatrix *mat)
	Copies complex matrix mat. More...
void	set_element (AurynLong data_index, T value, StateID z=0)
void	set_data (AurynLong i, T value, StateID z=0)
void	scale_element (AurynLong data_index, T value, StateID z=0)
void	scale_data (AurynLong i, T value, StateID z=0)
T	get_data (AurynLong i, StateID z=0)
T *	get_data_ptr (const AurynLong data_index, const StateID z=0)
	Gets the matching data ptr for a given index i and state z. More...
T *	get_data_ptr (const NeuronID *ind_ptr, const StateID z=0)
	Gets the matching data ptr for a given index pointer and state z. More...
T	get_data (const NeuronID *ind_ptr, StateID z=0)
	Gets the matching data value for a given index pointer and state z. More...
void	fill_na ()
	Pads non-existing elements for the remaining elements to a matrix. More...
void	fill_zeros ()
	Same as fill_na but deprecated because of bad name. More...
AurynDouble	get_fill_level ()
	Returns the fill level of the matrix element buffer. More...
T	get (const NeuronID i, const NeuronID j, const NeuronID z=0)
	Value of synaptic state variable i,j,z returns zero if the element is zero or does not exist. More...
bool	exists (const NeuronID i, const NeuronID j, const StateID z=0)
	Returns true if the matrix element exists. More...
T *	get_ptr (const NeuronID i, const NeuronID j, const StateID z=0)
	Returns the pointer to a particular element. More...
T *	get_ptr (const AurynLong data_index, const StateID z=0)
	Same as get_data_ptr. Returns the pointer to a particular element given its position in the data array. More...
T	get_element (const AurynLong data_index, const StateID z)
	Returns a particular element given its position in the data array. More...
AurynLong	ind_ptr_to_didx (const NeuronID *ind_ptr)
	Returns data index to a particular element specifed by an index pointer. More...
AurynLong	get_data_index (const NeuronID *ind_ptr)
	Returns data index to a particular element specifed by an index pointer. More...
AurynLong	get_data_index (const NeuronID i, const NeuronID j)
AurynLong	data_ptr_to_didx (const T *ptr)
	Returns data index to a particular element specifed by a data pointer. More...
AurynLong	get_data_index (const T *ptr)
	Returns data index to a particular element specifed by a data pointer. More...
void	set_num_synaptic_states (const StateID zsize)
	Sets number of synaptic states (z-value) More...
void	set_num_synapse_states (const StateID zsize)
	Sets number of synaptic states (z-value) More...
StateID	get_num_synaptic_states ()
	Returns number of synaptic states (z-value) More...
StateID	get_num_z_values ()
	Returns number of synaptic states (z-value) More...
StateID	get_num_synapse_states ()
	Synonymous to get_num_synaptic_states. More...
T *	get_state_begin (const StateID z=0)
	Gets pointer for the first element of a given synaptic state vector. More...
T *	get_state_end (const StateID z=0)
	Gets pointer for the element behind the last of a given synaptic state vector. More...
void	state_set_all (T *x, const T value)
	Sets all values in state x to value. More...
void	state_saxpy (const T a, T *x, T *y)
	Computes a*x + y and stores result in y. More...
void	state_mul (T *x, T *y)
	Multiplies x and y and stores result in y. More...
void	state_add (T *x, T *y)
	Adds x and y and stores result in y. More...
void	state_sub (T *x, T *y)
	Computes x-y and stores result in y. More...
void	state_sub (T *x, T *y, T *res)
	Computes x-y and stores result in res. More...
void	state_scale (const T a, T *x)
	Scale state x by a. More...
void	state_add_const (const T a, T *x)
	Adds constant a to all values in x. More...
void	state_clip (T *x, const T a, const T b)
	Clips state values to interval [a,b]. More...
T *	state_get_data_ptr (T *x, NeuronID i)
	Get data pointer for that state. More...
void	add_value (const AurynLong data_index, T value)
NeuronID	get_colind (const AurynLong data_index)
bool	set (const NeuronID i, const NeuronID j, T value)
void	set_all (const T value, const StateID z=0)
	Sets all non-zero elements to value. More...
void	set_row (const NeuronID i, const T value)
	Sets all non-zero elements in row i to value. More...
void	scale_row (const NeuronID i, const T value)
	Scales all non-zero elements in row i to value. More...
void	scale_all (const T value)
	Scales all non-zero elements. More...
void	set_col (const NeuronID j, const 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. More...
void	scale_col (const NeuronID j, const 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. More...
double	sum_col (const NeuronID j)
AurynLong	get_datasize ()
	Returns datasize: number of possible entries. More...
AurynLong	get_statesize ()
	Same as datasize : number of possible entries. More...
AurynLong	get_memsize ()
	Returns statesize multiplied by number of states. More...
AurynLong	get_nonzero ()
	Returns number of non-zero elements. More...
void	print ()
	stdout dump of all elements – for testing only. More...
double	mean ()
	Return mean value of elements for the first complex state (z=0). More...
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 (const StateID z=0)
	Returns pointer to data value corresponding to the first element. More...
T *	get_data_end (const StateID z=0)
	Returns pointer to data value corresponding to the element behind the last nonzero element. More...
T	get_value (const AurynLong data_index)
	Returns the data value to an item that is i-th in the colindex array. More...
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. More...
T *	get_value_ptr (const NeuronID i)
	Returns pointer to the the data value to an item that is i-th in the colindex array. More...
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. More...
NeuronID	get_data_offset (NeuronID *r)

Public Attributes
std::vector< AurynVector< T, AurynLong > *>	statevectors
	Vector that holds pointers to the state vectors storing the synaptic states. More...

Protected Member Functions
AurynVector< T, AurynLong > *	alloc_synaptic_state_vector ()
	Returns a synaptic state vector. More...
void	prepare_state_vectors ()
	Matches size of statevectors to number of synaptic states. More...
void	init (NeuronID m, NeuronID n, AurynLong size, NeuronID z)
	Default initializiation called by the constructor. More...
void	free ()

Protected Attributes
NeuronID **	rowptrs
	Array that holds the begin addresses of column indices. More...
NeuronID *	colinds
	Array that holds the column indices of non-zero elements. More...

Friends
class	boost::serialization::access

Detailed Description

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

Template for a sparse matrix with row major ordering and fast access of rows and capability to store float values per matrix entry.

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.

ComplexMatrix generalizes SimpleMatrix to a rank 3 tensor in which each synaptic connection can have more than one value (third tensor mode – corresponding to a synaptic state). This allows to efficiently implement state based complex synaptic models which have their own internal dynamics.

Instead of storing all synaptic data values in one long array the synaptic state values are stored in multiple state vectors which can be manipulated efficiently in a vector based manner.

For instance, suppose w holds your instance of ComplexMatris in which you have set_num_synapse_states(3) which makes it a connectivity matrix which reserves three state variables of type AurynWeight per synaptic connection. Now, decaying all elements of, say, state 3 by a factor "foo" is as simple as w->get_state_vector(2)->scale(foo). Adding two of the states for all synapses becomes w->get_state_vector(2)->add(w->get_state_vector(3)).

Because these expressions become quickly rather lenghty it is nice to declare shortcuts in your plastic Connection class such as: AurynSynStateVector * w_val = w->get_state_vector(0); AurynSynStateVector * tagging_val = w->get_state_vector(1); AurynSynStateVector * scaffold_val = w->get_state_vector(2);

You can now work with these as you are used with AurynVector or AurynStateVector instances w_val->saxpy(foo,tagging_val)

Constructor & Destructor Documentation

ComplexMatrix() [1/3]

template<typename T >

auryn::ComplexMatrix< T >::ComplexMatrix

(

)

Empty constructor.

{
        init(1,1,2,1);
}

Here is the call graph for this function:

ComplexMatrix() [2/3]

template<typename T >

auryn::ComplexMatrix< T >::ComplexMatrix

(

ComplexMatrix< T > *

mat

)

Copy constructor.

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

Here is the call graph for this function:

ComplexMatrix() [3/3]

template<typename T >

auryn::ComplexMatrix< T >::ComplexMatrix	(	NeuronID	rows,
		NeuronID	cols,
		AurynLong	size = 256,
		StateID	n_values = 1
	)

Default constructor.

{
        init(rows, cols, statesize, n_values);
}

Here is the call graph for this function:

~ComplexMatrix()

template<typename T >

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

virtual

Default destructor.

{
        free();
}

Here is the call graph for this function:

Member Function Documentation

add_value()

template<typename T >

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

{
        *get_ptr(data_index) += value;
}

Here is the call graph for this function:

alloc_synaptic_state_vector()

template<typename T >

AurynVector< T, AurynLong > * auryn::ComplexMatrix< T >::alloc_synaptic_state_vector ( )

protected

Returns a synaptic state vector.

{
        T * vec = new AurynVector<T,AurynLong>(get_statesize());
        return vec;
}

Here is the call graph for this function:

clear()

template<typename T >

void auryn::ComplexMatrix< T >::clear

(

)

Clears matrix.

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

copy()

template<typename T >

void auryn::ComplexMatrix< T >::copy

(

ComplexMatrix< T > *

mat

)

Copies complex matrix mat.

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

        clear();

        // copy sparse strcture and first state
        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));
                }
        }
        
        // copy the other states
        for ( StateID z = 1 ; z < get_num_synaptic_states() ; ++z ) {
                statevectors[z]->copy(mat->statevectors[z]);
        }
}

Here is the call graph for this function:

data_ptr_to_didx()

template<typename T >

AurynLong auryn::ComplexMatrix< T >::data_ptr_to_didx

(

const T *

ptr

)

Returns data index to a particular element specifed by a data pointer.

{
        return ptr - get_data_begin();
}

Here is the call graph for this function:

exists()

template<typename T >

bool auryn::ComplexMatrix< T >::exists	(	const NeuronID	i,
		const NeuronID	j,
		const StateID	z = 0
	)

Returns true if the matrix element exists.

{
        if ( get_data_index(i,j) == data_index_error_value || z >= get_num_synaptic_states() )
                return false;
        else 
                return true;
}

Here is the call graph for this function:

fill_na()

template<typename T >

void auryn::ComplexMatrix< T >::fill_na

(

)

Pads non-existing elements for the remaining elements to a matrix.

This function has to be called after filling the matrix with elements e.g. random sparse and before using it in a simulation. It is typically called by the finalize function in SparseConnection.

{
        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::ComplexMatrix< T >::fill_zeros

(

)

Same as fill_na but deprecated because of bad name.

Deprecated:

Due to bad name

{
        fill_na();
}

Here is the call graph for this function:

free()

template<typename T >

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

protected

{
        delete [] rowptrs;
        delete [] colinds;
        while ( statevectors.size() ) {
                AurynVector<T,AurynLong> * vec = statevectors.back();
                delete vec;
                statevectors.pop_back();
        }
}

get()

template<typename T >

T auryn::ComplexMatrix< T >::get	(	const NeuronID	i,
		const NeuronID	j,
		const NeuronID	z = 0
	)

Value of synaptic state variable i,j,z returns zero if the element is zero or does not exist.

{
        AurynLong data_index = get_data_index(i,j);
        if ( data_index != data_index_error_value )
                return *(statevectors[z]->data+get_data_index(i,j));
        else
                return 0;
}

Here is the call graph for this function:

get_colind()

template<typename T >

NeuronID auryn::ComplexMatrix< T >::get_colind

(

const AurynLong

data_index

)

{
        return colinds[data_index];
}

get_data() [1/2]

template<typename T >

T auryn::ComplexMatrix< T >::get_data	(	AurynLong	i,
		StateID	z = 0
	)

Gets the matching data entry for a given index i and state z

{
        return *get_data_ptr(i,z);
}

Here is the call graph for this function:

get_data() [2/2]

template<typename T >

T auryn::ComplexMatrix< T >::get_data	(	const NeuronID *	ind_ptr,
		StateID	z = 0
	)

Gets the matching data value for a given index pointer and state z.

{
        return *(get_data_ptr(ind_ptr,z));
}

Here is the call graph for this function:

get_data_begin()

template<typename T >

T * auryn::ComplexMatrix< T >::get_data_begin

(

const StateID

z = 0

)

Returns pointer to data value corresponding to the first element.

{
        return get_data_ptr((AurynLong)0,z);
}

Here is the call graph for this function:

get_data_end()

template<typename T >

T * auryn::ComplexMatrix< T >::get_data_end

(

const StateID

z = 0

)

Returns pointer to data value corresponding to the element behind the last nonzero element.

{
        return get_data_ptr(get_nonzero(),z);
}

Here is the call graph for this function:

get_data_index() [1/3]

template<typename T >

AurynLong auryn::ComplexMatrix< T >::get_data_index

(

const NeuronID *

ind_ptr

)

Returns data index to a particular element specifed by an index pointer.

{
        return ind_ptr_to_didx(ind_ptr);
}

Here is the call graph for this function:

get_data_index() [2/3]

template<typename T >

AurynLong auryn::ComplexMatrix< T >::get_data_index	(	const NeuronID	i,
		const NeuronID	j
	)

Returns data index to a particular element specifed by i and j

{
#ifdef DEBUG
                std::cout << "cm: starting bisect " << i << ":" << j << std::endl;
#endif // DEBUG

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

        // perform binary search
        NeuronID * lo = rowptrs[i];
        NeuronID * hi = rowptrs[i+1];

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

#ifdef DEBUG
                std::cout << "cm: " << "element not found" << std::endl;
#endif // DEBUG

        return data_index_error_value; 
}

get_data_index() [3/3]

template<typename T >

AurynLong auryn::ComplexMatrix< T >::get_data_index ( const T *  ptr )

inline

Returns data index to a particular element specifed by a data pointer.

{ return data_ptr_to_didx(ptr); };

Here is the call graph for this function:

get_data_offset()

template<typename T >

NeuronID auryn::ComplexMatrix< 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::ComplexMatrix< T >::get_data_ptr	(	const AurynLong	data_index,
		const StateID	z = 0
	)

Gets the matching data ptr for a given index i and state z.

{
        return statevectors[z]->data+data_index;
}

get_data_ptr() [2/2]

template<typename T >

T * auryn::ComplexMatrix< T >::get_data_ptr	(	const NeuronID *	ind_ptr,
		const StateID	z = 0
	)

Gets the matching data ptr for a given index pointer and state z.

{
        size_t ptr_offset = ind_ptr-get_ind_begin();
        return statevectors[z]->data+ptr_offset;
}

Here is the call graph for this function:

get_datasize()

template<typename T >

AurynLong auryn::ComplexMatrix< T >::get_datasize

(

)

Returns datasize: number of possible entries.

{
        return get_statesize();
}

Here is the call graph for this function:

get_element()

template<typename T >

T auryn::ComplexMatrix< T >::get_element	(	const AurynLong	data_index,
		const StateID	z
	)

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

{
        return *get_data_ptr(data_index);
}

Here is the call graph for this function:

get_fill_level()

template<typename T >

AurynDouble auryn::ComplexMatrix< T >::get_fill_level

(

)

Returns the fill level of the matrix element buffer.

A fill level of 1.0 corresponds to the sparse matrix element buffer being full.

{
        return 1.*n_nonzero/get_datasize();
}

Here is the call graph for this function:

get_ind_begin()

template<typename T >

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

(

)

{
        return rowptrs[0];
}

get_m_rows()

template<typename T >

NeuronID auryn::ComplexMatrix< T >::get_m_rows

(

)

{
        return m_rows;
}

get_memsize()

template<typename T >

AurynLong auryn::ComplexMatrix< T >::get_memsize

(

)

Returns statesize multiplied by number of states.

{
        return statesize*n_z_values;
}

get_n_cols()

template<typename T >

NeuronID auryn::ComplexMatrix< T >::get_n_cols

(

)

{
        return n_cols;
}

get_nonzero()

template<typename T >

AurynLong auryn::ComplexMatrix< T >::get_nonzero

(

)

Returns number of non-zero elements.

{
        return n_nonzero;
}

get_num_synapse_states()

template<typename T >

NeuronID auryn::ComplexMatrix< T >::get_num_synapse_states

(

)

Synonymous to get_num_synaptic_states.

{
        return get_num_synaptic_states();
}

Here is the call graph for this function:

get_num_synaptic_states()

template<typename T >

StateID auryn::ComplexMatrix< T >::get_num_synaptic_states

(

)

Returns number of synaptic states (z-value)

{
        return n_z_values;
}

get_num_z_values()

template<typename T >

NeuronID auryn::ComplexMatrix< T >::get_num_z_values

(

)

Returns number of synaptic states (z-value)

{
        return get_num_synaptic_states();
}

Here is the call graph for this function:

get_ptr() [1/2]

template<typename T >

T * auryn::ComplexMatrix< T >::get_ptr	(	const NeuronID	i,
		const NeuronID	j,
		const StateID	z = 0
	)

Returns the pointer to a particular element.

{
        AurynLong data_index = get_data_index(i,j);
        if ( data_index != data_index_error_value )
                return statevectors[z]->data+data_index;
        else
                return NULL;
}

Here is the call graph for this function:

get_ptr() [2/2]

template<typename T >

T * auryn::ComplexMatrix< T >::get_ptr	(	const AurynLong	data_index,
		const StateID	z = 0
	)

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

Todo:

TODO For two args this function is ambiguous with the above get_ptr def – need to find a better way for that

{
        return get_data_ptr(data_index, z);
}

Here is the call graph for this function:

get_row_begin()

template<typename T >

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

(

NeuronID

i

)

{
        return rowptrs[i];
}

get_row_begin_index()

template<typename T >

AurynLong auryn::ComplexMatrix< T >::get_row_begin_index

(

NeuronID

i

)

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

get_row_end()

template<typename T >

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

(

NeuronID

i

)

{
        return rowptrs[i+1];
}

get_row_end_index()

template<typename T >

AurynLong auryn::ComplexMatrix< T >::get_row_end_index

(

NeuronID

i

)

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

get_rowptrs()

template<typename T >

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

(

)

{
        return rowptrs;
}

get_state_begin()

template<typename T >

T * auryn::ComplexMatrix< T >::get_state_begin

(

const StateID

z = 0

)

Gets pointer for the first element of a given synaptic state vector.

{
        return statevectors[z]->data;
}

get_state_end()

template<typename T >

T * auryn::ComplexMatrix< T >::get_state_end

(

const StateID

z = 0

)

Gets pointer for the element behind the last of a given synaptic state vector.

{
        return get_state_begin(z)+get_datasize();
}

Here is the call graph for this function:

get_state_vector()

template<typename T >

AurynVector< T, AurynLong > * auryn::ComplexMatrix< T >::get_state_vector

(

StateID

z = 0

)

Sames as get_synaptic_state_vector(StateID z)

{
        return get_synaptic_state_vector(z);
}

Here is the call graph for this function:

get_statesize()

template<typename T >

AurynLong auryn::ComplexMatrix< T >::get_statesize

(

)

Same as datasize : number of possible entries.

{
        return statesize;
}

get_synaptic_state_vector()

template<typename T >

AurynVector< T, AurynLong > * auryn::ComplexMatrix< T >::get_synaptic_state_vector

(

StateID

z = 0

)

Returns pointer to statevector which is an AurynVector of specified synaptic state.

{
        if ( z >= get_num_synaptic_states() ) {
                logger->error("Trying to access a complex state larger than number of states in the tensor");
                throw AurynMatrixDimensionalityException();
        }
        return statevectors[z];
}

Here is the call graph for this function:

get_value() [1/2]

template<typename T >

T auryn::ComplexMatrix< T >::get_value

(

const AurynLong

data_index

)

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

{
        return *get_ptr(data_index);
}

Here is the call graph for this function:

get_value() [2/2]

template<typename T >

T auryn::ComplexMatrix< 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::ComplexMatrix< T >::get_value_ptr

(

const 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::ComplexMatrix< 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:

ind_ptr_to_didx()

template<typename T >

AurynLong auryn::ComplexMatrix< T >::ind_ptr_to_didx

(

const NeuronID *

ind_ptr

)

Returns data index to a particular element specifed by an index pointer.

{
        return ind_ptr - get_ind_begin();
}

Here is the call graph for this function:

init()

template<typename T >

void auryn::ComplexMatrix< T >::init ( NeuronID  m, NeuronID  n, AurynLong  size, NeuronID  z  )

protected

Default initializiation called by the constructor.

{
        m_rows = m;
        n_cols = n;

        statesize = size; // assumed maximum number of connections
        n_z_values = z;

        data_index_error_value = std::numeric_limits<AurynTime>::max();
        

        rowptrs = new NeuronID * [m_rows+1];
        colinds = new NeuronID [get_datasize()];
        prepare_state_vectors(); 
        clear();
}

Here is the call graph for this function:

mean()

template<typename T >

double auryn::ComplexMatrix< T >::mean

(

)

Return mean value of elements for the first complex state (z=0).

Warning: Note that ComplexMatrix can only compute the mean of all the subset of elements stored on thank it runs on.

{
        double sum = 0;
        for (NeuronID i = 0 ; i < get_nonzero() ; ++i) {
                sum += *get_ptr(i);
        }
        return sum/get_nonzero();
}

Here is the call graph for this function:

prepare_state_vectors()

template<typename T >

void auryn::ComplexMatrix< T >::prepare_state_vectors ( )

protected

Matches size of statevectors to number of synaptic states.

{
        // add synaptic state vectors until we have enough
        while ( statevectors.size() < get_num_synaptic_states() ) {
                AurynVector<T,AurynLong> * vec = new AurynVector<T,AurynLong>(get_statesize());
                statevectors.push_back(vec);
        }

        // remove state vectors from the end until we have the right amount
        // if the above code ran this will not run
        while ( statevectors.size() > get_num_synaptic_states() ) {
                delete [] *(statevectors.end());
                statevectors.pop_back();
        }
}

Here is the call graph for this function:

print()

template<typename T >

void auryn::ComplexMatrix< T >::print

(

)

stdout dump of all elements – for testing only.

{
        std::cout << get_nonzero() << " elements in sparse matrix:" << std::endl;
        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 << " " << *get_ptr(r-colinds) << "\n"; 
                        // TODO not dumping the other states yet
                }
        }
}

Here is the call graph for this function:

prune()

template<typename T >

void auryn::ComplexMatrix< T >::prune

(

)

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

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

Here is the call graph for this function:

push_back()

template<typename T >

void auryn::ComplexMatrix< 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;
        T * data_z0 = get_synaptic_state_vector(0)->data;
        if (i >= current_row && j >= current_col) {
                if ( n_nonzero >= get_datasize() ) throw AurynMatrixBufferException();
                *(rowptrs[i+1]) = j; // write last j to end of index array
                data_z0[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();
        }
}

Here is the call graph for this function:

resize_buffer_and_clear()

template<typename T >

void auryn::ComplexMatrix< 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, n_z_values );
}

Here is the call graph for this function:

resize_buffers()

template<typename T >

void auryn::ComplexMatrix< T >::resize_buffers

(

AurynLong

size

)

Resize buffer.

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

{
        const AurynLong old_statesize = get_statesize();
        const AurynLong new_statesize = std::min(new_size,(AurynLong)m_rows*n_cols);

        if ( old_statesize == new_statesize ) return; // nothing to be done

        // allocate new mem 
        NeuronID * new_colinds = new NeuronID [new_statesize];

        // copy column indices
        const AurynLong copysize = std::min(old_statesize,new_statesize);
        std::copy(colinds, colinds+copysize, new_colinds);

        // update rowpointers
        ptrdiff_t offset = new_colinds-colinds;
        for ( NeuronID i = 0 ; i < m_rows+1 ; ++i ) {
                rowptrs[i] += offset;
        }

        // free old memory
        delete [] colinds;
        colinds = new_colinds;

        // resize state vectors individually
        for ( StateID i = 0 ; i < get_num_synaptic_states() ; ++i ) {
                statevectors[i]->resize(new_statesize);
        }

        statesize = new_statesize;
}

Here is the call graph for this function:

scale_all()

template<typename T >

void auryn::ComplexMatrix< T >::scale_all

(

const T

value

)

Scales all non-zero elements.

{
        get_synaptic_state_vector()->scale(value);
}

Here is the call graph for this function:

scale_col()

template<typename T >

void auryn::ComplexMatrix< T >::scale_col	(	const NeuronID	j,
		const 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::ComplexMatrix< T >::scale_data	(	AurynLong	i,
		T	value,
		StateID	z = 0
	)

{
        scale_element(i, value, z);
}

Here is the call graph for this function:

scale_element()

template<typename T >

void auryn::ComplexMatrix< T >::scale_element	(	AurynLong	data_index,
		T	value,
		StateID	z = 0
	)

{
        if (data_index<statesize)
                statevectors[z]->data[data_index] *= value;
}

scale_row()

template<typename T >

void auryn::ComplexMatrix< T >::scale_row	(	const NeuronID	i,
		const 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) 
        {
                *get_ptr(c-colinds) *= value;
        }
}

Here is the call graph for this function:

set()

template<typename T >

bool auryn::ComplexMatrix< T >::set	(	const NeuronID	i,
		const 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::ComplexMatrix< T >::set_all	(	const T	value,
		const StateID	z = 0
	)

Sets all non-zero elements to value.

{
        get_state_vector(z)->set_all(value);
}

Here is the call graph for this function:

set_col()

template<typename T >

void auryn::ComplexMatrix< T >::set_col	(	const NeuronID	j,
		const 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::ComplexMatrix< T >::set_data	(	AurynLong	i,
		T	value,
		StateID	z = 0
	)

{
        set_element(i,value,z);
}

Here is the call graph for this function:

set_element()

template<typename T >

void auryn::ComplexMatrix< T >::set_element	(	AurynLong	data_index,
		T	value,
		StateID	z = 0
	)

{
        if (data_index<statesize)
                statevectors[z]->data[data_index] = value;
}

set_num_synapse_states()

template<typename T >

void auryn::ComplexMatrix< T >::set_num_synapse_states

(

const StateID

zsize

)

Sets number of synaptic states (z-value)

{
        set_num_synaptic_states(zsize);
}

Here is the call graph for this function:

set_num_synaptic_states()

template<typename T >

void auryn::ComplexMatrix< T >::set_num_synaptic_states

(

const StateID

zsize

)

Sets number of synaptic states (z-value)

{
        n_z_values = zsize;
        prepare_state_vectors();
        resize_buffers(statesize);
}

Here is the call graph for this function:

set_row()

template<typename T >

void auryn::ComplexMatrix< T >::set_row	(	const NeuronID	i,
		const 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) 
        {
                *get_ptr(c-colinds) = value;
        }
}

Here is the call graph for this function:

state_add()

template<typename T >

void auryn::ComplexMatrix< T >::state_add	(	T *	x,
		T *	y
	)

Adds x and y and stores result in y.

{
        for (AurynLong i = 0 ; i < get_nonzero() ; ++i ) {
                y[i] = x[i]+y[i];
        }
}

Here is the call graph for this function:

state_add_const()

template<typename T >

void auryn::ComplexMatrix< T >::state_add_const	(	const T	a,
		T *	x
	)

Adds constant a to all values in x.

{
        for (AurynLong i = 0 ; i < get_nonzero() ; ++i ) {
                y[i] = a+y[i];
        }
}

Here is the call graph for this function:

state_clip()

template<typename T >

void auryn::ComplexMatrix< T >::state_clip	(	T *	x,
		const T	a,
		const T	b
	)

Clips state values to interval [a,b].

{
        for (AurynLong i = 0 ; i < get_nonzero() ; ++i ) {
                if ( x[i] < a ) x[i] = a; 
                else if ( x[i] > b ) x[i] = b; 
        }
}

Here is the call graph for this function:

state_get_data_ptr()

template<typename T >

T * auryn::ComplexMatrix< T >::state_get_data_ptr	(	T *	x,
		NeuronID	i
	)

Get data pointer for that state.

{
        return x+i;
}

state_mul()

template<typename T >

void auryn::ComplexMatrix< T >::state_mul	(	T *	x,
		T *	y
	)

Multiplies x and y and stores result in y.

{
        for (AurynLong i = 0 ; i < get_nonzero() ; ++i ) {
                y[i] = x[i]*y[i];
        }
}

Here is the call graph for this function:

state_saxpy()

template<typename T >

void auryn::ComplexMatrix< T >::state_saxpy	(	const T	a,
		T *	x,
		T *	y
	)

Computes a*x + y and stores result in y.

{
        for (AurynLong i = 0 ; i < get_nonzero() ; ++i ) {
                y[i] = a*x[i]+y[i];
        }
}

Here is the call graph for this function:

state_scale()

template<typename T >

void auryn::ComplexMatrix< T >::state_scale	(	const T	a,
		T *	x
	)

Scale state x by a.

{
        for (AurynLong i = 0 ; i < get_nonzero() ; ++i ) {
                y[i] = a*y[i];
        }
}

Here is the call graph for this function:

state_set_all()

template<typename T >

void auryn::ComplexMatrix< T >::state_set_all	(	T *	x,
		const T	value
	)

Sets all values in state x to value.

{
        for (T * iter=x;
                         iter!=x+get_nonzero();
                         ++iter ) {
                *iter = value;
        }
}

Here is the call graph for this function:

state_sub() [1/2]

template<typename T >

void auryn::ComplexMatrix< T >::state_sub	(	T *	x,
		T *	y
	)

Computes x-y and stores result in y.

{
        state_sub(x,y,y);
}

state_sub() [2/2]

template<typename T >

void auryn::ComplexMatrix< T >::state_sub	(	T *	x,
		T *	y,
		T *	res
	)

Computes x-y and stores result in res.

{
        for (AurynLong i = 0 ; i < get_nonzero() ; ++i ) {
                res[i] = x[i]-y[i];
        }
}

Here is the call graph for this function:

sum_col()

template<typename T >

double auryn::ComplexMatrix< T >::sum_col

(

const 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

colinds

template<typename T >

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

protected

Array that holds the column indices of non-zero elements.

rowptrs

template<typename T >

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

protected

Array that holds the begin addresses of column indices.

statevectors

template<typename T >

std::vector< AurynVector<T,AurynLong> * > auryn::ComplexMatrix< T >::statevectors

Vector that holds pointers to the state vectors storing the synaptic states.

---

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

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