gslpp_matrix_complex.h

Go to the documentation of this file.

/* 
 * Copyright (C) 2012 HEPfit Collaboration
 *
 *
 * For the licensing terms see doc/COPYING.
 */
 
#ifndef GSLPP_MATRIX_COMPLEX_H
#define GSLPP_MATRIX_COMPLEX_H
#include <iostream>
#ifndef __GSL_MATRIX_COMPLEX_DOUBLE_H__
#include <gsl/gsl_matrix_complex_double.h>
#endif
#ifndef GSLPP_COMPLEX_H
#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_DOUBLE_H
#include "gslpp_matrix_double.h"
#endif
 
namespace gslpp
{
  template <>
  class matrix<complex>
  {
    gsl_matrix_complex *_matrix;
 
    public:
      matrix(const size_t& size_i, const size_t& size_j, const complex& z);
      matrix(const size_t& size_i, const complex& z);
      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<complex>& m);
      matrix(const matrix<double>& m);
      matrix(const vector<complex>& v);
      matrix(const vector<double>& v);
      matrix(const gsl_matrix_complex& m);
      matrix(const gsl_matrix_complex* m);
      ~matrix();
      const complex operator()(const size_t& i, const size_t& j) const;
//      complex& operator()(const size_t& i, const size_t& j);
      matrix<complex>& operator=(const matrix<complex>& m);
      void reset();
      void assign(const size_t& i, const size_t& j, const complex& z);
      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<complex>& z);
      void assign(const size_t& i, const size_t& j, const matrix<double>& a);
      void assignre(const size_t& i, const size_t& j,const double& a);
      void assignim(const size_t& i, const size_t& j,const double& a);
      size_t size_i() const;
      size_t size_j() const;
      size_t size() const;
      static matrix<complex> Id(size_t size);
      matrix<complex> transpose() const;
      matrix<complex> hconjugate() const;
      matrix<complex> inverse() const;
      bool isSingular();
      matrix<double> real() const;
      matrix<double> imag() const;
      void eigensystem(matrix<complex> &U, vector<double> &S) const;
      void singularvalue(matrix<complex> &U, matrix<complex> &V, vector<double> &S) const;
      gsl_matrix_complex* as_gsl_type_ptr() const;
      gsl_matrix_complex& as_gsl_type();
      const gsl_matrix_complex& as_gsl_type() const;
      //bool is_equal(const matrix<complex>& m1, const matrix<complex>& m2);
      matrix<complex> operator-() const;
      matrix<complex> operator+(const matrix<complex>& m) const;
      matrix<complex> operator-(const matrix<complex>& m) const;
      matrix<complex> operator*(const matrix<complex>& m) const;
      matrix<complex> operator+(const matrix<double>& m) const;
      matrix<complex> operator-(const matrix<double>& m) const;
      matrix<complex> operator*(const matrix<double>& m) const;
      vector<complex> operator*(const vector<complex>& v) const;
      vector<complex> operator*(const vector<double>& v) const;
      matrix<complex>& operator+=(const matrix<complex>& m);
      matrix<complex>& operator-=(const matrix<complex>& m);
      matrix<complex>& operator*=(const matrix<complex>& m);
      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;
      matrix<complex>& operator+=(const complex& z);
      matrix<complex>& operator-=(const complex& z);
      matrix<complex>& operator*=(const complex& z);
      matrix<complex>& operator/=(const complex& z);
      matrix<complex> operator+(const double& a) const;
      matrix<complex> operator-(const double& a) const;
      matrix<complex> operator*(const double& a) const;
      matrix<complex> operator/(const double& a) const;
      matrix<complex>& operator+=(const double& a);
      matrix<complex>& operator-=(const double& a);
      matrix<complex>& operator*=(const double& a);
      matrix<complex>& operator/=(const double& a);
      bool operator==(const matrix<complex>& a) const;
      bool operator!=(const matrix<complex>& a) const
      {
          return(!(*this == a));
      }
 
      friend std::ostream& operator<<(std::ostream& output, const matrix<complex>& v);
 
      friend matrix<complex> operator+(matrix<double> m1, const matrix<complex> m2);
 
      friend matrix<complex> operator-(matrix<double> m1, const matrix<complex> m2);
 
      friend matrix<complex> operator+(const complex& z, const matrix<complex> m);
 
      friend matrix<complex> operator-(const complex& z, const matrix<complex> m);
 
      friend matrix<complex> operator*(const complex& z, const matrix<complex> m);
 
      friend vector<complex> operator*(const vector<complex>& v, const matrix<complex> m);
 
      friend vector<complex> operator*(const vector<double>& v, const matrix<complex> m);
 
      friend matrix<complex> operator+(const double& a, const matrix<complex> m);
 
      friend matrix<complex> operator-(const double& a, const matrix<complex> m);
 
      friend matrix<complex> operator*(const double& a, const matrix<complex> m);
  };
}
 
#endif