chomp::homology::tCellVar< coordtype > Class Template Reference

This class defines cubical cell in R^n with edges parallel to the axes and with size 0 or 1 in each direction. More...

#include <cellvar.h>

Public Types
enum	OutputBitValues { BitProduct = 0x01 , BitSpace = 0x02 }
	Bit masks that define how to output the cell. More...
typedef coordtype	CoordType
	The type of the coordinates. More...
typedef tCubeVar< coordtype >::PointBase	PointBase
	The point base (for wrapping and tabulating coordinates). More...

Public Member Functions
	tCellVar ()
	The constructor of an empty cubical cell. More...
	tCellVar (const coordtype *c1, const coordtype *c2, int spcdim, int celldim=-1)
	The constructor of a cell spanning from one point to another. More...
	tCellVar (const tCubeVar< coordtype > &q1, const tCubeVar< coordtype > &q2)
	The constructor of a cell as an intersection of two cubes. More...
	tCellVar (const tCubeVar< coordtype > &q, int facedim)
	The constructor of an arbitrary k-dimensional face of a full cube. More...
	tCellVar (const tCubeVar< coordtype > &q)
	The constructor of a full-dimensional cubical cell. More...
	tCellVar (const tCellVar< coordtype > &q, int offset, int ncoords)
	The constructor of a projection of a cell to the given number of coordinates that start at the given offset. More...
	tCellVar (const tCellVar< coordtype > &c)
	The copy constructor. More...
tCellVar< coordtype > &	operator= (const tCellVar< coordtype > &c)
	The assignment operator. More...
int	dim () const
	Returns the dimension of the cubical cell. More...
int	spacedim () const
	Returns the dimension of the embedding space of the cubical cell. More...
coordtype *	leftcoord (coordtype *c) const
	Fills in the given table with the right corner coordinates. More...
coordtype *	rightcoord (coordtype *c) const
	Fills in the given table with the right corner coordinates. More...
int_t	hashkey1 () const
	Returns hashing key no. 1 required by the hashing set template. More...
int_t	hashkey2 () const
	Return shashing key no. 2 required by the hashing set template. More...

Static Public Member Functions
static const char *	name ()
	Returns the name of the objects represented by this class. More...
static const char *	pluralname ()
	Returns the plural name of the objects represented by this class. More...

Static Public Attributes
static const int	MaxDim
	The maximal dimension of a cell. More...
static const int	MaxSpaceDim = tCubeVar<coordtype>::MaxDim
	The maximal dimension of the embedding space of a cell. More...
static int	OutputBits = 0
	The output bits which determine how a cell is written. More...

Private Member Functions
void	initialize (const coordtype *c1, const coordtype *c2, int spcdim, int celldim=-1)
	Initializes a new cell given its two corners. More...

Private Attributes
coordtype *	tab
	The lower left etc. corner of the cell. More...
int_t	n
	High 6 bits = the dimension of the space. More...

Friends
int	operator== (const tCellVar< coordtype > &c1, const tCellVar< coordtype > &c2)
	Verifies if two cells are identical. More...

Detailed Description

template<class coordtype>
class chomp::homology::tCellVar< coordtype >

This class defines cubical cell in R^n with edges parallel to the axes and with size 0 or 1 in each direction.

In this implementation, an array is allocated for the coordinates of the minimal vertex of a cell.

Definition at line 67 of file cellvar.h.

Member Typedef Documentation

CoordType

template<class coordtype >

typedef coordtype chomp::homology::tCellVar< coordtype >::CoordType

The type of the coordinates.

Definition at line 71 of file cellvar.h.

PointBase

template<class coordtype >

typedef tCubeVar<coordtype>::PointBase chomp::homology::tCellVar< coordtype >::PointBase

The point base (for wrapping and tabulating coordinates).

Definition at line 82 of file cellvar.h.

Member Enumeration Documentation

OutputBitValues

template<class coordtype >

enum chomp::homology::tCellVar::OutputBitValues

Bit masks that define how to output the cell.

If 'BitProduct' is set, then the cell is displayed as a Cartesian product of intervals. Otherwise, it is indicated by two opposite vertices. If 'BitSpace' is set, the space is inserted in the output.

Enumerator
BitProduct
BitSpace

Definition at line 140 of file cellvar.h.

        {
                BitProduct = 0x01,      // unset => two vertices
                BitSpace = 0x02
        };

Constructor & Destructor Documentation

tCellVar() [1/7]

template<class coordtype >

chomp::homology::tCellVar< coordtype >::tCellVar

inline

The constructor of an empty cubical cell.

Definition at line 216 of file cellvar.h.

: tab (0), n (0)
{
        return;
} /* tCellVar::tCellVar */

tCellVar() [2/7]

template<class coordtype >

chomp::homology::tCellVar< coordtype >::tCellVar ( const coordtype *  c1, const coordtype *  c2, int  spcdim, int  celldim = -1  )

inline

The constructor of a cell spanning from one point to another.

Definition at line 223 of file cellvar.h.

{
        initialize (c1, c2, spcdim, celldim);
        return;
} /* tCellVar::tCellVar */

tCellVar() [3/7]

template<class coordtype >

chomp::homology::tCellVar< coordtype >::tCellVar ( const tCubeVar< coordtype > &  q1, const tCubeVar< coordtype > &  q2  )

inline

The constructor of a cell as an intersection of two cubes.

Definition at line 397 of file cellvar.h.

{
        // prepare tables for coordinates of the cubical cell
        coordtype left [MaxDim];
        coordtype right [MaxDim];
 
        // get the coordinates of minimal vertices of both cubes
        coordtype c1 [MaxDim];
        q1. coord (c1);
        coordtype c2 [MaxDim];
        q2. coord (c2);
 
        // get the dimension of the space and check for consistency
        int spcdim = q1. dim ();
        if (spcdim != q2. dim ())
                throw "Trying to intersect cubes of different dimension.";
 
        // calculate the coordinates of both vertices of the cubical cell
        // and the dimension of the cubical cell
        int celldim = 0;
        const coordtype *wrap = PointBase::getwrapping (spcdim);
        for (int i = 0; i < spcdim; ++ i)
        {
                if (c1 [i] == c2 [i])
                {
                        left [i] = c1 [i];
                        right [i] = c1 [i];
                        ++ right [i];
                        ++ celldim;
                }
                else if ((c1 [i] - c2 [i] == -1) || (wrap && wrap [i] &&
                        (c1 [i] - c2 [i] == wrap [i] - 1)))
                {
                        left [i] = c2 [i];
                        right [i] = c2 [i];
                }
                else if ((c1 [i] - c2 [i] == 1) || (wrap && wrap [i] &&
                        (c1 [i] - c2 [i] == -wrap [i] + 1)))
                {
                        left [i] = c1 [i];
                        right [i] = c1 [i];
                }
                else
                        throw "The cubes do not intersect.";
        }
 
        // initialize the data of the cube
        initialize (left, right, spcdim, celldim);
 
        return;
} /* tCellVar::tCellVar */

References chomp::homology::tPointBase< coordtype >::getwrapping().

tCellVar() [4/7]

template<class coordtype >

chomp::homology::tCellVar< coordtype >::tCellVar ( const tCubeVar< coordtype > &  q, int  facedim  )

inline

The constructor of an arbitrary k-dimensional face of a full cube.

Definition at line 474 of file cellvar.h.

{
        // get the coordinates of minimal vertex of the cube
        const coordtype *left = q. tab + 1;
 
        // prepare a table for coordinates of the other vertex of the cell
        coordtype right [MaxDim];
 
        // get the dimension of the space and of the cell
        int d = q. dim ();
 
        // calculate the coordinates of other vertex of the cell
        for (int i = 0; i < d; ++ i)
                right [i] = left [i] + ((i < facedim) ? 1 : 0);
 
        // initialize the cell
        initialize (left, right, d, facedim);
        return;
} /* tCellVar::tCellVar */

tCellVar() [5/7]

template<class coordtype >

chomp::homology::tCellVar< coordtype >::tCellVar ( const tCubeVar< coordtype > &  q )

inlineexplicit

The constructor of a full-dimensional cubical cell.

Definition at line 451 of file cellvar.h.

{
        // get the coordinates of minimal vertex of the cube
        const coordtype *left = q. tab + 1;
 
        // get the dimension of the space and of the cell
        int d = q. dim ();
 
        // prepare a table for coordinates of the other vertex of the cell
        coordtype right [MaxDim];
 
        // calculate the coordinates of other vertex of the cell
        for (int i = 0; i < d; ++ i)
                right [i] = left [i] + 1;
 
        // initialize the cell
        initialize (left, right, d, d);
        return;
} /* tCellVar::tCellVar */

tCellVar() [6/7]

template<class coordtype >

chomp::homology::tCellVar< coordtype >::tCellVar ( const tCellVar< coordtype > &  q, int  offset, int  ncoords  )

inline

The constructor of a projection of a cell to the given number of coordinates that start at the given offset.

Definition at line 249 of file cellvar.h.

{
        int spcdim = static_cast<int> (q. n >> NumBits);
        if ((offset < 0) || (ncoords <= 0) || (offset + ncoords > spcdim))
                throw "Wrong cell projection requested.";
        coordtype right [MaxDim];
        q. rightcoord (right);
        initialize (q. tab + offset, right + offset, ncoords);
//      *** More efficient [unfinished, yet] ***
//      tab = new coordtype [spcdim];
//      if (!tab)
//              throw "Not enough memory to create a projected cell.";
//      for (int i = 0; i < spcdim; ++ i)
//              tab [i] = q. tab [i];
//      [...]
        return;
} /* tCellVar::tCellVar */

References chomp::homology::NumBits.

tCellVar() [7/7]

template<class coordtype >

chomp::homology::tCellVar< coordtype >::tCellVar ( const tCellVar< coordtype > &  c )

inline

The copy constructor.

Definition at line 269 of file cellvar.h.

{
        n = q. n;
        tab = new coordtype [spacedim ()];
        if (!tab)
                throw "Not enough memory to copy a cubical cell.";
        copycoord (tab, q. tab, spacedim ());
        return;
} /* tCellVar::tCellVar */

References chomp::homology::copycoord().

Member Function Documentation

dim()

template<class coordtype >

int chomp::homology::tCellVar< coordtype >::dim

inline

Returns the dimension of the cubical cell.

Definition at line 231 of file cellvar.h.

{
        int count = 0;
        for (int i = 0; i < NumBits; ++ i)
        {
                if (n & (static_cast<int_t> (1) << i))
                        ++ count;
        }
        return count;
} /* tCellVar::dim */

References chomp::homology::NumBits.

hashkey1()

template<class coordtype >

int_t chomp::homology::tCellVar< coordtype >::hashkey1

inline

Returns hashing key no. 1 required by the hashing set template.

Definition at line 331 of file cellvar.h.

{
        switch (spacedim ())
        {
        case 0:
                return 0;
        case 1:
                return (static_cast<int_t> (tab [0]) << 12) ^ n;
        case 2:
                return (((static_cast<int_t> (tab [0])) << 18) +
                        ((static_cast<int_t> (tab [1])) << 6)) ^ n;
        default:
                return (((static_cast<int_t> (tab [0])) << 18) +
                        ((static_cast<int_t> (tab [1])) << 6) +
                        ((static_cast<int_t> (tab [2])) >> 6)) ^ n;
        }
} /* tCellVar::hashkey1 */

hashkey2()

template<class coordtype >

int_t chomp::homology::tCellVar< coordtype >::hashkey2

inline

Return shashing key no. 2 required by the hashing set template.

Definition at line 356 of file cellvar.h.

{
        int d = spacedim ();
        switch (d)
        {
        case 0:
                return 0;
        case 1:
                return (static_cast<int_t> (tab [0]) << 3) ^ (n << 5);
        case 2:
                return ((static_cast<int_t> (tab [0]) >> 1) +
                        (static_cast<int_t> (tab [1]) << 13)) ^ (n << 5);
        default:
                return (((static_cast<int_t> (tab [d - 1])) << 20) +
                        ((static_cast<int_t> (tab [d - 2])) << 9) +
                        ((static_cast<int_t> (tab [d - 3])) >> 1)) ^
                        (n << 5);
        }
} /* tCellVar::hashkey2 */

initialize()

template<class coordtype >

void chomp::homology::tCellVar< coordtype >::initialize ( const coordtype *  c1, const coordtype *  c2, int  spcdim, int  celldim = -1  )

inlineprivate

Initializes a new cell given its two corners.

Definition at line 182 of file cellvar.h.

{
        // test the validity of the dimension
        if (spcdim <= 0)
                throw "Non-positive dimension of the space.";
        else if (spcdim >= MaxDim)
                throw "Too high dimension of a cell.";
 
        // initialize the internal number with the space dimension
        n = static_cast<int_t> (spcdim) << NumBits;
 
        // prepare a table for coordinates if necessary
        tab = new coordtype [spcdim];
        if (!tab)
                throw "Not enough memory to create a cell.";
 
        // copy the left corner coordinates to the cell
        PointBase::wrapcopy (tab, c1, spcdim);
 
        // prepare wrapped right coordinates for the detection of cell bits
        coordtype r [MaxDim];
        PointBase::wrapcopy (r, c2, spcdim);
 
        // set the bits of the cell
        for (int i = 0; i < spcdim; ++ i)
        {
                if (tab [i] != r [i])
                        n |= (static_cast<int_t> (1) << i);
        }
        return;
} /* tCellVar::initialize */

References chomp::homology::NumBits, and chomp::homology::tPointBase< coordtype >::wrapcopy().

leftcoord()

template<class coordtype >

coordtype * chomp::homology::tCellVar< coordtype >::leftcoord ( coordtype *  c ) const

inline

Fills in the given table with the right corner coordinates.

Definition at line 304 of file cellvar.h.

{
        if (!c)
                throw "Null pointer to save left coordinates.";
        int d = spacedim ();
        for (int i = 0; i < d; ++ i)
                c [i] = tab [i];
        return c;
} /* tCellVar::leftcoord */

name()

template<class coordtype >

const char * chomp::homology::tCellVar< coordtype >::name

static

Returns the name of the objects represented by this class.

Definition at line 383 of file cellvar.h.

{
        return "cubical cell";
} /* tCellVar::name */

operator=()

template<class coordtype >

tCellVar< coordtype > & chomp::homology::tCellVar< coordtype >::operator= ( const tCellVar< coordtype > &  c )

inline

The assignment operator.

Definition at line 280 of file cellvar.h.

{
        // determine the new dimension
        int d = q. spacedim ();
 
        // allocate a new table if the dimension is to be changed
        if (d != spacedim ())
        {
                if (tab)
                        delete [] tab;
                tab = new coordtype [d];
                if (!tab)
                        throw "Not enough memory to copy a cubical cell.";
        }
 
        // copy the data of the cubical cell
        copycoord (tab, q. tab, d);
        n = q. n;
 
        return *this;
} /* tCellVar::operator = */

References chomp::homology::copycoord().

pluralname()

template<class coordtype >

const char * chomp::homology::tCellVar< coordtype >::pluralname

static

Returns the plural name of the objects represented by this class.

Definition at line 389 of file cellvar.h.

{
        return "cubical cells";
} /* tCellVar::pluralname */

rightcoord()

template<class coordtype >

coordtype * chomp::homology::tCellVar< coordtype >::rightcoord ( coordtype *  c ) const

inline

Fills in the given table with the right corner coordinates.

Definition at line 315 of file cellvar.h.

{
        if (!c)
                throw "Null pointer to save right coordinates.";
        int d = spacedim ();
        for (int i = 0; i < d; ++ i)
        {
                c [i] = tab [i];
                if (n & (static_cast<int_t> (1) << i))
                        ++ (c [i]);
        }
        PointBase::wrapcoord (c, d);
        return c;
} /* tCellVar::rightcoord */

References chomp::homology::tPointBase< coordtype >::wrapcoord().

spacedim()

template<class coordtype >

int chomp::homology::tCellVar< coordtype >::spacedim

inline

Returns the dimension of the embedding space of the cubical cell.

Definition at line 243 of file cellvar.h.

{
        return static_cast<int> (n >> NumBits);
} /* tCellVar::spacedim */

References chomp::homology::NumBits.

Friends And Related Function Documentation

operator==

template<class coordtype >

int operator== ( const tCellVar< coordtype > &  c1, const tCellVar< coordtype > &  c2  )

friend

Verifies if two cells are identical.

Definition at line 152 of file cellvar.h.

        {
                return ((c1. n == c2. n) && ((c1. n == 0) ||
                        thesame (c1. tab, c2. tab, c1. spacedim ())));
        } /* operator == */

Member Data Documentation

MaxDim

template<class coordtype >

const int chomp::homology::tCellVar< coordtype >::MaxDim

static

Initial value:

= 
                (tCubeVar<coordtype>::MaxDim < MaxBasDim) ?
                tCubeVar<coordtype>::MaxDim : MaxBasDim

The maximal dimension of a cell.

Definition at line 74 of file cellvar.h.

MaxSpaceDim

template<class coordtype >

const int chomp::homology::tCellVar< coordtype >::MaxSpaceDim = tCubeVar<coordtype>::MaxDim

static

The maximal dimension of the embedding space of a cell.

Definition at line 79 of file cellvar.h.

n

template<class coordtype >

int_t chomp::homology::tCellVar< coordtype >::n

private

High 6 bits = the dimension of the space.

Remaining bits set to 1 iff the cell has width 1 in the specified direction.

Definition at line 166 of file cellvar.h.

OutputBits

template<class coordtype >

int chomp::homology::tCellVar< coordtype >::OutputBits = 0

static

The output bits which determine how a cell is written.

Definition at line 147 of file cellvar.h.

tab

template<class coordtype >

coordtype* chomp::homology::tCellVar< coordtype >::tab

private

The lower left etc. corner of the cell.

Definition at line 161 of file cellvar.h.

---

The documentation for this class was generated from the following file:

• chomp/cubes/cellvar.h