tabulate.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 in January 2002. Last revision: June 2, 2007.
 
 
#ifndef _CHOMP_HOMOLOGY_TABULATE_H_
#define _CHOMP_HOMOLOGY_TABULATE_H_
 
#include "chomp/system/config.h"
#include "chomp/system/textfile.h"
 
#include <iostream>
#include <fstream>
#include <cstdlib>
 
namespace chomp {
namespace homology {
 
class Tabulated
{
public:
        Tabulated ();
 
        ~Tabulated ();
 
        int read (int dim, const char *filename);
 
        int write (int dim, const char *filename) const;
 
        int compute (int dim);
 
        int define (int dim, char *buffer);
 
        const char *operator [] (int dim) const;
 
        static int get (const char *table, int_t bitnumber);
 
        static void set (char *table, int_t bitnumber);
 
private:
        static const int maxdim = 8;
 
        char *tables [maxdim];
 
        bool deallocate [maxdim];
 
        int size [maxdim];
        
}; /* Tabulated */
 
// --------------------------------------------------
 
inline int Tabulated::define (int dim, char *buffer)
{
        if ((dim <= 0) || (dim >= maxdim))
                return -1;
        if (tables [dim] && deallocate [dim])
        {
                delete [] (tables [dim]);
                deallocate [dim] = false;
        }
        tables [dim] = buffer;
        return 0;
} /* Tabulated::define */
 
inline const char *Tabulated::operator [] (int dim) const
{
        if ((dim <= 0) || (dim >= maxdim))
                return 0;
        else
                return tables [dim];
} /* Tabulated::operator [] */
 
inline int Tabulated::get (const char *table, int_t bitnumber)
{
        if (table [bitnumber >> 3] & (1 << (bitnumber & 0x07)))
                return 1;
        else
                return 0;
} /* Tabulated::get */
 
inline void Tabulated::set (char *table, int_t bitnumber)
{
        table [bitnumber >> 3] |=
                static_cast<char> (1 << (bitnumber & 0x07));
        return;
} /* Tabulated::set */
 
// --------------------------------------------------
 
extern Tabulated tabulated;
 
 
} // namespace homology
} // namespace chomp
 
#endif // _CHOMP_HOMOLOGY_TABULATE_H_