linalg Namespace Reference

Linear algebra namespace. More...

Classes
class	matrix
	A wrapper class for GNU Scientific Library matrices. More...
class	vector
	A wrapper class for GSL vectors. More...
class	vector_view
	A vector that doesn't own its data; rather, points to data owned by another vector. More...
class	slice
	Vector slices corresponding to GNU Octave ranges. More...
Typedefs
typedef vector	point
	Useful alias, vectors are also points in space.
Functions
I/O
std::ostream &	operator<< (std::ostream &os, const vector &v)
	Stream insertion operator.
vector	operator>> (std::istream &is, vector &v)
	Stream extraction operator.
std::ostream &	operator<< (std::ostream &os, const matrix &M)
	Stream insertion operator.
matrix	operator>> (std::istream &is, matrix &v)
	Stream extraction operator.
Arithmetic
Some arithmetic functions for comfortable syntax.
vector	operator* (double a, const vector &v)
	Scale a vector.
double	norm (const vector &v)
	Euclidean norm of a vector.
matrix	operator* (double a, const matrix &M)
	Scale a matrix.
matrix	inv (const matrix &A)
	Matrix inverse, computed with LU factorisation.
matrix	T (const matrix &A)
	Return copy of transposed matrix.
double	tr (const matrix &A)
	Trace.
double	det (matrix &A)
	Determinant.
double	cond (matrix &A)
	L2 condition number, computed with SVD.

---

Detailed Description

Linear algebra namespace.

---

Typedef Documentation

typedef vector linalg::point

Useful alias, vectors are also points in space.

---

Function Documentation

double linalg::cond

(

matrix &

A

)

L2 condition number, computed with SVD.

  {
    return A.cond();
  }

Here is the call graph for this function:

double linalg::det

(

matrix &

A

)

Determinant.

  {
    return A.det();
  }

Here is the call graph for this function:

matrix linalg::inv

(

const matrix &

A

)

Matrix inverse, computed with LU factorisation.

  {
    return A.inv();
  }

Here is the call graph for this function:

double linalg::norm

(

const vector &

v

)

Euclidean norm of a vector.

  {
    return v.norm();
  }

Here is the call graph for this function:

matrix linalg::operator*	(	double	a,
		const matrix &	M
	)

Scale a matrix.

  {
    return M*a;
  }

vector linalg::operator*	(	double	a,
		const vector &	v
	)

Scale a vector.

  {
    return v*a;
  }

std::ostream & linalg::operator<<	(	std::ostream &	os,
		const matrix &	M
	)

Stream insertion operator.

                                                          {
     os.setf(std::ios::scientific);
     os << std::setprecision(int(A.precision()) );
     for(size_t i = 1; i <= A.rows(); i++){
       for(size_t j = 1; j <= A.cols(); j++)
         os << " " << std::setw(int(A.precision()+6) ) << A(i,j) << " ";
       os << std::endl;
     }
     return os;
   }

Here is the call graph for this function:

std::ostream & linalg::operator<<	(	std::ostream &	os,
		const vector &	v
	)

Stream insertion operator.

                                                         {
    os.setf(std::ios::scientific);
    os << std::setprecision(int(v.precision()) );
    for(size_t i = 1; i <= v.size(); i++){
      os << " " << std::setw(int(v.precision()+6) ) << v(i) << " ";
    }
    os << std::endl;
     return os;
   }

Here is the call graph for this function:

matrix linalg::operator>>	(	std::istream &	is,
		matrix &	v
	)

Stream extraction operator.

                                              {
    using namespace std;
    string line, token;
    bool rowset = false;
    list<double> data;
     
    size_t rowsize = 0;
    size_t rows = 0;
    size_t cols = 0;
    while(getline(is, line)){
      line = utils::trim(line);
      //Blank row or comment character.
      if(line[0] == '#' or line.length() == 0) 
        continue;
         
      stringstream ss_line;      
      cols = 0;
      ss_line << line;
      while(ss_line >> token){
        if(token[0] == '#'){
          break; //Rest of line is comment.
        }

        //The following may fail on a C++ implementation that doesn't
        //obey IEEE arithmetic (IEC 559). We could check for those,
        //but do we really want to compile Octave on C++
        //implementations that don't follow IEEE arithmetic?
        else if(token == "NaN"){ 
          double x = std::numeric_limits<double>::quiet_NaN();
          data.push_back(x);
          cols++;
        }
        else if(token == "Inf"){
          double x = std::numeric_limits<double>::infinity();
          data.push_back(x);
          cols++;
        }
        else if(token == "-Inf"){
          double x = -std::numeric_limits<double>::infinity();
          data.push_back(x);
          cols++;
        }
        else if(token == ","){
          ss_line >> token;
        }

        //This also ignores commas and any other token. I think. If
        //there's garbage in the token, I have to see what happens
        //here. Do we also need to check for garbage?
        else{ 
          double x;
          stringstream ss_token;
          ss_token << token;
          ss_token >> x;
          data.push_back(x);
          cols++;
        }

      }
       
      //First row gives the number of columns, and all successive rows
      //must have the same number of elements. 
      if(!rowset){
        rowset = true;
        rowsize = cols;
      }
       
      if (cols != rowsize){
        badArgument exc;
        exc.reason = "Cannot read matrix: bad format in input";
        exc.file = __FILE__;
        exc.line = __LINE__;
        throw exc;
      }
      rows++;
    }
    if(rows == 0){
      endOfFile exc;
      exc.reason = "Cannot read empty matrix from input.";
      exc.file = __FILE__;
      exc.line = __LINE__;
      throw exc;
    }
    
    matrix M(rows,cols);
    typedef list<double>::iterator LI;
    
    LI k = data.begin();
    for(size_t i = 1; i <= rows; i++){
      for(size_t j = 1; j <= cols; j++){
        M(i,j) = *k;
        k++;
      }
    }

    A = M;    
    return A;
  }

Here is the call graph for this function:

vector linalg::operator>>	(	std::istream &	is,
		vector &	v
	)

Stream extraction operator.

                                               {
     using namespace std;
     string s;
     list<double> data;
     bool colvector = true;
     bool shouldbedone = false;
     while(getline(is, s)){
       s = utils::trim(s);
       if(s[0] == '#' or s.size() == 0) //Blank line or comment character
         continue;

       stringstream ss;
       ss << s;

       double x;
       size_t i = 0;
       while(ss >> x){
         if( (i > 0 and colvector == false) or (shouldbedone == true)){
           badArgument exc;
           exc.reason = "Cannot read vector: bad format in input";
           exc.file = __FILE__;
           exc.line = __LINE__;
           throw exc;
         }
         data.push_back(x);
         i++;
       }
       if(i > 1){
         colvector = false; //So it must be a row vector instead
         shouldbedone = true;
       }
     }

     if(data.size() == 0){
       endOfFile exc;
       exc.reason = "Cannot read empty vector from input.";
       exc.file = __FILE__;
       exc.line = __LINE__;
       throw exc;
     }

     vector w(data.size());
     typedef list<double>::iterator LI;
     size_t k = 1;
     for(LI i = data.begin(); i != data.end(); i++){
       w(k) = *i;
       k++;
     }
     v = w;
     return v;
   }

Here is the call graph for this function:

matrix linalg::T

(

const matrix &

A

)

Return copy of transposed matrix.

  {
    return A.T();
  }

Here is the call graph for this function:

double linalg::tr

(

const matrix &

A

)

Trace.

  {
    return A.tr();
  }

Here is the call graph for this function: