main page namespaces classes files
ELL home

src/ell/S_Explicit.cc

Go to the documentation of this file.

#include "ell/S_Explicit.hh"

#include <sstream>
#include <iomanip>

#include <biu/RandomNumberFactory.hh>

namespace ell
{
    const std::string S_Explicit::ID = std::string("ell::S_Explicit");
    const biu::Alphabet S_Explicit::numberAlph = biu::Alphabet(std::string("0123456789"),1);

    
    S_Explicit::S_Explicit( const LandscapeGraph* lg_
                            , const size_t nodeIndex_ )
     :  lg(lg_)
        , nodeIndex(nodeIndex_)
        , sRepLength(0)
    {
        assertbiu( lg != NULL, "no LandscapeGraph given (==NULL)");
        assertbiu( nodeIndex < lg->nodes(), "node index out of range");
          // get minimal string representation length 
        std::ostringstream os;
        os <<lg->nodes();
          // == length of highest node index string
        sRepLength = os.str().size();
    }
    
    S_Explicit::~S_Explicit()
    {
    }
    
    const std::string & 
    S_Explicit::getID( void ) const {
        return S_Explicit::ID; 
    }

      // How many neighbor indices are accessible.
      // @return the number of neighbors
    size_t 
    S_Explicit::
	getNeighborNumber(void) const
    {
        return lg->degree(nodeIndex);
    }
    
    bool
    S_Explicit::
	operator== (const State& state2) const 
    {
        const S_Explicit*const s2 = dynamic_cast<const S_Explicit* const>(&state2);
        assertbiu(s2 != NULL, "given state to compare to is no S_Explicit instance");
          // check
        return (this->nodeIndex == s2->nodeIndex);
    }
    bool
    S_Explicit::
	operator!= (const State& state2) const
    {
        const S_Explicit*const s2 = dynamic_cast<const S_Explicit* const>(&state2);
        assertbiu(s2 != NULL, "given state to compare to is no S_Explicit instance");
          // check
        return (this->nodeIndex != s2->nodeIndex);
    }
    
        /* Implements a unique order on states based on their energy and
         * string representation. A state is smaller than another one iff
         * it has smaller energy or it has equal energy and a 
         * lexicographically smaller string representation (tie breaker).
         * 
         * This function will be overwritten to achive a better performance
         * than calling getEnergy() and getString().
         * 
         * If the energy function is non-degenerate the string comparison
         * is obsolete.
         * 
         * @param state2 the State object to compare to
         * @return true if this state is smaller than state2 according to 
         *         the unique order of the states
         */
    bool
    S_Explicit::
	operator< (const State& state2) const
    {
        const S_Explicit*const s2 = dynamic_cast<const S_Explicit* const>(&state2);
        assertbiu(s2 != NULL, "given state to compare to is no S_Explicit instance");
          // check
        const double e1 = this->getEnergy();
        const double e2 = s2->getEnergy(); 
        return ( e1 < e2 || ( e1 == e2 && this->toString().compare(s2->toString()) < 0 ));
    }
    

    
        /* Returns the state specific energy. */
    double
    S_Explicit::
	getEnergy() const
    {
        return lg->getNodeEnergy(nodeIndex);
    }

    
        /* Returns the minimal number of steps via valid
         *  neighbored states from this to another valid State.
         *  @param state2 the State to reach
         */
    unsigned int
    S_Explicit::
	getMinimalDistance(const State& state2) const
    {
        return 0;
    }

    
        /* Returns a pointer to a clone of the current state. */
    S_Explicit*
    S_Explicit::
	clone(State* toFill) const
    {
        if (toFill == NULL) {
            return new S_Explicit( lg, nodeIndex );
        }
          // cast toFill
        assertbiu( dynamic_cast<S_Explicit*>(toFill) != NULL
                    , "given State is no S_Explicit instance");
        S_Explicit* s = static_cast<S_Explicit*>(toFill);
        
          // copy data
        s->lg = this->lg;
        s->nodeIndex = this->nodeIndex;
        s->sRepLength = this->sRepLength;
        
        return s;
    }
    
        /* Returns a new State based on the current state. The new state
         *  differs only by the information given by stringRep. */
    State* 
    S_Explicit::
	fromString(const std::string& stringRep) const {
        assertbiu(stringRep.size() > 0, "given string representation is empty");
          // parse index from stream
        std::istringstream is (stringRep);
        size_t idx = UINT_MAX;
        is >> idx;
        assertbiu(idx != UINT_MAX, "could not read node index from string representation");
          // create new state
        return new S_Explicit( lg, idx );
    }
    
        /* Returns a specific std::string representation of this
         *  State.
         */
    std::string 
    S_Explicit::
	toString() const {
        std::ostringstream os;
        os  <<std::setw(sRepLength) // the length of the string representation
            <<std::setfill('0')     // the leading fill character for shorter indices
            <<nodeIndex;            // the index
        return os.str();
    }
    
        /* Fill the given string with a specific std::string 
         * representation of this State.
         * @param toFill the string to overwrite
         * @return the changed toFill in parameter
         */
    std::string& 
    S_Explicit::
	toString( std::string & toFill ) const {
          // no the best way but easiest ....
        toFill = toString();
        return toFill;
    }
    


    // neighborhood
        /* Returns a list of all VALID neighbored states in
         *  the energy landscape in a specific order.
         */
    State::NeighborListPtr 
    S_Explicit::
	getNeighborList() const {
        return NeighborListPtr(new SuccessiveNeighborList(this));
    }

        /* Returns a list of all VALID neighbored states in
         *  the energy landscape in a random order.
         *  If a state is given, this is changed to a neighbor.
         */
    State::NeighborListPtr 
    S_Explicit::
	getRandomNeighborList() const  {
        return NeighborListPtr(new RandomNeighborList(this));
    }

        /* Returns a VALID random neighbored state.
         *  If a state is given, this is changed to a neighbor.
         */
    State* 
    S_Explicit::
	getRandomNeighbor(State* inPlaceNeigh ) const {
          // get random neighbor index
        size_t pos = biu::RNF::getRN(this->getNeighborNumber());
          // generate random neighbor 
        return getNeighbor( pos, inPlaceNeigh );

    }
    
    
        /* Access to a compressed sequence representation of the state.
         * @return the compressed sequence representation
         */
    CSequence 
    S_Explicit::
	compress(void) const {
          // compress string representation
        return numberAlph.compressS(this->toString());
    }
    
        /* Access to a compressed sequence representation of the state.
         * @param toFill a data structure to write the compressed 
         *               representation too
         * @return the compressed sequence representation
         */
    CSequence& 
    S_Explicit::
	compress(CSequence& toFill) const {
          // compress
        toFill = this->compress();
        return toFill;
    }
    
        /* Uncompresses a compressed sequencce representation into a new
         * State object.
         * @param cseq the compressed sequence representation of a state
         * @param toFill a state object to uncompress too or NULL if a new 
         *               object has to be created
         * @return new State object that is encoded in cseq or NULL in error
         *         case.
         */
    State* 
    S_Explicit::
	uncompress(const CSequence& cseq, State* toFill ) const {
        assertbiu(cseq.size()>0, "no compressed sequence given (size==0)");
          // create return value
        S_Explicit* ret = NULL;
        if (toFill == NULL) {
            ret = new S_Explicit( lg, nodeIndex );
        } else {
            ret = dynamic_cast<S_Explicit*>(toFill);
            assertbiu(ret != NULL, "given state toFill is no S_Explicit instance");
            ret->lg = lg;
        }
          // parse and set index
        std::istringstream is( numberAlph.decompressS(cseq, sRepLength) );
        ret->nodeIndex = UINT_MAX;
        is >> ret->nodeIndex;
        assertbiu(ret->nodeIndex != UINT_MAX, "could not parse node index from compressed string representation");
          // create state
        return ret;
    }
    
        /* Uncompresses a compressed sequencce representation into a this
         * State object.
         * @param cseq the compressed sequence representation of a state
         * @return this or NULL in error case
         */
    State* 
    S_Explicit::
	uncompress(const CSequence& cseq) {
        assertbiu(cseq.size()>0, "no compressed sequence given (size==0)");
          // parse index
        std::istringstream is( numberAlph.decompressS(cseq, sRepLength) );
        size_t idx = UINT_MAX;
        is >> idx;
        assertbiu(idx != UINT_MAX, "could not parse node index from compressed string representation");
          // check for parsing error
        if (idx==UINT_MAX)
            return NULL;
          // set index
        nodeIndex = idx;
          // create state
        return this;
    }
    
    
      // Access to a specific neighbor.
      // @param index the index of the neighbor in [0, getNeighborNumber())
      // @param neigh if != NULL this state should be converted into the 
      //              neighbor otherwise a new one is created and returned
      // @return the new neighbor state or NULL if the index is >= 
      // getNeighborNumber()
    State* 
    S_Explicit::
	getNeighbor(const size_t index, State* neigh) const {
          // set up state to return
        S_Explicit * ret = NULL;
        if (neigh == NULL) {
            ret = new S_Explicit( lg, nodeIndex );
        } else {
            ret = dynamic_cast<S_Explicit*>(neigh);
            assertbiu(ret != NULL, "the given neigh State is no S_Explicit instance");
            ret->lg = lg;
        }
          // get neighbor list
        LandscapeGraph::AdjItPair adj = lg->adjNodes( nodeIndex );
          // go to requested neighbor in adjacency list
        for (size_t i=0; i<index && adj.first !=adj.second; i++) {
            adj.first++;
        }
        assertbiu( adj.first != adj.second, "index out of range");
          // set neighbor node index
        ret->nodeIndex = *(adj.first);
          // return neighbor
        return ret;
    }
    
      // Undo the changes done to this state to generate the given neighbor.
      // The goal is to do less operations than doing a full copy like
      // (*neigh = *this).
      // @param index the neighbor index that was applied last 
      //              [ 0, getNeighborNumber() )
      // @param neigh the state resulting from the last changes
      // @return the copy of this object via undoing the last changes in 
      //         neigh or NULL if neigh == NULL
    State* 
    S_Explicit::
	undoNeighborChange(const size_t index, State* const neigh) const {
        if (neigh == NULL) {
            return neigh;
        }
          // casting
        S_Explicit* ret = dynamic_cast<S_Explicit*>(neigh);
        assertbiu(ret != NULL, "the given neigh State is no S_Explicit instance");
          // undo possible changes
        ret->lg = lg;
        ret->nodeIndex = nodeIndex;
          // return copy of this
        return ret;
    }
    
      // Applies the necessary changes to a given state to get the neighbor.
      // Note: \@copy is expected to be a copy (i.e. *this == *copy) and
      // therefore direct changes are possible and != NULL. 
      // @param index the neighbor to generate
      // @param copy a copy of *this the changes should be applied to
      // @return copy = the neighbor state of the given index or NULL if the index
      //         is out of range
    State* 
    S_Explicit::
	applyNeighborChange(const size_t index, State* const copy) const {
        S_Explicit* ret = dynamic_cast<S_Explicit*>(copy);
        assertbiu(ret != NULL, "the given neigh State is no S_Explicit instance");
          // get neighbor list
        LandscapeGraph::AdjItPair adj = lg->adjNodes( nodeIndex );
          // go to requested neighbor in adjacency list
        for (size_t i=0; i<index && adj.first !=adj.second; i++) {
            adj.first++;
        }
        assertbiu( adj.first != adj.second, "index out of range");
          // set neighbor node index
        ret->nodeIndex = *(adj.first);
          // return indexed neighbor
        return ret;
    }

} // namespace ell


namespace ell
{

    S_Explicit::LandscapeGraph::
	LandscapeGraph( )
      : Graph_UD( 0 )
    {
        
    }
    
    S_Explicit::LandscapeGraph::
	~LandscapeGraph()
    {
        
    }

    size_t
    S_Explicit::LandscapeGraph::
	addNode( const double energy ) {
          // get index of new node
        size_t newIndex = nodes();
        assertbiu( newIndex == nodeEnergy.size(), "node label size and node number differ");
          // increase node number
        setNodeNumber( newIndex + 1 );
          // set node label
        nodeEnergy.push_back(energy);
          // return index
        return newIndex;
    }
    
    double
    S_Explicit::LandscapeGraph::
	getNodeEnergy( const size_t nodeIndex ) const {
        assertbiu(nodeIndex < nodeEnergy.size(), "node index out of range");
        return nodeEnergy[nodeIndex];
    }
    

} // namespace ell