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
{
    
    S_SG_NPP::S_SG_NPP(const WeightType* weights_, bool random )
     :  S_SG_Ising(weights_->size(), random),
        weights(weights_)
    {
    }
    
    S_SG_NPP::S_SG_NPP(const WeightType* weights_, const std::string& spinStr)
     :  S_SG_Ising(spinStr), weights(weights_) 
    {
    }
    
    S_SG_NPP::S_SG_NPP(const S_SG_NPP& s2)
     :  S_SG_Ising(s2), weights(s2.weights)
    {
    }
    
    
    S_SG_NPP::~S_SG_NPP()
    {
    }

    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
                );
    }
    
    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
                );
    }

    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
    }
    
    double      
    S_SG_NPP::getEnergy() const {
        double sum = 0.0;
        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 ? sum : -sum);
    }

        /* Returns a pointer to a clone of the current state. */
    State*
    S_SG_NPP::clone() const {
        return new S_SG_NPP(*this);
    }

    State* 
    S_SG_NPP::fromString(const std::string& stringRep) const {
        return new S_SG_NPP(weights, stringRep);
    }   
    
    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;
        }
        ret->weights = this->weights;
        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");
        return S_SG_Ising::applyNeighborChange(index, neigh);
    }
    

    State*  
    S_SG_NPP::uncompress(const CSequence& cseq, State* toFill) const {
        S_SG_NPP* sgi = dynamic_cast<S_SG_NPP*>(toFill);
        if (sgi == NULL) {
            if (toFill != NULL)
                delete toFill;
            sgi = new S_SG_NPP(*this);
            toFill = sgi;
        }
        sgi->weights = this->weights;
        return S_SG_Ising::uncompress(cseq, toFill);
    }
    
    

} // namespace ell