fp_gsl_matrix.h

Go to the documentation of this file.

#ifndef FP_GSL_MATRIX_H
#define FP_GSL_MATRIX_H
#include <gsl/gsl_matrix.h>
#include <blitz/array.h>
#include <boost/utility.hpp>

namespace FullPhysics {

/****************************************************************/
class GslMatrix : public boost::noncopyable {
public:
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------

  GslMatrix() : gsl_matrix_(0) {}

//-----------------------------------------------------------------------
//-----------------------------------------------------------------------

  GslMatrix(gsl_matrix* M, bool Owned = true) : gsl_matrix_(0) 
  {reset(M, Owned);}

//-----------------------------------------------------------------------
//-----------------------------------------------------------------------

  GslMatrix(blitz::Array<double, 2>& M) : gsl_matrix_(0) {reset(M);}
  ~GslMatrix();
  void reset(gsl_matrix* M, bool Owned = true);
  void reset(blitz::Array<double, 2>& M);

//-----------------------------------------------------------------------
//-----------------------------------------------------------------------

  const gsl_matrix* gsl() const { return gsl_matrix_; }

//-----------------------------------------------------------------------
//-----------------------------------------------------------------------

  gsl_matrix* gsl() { return gsl_matrix_; }

//-----------------------------------------------------------------------
//-----------------------------------------------------------------------

  const blitz::Array<double, 2>& blitz_array() const {return blitz_array_;}

//-----------------------------------------------------------------------
//-----------------------------------------------------------------------

  blitz::Array<double, 2>& blitz_array() {return blitz_array_;}
public:
  blitz::Array<double, 2> blitz_array_;
  gsl_matrix* gsl_matrix_;
  bool owned_;                  // This only applies to gsl_matrix_,
                                // blitz_array manages itself.
  bool block_owned_;
};

/****************************************************************/
class GslVector : public boost::noncopyable {
public:
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------

  GslVector() : gsl_vector_(0) {}

//-----------------------------------------------------------------------
//-----------------------------------------------------------------------

  GslVector(gsl_vector* M, bool Owned = true) :gsl_vector_(0) 
  { reset(M, Owned);}

//-----------------------------------------------------------------------
//-----------------------------------------------------------------------

  GslVector(blitz::Array<double, 1>& M) 
    :gsl_vector_(0) { reset(M);}
  ~GslVector();
  void reset(gsl_vector* M, bool Owned = true);
  void reset(blitz::Array<double, 1>& M);

//-----------------------------------------------------------------------
//-----------------------------------------------------------------------

  const gsl_vector* gsl() const { return gsl_vector_; }

//-----------------------------------------------------------------------
//-----------------------------------------------------------------------

  gsl_vector* gsl() { return gsl_vector_; }

//-----------------------------------------------------------------------
//-----------------------------------------------------------------------

  const blitz::Array<double, 1>& blitz_array() const {return blitz_array_;}

//-----------------------------------------------------------------------
//-----------------------------------------------------------------------

  blitz::Array<double, 1>& blitz_array() {return blitz_array_;}
public:
  blitz::Array<double, 1> blitz_array_;
  gsl_vector* gsl_vector_;
  bool owned_;                  // This only applies to gsl_vector_,
                                // blitz_array manages itself.
  bool block_owned_;
};
}
#endif