source: trunk/src/vector.h @ 40

// $Id: vector.h 40 2004-02-20 14:03:25Z jari $

#ifndef _thep_gsl_api_vector_ 
#define _thep_gsl_api_vector_

#include <iostream>
#include <fstream>
#include <iomanip>
#include <cmath>
#include <cstdlib>
#include <cassert>

#include <gsl/gsl_math.h>
#include <gsl/gsl_vector.h>
#include <gsl/gsl_linalg.h>
#include <gsl/gsl_blas.h>


namespace thep_gsl_api
{

  /**
     This is a vector interface to GSL for c++. 
     Important: vector has two dimenstions depending on 
     whether it's a "row" vector or a "column" vector.
     A column vector is created by default.
     Note that the namespace is "thep_gsl_api".
  */

  class vector
  {
  public:
    typedef double Type;
  
    /**
       Default constructor
       Does not allocate any memory
    */
    vector();

    /**
       Constructor taking three argumens:
       N = Number of elements
       init_to_zero, if true vector will be initialized with zeros.
    */
    vector( const size_t&, bool is_col_vector = true, 
      bool init_to_zero = true );



    /** 
  Copy constructor
    */
    vector( const vector& other );


    /**
       Constructor taking as only argument a matrix of gsl type.
       Be causious here! Do not delete this matrix outside of
       class: NO COPY IS MADE!!!
    */
    vector( gsl_vector*, bool is_col = true );

    /**
       Constructor taking as only argument a an istream that should
       contain the vector. Column vector should be sepated with '\\n' 
       and row vector should be separeted with whitespace (not '\\n').       

    */
    vector(std::istream &);


    /**
       Destructor will clear matrix's allocated memory
    */
    ~vector();


    /**
       The most important function when adding new classes to 
       c++_tools. This function will return a pointer to the 
       inner data of the class. Should be forbidden in a strictly 
       object-orientated environment.
       Motivation: Effeciency! ( CAN IT BE MADE CONST? )
       To be used when writting new classes using gsl-functions. 
    */
    inline gsl_vector* get_gsl_vector() const { return v_; }


    /**
       Returns the number of rows in the vector.
    */
    size_t size() const { return v_->size; }


    /**
       Tells whether a vector is column or not
     */
    bool is_column() const { return is_col_; }


    /**
       get( i ) will return the vi element in vector v
       where i = column (if row vector) or row (if column vector)
    */
    inline Type get( const size_t& i ) const { return gsl_vector_get(v_,i); }


    /**
       set( i, val ) will make vi = val in vector v
       where i = column (if row vector) or row (if column vector)
    */
    inline void set( const size_t& i, const Type& val )
      { gsl_vector_set(v_,i,val); }

    /**
       set_all( val ) will make vi = val in vector v
       for all "i"
    */
    inline void set_all( const Type& val ) { gsl_vector_set_all(v_,val); }


    /**
       Assignment-operator. No requirements on dimensions,
       i.e. if a = b, then a will be a copy of b with b:s
       dimensions.
     */
    vector& operator=( const vector& other );


    /**
       Access element-operator
    */
    inline double &operator[](size_t i)  { return *gsl_vector_ptr( v_, i ); }
    const double &operator[](size_t i) const { return *gsl_vector_ptr( v_, i ); }

    
    /**
       operators for comparison are: \n
       == equal \n
       != not equal
    */
    bool operator==( const vector &other ) const;
    bool operator!=( const vector &other ) const; 

    /**
       operators for basic arithmetics are: \n
       \f$+\f$ vector-vector addition \n
       \f$-\f$ vector-vector subtraction \n
       \f$/=\f$ divide all elements with a constant
    */
    vector operator+( const vector& other ) const;
    vector operator-( const vector& other ) const;
    int operator/=( const double& c );
    int operator/=( const vector& other ) const;
    vector operator-() const;
    /**
       This operator is implemented as dot-product.
       I case of discussions later on; Jari decided 
       this!
    */
    double operator*( const vector &other ) const;

    /**
       This function multiplies all elements in two vectors
       and returns a third vector containing the result.
       res = a*b; where size(a) = size(b) = size(res)
    */
    vector vector::mul_elements( const vector& other ) const;
    
    
    /**
       Calculates sum of all elements in vector
    */ 
    double vector::sum() const;
    
    /**
        standard output operator is defined
    */
    friend std::ostream& operator<< ( std::ostream&, const vector& );
    

  private:
    gsl_vector* new_copy( const gsl_vector* );

    gsl_vector* v_;
    bool is_col_;
  };


};




#endif