main page namespaces classes files
ELL home

src/ell/spinglass/S_SG_NPP.cc

Go to the documentation of this file.

#include "S_SG_NPP.hh"

namespace ell
{

    const std::string S_SG_NPP::ID = std::string("ell::S_SG_NPP");
    
    S_SG_NPP::S_SG_NPP( const WeightType* weights_
                        , const bool random_
                        , const double symmShift_)
     :  S_SG_Ising(weights_->size(), random_),
        weights(weights_), symmShift(symmShift_)
    {
    }
    
    S_SG_NPP::S_SG_NPP( const WeightType* weights_
                        , const std::string& spinStr
                        , const double symmShift_)
     :  S_SG_Ising(spinStr), weights(weights_), symmShift(symmShift_)
    {
    }
    
    S_SG_NPP::S_SG_NPP(const S_SG_NPP& s2)
     :  S_SG_Ising(s2), weights(s2.weights), symmShift(s2.symmShift)
    {
    }
    
    
    S_SG_NPP::~S_SG_NPP()
    {
    }
    
    const std::string & 
    S_SG_NPP::getID( void ) const {
        return S_SG_NPP::ID; 
    }

    bool
    S_SG_NPP::operator== (const State& state2) const {
        const S_SG_NPP* s2 = dynamic_cast<const S_SG_NPP*>(&state2);
        return  (this == &state2) 
                || ( s2 != NULL
                    && S_SG_Ising::operator==(state2)
                    && weights == s2->weights
                    && symmShift == s2->symmShift
                );
    }
    
    bool
    S_SG_NPP::operator!= (const State& state2) const {
        const S_SG_NPP* s2 = dynamic_cast<const S_SG_NPP*>(&state2);
        return  (this != &state2) 
                && ( s2 == NULL
                    || S_SG_Ising::operator!=(state2)
                    || weights != s2->weights
                    || symmShift != s2->symmShift
                );
    }

    void
    S_SG_NPP::operator= (const S_SG_NPP& sg2) {
        if (this == &sg2)
            return;
        S_SG_Ising::operator=(sg2); // copy spins
        weights = sg2.weights;  // copy weights
        symmShift = sg2.symmShift; // copy symmShift weight
    }
    
    double      
    S_SG_NPP::getEnergy() const {
        double sum = symmShift;
        for (size_t i=0; i<weights->size(); i++) {
            sum += weights->at(i) * ( spin[i]==S_SG_Ising::SPIN_UP ? 1 : -1 ) ;
        }
        return (sum >= 0.0 ? sum : -sum);
    }

        /* Returns a pointer to a clone of the current state. */
    S_SG_NPP*
    S_SG_NPP::clone(State* toFill) const {
        if (toFill == NULL) {
            return new S_SG_NPP(*this);
        }
          // cast toFill
        assertbiu( dynamic_cast<S_SG_NPP*>(toFill) != NULL
                    , "given State is no S_SG_NPP instance");
        S_SG_NPP* s = static_cast<S_SG_NPP*>(toFill);
        
          // copy data
        s->operator=(*this);
        
        return s;
    }

    State* 
    S_SG_NPP::fromString(const std::string& stringRep) const {
        return new S_SG_NPP(weights, stringRep, symmShift);
    }   
    
    State* 
    S_SG_NPP::getRandomNeighbor(State* inPlaceNeigh) const {
        S_SG_NPP *s2 = NULL;
         // copy myself into inPlaceNeigh
        if (inPlaceNeigh == NULL) {
            s2 = new S_SG_NPP(*this);
            inPlaceNeigh = s2;
        } else {
            s2 = dynamic_cast<S_SG_NPP*>(inPlaceNeigh);
            assertbiu(s2 != NULL, "given state is no S_SG_Ising");
            *s2 = *this;
        }
        
        return S_SG_Ising::getRandomNeighbor(s2);
    }
    
      // 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_NPP::getNeighbor(const size_t index, State* neigh) const {
        if (index >= spin.size())
            return NULL;
        S_SG_NPP* ret = dynamic_cast<S_SG_NPP*>(neigh);
        if (ret == NULL) { // create copy
            if (neigh != NULL)
                delete neigh;
            ret = new S_SG_NPP(*this);
            neigh = ret;
        } else {
            ret->weights = this->weights;
            ret->symmShift = this->symmShift;
        }
        return S_SG_Ising::getNeighbor(index, 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_NPP::applyNeighborChange(const size_t index, State* const neigh) const {
        assertbiu(neigh != NULL, "no state to fill given");
        if (index >= spin.size())
            return NULL;
        S_SG_NPP* ret = NULL;
        if (neigh == NULL) {
            return neigh;
        } else {
            ret = dynamic_cast<S_SG_NPP*>(neigh);
        }
        assertbiu(ret != NULL, "given neigh is no S_SG_Ising object");
        assertbiu(*ret == *this, "given neigh is not equal to this S_SG_Ising object");
        return S_SG_Ising::applyNeighborChange(index, neigh);
    }
    

    State*  
    S_SG_NPP::uncompress(const CSequence& cseq, State* toFill) const {
        S_SG_NPP* sgi = NULL;
        if (toFill == NULL) {
            sgi = new S_SG_NPP(*this);
        } else {
            sgi = dynamic_cast<S_SG_NPP*>(toFill);
            assertbiu(sgi!=NULL, "given State toFill is no S_SG_NPP instance");
        }
        sgi->weights = this->weights;
        sgi->symmShift = this->symmShift;
        return S_SG_Ising::uncompress(cseq, sgi);
    }
    
      // Access to the weight shift used for symmetry breaking.
      // @return the weight shift
    const double 
    S_SG_NPP::getSymmShift(void) const
    {
        return symmShift;
    }
    
      // Access to the weights used.
      // @return the weights
    const S_SG_NPP::WeightType* const 
    S_SG_NPP::getWeights(void) const
    {
        return weights;
    }
    

} // namespace ell