gslpp_matrix_double.h

Go to the documentation of this file.

/* 
 * Copyright (C) 2012 HEPfit Collaboration
 *
 *
 * For the licensing terms see doc/COPYING.
 */
 
#ifndef GSLPP_MATRIX_DOUBLE_H
#define GSLPP_MATRIX_DOUBLE_H
#include <iostream>
#ifndef __GSL_MATRIX_DOUBLE_H__
#include <gsl/gsl_matrix_double.h>
#endif
#ifndef GSLPP_COMPLEX_H
#ifndef __GSL_MATRIX_DOUBLE_H__
#include <gsl/gsl_matrix_double.h>
#endif
#include "gslpp_complex.h"
#endif
#ifndef GSLPP_VECTOR_BASE_H
#include "gslpp_vector_base.h"
#endif
#ifndef GSLPP_VECTOR_DOUBLE_H
#include "gslpp_vector_double.h"
#endif
#ifndef GSLPP_VECTOR_COMPLEX_H
#include "gslpp_vector_complex.h"
#endif
#ifndef GSLPP_MATRIX_BASE_H
#include "gslpp_matrix_base.h"
#endif
#ifndef GSLPP_MATRIX_COMPLEX_H
#include "gslpp_matrix_complex.h"
#endif
 
namespace gslpp
{
  template <>
  class matrix<double>
    {
      gsl_matrix *_matrix;
 
    public:
      matrix(const size_t& size_i, const size_t& size_j, const double& a);
      matrix(const size_t& size_i, const double& a);
      matrix(const matrix<double>& m);
      matrix(const gsl_matrix& m);
      matrix(const gsl_matrix* m);
      matrix(const vector<double>& v);
      ~matrix();
      double operator()(const size_t& i, const size_t& j) const;
      double& operator()(const size_t& i, const size_t& j);
      void reset();
      matrix<double>& operator=(const matrix<double>& m);
      matrix<double>& operator=(double a);
      void assign(const size_t& i, const size_t& j, const double& a);
      void assign(const size_t& i, const size_t& j, const matrix<double>& a);
      size_t size_i() const;
      size_t size_j() const;
      size_t size() const;
      static matrix<double> Id(size_t size);
      matrix<double> transpose() const;
      matrix<double> inverse();
      bool isSingular();
      double determinant();
      void eigensystem(matrix<complex> &U, vector<complex> &S);
      gsl_matrix* as_gsl_type_ptr() const;
      gsl_matrix& as_gsl_type();
      const gsl_matrix& as_gsl_type() const;
      //bool is_equal(const matrix<double>& m1, const matrix<double>& m2);
 
      matrix<double> operator-() const;
      matrix<double> operator+(const matrix<double>& m) const;
      matrix<double> operator-(const matrix<double>& m) const;
      matrix<double> operator*(const matrix<double>& m) const;
      matrix<complex> operator*(const matrix<complex>& m) const;
      vector<double> operator*(const vector<double>& v) const;
      vector<complex> operator*(const vector<complex>& v) const;
      matrix<double>& operator+=(const matrix<double>& m);
      matrix<double>& operator-=(const matrix<double>& m);
      matrix<double>& operator*=(const matrix<double>& m);
      matrix<double> operator+(const double& a) const;
      matrix<double> operator-(const double& a) const;
      matrix<double> operator*(const double& a) const;
      matrix<double> operator/(const double& a) const;
      matrix<double>& operator+=(const double& a);
      matrix<double>& operator-=(const double& a);
      matrix<double>& operator*=(const double& a);
      matrix<double>& operator/=(const double& a);
      matrix<complex> operator+(const complex& z) const;
      matrix<complex> operator-(const complex& z) const;
      matrix<complex> operator*(const complex& z) const;
      matrix<complex> operator/(const complex& z) const;
      bool operator==(const matrix<double>& a) const;
      bool operator!=(const matrix<double>& a) const
      {
          return(!(*this == a));
      }
 
      friend std::ostream& operator<<(std::ostream& output, const matrix<double>& m);
      friend matrix<double> operator+(const double& a, matrix<double> m);
 
      friend matrix<double> operator-(const double& a, matrix<double>  m);
 
      friend matrix<double> operator*(const double& a, matrix<double> m);
 
      friend vector<double> operator*(const vector<double>& v, matrix<double> m);
 
      friend vector<complex> operator*(const vector<complex>& v, matrix<double> m);
 
      friend matrix<complex> operator+(const complex& z, matrix<double> m);
 
      friend matrix<complex> operator-(const complex& z, matrix<double> m);
 
      friend matrix<complex> operator*(const complex& z, matrix<double> m);
  };
 
}
 
#endif