main page namespaces classes files
ELL home

src/ell/spinglass/S_SG_Ising.cc

Go to the documentation of this file.

#include "ell/spinglass/S_SG_Ising.hh"
#include <biu/assertbiu.hh>
#include "biu/RandomNumberFactory.hh"

#include <iostream>

namespace ell
{

    const biu::Alphabet S_SG_Ising::spinAlph = biu::Alphabet("-+",1);
    const S_SG_Ising::SpinType S_SG_Ising::SPIN_UP = S_SG_Ising::spinAlph.getElement("+");
    const S_SG_Ising::SpinType S_SG_Ising::SPIN_DOWN = S_SG_Ising::spinAlph.getElement("-");
    const std::string S_SG_Ising::ID = std::string("ell::S_SG_Ising");

        /* Constructs a spin array of the given size and initializes with 
         * SPIN_UP for all spins or a random distribution.
         * @param size the size of the spin array
         * @param random if true a random initialization is done
         */ 
    S_SG_Ising::S_SG_Ising(size_t size, bool rand)
     :  spin(size,SPIN_UP) 
    {
        if (rand) {
            for (SpinArray::iterator it = spin.begin(); it!=spin.end();it++) {
                *it = ( biu::RNF::getRN(2) == 1 ? SPIN_UP : SPIN_DOWN );
            }
        }
    }
    
    S_SG_Ising::S_SG_Ising(const std::string & spinStr)
     :  spin() 
    {
        assertbiu(spinAlph.isAlphabetString(spinStr), "given spin string is no +- string");
        spin = spinAlph.getSequence(spinStr);
    }
    
    S_SG_Ising::S_SG_Ising(const S_SG_Ising& s2)
     : spin(s2.spin)
    {
    }

    S_SG_Ising::~S_SG_Ising()
    {
    }
    
    const std::string & 
    S_SG_Ising::getID( void ) const {
        return S_SG_Ising::ID; 
    }

    bool
    S_SG_Ising::operator== (const State& state2) const {
        return (this == &state2) || getMinimalDistance(state2) == 0;
    }
    
    bool
    S_SG_Ising::operator!= (const State& state2) const {
        return (this != &state2) && getMinimalDistance(state2) != 0;
    }

    void
    S_SG_Ising::operator= (const S_SG_Ising& sg2) {
        if (this == &sg2)
            return;
        spin.resize(sg2.spin.size());
        std::copy<SpinArray::const_iterator, SpinArray::iterator>
            (   sg2.spin.begin(), sg2.spin.end(), 
                spin.begin());
    }

        /* Returns the state specific energy, i.e.
         * E = sum ( J(i,j)*spin(i)*spin(j) ) for all 0<=i<j<=spinnumber
         * and J(i,j) = 1 iif spin i and j are neighbored and 0 otherwise. */
    double  
    S_SG_Ising::getEnergy() const {
        if (spin.size() == 0)
            return 0;
        SpinType last = *spin.rbegin();
        int e = 0;
        for (SpinArray::const_iterator it = spin.begin(); it != spin.end(); it++) {
            e += ((*it) == last ? +1 : -1);
            last = *it;
        }
        return -(double)e;
    }
    
        /* 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_SG_Ising::getMinimalDistance(const State& state2) const {
        unsigned int minD = UINT_MAX;
        const S_SG_Ising* s2 = dynamic_cast<const S_SG_Ising*>(&state2);
        if (s2 != NULL && spin.size() == s2->spin.size()) {
            minD = 0;
            SpinArray::const_iterator is1 = spin.begin(), is2 = s2->spin.begin();
            while (is1 != spin.end()) {
                minD += (*is1++ == *is2++ ? 0 : 1); // count different positions
            }
        }
        return minD;
    }

        /* Returns a pointer to a clone of the current state. */
    S_SG_Ising*
    S_SG_Ising::clone(State* toFill) const {
        if (toFill == NULL) {
            return new S_SG_Ising(*this);
        }
          // cast toFill
        assertbiu( dynamic_cast<S_SG_Ising*>(toFill) != NULL
                    , "given State is no S_SG_Ising instance");
        S_SG_Ising* s = static_cast<S_SG_Ising*>(toFill);
        
          // copy data
        s->operator=(*this);
        
        return s;
    }
    
    State* 
    S_SG_Ising::fromString(const std::string& stringRep) const {
        return new S_SG_Ising(stringRep);
    }
    
        /* Returns a specific std::string representation of this
         *  State.
         */
    std::string 
    S_SG_Ising::toString() const {
        return spinAlph.getString(spin);
    }
    
    std::string& 
    S_SG_Ising::toString( std::string & toFill ) const {
        toFill = spinAlph.getString(spin);
        return toFill;
    }

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

        /* Returns a virtual 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_SG_Ising::getRandomNeighborList() const {
        return NeighborListPtr(new RandomNeighborList(this));
    }
    
        /* Returns a VALID random neighbored state.
         *  If a state is given it is overwritten and changed to a neighbor.
         */
    State* 
    S_SG_Ising::getRandomNeighbor(State* inPlaceNeigh) const {
        S_SG_Ising *s2 = NULL;
         // copy myself into inPlaceNeigh
        if (inPlaceNeigh == NULL) {
            s2 = new S_SG_Ising(*this);
            inPlaceNeigh = s2;
        } else {
            s2 = dynamic_cast<S_SG_Ising*>(inPlaceNeigh);
            assertbiu(s2 != NULL, "given state is no S_SG_Ising");
            *s2 = *this;
        }
         // get random position to flip
        size_t pos = biu::RNF::getRN(spin.size());
         // apply spin flip to pos in new state
        s2->spin[pos] = flipSpin(spin[pos]);
        
        return inPlaceNeigh;
    }


      // How many neighbor indices are accessible.
      // @return the number of neighbors
    size_t 
    S_SG_Ising::getNeighborNumber(void) const {
        return spin.size();
    }
    
      // 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
      // @return the new neighbor state or NULL if the index is >= 
      // getNeighborNumber()
    State* 
    S_SG_Ising::getNeighbor(const size_t index, State* neigh) const {
        assertbiu(index < spin.size(), "index out of spin range");
        S_SG_Ising* ret = dynamic_cast<S_SG_Ising*>(neigh);
        if (ret == NULL) { // create copy
            ret = new S_SG_Ising(*this);
        } else {
            ret->spin = this->spin;
        }
        ret->spin[index] = flipSpin(spin[index]);
        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 ( != NULL)
      // @return the copy of this object via undoing the last changes in 
      //         neigh
    State* 
    S_SG_Ising::undoNeighborChange(const size_t index, State* const neigh) const {
        S_SG_Ising* ret = dynamic_cast<S_SG_Ising*>(neigh);
        assertbiu(ret != NULL, "given neigh is no S_SG_Ising object");
        assertbiu(index < spin.size(), "index out of spin range");
        ret->spin[index] = spin[index];
        return ret;
    }
    
      // Applies the necessary changes to a given state to get the neighbor.
      // Note: neigh is expected to be a copy (i.e. *this == *neigh) and
      // therefore direct changes are possible or to be NULL. If 
      // (neigh==NULL) a copy of this has to be generated, modified, and
      // returned.
      // @param index the neighbor to generate
      // @param neigh a copy of this the changes should be applied to
      // @return the neighbor state of the given index or NULL if the index is
      //         out of range
    State* 
    S_SG_Ising::applyNeighborChange(const size_t index, State* const neigh) const {
        assertbiu(index < spin.size(), "index out of spin range");
        assertbiu(neigh != NULL, "no state to fill given");
        S_SG_Ising* ret = dynamic_cast<S_SG_Ising*>(neigh);
        assertbiu(ret != NULL, "given neigh is no S_SG_Ising object");
        ret->spin[index] = flipSpin(spin[index]);
        return ret;
    }
    

    
        /* Access to a compressed sequence representation of the state.
         * @return the compressed sequence representation
         */
    CSequence  
    S_SG_Ising::compress(void) const {
        assertbiu(spin.size()>0, "no spins available");
        return spinAlph.compress(spin);
    }
    
        /* 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_SG_Ising::compress(CSequence& toFill) const {
        assertbiu(spin.size()>0, "no spins available");
        toFill = spinAlph.compress(spin);
        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_SG_Ising::uncompress(const CSequence& cseq, State* toFill) const {
        S_SG_Ising* sgi = NULL;
        if (toFill == NULL) {
            sgi = new S_SG_Ising(*this);
        } else {
            sgi = dynamic_cast<S_SG_Ising*>(toFill);
            assertbiu(sgi != NULL, "given State toFill is no S_SG_Ising instance");
        }
        sgi->spin = spinAlph.decompress(cseq, spin.size()); 
        return sgi;
    }
    
        /* 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_SG_Ising::uncompress(const CSequence& cseq) {
        spin = spinAlph.decompress(cseq, spin.size());
        return this;
    }
    
} // namespace