source: trunk/src/vector.h @ 63

// $Id: vector.h 63 2004-04-19 11:21:28Z peter $

#ifndef _theplu_gslapi_vector_ 
#define _theplu_gslapi_vector_

#include <iostream>
#include <vector>
#include <utility>

#include <gsl/gsl_vector.h>

// Jari, this should probably go somewhere else for doxygen to process.
///
/// All our C++ projects should ideally be defined within theplu
/// namespace.
///
namespace theplu {
// Jari, this should probably go somewhere else for doxygen to process.
///
/// All GSL wrapper functionality is to be defined within gslapi
/// namespace.
///
/// There are a number of support operators and functions for the
/// wrapper classes that do not belong to the classes themselves, but
/// still are defined in this namespace.
///
namespace gslapi {

  ///
  /// This is the C++ tools interface to GSL vector.
  ///

  class vector
  {
  public:

    ///
    /// The default constructor.
    ///
    vector(void);

    ///
    /// Constructor. Allocates memory space for \a n elements, and
    /// sets all elements to \a init_value.
    ///
    vector(const size_t n, const double init_value=0);

    ///
    /// The copy constructor.
    ///
    vector(const vector&);

    ///
    /// Constructor that imports a GSL vector. The GSL object is owned
    /// by the created object.
    ///
    vector(gsl_vector*);

    ///
    /// The istream constructor.
    ///
    /// Elements should be separated with white space characters, the
    /// end of input to the vector is at end of file marker.
    ///
    explicit vector(std::istream &);

    ///
    /// The destructor.
    ///
    ~vector(void);

    ///
    /// Create a new copy of the internal GSL vector.
    ///
    /// Necessary memory for the new GSL vector is allocated and the
    /// caller is responsible for freeing the allocated memory.
    ///
    /// @return A pointer to a copy of the internal GSL vector.
    ///
    gsl_vector* gsl_vector_copy(void) const;

    ///
    /// @return A const pointer to the internal GSL vector,
    ///
    inline const gsl_vector* gsl_vector_pointer(void) const { return v_; }

    ///
    /// @return A pointer to the internal GSL vector,
    ///
    inline gsl_vector* gsl_vector_pointer(void) { return v_; }

    ///This function returns the indices of the minimum and maximum values in
    ///the sub-vector (defined by subset), storing them in imin and imax. When
    ///there are several equal minimum or maximum elements then the lowest
    ///indices are returned. The returned index is the index from the complete vector (not the sub-vector)  @return Index corresponding to the smallest
    ///and largest value.
    ///
    std::pair<u_int,u_int> vector::minmax_index(const std::vector<u_int>& subset ) const;

    ///
    /// This function multiplies all elements between two vectors and
    /// returns a third vector containing the result, \f$a_i = b_i *
    /// c_i \; \forall i\f$.
    ///
    /// @return The result vector.
    ///
    vector vector::mul_elements( const vector& other ) const;

    ///
    /// Set all elements to \a value.
    ///
    inline void set_all(const double& value) { gsl_vector_set_all(v_,value); }

    ///
    /// @return the number of elements in the vector.
    ///
    inline size_t size(void) const { return v_->size; }

    ///
    /// Calculate the sum of all vector elements.
    ///
    /// @return The sum.
    ///
    double vector::sum(void) const;

    ///
    /// Element access operator.
    ///
    /// @return Reference to element \a i.
    ///
    inline double& operator()(size_t i) { return *gsl_vector_ptr(v_,i); }

    ///
    /// Const element access operator.
    ///
    /// @return The value of element \a i.
    ///
    inline const double& operator()(size_t i) const
      { return *gsl_vector_ptr(v_,i); }
    
    ///
    /// Element access operator.
    ///
    /// @return Reference to element \a i.
    ///
    inline double& operator[](size_t i) { return (*this)(i); }

    ///
    /// Const element access operator.
    ///
    /// @return The value of element \a i.
    ///
    inline const double& operator[](size_t i) const { return (*this)(i); }
    
    ///
    /// @return The negation of the vector.
    ///
    vector operator-(void) const;

    ///
    /// @return The dot product.
    ///
    double operator*( const vector &other ) const;

    ///
    /// Vector addition.
    ///
    /// @return The resulting vector.
    ///
    vector operator+( const vector& other ) const;

    ///
    /// Vector subtraction.
    ///
    /// @return The resulting vector.
    ///
    vector operator-( const vector& other ) const;

    ///
    /// The assignment operator. There is no requirements on
    /// dimensions.
    ///
    vector& operator=(const vector&);

    ///
    /// Multiply and assign operator.
    ///
    vector& operator*=(const double d) { gsl_vector_scale(v_,d); return *this; }

    ///
    /// Multiply operator.
    ///
    vector& operator*(const double d) { gsl_vector_scale(v_,d); return *this; }


  private:

    gsl_vector* v_;

  };

  ///
  /// The output operator for the vector class.
  ///
  std::ostream& operator<< ( std::ostream&, const vector& );


}} // of namespace gslapi and namespace theplu

#endif