mosesdecoder/moses/RuleCube.h

136 lines
3.5 KiB
C
Raw Normal View History

// $Id$
// vim:tabstop=2
/***********************************************************************
Moses - factored phrase-based language decoder
Copyright (C) 2010 Hieu Hoang
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
***********************************************************************/
#pragma once
#include "RuleCubeItem.h"
#include <boost/functional/hash.hpp>
#include <boost/unordered_set.hpp>
#include <boost/version.hpp>
#include "util/exception.hh"
#include <queue>
#include <set>
#include <vector>
namespace Moses
{
class ChartCellCollection;
class ChartManager;
2012-09-25 20:34:43 +04:00
class ChartTranslationOptions;
2012-06-29 02:29:46 +04:00
/** Define an ordering between RuleCubeItems based on their scores.
* This is used to order items in the cube's priority queue.
*/
class RuleCubeItemScoreOrderer
{
2013-05-29 21:16:15 +04:00
public:
bool operator()(const RuleCubeItem *p, const RuleCubeItem *q) const {
return p->GetScore() < q->GetScore();
}
};
2012-06-29 02:29:46 +04:00
/** @todo what is this?
*/
class RuleCubeItemHasher
{
2013-05-29 21:16:15 +04:00
public:
size_t operator()(const RuleCubeItem *p) const {
size_t seed = 0;
const std::vector<HypothesisDimension> &hypoDim = p->GetHypothesisDimensions();
const ChartTranslationOption *transOpt = p->GetTranslationDimension().GetTranslationOption().get();
boost::hash_combine(seed, hypoDim);
boost::hash_combine(seed, transOpt);
return seed;
}
};
2012-06-29 02:29:46 +04:00
/** @todo what is this?
*/
class RuleCubeItemEqualityPred
{
2013-05-29 21:16:15 +04:00
public:
bool operator()(const RuleCubeItem *p, const RuleCubeItem *q) const {
bool ret = p->GetHypothesisDimensions() == q->GetHypothesisDimensions() &&
p->GetTranslationDimension() == q->GetTranslationDimension();
return ret;
}
};
2012-06-29 02:29:46 +04:00
/** @todo what is this?
*/
class RuleCube
{
2013-12-12 00:03:30 +04:00
friend std::ostream& operator<<(std::ostream &out, const RuleCube &obj);
2013-05-29 21:16:15 +04:00
public:
2012-09-25 20:34:43 +04:00
RuleCube(const ChartTranslationOptions &, const ChartCellCollection &,
ChartManager &);
~RuleCube();
float GetTopScore() const {
2013-11-23 00:27:46 +04:00
UTIL_THROW_IF2(m_queue.empty(), "Empty queue, nothing to pop");
RuleCubeItem *item = m_queue.top();
return item->GetScore();
}
RuleCubeItem *Pop(ChartManager &);
2013-05-29 21:16:15 +04:00
bool IsEmpty() const {
return m_queue.empty();
}
2012-09-25 20:34:43 +04:00
const ChartTranslationOptions &GetTranslationOption() const {
return m_transOpt;
}
2013-12-12 00:03:30 +04:00
size_t GetItemSetSize() const
{ return m_covered.size(); }
2013-05-29 21:16:15 +04:00
private:
typedef boost::unordered_set<RuleCubeItem*,
2013-05-29 21:16:15 +04:00
RuleCubeItemHasher,
RuleCubeItemEqualityPred
> ItemSet;
typedef std::priority_queue<RuleCubeItem*,
2013-05-29 21:16:15 +04:00
std::vector<RuleCubeItem*>,
RuleCubeItemScoreOrderer
> Queue;
RuleCube(const RuleCube &); // Not implemented
RuleCube &operator=(const RuleCube &); // Not implemented
void CreateNeighbors(const RuleCubeItem &, ChartManager &);
void CreateNeighbor(const RuleCubeItem &, int, ChartManager &);
2012-09-25 20:34:43 +04:00
const ChartTranslationOptions &m_transOpt;
ItemSet m_covered;
Queue m_queue;
};
}