main page namespaces classes files
BIU home

src/biu/DistanceEnergyFunction.cc

Go to the documentation of this file.

#include "biu/DistanceEnergyFunction.hh"

namespace biu
{
    
    DistanceEnergyFunction::~DistanceEnergyFunction()
    {
    }

} // biu


#include <algorithm>

namespace biu
{

    IntervalEnergyFunction::IntervalEnergyFunction( const Alphabet* const alph_)
     :  biu::DistanceEnergyFunction(), 
        alphabet(alph_),
        energyMat(),
        intervalMax()
    {
        
    }
    
    IntervalEnergyFunction::IntervalEnergyFunction( const biu::IntervalEnergyFunction & toCopy)
     :  biu::DistanceEnergyFunction(),
        alphabet(toCopy.alphabet),
        energyMat(),
        intervalMax(toCopy.intervalMax)
    {
        for (size_t i=0; i<toCopy.energyMat.size(); i++) {
            energyMat.push_back(new biu::EnergyMatrix(*(toCopy.energyMat[i])));
        }
        assertbiu(energyMat.size() == intervalMat.size(),
                "different numbers of energy tables and interval boundaries");
    }

    
    IntervalEnergyFunction::~IntervalEnergyFunction()
    {
         // remove heap data
        for (size_t i=0; i<energyMat.size(); i++) {
            delete energyMat[i];
        }
         // clear vectors
        energyMat.clear();
        intervalMax.clear();
    }
    
    const Alphabet* const
    IntervalEnergyFunction::getAlphabet() const 
    {
        return alphabet;
    }
    
    double 
    IntervalEnergyFunction::getEnergy(  const Alphabet::AlphElem& first, 
                                        const Alphabet::AlphElem& second,
                                        const double distance ) const 
    {
        assertbiu( distance < *(intervalMax.rbegin()), "given distance is out of interval bounds");
    
        return (*energyMat[getInterval(distance)])[alphabet->getIndex(first)][alphabet->getIndex(second)];;
    }

    bool 
    IntervalEnergyFunction::operator == (const DistanceEnergyFunction& ef2) const
    {
        if (&ef2 == this)
            return true;
        
        bool retVal = false;
        
        const IntervalEnergyFunction* ief = dynamic_cast<const IntervalEnergyFunction*>(&ef2);
        if (ief != NULL) {
            retVal = ief->intervalMax.size() == this->intervalMax.size()
                        && ief->energyMat.size() == this->energyMat.size();
              // compare all intervals in worst case
            for (size_t i=0; retVal && i<intervalMax.size(); i++) {
                retVal =    ief->intervalMax[i] == this->intervalMax[i]
                         && *(ief->energyMat[i]) == *(this->energyMat[i]);
            }
        }
        
        return retVal;
    }
    
    bool 
    IntervalEnergyFunction::operator != (const DistanceEnergyFunction& ef2) const
    {
        return !(this->operator ==(ef2));
    }

    size_t
    IntervalEnergyFunction::addInterval(    const biu::EnergyMatrix& energies,
                                            const double upperBound )
    {
        assertbiu( intervalMax.size() == 0 || upperBound > *(intervalMax.rbegin()),
                    "given upperBound is NOT greater than the last in use");
        assertbiu(  alphabet->getAlphabetSize() == energies.numRows() 
                    && alphabet->getAlphabetSize() == energies.numColumns(),
                    "energy matrix has the wrong size for this alphabet size");
        
          // add energy matrix (copy)
        energyMat.push_back(new biu::EnergyMatrix(energies));
          // add upper bound of the interval
        intervalMax.push_back(upperBound);
        
        return intervalMax.size()-1;
    }

    size_t
    IntervalEnergyFunction::getIntervalNum(void) const {
        return intervalMax.size();
    }
    
    double
    IntervalEnergyFunction::getIntervalMax(const size_t index) const {
        assertbiu(index < intervalMax.size(), "index out of bound");
        return intervalMax[index];
    }

    const biu::EnergyMatrix* const
    IntervalEnergyFunction::getIntervalMatrix(const size_t index) const {
        assertbiu(index < intervalMax.size(), "index out of bound");
        return energyMat[index];
    }

    size_t
    IntervalEnergyFunction::getInterval( double distance) const {
        if (intervalMax.size() == 0 || distance > *(intervalMax.rbegin())) {
            return UINT_MAX;
        }
          // find the corresponding index
        size_t index = 0;
        while (distance > intervalMax[index]) {
            index++;
        }
        return index;
    }


} // biu