src/colarray/matrix.h

Go to the documentation of this file.

/***************************************************************************
                          matrix.h  -  description
                             -------------------
    begin                : Mon Dec 15 2003
    copyright            : (C) 2003 by Roman Geus
    email                : roman.geus@psi.ch
***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   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.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef MATRIX_H
#define MATRIX_H

#include "vector.h"

namespace colarray {

    // declare friend operator before class: seems to be necessary for Borland C++
    template <typename T> class Matrix;
    template <typename T>
    std::ostream& operator << (std::ostream& , const Matrix<T> &);

    template <typename T>
    class Matrix {
    public:
        int_t _m, _n, _ld;
        T* _v;
    protected:
        T* _data;                      /* pointer to data array */
        int* _refCount;                /* pointer to reference counter */

    public:
        // constructors

        Matrix() : _m(0), _n(0), _ld(0), _v(NULL), _data(NULL), _refCount(new int(1))
        {}

        Matrix(int_t m, int_t n);

        inline Matrix(const Matrix&);

        inline Matrix(const Matrix<T>& A,
                      int_t i_start, int_t i_end,
                      int_t j_start, int_t j_end);

        //destructor
        ~Matrix();

        // index operators
        inline const T& operator () (int_t, int_t) const;
        inline T& operator () (int_t, int_t);

        // assignment operators
        inline Matrix& operator = (const Matrix&);
        inline T operator = (const T);
        inline Matrix& operator *= (T val);

        // methods
        void fill(const T v) {
            for(int_t j = 0; j < _n; j ++)
                for (int_t i = 0; i < _m; i ++)
                    this->operator()(i,j) = v;
        }
        void fill(const T v1, const T v2) {
            for(int_t j = 0; j < _n; j ++)
                for (int_t i = 0; i < _m; i ++)
                    this->operator()(i,j) = i == j ? v2 : v1;
        }
        void inject(const Matrix<T> &A);

        friend std::ostream& operator << <T> (std::ostream&, const Matrix<T> &);
        // friend class Vector<T>;
        friend class RowVector<T>;
        friend class ColumnVector<T>;

        const int& get_m() const
        { return _m; }
        const int& get_n() const
        { return _n; }
    }; // class

} // namespace


// #include "matrix.cpp"

/***************************************************************************
                          matrix.cpp  -  description
                             -------------------
    begin                : Mon Dec 15 2003
    copyright            : (C) 2003 by Roman Geus
    email                : roman.geus@psi.ch
***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   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.                                   *
 *                                                                         *
 ***************************************************************************/

#include "matrix.h"

namespace colarray {

    template <typename T>
    inline Matrix<T>::Matrix(int_t rows, int_t cols) :
        _m(rows), _n(cols), _ld(rows)
    {
        _refCount = new int(1);
        _v = _data = new T[rows*cols];
#if 0
        std::cout << std::showbase << std::hex << this->v << std::endl << std::dec;
#endif
    }

    template <typename T>
    inline Matrix<T>::Matrix(const Matrix& a) :
        _m(a._m), _n(a._n), _ld(a._ld), _v(a._v), _data(a._data), _refCount(a._refCount)
    { *_refCount += 1; }

    template <typename T>
    inline Matrix<T>::Matrix(const Matrix<T>& a,
                             int_t i_start, int_t i_end,
                             int_t j_start, int_t j_end) {
        _m = i_end - i_start;
        _n = j_end - j_start;
        _ld = a._ld;
        _v = a._v + i_start + j_start * _ld;
        _data = a._data;
        _refCount = a._refCount;
        *_refCount += 1;
    }

    template <typename T>
    inline Matrix<T>::~Matrix() {
        *_refCount -= 1;
        if (*_refCount < 1) {
            delete [] _data;
            delete _refCount;
        }
    }

    template <typename T>
    inline const T& Matrix<T>::operator () (int_t i, int_t j) const {
        return _v[i + j*_ld];
    }

    template <typename T>
    inline T& Matrix<T>::operator () (int_t i, int_t j) {
        return _v[i + j*_ld];
    }

    template <typename T>
    inline Matrix<T>& Matrix<T>::operator = (const Matrix<T>& a) {
        if (&a != this) {
            // remove ref to old matrix
            *_refCount -= 1;
            if (*_refCount < 1) {
                delete [] _data;
                delete _refCount;
            }
            // add ref to new matrix
            _m = a._m;
            _n = a._n;
            _ld = a._ld;
            _v = a._v;
            _data = a._data;
            _refCount = a._refCount;
            *_refCount += 1;
        }
        return *this;
    }

    template <typename T>
    inline T Matrix<T>::operator = (const T val) {
        for(int_t j = 0; j < _n; j ++)
            for (int_t i = 0; i < _m; i ++)
                this->operator()(i,j) = val;
        return val;
    }

    template <typename T>
    inline Matrix<T>& Matrix<T>::operator *= (T val) {
        for(int_t j = 0; j < _n; ++ j)
            for (int_t i = 0; i < _m; ++ i)
                this->operator()(i,j) *= val;
        return *this;
    }
  
    template <typename T>
    void Matrix<T>::inject(const Matrix<T> &A) {
        assert(_m == A._m && _n == A._n);
        for (int_t i = 0; i < _m; i ++)
            for (int_t j = 0; j < _n; j ++)
                this->operator()(i,j) = A(i,j);
    }


    template <typename T>
    std::ostream& operator << (std::ostream& ostr, const Matrix<T>& A)
    {
        ostr << "Matrix(" << A._m << "," << A._n << ") " ;
        ostr << "{";
        for (int_t i = 0; i < A._m; i ++) {
            if (i != 0)
                ostr << ", ";
            ostr << "{";
            for (int_t j = 0; j < A._n; j ++) {
                if (j != 0)
                    ostr << ", ";
                ostr << A(i,j);
            }
            ostr << "}";
        }
        ostr << "}";

        return ostr;
    }

} // namespace colarr


#endif

---