linalg::vector Class Reference

A wrapper class for GSL vectors. More...

#include <linalg.hpp>

Inheritance diagram for linalg::vector:

[legend]

List of all members.

Public Member Functions
	vector ()
	Allocate zero vector of size one.
	vector (const size_t n, const double fillvalue=0)
	Allocate GSL vector of size n, filled with fillvalue.
	vector (gsl_vector *y)
	Associate a vector to a GSL vector pointer.
	vector (const gsl_vector *y)
	Associate a vector to a constant GSL vector pointer.
	vector (const vector &y)
	Copy contstructor.
vector &	operator= (const vector &y)
	Assignment.
	~vector ()
	Clear memory assigned to vector by GSL.
size_t	precision () const
	Number of decimal digits to output.
size_t	size () const
	Number of elements.
double &	operator() (const size_t i)
	Fortran-style parenthetical indexing (hence Octave-style too). Indices start at 1.
const double &	operator() (const size_t i) const
	Constant version of previous function.
vector_view	operator() (const slice &v)
	Indexing for vectorisation. The GSL provides limited vectorisation routines which can be useful for operating on blocks of vectors all at once.
const vector_view	operator() (const slice &v) const
	Constant version of previous function.
vector	operator* (const double a) const
	Scale the vector.
vector	operator/ (const double a) const
	Scale the vector.
vector	operator+ (const vector &w) const
	Vector addition.
vector	operator- (const vector &w) const
	Vector subtration.
vector	operator* (const vector &w) const
	Element-by-element multiplication.
vector	operator/ (const vector &w) const
	Element-by-element division.
vector	operator* (const matrix &M) const
	Computes vM where v is treated as a row vector.
bool	operator== (const vector &w) const
	Compares vectors elementwise, using machine epsilon.
bool	operator< (const vector &w) const
	Lexicographical order, used for putting into STL sets or maps.
double	norm () const
	Euclidean norm.
double	operator% (const vector &w) const
	Dot product.
Static Public Member Functions
static void	set_precision (size_t p)
	Set the number of decimal digits to output.
Private Attributes
gsl_vector *	x
	Pointer to associated GSL vector.
Static Private Attributes
static size_t	precsn = 4
	Output precision.
static const double	eps = std::numeric_limits<double>::epsilon()
	Machine epsilon.
Friends
class	vector_view
class	matrix

---

Detailed Description

A wrapper class for GSL vectors.

---

Constructor & Destructor Documentation

linalg::vector::vector

(

)

Allocate zero vector of size one.

                {
    x = gsl_vector_calloc(1); //Allocate zero vector of size one.
  }

linalg::vector::vector	(	const size_t	n,
		const double	fillvalue = 0
	)

Allocate GSL vector of size n, filled with fillvalue.

Parameters:

	n	- Size of new vector
	fillvalue	- Value for filling vector, default is 0.

                                                      {
    x = gsl_vector_alloc(n);
    gsl_vector_set_all(x,fillvalue);
  }

linalg::vector::vector

(

gsl_vector *

y

)

Associate a vector to a GSL vector pointer.

                             {
    x = y;
  }

linalg::vector::vector

(

const gsl_vector *

y

)

Associate a vector to a constant GSL vector pointer.

                                   {
    x = gsl_vector_alloc(y -> size);
    gsl_vector_memcpy(x,y);
  }

Here is the call graph for this function:

linalg::vector::vector

(

const vector &

y

)

Copy contstructor.

                               {
    x = gsl_vector_alloc(y.x->size);
    gsl_vector_memcpy(x,y.x);
  }

linalg::vector::~vector

(

)

Clear memory assigned to vector by GSL.

                 {
    if(x != 0) //Has subclass vector_view already deleted this vector?
      gsl_vector_free(x);
  }

---

Member Function Documentation

vector & linalg::vector::operator=

(

const vector &

y

)

Assignment.

Reimplemented in linalg::vector_view.

                                          {
    if(this != &y){
      gsl_vector_free(x);
      x = gsl_vector_alloc(y.x -> size);
      gsl_vector_memcpy(x,y.x);
    }
    return *this;
  }

Here is the call graph for this function:

size_t linalg::vector::precision

(

)

const

Number of decimal digits to output.

                                {
    return precsn;
  }

void linalg::vector::set_precision

(

size_t

p

)

[static]

Set the number of decimal digits to output.

                                    {
    precsn = p;
  }

size_t linalg::vector::size

(

)

const

Number of elements.

                           {
    return x->size;
  }

double & linalg::vector::operator()

(

const size_t

i

)

[inline]

Fortran-style parenthetical indexing (hence Octave-style too). Indices start at 1.

Parameters:

i

- Index number.

Returns:

A reference to the vector element.

                                                  {
    try{
      return *gsl_vector_ptr(x,i-1);
    }
    catch(indexOutOfRange& exc){
      exc.i = i;
      exc.n = x -> size;
      throw exc;
    }
  }

Here is the call graph for this function:

const double & linalg::vector::operator()

(

const size_t

i

)

const [inline]

Constant version of previous function.

                                                              {
    try{
      return *gsl_vector_const_ptr(x,i-1);
    }
    catch(indexOutOfRange& exc){
      exc.i = i;
      exc.n = x -> size;
      throw exc;
    }
  }

Here is the call graph for this function:

vector_view linalg::vector::operator()

(

const slice &

v

)

Indexing for vectorisation. The GSL provides limited vectorisation routines which can be useful for operating on blocks of vectors all at once.

Parameters:

v

- Slice range.

Returns:

A vector_view of the slice.

                                               {
    vector_view x_sub(x,s);
    return x_sub;
  }

const vector_view linalg::vector::operator()

(

const slice &

v

)

const

Constant version of previous function.

                                                           {
    vector_view x_sub(x,s);
    return x_sub;
  }

vector linalg::vector::operator*

(

const double

a

)

const

Scale the vector.

                                              {
    vector v = *this;
    gsl_vector_scale(v.x, a);
    return v;
  }

vector linalg::vector::operator/

(

const double

a

)

const

Scale the vector.

                                              {
    vector v = *this;
    gsl_vector_scale(v.x, 1.0/a);
    return v;
  }

vector linalg::vector::operator+

(

const vector &

w

)

const

Vector addition.

                                               {
    if(x -> size != w.x->size){
      inconformantSizes exc;
      exc.reason = "Cannot add vectors of different sizes.";
      exc.file = __FILE__;
      exc.line = __LINE__;
      exc.n_A = x->size;
      exc.n_B = w.x->size;
      throw exc;
    }
    vector u = *this;
    gsl_vector_add(u.x,w.x);
    return u;    
  }

Here is the call graph for this function:

vector linalg::vector::operator-

(

const vector &

w

)

const

Vector subtration.

                                               {
    if(x -> size != w.x->size){
      inconformantSizes exc;
      exc.reason = "Cannot subtract vectors of different sizes.";
      exc.file = __FILE__;
      exc.line = __LINE__;
      exc.n_A = x->size;
      exc.n_B = w.x->size;
      throw exc;
    }
    vector u = *this;
    gsl_vector_sub(u.x,w.x);
    return u;    
  }

Here is the call graph for this function:

vector linalg::vector::operator*

(

const vector &

w

)

const

Element-by-element multiplication.

  {
    vector u = *this;
    try{
      gsl_vector_mul(u.x, w.x);
    }
    catch(inconformantSizes& exc){
      exc.reason = "Can't multiply vectors of different sizes.";
      exc.file = __FILE__;
      exc.line = __LINE__;
      exc.n_A = x->size;
      exc.n_B = w.x -> size;
      throw exc;
    }
    return u;
  }

Here is the call graph for this function:

vector linalg::vector::operator/

(

const vector &

w

)

const

Element-by-element division.

  {
    vector u = *this;
    try{
      gsl_vector_div(u.x, w.x);
    }
    catch(inconformantSizes& exc){
      exc.reason = "Can't divide vectors of different sizes.";
      exc.file = __FILE__;
      exc.line = __LINE__;
      exc.n_A = x->size;
      exc.n_B = w.x -> size;
      throw exc;
    }
    return u;
  }

Here is the call graph for this function:

vector linalg::vector::operator*

(

const matrix &

M

)

const

Computes vM where v is treated as a row vector.

  {
    return T(M)* (*this);
  }

Here is the call graph for this function:

bool linalg::vector::operator==

(

const vector &

w

)

const

Compares vectors elementwise, using machine epsilon.

                                              {
    if(x -> size != w.x -> size){
      badArgument exc;
      exc.reason = "Cannot compare vectors of different sizes.";
      exc.file = __FILE__;
      exc.line = __LINE__;
      throw exc;
    }

    for(size_t i = 0; i < x -> size; i++)
      if(gsl_fcmp(gsl_vector_get(x,i), gsl_vector_get(w.x,i), eps) != 0)
        return false;
    
    return true;
  }

Here is the call graph for this function:

bool linalg::vector::operator<

(

const vector &

w

)

const

Lexicographical order, used for putting into STL sets or maps.

Lexicographical ordering of vectors. Vectors of smaller dimension are smaller.

                                             {
    if(x -> size < w.x -> size) //Smaller vectors go first in this order.
       return true;

    for(size_t i = 0; i < x -> size; i++){
      double L = gsl_vector_get(x,i);
      double R = gsl_vector_get(w.x,i);
      if(L < R )
        return true;
      if(L > R )
        return false;
    }
   
    return false; //Then vectors are equal.
  }

Here is the call graph for this function:

double linalg::vector::norm

(

)

const

Euclidean norm.

  {
    return gsl_blas_dnrm2(x);
  }

double linalg::vector::operator%

(

const vector &

w

)

const

Dot product.

  {
    double a;
    try{
      gsl_blas_ddot(x, w.x, &a);
    }
    catch(inconformantSizes& exc){
      exc.reason = "Can't dot product vectors of different sizes.";
      exc.file = __FILE__;
      exc.line = __LINE__;
      exc.n_A = x->size;
      exc.n_B = w.x -> size;
      throw exc;
    }
    return a;
  }

Here is the call graph for this function:

---

Friends And Related Function Documentation

friend class vector_view [friend]

friend class matrix [friend]

Reimplemented in linalg::vector_view.

---

Member Data Documentation

gsl_vector* linalg::vector::x [private]

Pointer to associated GSL vector.

size_t linalg::vector::precsn = 4 [static, private]

Output precision.

const double linalg::vector::eps = std::numeric_limits<double>::epsilon() [static, private]

Machine epsilon.

---

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

• include/linalg.hpp
• linalg.cpp