flatmatr.h

Go to the documentation of this file.

 
 
 
// Copyright (C) 1997-2020 by Pawel Pilarczyk.
//
// This file is part of my research software package. This 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 3 of the License, or (at your option) any later version.
//
// This software 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,
// please, see <https://www.gnu.org/licenses/>.
 
// 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_