---

Matrix.h

Go to the documentation of this file.

#ifndef ATLFAST_MATRIX_H
#define ATLFAST_MATRIX_H
#include <valarray>
#include "AtlfastUtils/Slice_iter.h"
#include "AtlfastUtils/Cslice_iter.h"
//=================================================
//
// Matrix
//
// Matrix class from Sjoustrup's "the C++ programming language" ch 22.4.6
// This class has been written because of a compiler bug on the
// SUN which prevents std::vector<HepMatrix> due to the misinterpretation
// b the compiler of:  HepMatrix T() const (compiler thinks this is a 
// conversion, wheras it is really makes the Tranpose!!!
//
//


namespace Atlfast {
  using std::valarray;
  using std::slice;

  class Matrix{
  private:
    valarray<double>* m_v;
    size_t m_d1, m_d2;
  public:
    Matrix(size_t x, size_t y);
    Matrix(size_t x, size_t y, double init);
    Matrix(const Matrix&);
    Matrix& operator=(const Matrix&);
    ~Matrix();
    
    size_t size() const {return m_d1*m_d2;}
    size_t dim1() const {return m_d1;}
    size_t dim2() const {return m_d2;}
    
    Slice_iter<double> row(size_t i);
    Cslice_iter<double> row(size_t i)const;

    Slice_iter<double> column(size_t i);
    Cslice_iter<double> column(size_t i)const;

    double& operator()(size_t x, size_t y);
    double operator()(size_t x, size_t y)const;

    Slice_iter<double> operator()(size_t i) {return column(i);}
    Cslice_iter<double> operator()(size_t i) const {return column(i);}

    Slice_iter<double> operator[](size_t i) {return column(i);}
    Cslice_iter<double> operator[](size_t i) const {return column(i);}

    Matrix& operator*=(double);

    valarray<double>& array() {return *m_v;}

    Matrix sub(int minRow,int maxRow,int minCol,int maxCol) const;
    void sub(int minRow, int minCol, Matrix& dest) const;
  };

  inline Slice_iter<double> Matrix::row(size_t i){
    return Slice_iter<double>(m_v, slice(i,m_d1,m_d2));
  }

  inline Cslice_iter<double> Matrix::row(size_t i) const {
    return Cslice_iter<double>(m_v, slice(i,m_d1,m_d2));
  }

  inline Slice_iter<double> Matrix::column(size_t i){
    return Slice_iter<double>(m_v, slice(i*m_d2,m_d2,1));
  }

  inline Cslice_iter<double> Matrix::column(size_t i) const {
    return Cslice_iter<double>(m_v, slice(i*m_d2,m_d2,1));
  }
}//namespace

#endif

---