auryn::AurynVector< T, IndexType > Class Template Reference

Default Auryn vector template. More...

#include <auryn_definitions.h>

Collaboration diagram for auryn::AurynVector< T, IndexType >:

Public Member Functions
	AurynVector (IndexType n)
	Default constructor. More...
	AurynVector (AurynVector *vec)
	Copy constructor. More...
virtual	~AurynVector ()
	Default destructor. More...
virtual void	resize (IndexType new_size)
	resize data array to new_size More...
void	copy (AurynVector *v)
	Copies vector v. More...
T	get (IndexType i)
	Gets element i from vector. More...
T *	ptr (IndexType i=0)
	Gets pointer to element i from vector. More...
void	set (IndexType i, T value)
	Sets element i in vector to value. More...
void	set_all (const T v)
	Set all elements to value v. More...
void	set_zero ()
	Set all elements to zero. More...
void	scale (const T a)
	Scales all vector elements by a. More...
void	add (const T c)
	Adds constant c to each vector element. More...
void	add_specific (const IndexType i, const T c)
	Adds the value c to specific vector element i. More...
void	mul_specific (const IndexType i, const T c)
	Multiply to specific vector element with data index i with the constant c. More...
void	add (AurynVector *v)
	Adds a vector v to the vector. More...
void	sub (const T c)
	Subtract constant c to each vector element. More...
void	sub (AurynVector *v)
	Elementwise subtraction. More...
void	mul (const T a)
	Multiply all vector elements by constant. More...
void	mul (AurynVector *v)
	Element-wise vector multiply. More...
void	div (const T a)
	Element-wise division. More...
void	div (AurynVector *v)
	Element-wise vector division. More...
void	div (AurynVector *a, AurynVector *b)
	Element-wise vector division which stores the result in this. More...
void	saxpy (const T a, AurynVector *x)
	SAXPY operation as in GSL. More...
void	follow (AurynVector< T, IndexType > *v, const T rate)
	Follows target vector v with rate. More...
void	follow_scalar (const T a, const T rate)
	Like follow but with a scalar target value a. More...
void	elementwise_max (AurynVector *v1, AurynVector *v2)
	Elementwise max operation. More...
void	elementwise_max (AurynVector *v1)
	Elementwise max operation with another vector. More...
void	pow (const unsigned int n)
	Takes each element to the n-th power. More...
void	fast_exp ()
	Computes an approximation of exp(x) for each vector element. More...
void	exp ()
	Computes exp(x) for each vector element. More...
void	sigmoid (AurynVector *x, const T beta, const T thr)
	Computes sigmoid(beta*(x-thr)) for each vector element and stores result in this instance. More...
void	sqrt ()
	Takes the square root of each element. More...
void	neg ()
	Flips the sign of all elements. More...
void	inv ()
	Computes 1./x of each element. More...
void	sum (AurynVector *a, AurynVector *b)
	Computes the sum a+b and stores the result in this instance. More...
void	sum (AurynVector *a, const T b)
	Computes the sum a+b and stores the result in this instance. More...
void	diff (AurynVector *a, AurynVector *b)
	Computes the difference a-b and stores the result in this instance. More...
void	diff (AurynVector *a, const T b)
	Computes the difference a-b and stores the result in this instance. More...
void	diff (const T a, AurynVector *b)
	Computes the difference a-b and stores the result in this instance. More...
void	sqr ()
	Squares each element. More...
void	abs ()
	Takes absolute value of each element. More...
void	rect ()
	Rectifies all elements. More...
void	neg_rect ()
	Negatively rectifies all elements. More...
void	clip (T min, T max)
	Clips all vector elements to the range min max. More...
double	var ()
	Computes the variance of the vector elements on this rank. More...
double	std ()
	Computes the standard deviation of all elements on this rank. More...
double	mean ()
	Computes the mean of the vector elements on this rank. More...
double	element_sum ()
	Computes the sum of the vector elements. More...
double	l1norm ()
	Computes the l1 norm of the vector. More...
double	l2norm ()
	Computes the l2 norm of the vector. More...
double	max ()
	Returns the max of the vector elements. More...
double	min ()
	Returns the min of the vector elements. More...
IndexType	nonzero ()
	Computes number of nonzero elements on this rank. More...
void	zero_effective_zeros (const T epsilon=1e-3)
	Sets all values whose absolute value is smaller than epsilon to zero. More...
void	add_random_normal (AurynState mean=0.0, AurynState sigma=1.0, unsigned int seed=8721)
void	set_random_normal (AurynState mean=0.0, AurynState sigma=1.0, unsigned int seed=8721)
void	set_random (unsigned int seed=0)
	Initializes vector elements with Gaussian of unit varince and a seed derived from system time if no seed or seed of 0 is given. More...
bool	any ()
	Returns true if any element is nonzero. More...
bool	any (T eps)
	Returns true if any element is nonzero. More...
void	print ()
	Print vector elements to stdout for debugging. More...
void	write_to_file (std::string filename)
	Print vector elements to a text file for debugging. More...

Public Attributes
IndexType	size
	Size of the vector. More...
T *	data
	Pointer to the array housing the data. More...

Protected Member Functions
void	check_size (IndexType x)
	Checks if argument is larger than size and throws and exception if so. More...
void	check_size (AurynVector *v)
	Checks if vector size matches to this instance. More...
void	allocate (const NeuronID n)
	Implements aligned memory allocation. More...
void	freebuf ()
T	fast_exp256 (T x)
	Computes approximation of exp(x) via fast series approximation up to n=256. More...

Friends
class	boost::serialization::access

Detailed Description

template<typename T, typename IndexType = NeuronID>
class auryn::AurynVector< T, IndexType >

Default Auryn vector template.

This class implements the base vector class for Auryn. Neuronal or synaptic state variables are stored as AurynVectors. For performance reasons, time critical functions of this template have to be reimplemented in derived classes with a specific template parameter T. For instance I will always provide a derived type AurynVectorFloat (T=float) which per default is synonymous to AurynStateVector which implements SSE instructions for labour intensive operations on the vectors. When using the AurynStateVector in NeuronGroups etc this will speed up computation performance automatically. Note, that all Auryn vectors should initialized with multiple of 4 elements (later that number might change) when we add AVX support to the code. This is done automatically

Constructor & Destructor Documentation

AurynVector() [1/2]

template<typename T, typename IndexType = NeuronID>

auryn::AurynVector< T, IndexType >::AurynVector ( IndexType  n )

inline

Default constructor.

                        {
                                allocate(n);
                        }

AurynVector() [2/2]

template<typename T, typename IndexType = NeuronID>

auryn::AurynVector< T, IndexType >::AurynVector ( AurynVector< T, IndexType > *  vec )

inline

Copy constructor.

Constructs vector as a copy of argument vector.

                        {
                                allocate(vec->size);
                                copy(vec);
                        }

~AurynVector()

template<typename T, typename IndexType = NeuronID>

virtual auryn::AurynVector< T, IndexType >::~AurynVector ( )

inlinevirtual

Default destructor.

                        {
                                freebuf();
                        }

Member Function Documentation

abs()

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::abs ( )

inline

Takes absolute value of each element.

                        {       
                                sqr();
                                sqrt();
                        }

add() [1/2]

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::add ( const T  c )

inline

Adds constant c to each vector element.

                        {
                                for ( IndexType i = 0 ; i < size ; ++i ) {
                                        data[i] += c;
                                }
                        }

add() [2/2]

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::add ( AurynVector< T, IndexType > *  v )

inline

Adds a vector v to the vector.

No checking of the dimensions match!

                        {
                                check_size(v);
                                for ( IndexType i = 0 ; i < size ; ++i ) {
                                        data[i] += v->data[i];
                                }
                        }

add_random_normal()

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::add_random_normal ( AurynState  mean = 0.0, AurynState  sigma = 1.0, unsigned int  seed = 8721  )

inline

                        {
                                if ( seed == 0 )
                                        seed = static_cast<unsigned int>(std::time(0));
                                boost::mt19937 randgen(seed); 
                                boost::normal_distribution<> dist((double)mean, (double)sigma);
                                boost::variate_generator<boost::mt19937&, boost::normal_distribution<> > die(randgen, dist);
                                AurynState rv;
                                for ( IndexType i = 0 ; i<size ; ++i ) {
                                        rv = die();
                                        data[i] += rv;
                                }
                        }

add_specific()

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::add_specific ( const IndexType  i, const T  c  )

inline

Adds the value c to specific vector element i.

                        {
                                check_size(i);
                                data[i] += c;
                        }

allocate()

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::allocate ( const NeuronID  n )

inlineprotected

Implements aligned memory allocation.

Todo:

TODO Replace above alignment code with boost code once boost 1.56 is commonly available with the dists

                                                        {
#if defined(CODE_USE_SIMD_INSTRUCTIONS_EXPLICITLY) && defined(CODE_ALIGNED_SIMD_INSTRUCTIONS)
                                std::size_t mem_alignment = sizeof(T)*SIMD_NUM_OF_PARALLEL_FLOAT_OPERATIONS;
                                std::size_t mem_size = sizeof(T)*n;
                                mem = malloc(mem_size+mem_alignment-1); // adds padding to allocated memory
                                T * ptr = (T*)mem; 
                                if ( (unsigned long)mem%mem_alignment ) ptr = (T*)(((unsigned long)mem/mem_alignment+1)*mem_alignment);
                                // T * ptr = (T*)boost::alignment::aligned_alloc(sizeof(T)*SIMD_NUM_OF_PARALLEL_FLOAT_OPERATIONS,sizeof(T)*n);
                                if ( mem == NULL ) {
                                        // TODO implement proper exception handling
                                        throw AurynMemoryAlignmentException(); 
                                }
                                assert(((unsigned long)ptr % mem_alignment) == 0);
#else
                                T * ptr = new T[n];
#endif
                                data = ptr;
                                size = n;
                                set_zero();
                        }

any() [1/2]

template<typename T, typename IndexType = NeuronID>

bool auryn::AurynVector< T, IndexType >::any ( )

inline

Returns true if any element is nonzero.

                                   {
                                for ( IndexType i = 0 ; i < size ; ++i ) {
                                        if ( get(i) ) return true;
                                }
                                return false;
                        }

any() [2/2]

template<typename T, typename IndexType = NeuronID>

bool auryn::AurynVector< T, IndexType >::any ( T  eps )

inline

Returns true if any element is nonzero.

                                        {
                                for ( IndexType i = 0 ; i < size ; ++i ) {
                                        if ( std::abs(get(i))>eps ) return true;
                                }
                                return false;
                        }

check_size() [1/2]

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::check_size ( IndexType  x )

inlineprotected

Checks if argument is larger than size and throws and exception if so.

Check only enabled if NDEBUG is not defined.

                        {
#ifndef NDEBUG
                                if ( x >= size ) {
                                        throw AurynVectorDimensionalityException();
                                }
#endif 
                        }

check_size() [2/2]

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::check_size ( AurynVector< T, IndexType > *  v )

inlineprotected

Checks if vector size matches to this instance.

Check only enabled if NDEBUG is not defined.

                        {
#ifndef NDEBUG
                                if ( v->size != size ) {
                                        throw AurynVectorDimensionalityException();
                                }
#endif 
                        }

clip()

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::clip ( T  min, T  max  )

inline

Clips all vector elements to the range min max.

Parameters

min	Minimum value
max	Maximum value

                        {
                                for ( IndexType i = 0 ; i < size ; ++i ) {
                                        if ( data[i] < min ) {
                                                 data[i] = min;
                                        } else 
                                                if ( data[i] > max ) 
                                                         data[i] = max;
                                }
                        }

copy()

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::copy ( AurynVector< T, IndexType > *  v )

inline

Copies vector v.

                        {
                                check_size(v);
                                std::copy(v->data, v->data+v->size, data);
                        }

diff() [1/3]

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::diff ( AurynVector< T, IndexType > *  a, AurynVector< T, IndexType > *  b  )

inline

Computes the difference a-b and stores the result in this instance.

                        {
                                check_size(a);
                                check_size(b);
                                for ( IndexType i = 0 ; i < size ; ++i ) {
                                        data[i] = a->data[i]-b->data[i];
                                }
                        }

diff() [2/3]

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::diff ( AurynVector< T, IndexType > *  a, const T  b  )

inline

Computes the difference a-b and stores the result in this instance.

                        {
                                sum(a,-b);
                        }

diff() [3/3]

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::diff ( const T  a, AurynVector< T, IndexType > *  b  )

inline

Computes the difference a-b and stores the result in this instance.

                        {
                                check_size(b);
                                sum(b,-a);
                                neg();
                        }

div() [1/3]

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::div ( const T  a )

inline

Element-wise division.

                        {
                                scale(1.0/a);
                        }

div() [2/3]

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::div ( AurynVector< T, IndexType > *  v )

inline

Element-wise vector division.

                        {
                                check_size(v);
                                for ( IndexType i = 0 ; i < size ; ++i ) {
                                        data[i] /= v->data[i];
                                }
                        }

div() [3/3]

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::div ( AurynVector< T, IndexType > *  a, AurynVector< T, IndexType > *  b  )

inline

Element-wise vector division which stores the result in this.

Computes elemntwise a/b and stores the result in current instance.

                        {
                                check_size(a);
                                for ( IndexType i = 0 ; i < size ; ++i ) {
                                        data[i] = a->data[i]/b->data[i];
                                }
                        }

element_sum()

template<typename T, typename IndexType = NeuronID>

double auryn::AurynVector< T, IndexType >::element_sum ( )

inline

Computes the sum of the vector elements.

                        {
                                double sum = 0.0;
                                for ( IndexType i = 0 ; i < size ; ++i ) {
                                        sum += get(i);
                                }
                                return sum;
                        }

elementwise_max() [1/2]

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::elementwise_max ( AurynVector< T, IndexType > *  v1, AurynVector< T, IndexType > *  v2  )

inline

Elementwise max operation.

                        {
                                check_size(v1);
                                check_size(v2);
                                for ( IndexType i = 0 ; i < size ; ++i ) {
                                        data[i] = std::max(v1->data[i],v2->data[i]);
                                }
                        }

elementwise_max() [2/2]

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::elementwise_max ( AurynVector< T, IndexType > *  v1 )

inline

Elementwise max operation with another vector.

                        {
                                elementwise_max(this,v1);
                        }

exp()

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::exp ( )

inline

Computes exp(x) for each vector element.

                        {
                                for ( IndexType i = 0 ; i < size ; ++i ) {
                                        data[i] = std::exp(data[i]);
                                }
                        }

fast_exp()

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::fast_exp ( )

inline

Computes an approximation of exp(x) for each vector element.

                        {
                                // mul(0.00390625); // ie. 1.0/256.0
                                // add(1.0);
                                // for ( int i = 0 ; i < 8 ; ++i ) {
                                //      sqr();
                                // }
                                // seems as if the naive version is faster
                                for ( IndexType i = 0 ; i < size ; ++i ) {
                                        data[i] = fast_exp256(data[i]);
                                }
                        }

fast_exp256()

template<typename T, typename IndexType = NeuronID>

T auryn::AurynVector< T, IndexType >::fast_exp256 ( T  x )

inlineprotected

Computes approximation of exp(x) via fast series approximation up to n=256.

            {
                    x = 1.0 + x / 256.0;
                    x *= x; x *= x; x *= x; x *= x;
                    x *= x; x *= x; x *= x; x *= x;
                    return x;
            }

follow()

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::follow ( AurynVector< T, IndexType > *  v, const T  rate  )

inline

Follows target vector v with rate.

Example to implement the ODE: tau dx/dt = -(x-v)

the rate parameter should be set to auryn_timestep/tau.

                        {
                                for ( IndexType i = 0 ; i < size ; ++i ) {
                                        data[i] += rate*(v->data[i]-data[i]);
                                }
                        }

follow_scalar()

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::follow_scalar ( const T  a, const T  rate  )

inline

Like follow but with a scalar target value a.

                        {
                                for ( IndexType i = 0 ; i < size ; ++i ) {
                                        data[i] += rate*(a-data[i]);
                                }
                        }

freebuf()

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::freebuf ( )

inlineprotected

Todo:

TODO Replace above alignment code with boost code once boost 1.56 is commonly available with the dists

                                       {
#if defined(CODE_USE_SIMD_INSTRUCTIONS_EXPLICITLY) && defined(CODE_ALIGNED_SIMD_INSTRUCTIONS)
                                free(mem);
                                // boost::alignment::aligned_free(data);
#else
                                delete [] data;
#endif
                        }

get()

template<typename T, typename IndexType = NeuronID>

T auryn::AurynVector< T, IndexType >::get ( IndexType  i )

inline

Gets element i from vector.

                        {
                                check_size(i);
                                return data[i];
                        }

inv()

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::inv ( )

inline

Computes 1./x of each element.

                        {
                                for ( IndexType i = 0 ; i < size ; ++i ) {
                                        data[i] = 1.0/data[i];
                                }
                        }

l1norm()

template<typename T, typename IndexType = NeuronID>

double auryn::AurynVector< T, IndexType >::l1norm ( )

inline

Computes the l1 norm of the vector.

                        {
                                double sum = 0.0;
                                for ( IndexType i = 0 ; i < size ; ++i ) {
                                        double e = get(i);
                                        sum += std::abs(e);
                                }
                                return sum;
                        }

l2norm()

template<typename T, typename IndexType = NeuronID>

double auryn::AurynVector< T, IndexType >::l2norm ( )

inline

Computes the l2 norm of the vector.

                        {
                                double sum = 0.0;
                                for ( IndexType i = 0 ; i < size ; ++i ) {
                                        double e = get(i);
                                        sum += e*e;
                                }
                                return std::sqrt(sum);
                        }

max()

template<typename T, typename IndexType = NeuronID>

double auryn::AurynVector< T, IndexType >::max ( )

inline

Returns the max of the vector elements.

                        {
                                double max = -1e64; // TODO use numeric limits for this
                                for ( IndexType i = 0 ; i < size ; ++i ) {
                                        double el = get(i);
                                        if ( el > max ) max = el;
                                }
                                return max;
                        }

mean()

template<typename T, typename IndexType = NeuronID>

double auryn::AurynVector< T, IndexType >::mean ( )

inline

Computes the mean of the vector elements on this rank.

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

                        {
                                return element_sum()/size;
                        }

min()

template<typename T, typename IndexType = NeuronID>

double auryn::AurynVector< T, IndexType >::min ( )

inline

Returns the min of the vector elements.

                        {
                                double min = 1e64; // TODO use numeric limits for this
                                for ( IndexType i = 0 ; i < size ; ++i ) {
                                        double el = get(i);
                                        if ( el < min ) min = el;
                                }
                                return min;
                        }

mul() [1/2]

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::mul ( const T  a )

inline

Multiply all vector elements by constant.

                        {
                                scale(a);
                        }

mul() [2/2]

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::mul ( AurynVector< T, IndexType > *  v )

inline

Element-wise vector multiply.

                        {
                                check_size(v);
                                for ( IndexType i = 0 ; i < size ; ++i ) {
                                        data[i] *= v->data[i];
                                }
                        }

mul_specific()

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::mul_specific ( const IndexType  i, const T  c  )

inline

Multiply to specific vector element with data index i with the constant c.

                        {
                                check_size(i);
                                data[i] *= c;
                        }

neg()

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::neg ( )

inline

Flips the sign of all elements.

                        {
                                for ( IndexType i = 0 ; i < size ; ++i ) {
                                        data[i] = -data[i];
                                }
                        }

neg_rect()

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::neg_rect ( )

inline

Negatively rectifies all elements.

                        {
                                for ( IndexType i = 0 ; i < size ; ++i ) {
                                        if ( data[i] > 0.0 ) {
                                                 data[i] = 0.0;
                                        } 
                                }
                        }

nonzero()

template<typename T, typename IndexType = NeuronID>

IndexType auryn::AurynVector< T, IndexType >::nonzero ( )

inline

Computes number of nonzero elements on this rank.

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

                        {
                                IndexType sum = 0;
                                for ( IndexType i = 0 ; i < size ; ++i ) {
                                        if ( get(i) != 0 ) ++sum;
                                }
                                return sum;
                        }

pow()

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::pow ( const unsigned int  n )

inline

Takes each element to the n-th power.

Parameters

n	the exponent

                        {
                                for ( IndexType i = 0 ; i < size ; ++i ) {
                                        data[i] = std::pow(data[i],n);
                                }
                        }

print()

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::print ( )

inline

Print vector elements to stdout for debugging.

                                     {
                                for ( IndexType i = 0 ; i < size ; ++i ) {
                                        std::cout << get(i) << " ";
                                }
                                std::cout << std::endl;
                        }

ptr()

template<typename T, typename IndexType = NeuronID>

T* auryn::AurynVector< T, IndexType >::ptr ( IndexType  i = 0 )

inline

Gets pointer to element i from vector.

When no argument is given the function returns the first element of data array of the vector.

                        {
                                check_size(i);
                                return data+i;
                        }

rect()

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::rect ( )

inline

Rectifies all elements.

                        {
                                for ( IndexType i = 0 ; i < size ; ++i ) {
                                        if ( data[i] < 0.0 ) {
                                                 data[i] = 0.0;
                                        } 
                                }
                        }

resize()

template<typename T, typename IndexType = NeuronID>

virtual void auryn::AurynVector< T, IndexType >::resize ( IndexType  new_size )

inlinevirtual

resize data array to new_size

The function tries to preserve data while resizing. If a vector is downsized elements at the end are simply dropped. When the vector size is increased the new elements at the end are intialized with zeros.

Reimplemented in auryn::AurynVectorFloat, and auryn::AurynDelayVector.

                        {
                                if ( size != new_size ) {
                                        T * old_data = data;
                                        IndexType old_size = size;
                                        allocate(new_size);
                                        // copy old data
                                        const size_t copy_size = std::min(old_size,new_size) * sizeof(T);
                                        memcpy(data, old_data, copy_size);
                                        free(old_data);
                                }
                        }

saxpy()

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::saxpy ( const T  a, AurynVector< T, IndexType > *  x  )

inline

SAXPY operation as in GSL.

Computes a*x + y and stores the result to y where y is the present instance.

Parameters

a	The scaling factor for the additional vector
x	The additional vector to add

                        {
                                check_size(x);
                                for ( IndexType i = 0 ; i < size ; ++i ) {
                                        data[i] += a * x->data[i];
                                }
                        }

scale()

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::scale ( const T  a )

inline

Scales all vector elements by a.

                        {
                                for ( IndexType i = 0 ; i < size ; ++i ) {
                                        data[i] *= a;
                                }
                        }

set()

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::set ( IndexType  i, T  value  )

inline

Sets element i in vector to value.

                        {
                                check_size(i);
                                data[i] = value;
                        }

set_all()

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::set_all ( const T  v )

inline

Set all elements to value v.

                        {
                                for ( IndexType i = 0 ; i < size ; ++i ) {
                                        data[i] = v;
                                }
                        }

set_random()

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::set_random ( unsigned int  seed = 0 )

inline

Initializes vector elements with Gaussian of unit varince and a seed derived from system time if no seed or seed of 0 is given.

                        {
                                set_random_normal(0.0,1.0,seed);
                        }

set_random_normal()

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::set_random_normal ( AurynState  mean = 0.0, AurynState  sigma = 1.0, unsigned int  seed = 8721  )

inline

                        {
                                set_all(0.0);
                                add_random_normal(mean, sigma);
                        }

set_zero()

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::set_zero ( )

inline

Set all elements to zero.

                        {
                                set_all(0.0);
                        }

sigmoid()

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::sigmoid ( AurynVector< T, IndexType > *  x, const T  beta, const T  thr  )

inline

Computes sigmoid(beta*(x-thr)) for each vector element and stores result in this instance.

                        {
                                diff(x,thr);
                                mul(-beta);
                                exp();
                                add(1.0);
                                inv();
                        }

sqr()

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::sqr ( )

inline

Squares each element.

                        {       
                                this->mul(this);
                        }

sqrt()

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::sqrt ( )

inline

Takes the square root of each element.

                        {
                                for ( IndexType i = 0 ; i < size ; ++i ) {
                                        data[i] = std::sqrt(data[i]);
                                }
                        }

std()

template<typename T, typename IndexType = NeuronID>

double auryn::AurynVector< T, IndexType >::std ( )

inline

Computes the standard deviation of all elements on this rank.

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

                        {
                                return std::sqrt(var());
                        }

sub() [1/2]

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::sub ( const T  c )

inline

Subtract constant c to each vector element.

                        {
                                add(-c);
                        }

sub() [2/2]

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::sub ( AurynVector< T, IndexType > *  v )

inline

Elementwise subtraction.

                        {
                                check_size(v);
                                for ( IndexType i = 0 ; i < size ; ++i ) {
                                        data[i] -= v->data[i];
                                }
                        }

sum() [1/2]

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::sum ( AurynVector< T, IndexType > *  a, AurynVector< T, IndexType > *  b  )

inline

Computes the sum a+b and stores the result in this instance.

                        {
                                check_size(a);
                                check_size(b);
                                for ( IndexType i = 0 ; i < size ; ++i ) {
                                        data[i] = a->data[i]+b->data[i];
                                }
                        }

sum() [2/2]

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::sum ( AurynVector< T, IndexType > *  a, const T  b  )

inline

Computes the sum a+b and stores the result in this instance.

                        {
                                check_size(a);
                                for ( IndexType i = 0 ; i < size ; ++i ) {
                                        data[i] = a->data[i]+b;
                                }
                        }

var()

template<typename T, typename IndexType = NeuronID>

double auryn::AurynVector< T, IndexType >::var ( )

inline

Computes the variance of the vector elements on this rank.

Uses Bessel's correction to calculate an unbiased estimate of the population variance which requires n > 1 otherwise the output is not defined.

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

                        {
                                double sum = 0.0;
                                double sum2 = 0.0;
                                for ( IndexType i = 0 ; i < size ; ++i ) {
                                        double elem = get(i);
                                        sum  += elem;
                                        sum2 += std::pow(elem,2);
                                }
                                double var  = (sum2-(sum*sum)/size)/(size-1);
                                return var;
                        }

write_to_file()

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::write_to_file ( std::string  filename )

inline

Print vector elements to a text file for debugging.

                                                               {

                                std::ofstream outfile;
                                outfile.open(filename.c_str(),std::ios::out);
                                if (!outfile) {
                                        std::stringstream oss;
                                        throw AurynOpenFileException();
                                }

                                outfile << std::setprecision(7);

                                for ( IndexType i = 0 ; i < size ; ++i ) {
                                        outfile << get(i) << "\n";
                                }

                                outfile.close();
                        }

zero_effective_zeros()

template<typename T, typename IndexType = NeuronID>

void auryn::AurynVector< T, IndexType >::zero_effective_zeros ( const T  epsilon = 1e-3 )

inline

Sets all values whose absolute value is smaller than epsilon to zero.

                        {
                                for ( IndexType i = 0 ; i < size ; ++i ) {
                                        if ( std::abs(get(i)) < epsilon ) set(i, 0.0);
                                }
                        }

Friends And Related Function Documentation

boost::serialization::access

template<typename T, typename IndexType = NeuronID>

friend class boost::serialization::access

friend

Member Data Documentation

data

template<typename T, typename IndexType = NeuronID>

T* auryn::AurynVector< T, IndexType >::data

Pointer to the array housing the data.

size

template<typename T, typename IndexType = NeuronID>

IndexType auryn::AurynVector< T, IndexType >::size

Size of the vector.

Todo:

Consider including a non_zero size paramter too, because we are using this template also in sparse matrices now for complex synaptic dynamics in which not all elements are necessarily used...

---

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

• /home/zenke/auryn/src/auryn/auryn_definitions.h
• /home/zenke/auryn/src/auryn/AurynVector.h