main page namespaces classes files
ELL home

src/ell/IterableNeighbors.cc

Go to the documentation of this file.

#include "ell/IterableNeighbors.hh"
#include <biu/assertbiu.hh>
#include <algorithm>
#include "biu/RandomNumberFactory.hh"

namespace ell {
    
    SuccessiveNeighborList::SuccessiveNeighborList(const IterableNeighbors* source_)
     :  source(source_)
    { }
    
    SuccessiveNeighborList::~SuccessiveNeighborList() 
    {}
  
    State*
    SuccessiveNeighborList::next(State::NeighborList::ItState *itstate, State* const elem) const 
    {
        assertbiu(elem != NULL, "Elem is not allowed to be NULL");
        assertbiu(itstate != NULL, "no itstate given (NULL)");

        ItState* myitstate = static_cast<ItState*>(itstate);
        assertbiu(myitstate->idx < source->getNeighborNumber(), "call is too late");
        
        do {
            // undo last move
            source->undoNeighborChange(myitstate->idx, elem);
            // update itstate and perform next move
            myitstate->idx++;
            // if new neighbor is valid and available
        } while (   myitstate->idx < source->getNeighborNumber()
                    && source->applyNeighborChange(myitstate->idx, elem) == NULL); 
        if ( myitstate->idx < source->getNeighborNumber())
            return elem;
        else {
            return NULL;
        }
    }

    State* 
    SuccessiveNeighborList::first(State::NeighborList::ItState** itstate) const 
    {
        assertbiu(itstate != NULL, "itstate is not allowed to be NULL");
        if (*itstate != NULL) delete *itstate;

        ItState* myitstate = new ItState();
        *itstate = myitstate;
        
        State* firstNeigh = NULL;
        myitstate->idx = 0;
          // find first valid neighbor
        while(  myitstate->idx < source->getNeighborNumber()
                && (firstNeigh = source->getNeighbor(myitstate->idx,firstNeigh)) == NULL) 
        {
            myitstate->idx++;
        }
        if (myitstate->idx < source->getNeighborNumber())
            return firstNeigh;
        else {
            return NULL;
        }
    }
    
    
} // namespace


namespace ell {
    
    RandomNeighborList::RandomNeighborList(const IterableNeighbors* source_)
     :  source(source_), idx2apply(source_->getNeighborNumber(),0)
    {
          // initialize index array
        for(size_t i=0; i < idx2apply.size(); i++) {
            idx2apply[i] = i;
        }
          // shuffle index array using biu::RNF random number generator
        std::random_shuffle<std::vector<size_t>::iterator>
            (idx2apply.begin(), idx2apply.end(), biu::RNF::pt_getRN);
    }
    
    RandomNeighborList::~RandomNeighborList() 
    {}
  
    State*
    RandomNeighborList::next(State::NeighborList::ItState *itstate, State* elem) const 
    {
        assertbiu(elem != NULL, "Elem is not allowed to be NULL");

        ItState* myitstate = static_cast<ItState*>(itstate);
        
        do {
            // undo last move
            source->undoNeighborChange(idx2apply[myitstate->pos], elem);
            // update itstate and perform next move
            myitstate->pos++;
            // if new neighbor is valid and available
        } while (   myitstate->pos < idx2apply.size()
                    && source->applyNeighborChange(idx2apply[myitstate->pos], elem) == NULL);
        
        if ( myitstate->pos < idx2apply.size())
            return elem;
        else {
            return NULL;
        }
    }

    State* 
    RandomNeighborList::first(State::NeighborList::ItState** itstate) const 
    {
        assertbiu(itstate != NULL, "itstate is not allowed to be NULL");
        if (*itstate != NULL) delete *itstate;

        ItState* myitstate = new ItState();
        *itstate = myitstate;
        
        State* firstNeigh = NULL;
        
        myitstate->pos = 0;
          // find first valid neighbor
        while(  myitstate->pos < idx2apply.size()
                && (firstNeigh = source->getNeighbor(idx2apply[myitstate->pos],firstNeigh)) == NULL) 
        {
            myitstate->pos++;
        }
        if (myitstate->pos < idx2apply.size())
            return firstNeigh;
        else {
            return NULL;
        }
    }
    
    
} // namespace