auryn::AurynVectorFloat Class Reference

Default AurynVectorFloat class for performance computation. More...

#include <AurynVector.h>

Inheritance diagram for auryn::AurynVectorFloat:

Collaboration diagram for auryn::AurynVectorFloat:

Public Member Functions
	AurynVectorFloat (NeuronID n)
	Default constructor. More...
	~AurynVectorFloat ()
	Default destructor. More...
virtual void	resize (NeuronID new_size)
	resize data array to new_size More...
void	scale (const float a)
void	saxpy (const float a, AurynVectorFloat *x)
void	clip (const float min, const float max)
void	add (const float c)
void	add (AurynVectorFloat *v)
void	sum (AurynVectorFloat *a, AurynVectorFloat *b)
void	sum (AurynVectorFloat *a, const float b)
void	mul (const float a)
void	mul (AurynVectorFloat *v)
void	diff (AurynVectorFloat *a, AurynVectorFloat *b)
void	diff (AurynVectorFloat *a, const float b)
void	diff (const float a, AurynVectorFloat *b)
void	follow (AurynVectorFloat *v, const float rate)
Public Member Functions inherited from auryn::AurynVector< float, NeuronID >
	AurynVector (NeuronID n)
	Default constructor. More...
	AurynVector (AurynVector *vec)
	Copy constructor. More...
virtual	~AurynVector ()
	Default destructor. More...
void	copy (AurynVector *v)
	Copies vector v. More...
float	get (NeuronID i)
	Gets element i from vector. More...
float *	ptr (NeuronID i=0)
	Gets pointer to element i from vector. More...
void	set (NeuronID i, float value)
	Sets element i in vector to value. More...
void	set_all (const float v)
	Set all elements to value v. More...
void	set_zero ()
	Set all elements to zero. More...
void	scale (const float a)
	Scales all vector elements by a. More...
void	add (const float c)
	Adds constant c to each vector element. More...
void	add (AurynVector *v)
	Adds a vector v to the vector. More...
void	add_specific (const NeuronID i, const float c)
	Adds the value c to specific vector element i. More...
void	mul_specific (const NeuronID i, const float c)
	Multiply to specific vector element with data index i with the constant c. More...
void	sub (const float c)
	Subtract constant c to each vector element. More...
void	sub (AurynVector *v)
	Elementwise subtraction. More...
void	mul (const float a)
	Multiply all vector elements by constant. More...
void	mul (AurynVector *v)
	Element-wise vector multiply. More...
void	div (const float 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 float a, AurynVector *x)
	SAXPY operation as in GSL. More...
void	follow (AurynVector< float, NeuronID > *v, const float rate)
	Follows target vector v with rate. More...
void	follow_scalar (const float a, const float 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 float beta, const float 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 float 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 float b)
	Computes the difference a-b and stores the result in this instance. More...
void	diff (const float 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 (float min, float 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...
NeuronID	nonzero ()
	Computes number of nonzero elements on this rank. More...
void	zero_effective_zeros (const float 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 (float 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...

Additional Inherited Members
Public Attributes inherited from auryn::AurynVector< float, NeuronID >
NeuronID	size
	Size of the vector. More...
float *	data
	Pointer to the array housing the data. More...
Protected Member Functions inherited from auryn::AurynVector< float, NeuronID >
void	check_size (NeuronID 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 ()
float	fast_exp256 (float x)
	Computes approximation of exp(x) via fast series approximation up to n=256. More...

Detailed Description

Default AurynVectorFloat class for performance computation.

This class derives from AurynVector<float,NeuronID> and overwrites some performance critical member functions defined in the template with SIMD intrinsics for higher performance.

Constructor & Destructor Documentation

AurynVectorFloat()

AurynVectorFloat::AurynVectorFloat

(

NeuronID

n

)

Default constructor.

                                             : AurynVector<float>(n)
{
#ifdef CODE_USE_SIMD_INSTRUCTIONS_EXPLICITLY
        // check that size is a multiple of SIMD_NUM_OF_PARALLEL_FLOAT_OPERATIONS
        // which is typically 4 for float and SSE
        if ( n%SIMD_NUM_OF_PARALLEL_FLOAT_OPERATIONS ) {
                resize(n);
        }
#endif /* CODE_USE_SIMD_INSTRUCTIONS_EXPLICITLY */
}

Here is the call graph for this function:

~AurynVectorFloat()

auryn::AurynVectorFloat::~AurynVectorFloat ( )

inline

Default destructor.

                        {
                        };

Here is the call graph for this function:

Member Function Documentation

add() [1/2]

void AurynVectorFloat::add

(

const float

c

)

{
#ifdef CODE_USE_SIMD_INSTRUCTIONS_EXPLICITLY
        #ifdef CODE_ACTIVATE_CILK_INSTRUCTIONS
        data[0:size:1] = a + data[0:size:1];
        #else
        const __m128 scalar = _mm_set1_ps(a);
        for ( float * i = data ; i != data+size ; i += SIMD_NUM_OF_PARALLEL_FLOAT_OPERATIONS )
        {
                // _mm_prefetch((i + SIMD_NUM_OF_PARALLEL_FLOAT_OPERATIONS),  _MM_HINT_NTA);  
                __m128 chunk = sse_load( i );
                __m128 result = _mm_add_ps(chunk, scalar);
                sse_store( i, result );
        }
        #endif /* CODE_ACTIVATE_CILK_INSTRUCTIONS */
#else
        for ( NeuronID i = 0 ; i < size ; ++i ) {
                data[i] += a;
        }
#endif
}

Here is the call graph for this function:

add() [2/2]

void AurynVectorFloat::add

(

AurynVectorFloat *

v

)

{
        check_size(v);
#ifdef CODE_USE_SIMD_INSTRUCTIONS_EXPLICITLY
        #ifdef CODE_ACTIVATE_CILK_INSTRUCTIONS
        data[0:size:1] = data[0:size:1] + v->data[0:v->size:1];
        #else
        float * bd = v->data;
        for ( float * i = data ; i != data+size ; i += SIMD_NUM_OF_PARALLEL_FLOAT_OPERATIONS )
        {
                __m128 chunk_a = sse_load( i );
                __m128 chunk_b = sse_load( bd ); bd+=SIMD_NUM_OF_PARALLEL_FLOAT_OPERATIONS;
                __m128 result = _mm_add_ps(chunk_a, chunk_b);
                sse_store( i, result );
        }
        #endif /* CODE_ACTIVATE_CILK_INSTRUCTIONS */
#else
        for ( NeuronID i = 0 ; i < size ; ++i ) {
                data[i] += v->data[i];
        }
#endif
}

Here is the call graph for this function:

clip()

void AurynVectorFloat::clip	(	const float	min,
		const float	max
	)

{
#ifdef CODE_USE_SIMD_INSTRUCTIONS_EXPLICITLY
        #ifdef CODE_ACTIVATE_CILK_INSTRUCTIONS
        for ( NeuronID i = 0 ; i < size ; ++i ) {
                if ( data[i] < min ) {
                        data[i] = min;
                } else 
                        if ( data[i] > max ) 
                                data[i] = max;
        }
        #else
        const __m128 lo = _mm_set1_ps(min);
        const __m128 hi = _mm_set1_ps(max);
        for ( float * i = data ; i != data+size ; i += SIMD_NUM_OF_PARALLEL_FLOAT_OPERATIONS )
        {
                __m128 chunk = sse_load( i );
                __m128 result = _mm_min_ps(chunk, hi);
                result = _mm_max_ps(result, lo);
                sse_store( i, result );
        }
        #endif /* CODE_ACTIVATE_CILK_INSTRUCTIONS */
#else
        for ( NeuronID i = 0 ; i < size ; ++i ) {
                if ( data[i] < min ) {
                        data[i] = min;
                } else 
                        if ( data[i] > max ) 
                                data[i] = max;
        }
#endif
}

Here is the call graph for this function:

diff() [1/3]

void AurynVectorFloat::diff	(	AurynVectorFloat *	a,
		AurynVectorFloat *	b
	)

{
        check_size(a);
        check_size(b);
#ifdef CODE_USE_SIMD_INSTRUCTIONS_EXPLICITLY
        float * ea = a->data;
        float * eb = b->data;
        for ( float * i = data ; i != data+size ; i += SIMD_NUM_OF_PARALLEL_FLOAT_OPERATIONS )
        {
                const __m128 chunk_a = sse_load( ea ); ea+=SIMD_NUM_OF_PARALLEL_FLOAT_OPERATIONS;
                const __m128 chunk_b = sse_load( eb ); eb+=SIMD_NUM_OF_PARALLEL_FLOAT_OPERATIONS;
                __m128 result = _mm_sub_ps(chunk_a, chunk_b);
                sse_store( i, result );
        }
#else
        AurynVector::diff(a,b);
#endif
}

Here is the call graph for this function:

diff() [2/3]

void AurynVectorFloat::diff	(	AurynVectorFloat *	a,
		const float	b
	)

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

Here is the call graph for this function:

diff() [3/3]

void AurynVectorFloat::diff	(	const float	a,
		AurynVectorFloat *	b
	)

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

Here is the call graph for this function:

follow()

void AurynVectorFloat::follow	(	AurynVectorFloat *	v,
		const float	rate
	)

{
#ifdef CODE_USE_SIMD_INSTRUCTIONS_EXPLICITLY
        for ( NeuronID i = 0 ; i < size ; i += SIMD_NUM_OF_PARALLEL_FLOAT_OPERATIONS )
        {
                const __m128 chunk_a = sse_load( v->data+i ); 
                const __m128 chunk_b = sse_load( data+i ); 
                const __m128 scalar  = _mm_set1_ps(rate);
                __m128 temp = _mm_sub_ps(chunk_a, chunk_b);
                temp = _mm_mul_ps( scalar, temp );
                temp = _mm_add_ps( chunk_b, temp );
                sse_store( data+i, temp );
        }
#else
        super::follow(v,rate);
#endif
}

Here is the call graph for this function:

mul() [1/2]

void auryn::AurynVectorFloat::mul ( const float  a )

inline

{ scale(a); };

Here is the call graph for this function:

mul() [2/2]

void AurynVectorFloat::mul

(

AurynVectorFloat *

v

)

{
        check_size(v);
#ifdef CODE_USE_SIMD_INSTRUCTIONS_EXPLICITLY
        #ifdef CODE_ACTIVATE_CILK_INSTRUCTIONS
        data[0:size:1] = data[0:size:1] * v->data[0:v->size:1];
        #else
        float * bd = v->data;
        for ( float * i = data ; i != data+size ; i += SIMD_NUM_OF_PARALLEL_FLOAT_OPERATIONS )
        {
                __m128 chunk_a = sse_load( i );
                __m128 chunk_b = sse_load( bd ); bd+=SIMD_NUM_OF_PARALLEL_FLOAT_OPERATIONS;
                __m128 result = _mm_mul_ps(chunk_a, chunk_b);
                sse_store( i, result );
        }
        #endif /* CODE_ACTIVATE_CILK_INSTRUCTIONS */
#else
        for ( NeuronID i = 0 ; i < size ; ++i ) {
                data[i] *= v->data[i];
        }
#endif
}

Here is the call graph for this function:

resize()

void AurynVectorFloat::resize ( NeuronID  new_size )

virtual

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 from auryn::AurynVector< float, NeuronID >.

Reimplemented in auryn::AurynDelayVector.

{
#ifdef CODE_USE_SIMD_INSTRUCTIONS_EXPLICITLY
        if ( new_size%SIMD_NUM_OF_PARALLEL_FLOAT_OPERATIONS ) {
                const NeuronID div = new_size/SIMD_NUM_OF_PARALLEL_FLOAT_OPERATIONS; // rounds down
                new_size = (div+1)*SIMD_NUM_OF_PARALLEL_FLOAT_OPERATIONS; // is multiple of SIMD...
        }
#endif /* CODE_USE_SIMD_INSTRUCTIONS_EXPLICITLY */
        super::resize(new_size);
}

Here is the call graph for this function:

saxpy()

void AurynVectorFloat::saxpy	(	const float	a,
		AurynVectorFloat *	x
	)

{
        check_size(x);
#ifdef CODE_USE_SIMD_INSTRUCTIONS_EXPLICITLY
        #ifdef CODE_ACTIVATE_CILK_INSTRUCTIONS
        data[0:size:1] = a * x->data[0:x->size:1] + data[0:size:1];
        #else
        float * xp = x->data;
        const __m128 alpha = _mm_set1_ps(a);
        for ( float * i = data ; i < data+size ; i += SIMD_NUM_OF_PARALLEL_FLOAT_OPERATIONS )
        {
                __m128 chunk = sse_load( xp ); xp += SIMD_NUM_OF_PARALLEL_FLOAT_OPERATIONS;
                __m128 result     = _mm_mul_ps( alpha, chunk );

                chunk  = sse_load( i );
                result = _mm_add_ps( result, chunk );
                sse_store( i, result ); 
        }
        #endif /* CODE_ACTIVATE_CILK_INSTRUCTIONS */
#else
        for ( NeuronID i = 0 ; i < size ; ++i ) {
                data[i] += a * x->data[i];
        }
#endif
}

Here is the call graph for this function:

scale()

void AurynVectorFloat::scale

(

const float

a

)

{
#ifdef CODE_USE_SIMD_INSTRUCTIONS_EXPLICITLY
        #ifdef CODE_ACTIVATE_CILK_INSTRUCTIONS
        data[0:size:1] = a * data[0:size:1];
        #else
        const __m128 scalar = _mm_set1_ps(a);
        for ( float * i = data ; i != data+size ; i += SIMD_NUM_OF_PARALLEL_FLOAT_OPERATIONS )
        {
                __m128 chunk = sse_load( i );
                __m128 result = _mm_mul_ps(chunk, scalar);
                sse_store( i, result );
        }
        #endif /* CODE_ACTIVATE_CILK_INSTRUCTIONS */
#else
        for ( NeuronID i = 0 ; i < size ; ++i ) {
                data[i] *= a;
        }
#endif /* CODE_USE_SIMD_INSTRUCTIONS_EXPLICITLY */
}

Here is the call graph for this function:

sum() [1/2]

void AurynVectorFloat::sum	(	AurynVectorFloat *	a,
		AurynVectorFloat *	b
	)

{
        check_size(a);
        check_size(b);
#ifdef CODE_USE_SIMD_INSTRUCTIONS_EXPLICITLY
        float * ea = a->data;
        float * eb = b->data;
        for ( float * i = data ; i != data+size ; i += SIMD_NUM_OF_PARALLEL_FLOAT_OPERATIONS )
        {
                __m128 chunk_a = sse_load( ea ); ea+=SIMD_NUM_OF_PARALLEL_FLOAT_OPERATIONS;
                __m128 chunk_b = sse_load( eb ); eb+=SIMD_NUM_OF_PARALLEL_FLOAT_OPERATIONS;
                __m128 result = _mm_add_ps(chunk_a, chunk_b);
                sse_store( i, result );
        }
#else
        AurynVector::sum(a,b);
#endif
}

Here is the call graph for this function:

sum() [2/2]

void AurynVectorFloat::sum	(	AurynVectorFloat *	a,
		const float	b
	)

{
        check_size(a);
#ifdef CODE_USE_SIMD_INSTRUCTIONS_EXPLICITLY
        float * ea = a->data;
        const __m128 scalar = _mm_set1_ps(b);
        for ( float * i = data ; i != data+size ; i += SIMD_NUM_OF_PARALLEL_FLOAT_OPERATIONS )
        {
                __m128 chunk_a = sse_load( ea ); ea+=SIMD_NUM_OF_PARALLEL_FLOAT_OPERATIONS;
                __m128 result = _mm_add_ps(chunk_a, scalar);
                sse_store( i, result );
        }
#else
        AurynVector::sum(a,b);
#endif
}

Here is the call graph for this function:

---

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

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