flatmatr.h

Go to the documentation of this file.

// Copyright (C) 1997-2010 by Pawel Pilarczyk.
//
// This file is part of the Homology Library.  This library 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.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this software; see the file "license.txt".  If not, write to the
// Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
// MA 02111-1307, USA.

// Started on August 25, 2006. Last revision: October 8, 2008.


#ifndef _CHOMP_STRUCT_FLATMATR_H_
#define _CHOMP_STRUCT_FLATMATR_H_

#include <new>

namespace chomp {
namespace homology {


// --------------------------------------------------
// ------------------ FLAT MATRIX -------------------
// --------------------------------------------------

template <class element>
class flatMatrix
{
public:
        flatMatrix (int size): n (size), tab (new element [n * n]) {return;}

        flatMatrix (const flatMatrix<element> &M):
                n (M. n), tab (new element [n * n])
        {
                int memSize = n * n;
                for (int i = 0; i < memSize; ++ i)
                        tab [i] = M. tab [i];
                return;
        }

        flatMatrix &operator = (const flatMatrix<element> &M)
        {
                if (n != M. n)
                        throw "Different matrix sizes in operator =.";
                int memSize = n * n;
                for (int i = 0; i < memSize; ++ i)
                        tab [i] = M. tab [i];
                return *this;
        }

        ~flatMatrix () {delete [] tab;}

        class row
        {
        public:
                row (int _offset, element *_v):
                        offset (_offset), v (_v) {}

                element &operator [] (int j) {return v [offset + j];}

        protected:
                int offset;

                element *v;
        };

        row operator [] (int i)
                {return row (n * i, tab);}

        class const_row
        {
        public:
                const_row (int _offset, const element *_v):
                        offset (_offset), v (_v) {}

                const element &operator [] (int m) {return v [offset + m];}

        protected:
                int offset;

                const element *v;
        };

        const_row operator [] (int i ) const
                {return const_row (n * i, tab);}

        void clear (const element &elem)
        {
                int size = n * n;
                for (int i = 0; i < size; ++ i)
                        tab [i] = elem;
                return;
        }

        void swap (flatMatrix<element> &M)
        {
                int this_n = n;
                element *this_tab = tab;
                n = M. n;
                tab = M. tab;
                M. n = this_n;
                M. tab = this_tab;
                return;
        }

        const element *memory () const {return tab;}

        element *memory () {return tab;}

protected:
        int n;

        element *tab;

}; /* class flatMatrix */


} // namespace homology
} // namespace chomp

#endif // _CHOMP_STRUCT_FLATMATR_H_