chomp::homology::reduction0 Namespace Reference

Functions
template<class tCube , class tVerify >
int_t	cubreducequiet (const hashedset< tCube > &maincset, hashedset< tCube > &cset, hashedset< tCube > &other, const hashedset< tCube > &keep, const tVerify &verify, bool quiet=true)
	Reduces a pair of sets of cubes for relative homology computation. More...
template<class tCube , class tVerify >
int_t	cubexpand (hashedset< tCube > &cset, hashedset< tCube > &other, const tVerify &verify, bool quiet=false)
	Expands the set 'other' towards 'cset' without changing the homology of (cset + other, other). More...

Function Documentation

cubexpand()

template<class tCube , class tVerify >

int_t chomp::homology::reduction0::cubexpand	(	hashedset< tCube > &	cset,
		hashedset< tCube > &	other,
		const tVerify &	verify,
		bool	quiet = false
	)

Expands the set 'other' towards 'cset' without changing the homology of (cset + other, other).

The two sets must be disjoint. Use an externally defined additional criterion for the verification if the cubes that look good for removal are actually allowed to be removed.

Definition at line 239 of file cubired0.h.

{
        // if the case is trivial, return the answer
        if (cset. empty () || other. empty ())
                return 0;
 
        // remember the initial number of cubes in the main set
        int_t prev = cset. size ();
 
        // determine the space dimension
        int dim = cset [0]. dim ();
 
        // compute the maximal number of neighbors of a cube
        int_t maxneighbors = getmaxneighbors (dim);
 
        // prepare a bitfield and allocate it if necessary
        static BitField b;
        static int_t _maxneighbors = 0;
        static auto_array<unsigned char> buffer;
        if (maxneighbors != _maxneighbors)
        {
                _maxneighbors = maxneighbors;
                buffer. reset (new unsigned char [(maxneighbors + 7) >> 3]);
                b. define (buffer. get (), maxneighbors);
        }
 
        // prepare a counter for displaying the progress of computations
        int_t count = 0;
 
        // repeat scanning cubes until no change can be made
        while (1)
        {
                // remember if any changes were made in this round
                bool modified (false);
 
                // go through the main set, and move cubes to the other set
                // if this doesn't change the homology
                for (int_t i = 0; i < cset. size (); ++ i)
                {
                        // show progress indicator
                        ++ count;
                        if (!quiet && !(count % 373))
                                scon << std::setw (10) << count <<
                                        "\b\b\b\b\b\b\b\b\b\b";
 
                        // take a cube from 'cset'
                        const tCube &c = cset [i];
 
                        // clear the neighborbits
                        b. clearall (maxneighbors);
 
                        // if the neighborhood of the cube is not acyclic, skip it
                        if (!acyclic (c, dim, other, &b, maxneighbors))
                                continue;
 
                        // verify if moving this cube to 'other' is allowed
                        if (!verify (c, cset, other))
                                continue;
 
                        // move the cube to the other set
                        modified = true;
                        if (!quiet)
                                sseq << "L\n" << '2' << c << '\n';
                        other. add (c);
                        cset. removenum (i);
                        -- i;
                }
 
                // if the sets were not modified then quit the loop
                if (!modified)
                        break;
        }
 
        // return the number of cubes removed from 'cset'
        return prev - cset. size ();
} /* cubexpand */

References chomp::homology::acyclic(), chomp::homology::getmaxneighbors(), chomp::homology::scon, and chomp::homology::sseq.

cubreducequiet()

template<class tCube , class tVerify >

int_t chomp::homology::reduction0::cubreducequiet	(	const hashedset< tCube > &	maincset,
		hashedset< tCube > &	cset,
		hashedset< tCube > &	other,
		const hashedset< tCube > &	keep,
		const tVerify &	verify,
		bool	quiet = true
	)

Reduces a pair of sets of cubes for relative homology computation.

The pair is (maincset + cset + other, other), where the cubes in maincset are not to be removed (this is like the "core" of the pair that should be fixed),, the cubes in cset and other are to be considered for removal and could be removed if this is found feasible. The sets maincset + cset and other are disjoint. Does not remove any cubes that are listed in the set keep. Does additional verification, e.g., makes sure that the acyclicity of the given map is preserved. If 'quiet' is set to true then suppresses any messages. Returns the number of cubes removed from both sets.

Definition at line 84 of file cubired0.h.

{
        // remember the initial number of cubes in both sets
        int_t prev = cset. size () + other. size ();
 
        // if the case is trivial, return the answer
        if (maincset. empty () && cset. empty ())
        {
                if (!other. empty ())
                {
                        hashedset<tCube> empty;
                        other = empty;
                }
                return prev;
        }
 
        // determine the space dimension
        int dim = (cset. empty ()) ? maincset [0]. dim () :
                cset [0]. dim ();
 
        // compute the maximal number of neighbors of a cube
        int_t maxneighbors = getmaxneighbors (dim);
 
        // prepare a bitfield for storing neighborhood configurations
        // and allocate the buffer if necessary (this is a static variable)
        static BitField b;
        static int_t _maxneighbors = 0;
        static auto_array<unsigned char> buffer;
        if (maxneighbors != _maxneighbors)
        {
                _maxneighbors = maxneighbors;
                buffer. reset (new unsigned char [(maxneighbors + 7) >> 3]);
                b. define (buffer. get (), maxneighbors);
        }
 
        // prepare a counter for displaying the progress of computations
        int_t count = 0;
 
        // repeat scanning cubes until no change can be made
        while (1)
        {
                // remember if any changes were made in this round
                bool modified (false);
 
                // scan all the cubs in both sets
                for (int_t i = 0; i < cset. size () + other. size (); ++ i)
                {
                        // show the progress indicator
                        ++ count;
                        if (!quiet && !(count % 373))
                                scon << std::setw (10) << count <<
                                        "\b\b\b\b\b\b\b\b\b\b";
 
                        // is this cube from the other set?
                        bool is_other (i >= cset. size ());
 
                        // determine the cube corresponding to the index
                        const tCube &c (is_other ?
                                other [i - cset. size ()] : cset [i]);
 
                        // if this cube is to be kept then skip it
                        if (keep. check (c))
                                continue;
 
                        // clean the neighborbits
                        b. clearall (maxneighbors);
 
                        // if this cube belongs to the other set...
                        if (is_other)
                        {
                                // no neighbors need to be remembered
                                hashedset<tCube> *no_neighbors (0);
 
                                // check if this cube can be removed
                                if (!acyclic_rel (c, dim,
                                        makesetunion (maincset, cset),
                                        other, &b, maxneighbors,
                                        no_neighbors, no_neighbors))
                                {
                                        continue;
                                }
 
                                // verify if the removal of the cube from A is OK
                                if (!verify (c, other))
                                        continue;
 
                                // verify if the removal of the cube from X is OK
                                if (!verify (c, makesetunion (maincset,
                                        makesetunion (other, cset))))
                                {
                                        continue;
                                }
 
                                // remove the cube from the other set
                                modified = true;
                                if (!quiet)
                                        sseq << '0' << c << '\n';
                                other. removenum (i - cset. size ());
                                -- i;
                        }
 
                        // otherwise, if this cube belongs to 'cset'...
                        else
                        {
                                // no neighbors need to be remembered
                                hashedset<tCube> *no_neighbors (0);
 
                                // if the neighborhood of the cube
                                // is not acyclic then skip the cube
                                if (!acyclic (c, dim, makesetunion (maincset,
                                        makesetunion (cset, other)),
                                        &b, maxneighbors, no_neighbors))
                                {
                                        continue;
                                }
 
                                // verify if the removal of the cube from X is OK
                                if (!verify (c, makesetunion (maincset,
                                        makesetunion (cset, other))))
                                {
                                        continue;
                                }
 
                                // remove the cube from 'cset'
                                modified = true;
                                if (!quiet)
                                        sseq << '0' << c << '\n';
                                cset. removenum (i);
                                -- i;
                        }
                }
 
                // if the sets were not modified then quit the loop
                if (!modified)
                        break;
        }
 
        // return the number of cubes removed from both sets
        return prev - cset. size () - other. size ();
} /* cubreducequiet */

References chomp::homology::acyclic(), chomp::homology::acyclic_rel(), chomp::homology::getmaxneighbors(), chomp::homology::makesetunion(), chomp::homology::scon, and chomp::homology::sseq.