gsl_vector_double.h

Go to the documentation of this file.

//

//  This vector double class has been adapted from the gslwrap project.
//  It is a C++ wrapper for the GNU Scientific Library
//  Copyright (C) 2001 Ramin Nakisa

//  This program is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.

//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.

//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.


#ifndef _GSL_VECTOR_DOUBLE_H
#define _GSL_VECTOR_DOUBLE_H

#include <iostream>
#include <assert.h>
#include <gsl/gsl_math.h>
#include <gsl/gsl_vector.h>

#define type_is
#ifdef  type_is
#define type_is_double
#endif


class vector_view;

//

class vector
{

protected:

//

gsl_vector *v;

public:

//
//

vector();

//
//

vector(size_t n, bool clear=true);

//
//

~vector();

// 
//

int fprintf (FILE * stream, const char * format) const;

//
//

int fscanf (FILE * stream);

// 
//

void resize(size_t n);

// 
//

void copy(const vector& other);

//

size_t size() const;

//
//

void  set(size_t i,double x);

//
//

double get(size_t i) const;

//
//

void set_all(double x);

//
//

void set_zero();

//

double max() const;

//

double min() const;

//

size_t max_index();

//

size_t min_index();

//
//

double &operator[](size_t i);

//
//

const double &operator[](size_t i) const;

//
//      

bool operator==(const vector& other) const;

//
//

bool operator!=(const vector& other) const { return (!((*this)==other));}

//
//

vector& operator=(const vector& other){copy(other);return (*this);}

//

vector operator+( const vector &other ) const;

//

vector operator-( const vector &other ) const;

//

int operator+=(const vector &other) {return gsl_vector_add (v, other.v);}

//

int operator-=(const vector &other) {return gsl_vector_sub (v, other.v);}

//

int operator*=(const vector &other) {return gsl_vector_mul (v, other.v);}

//

int operator/=(const vector &other) {return gsl_vector_div (v, other.v);}

//
//

int operator*=(double x) {return gsl_vector_scale (v, x);}

//
//

int operator+=(double x) {return gsl_vector_add_constant (v,x);}

//
//

int operator/=(double x) {return gsl_vector_scale (v, 1/x);}


//
//  

void alloc(size_t n);

//

void calloc(size_t n);

// Function that removes the vector from memeory.
//

void free();

//

bool is_set() const;

//

double sum() const;

//

double norm2() const;

//

gsl_vector       *gslobj()       {assert(v);return v;}

//

const gsl_vector *gslobj() const {assert(v);return v;}

//
//

static vector_view create_vector_view( const gsl_vector_view &other );

//
// 

vector_view subvector (size_t offset, size_t n);

//
//

const vector_view subvector (size_t offset, size_t n) const;

//
//

};

//

class vector_view : public vector
{
 public:
        vector_view(const vector&     other) :vector(){init(other);}
        vector_view(const vector_view& other):vector(){init(other);}
        vector_view(const gsl_vector& gsl_other) : vector() {init_with_gsl_vector(gsl_other);}

        void init(const vector& other);
        void init_with_gsl_vector(const gsl_vector& gsl_other);
        void change_view(const vector& other){init(other);}
 private:
};

#define tmp_type_is
/*#ifdef tmp_type_is
typedef vector vector_double;
template<class T> 
struct vector_type  {typedef vector_double   type;};

template<class T> 
struct value_type  {typedef double   type;};

#else
template<> struct vector_type<double> {typedef vector type;};
#endif*/
#undef tmp_type_is

#endif // GSL_VECTOR_DOUBLE_H