Remove all the "using namespace" usage
This commit is contained in:
Lukhnos Liu
parent
d3302ef70a
commit
13609f41f5
|
|
@ -46,8 +46,8 @@ class Bigram {
|
|||
bool operator<(const Bigram& inAnother) const;
|
||||
};
|
||||
|
||||
inline ostream& operator<<(ostream& inStream, const Bigram& inGram) {
|
||||
streamsize p = inStream.precision();
|
||||
inline std::ostream& operator<<(std::ostream& inStream, const Bigram& inGram) {
|
||||
std::streamsize p = inStream.precision();
|
||||
inStream.precision(6);
|
||||
inStream << "(" << inGram.keyValue << "|" << inGram.preceedingKeyValue << ","
|
||||
<< inGram.score << ")";
|
||||
|
|
@ -55,13 +55,14 @@ inline ostream& operator<<(ostream& inStream, const Bigram& inGram) {
|
|||
return inStream;
|
||||
}
|
||||
|
||||
inline ostream& operator<<(ostream& inStream, const vector<Bigram>& inGrams) {
|
||||
inline std::ostream& operator<<(std::ostream& inStream,
|
||||
const std::vector<Bigram>& inGrams) {
|
||||
inStream << "[" << inGrams.size() << "]=>{";
|
||||
|
||||
size_t index = 0;
|
||||
|
||||
for (vector<Bigram>::const_iterator gi = inGrams.begin(); gi != inGrams.end();
|
||||
++gi, ++index) {
|
||||
for (std::vector<Bigram>::const_iterator gi = inGrams.begin();
|
||||
gi != inGrams.end(); ++gi, ++index) {
|
||||
inStream << index << "=>";
|
||||
inStream << *gi;
|
||||
if (gi + 1 != inGrams.end()) {
|
||||
|
|
|
|||
|
|
@ -35,7 +35,6 @@
|
|||
|
||||
namespace Formosa {
|
||||
namespace Gramambular {
|
||||
using namespace std;
|
||||
|
||||
class BlockReadingBuilder {
|
||||
public:
|
||||
|
|
@ -45,35 +44,35 @@ class BlockReadingBuilder {
|
|||
size_t length() const;
|
||||
size_t cursorIndex() const;
|
||||
void setCursorIndex(size_t inNewIndex);
|
||||
void insertReadingAtCursor(const string& inReading);
|
||||
void insertReadingAtCursor(const std::string& inReading);
|
||||
bool deleteReadingBeforeCursor(); // backspace
|
||||
bool deleteReadingAfterCursor(); // delete
|
||||
|
||||
bool removeHeadReadings(size_t count);
|
||||
|
||||
void setJoinSeparator(const string& separator);
|
||||
const string joinSeparator() const;
|
||||
void setJoinSeparator(const std::string& separator);
|
||||
const std::string joinSeparator() const;
|
||||
|
||||
vector<string> readings() const;
|
||||
std::vector<std::string> readings() const;
|
||||
|
||||
Grid& grid();
|
||||
|
||||
protected:
|
||||
void build();
|
||||
|
||||
static const string Join(vector<string>::const_iterator begin,
|
||||
vector<string>::const_iterator end,
|
||||
const string& separator);
|
||||
static const std::string Join(std::vector<std::string>::const_iterator begin,
|
||||
std::vector<std::string>::const_iterator end,
|
||||
const std::string& separator);
|
||||
|
||||
//最多使用六個字組成一個詞
|
||||
static const size_t MaximumBuildSpanLength = 6;
|
||||
|
||||
size_t m_cursorIndex;
|
||||
vector<string> m_readings;
|
||||
std::vector<std::string> m_readings;
|
||||
|
||||
Grid m_grid;
|
||||
LanguageModel* m_LM;
|
||||
string m_joinSeparator;
|
||||
std::string m_joinSeparator;
|
||||
};
|
||||
|
||||
inline BlockReadingBuilder::BlockReadingBuilder(LanguageModel* inLM)
|
||||
|
|
@ -95,7 +94,7 @@ inline void BlockReadingBuilder::setCursorIndex(size_t inNewIndex) {
|
|||
}
|
||||
|
||||
inline void BlockReadingBuilder::insertReadingAtCursor(
|
||||
const string& inReading) {
|
||||
const std::string& inReading) {
|
||||
m_readings.insert(m_readings.begin() + m_cursorIndex, inReading);
|
||||
|
||||
m_grid.expandGridByOneAtLocation(m_cursorIndex);
|
||||
|
|
@ -103,7 +102,7 @@ inline void BlockReadingBuilder::insertReadingAtCursor(
|
|||
m_cursorIndex++;
|
||||
}
|
||||
|
||||
inline vector<string> BlockReadingBuilder::readings() const {
|
||||
inline std::vector<std::string> BlockReadingBuilder::readings() const {
|
||||
return m_readings;
|
||||
}
|
||||
|
||||
|
|
@ -149,11 +148,12 @@ inline bool BlockReadingBuilder::removeHeadReadings(size_t count) {
|
|||
return true;
|
||||
}
|
||||
|
||||
inline void BlockReadingBuilder::setJoinSeparator(const string& separator) {
|
||||
inline void BlockReadingBuilder::setJoinSeparator(
|
||||
const std::string& separator) {
|
||||
m_joinSeparator = separator;
|
||||
}
|
||||
|
||||
inline const string BlockReadingBuilder::joinSeparator() const {
|
||||
inline const std::string BlockReadingBuilder::joinSeparator() const {
|
||||
return m_joinSeparator;
|
||||
}
|
||||
|
||||
|
|
@ -179,14 +179,14 @@ inline void BlockReadingBuilder::build() {
|
|||
|
||||
for (size_t p = begin; p < end; p++) {
|
||||
for (size_t q = 1; q <= MaximumBuildSpanLength && p + q <= end; q++) {
|
||||
string combinedReading = Join(
|
||||
std::string combinedReading = Join(
|
||||
m_readings.begin() + p, m_readings.begin() + p + q, m_joinSeparator);
|
||||
if (!m_grid.hasNodeAtLocationSpanningLengthMatchingKey(p, q,
|
||||
combinedReading)) {
|
||||
vector<Unigram> unigrams = m_LM->unigramsForKey(combinedReading);
|
||||
std::vector<Unigram> unigrams = m_LM->unigramsForKey(combinedReading);
|
||||
|
||||
if (unigrams.size() > 0) {
|
||||
Node n(combinedReading, unigrams, vector<Bigram>());
|
||||
Node n(combinedReading, unigrams, std::vector<Bigram>());
|
||||
m_grid.insertNode(n, p, q);
|
||||
}
|
||||
}
|
||||
|
|
@ -194,11 +194,12 @@ inline void BlockReadingBuilder::build() {
|
|||
}
|
||||
}
|
||||
|
||||
inline const string BlockReadingBuilder::Join(
|
||||
vector<string>::const_iterator begin, vector<string>::const_iterator end,
|
||||
const string& separator) {
|
||||
string result;
|
||||
for (vector<string>::const_iterator iter = begin; iter != end;) {
|
||||
inline const std::string BlockReadingBuilder::Join(
|
||||
std::vector<std::string>::const_iterator begin,
|
||||
std::vector<std::string>::const_iterator end,
|
||||
const std::string& separator) {
|
||||
std::string result;
|
||||
for (std::vector<std::string>::const_iterator iter = begin; iter != end;) {
|
||||
result += *iter;
|
||||
++iter;
|
||||
if (iter != end) {
|
||||
|
|
|
|||
|
|
@ -31,6 +31,9 @@
|
|||
#include "Gramambular.h"
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
namespace Formosa {
|
||||
namespace Gramambular {
|
||||
|
||||
const char* SampleData = R"(
|
||||
#
|
||||
# The sample is from libtabe (http://sourceforge.net/projects/libtabe/)
|
||||
|
|
@ -120,25 +123,22 @@ const char* SampleData = R"(
|
|||
ㄍㄠㄎㄜㄐㄧˋ 高科技 -9.842421
|
||||
)";
|
||||
|
||||
using namespace std;
|
||||
using namespace Formosa::Gramambular;
|
||||
|
||||
class SimpleLM : public LanguageModel {
|
||||
public:
|
||||
SimpleLM(const char* input, bool swapKeyValue = false) {
|
||||
stringstream sstream(input);
|
||||
std::stringstream sstream(input);
|
||||
while (sstream.good()) {
|
||||
string line;
|
||||
std::string line;
|
||||
getline(sstream, line);
|
||||
|
||||
if (!line.size() || (line.size() && line[0] == '#')) {
|
||||
continue;
|
||||
}
|
||||
|
||||
stringstream linestream(line);
|
||||
string col0;
|
||||
string col1;
|
||||
string col2;
|
||||
std::stringstream linestream(line);
|
||||
std::string col0;
|
||||
std::string col1;
|
||||
std::string col2;
|
||||
linestream >> col0;
|
||||
linestream >> col1;
|
||||
linestream >> col2;
|
||||
|
|
@ -159,23 +159,25 @@ class SimpleLM : public LanguageModel {
|
|||
}
|
||||
}
|
||||
|
||||
const vector<Bigram> bigramsForKeys(const string& preceedingKey,
|
||||
const string& key) override {
|
||||
return vector<Bigram>();
|
||||
const std::vector<Bigram> bigramsForKeys(const std::string& preceedingKey,
|
||||
const std::string& key) override {
|
||||
return std::vector<Bigram>();
|
||||
}
|
||||
|
||||
const vector<Unigram> unigramsForKey(const string& key) override {
|
||||
map<string, vector<Unigram> >::const_iterator f = m_db.find(key);
|
||||
return f == m_db.end() ? vector<Unigram>() : (*f).second;
|
||||
const std::vector<Unigram> unigramsForKey(const std::string& key) override {
|
||||
std::map<std::string, std::vector<Unigram> >::const_iterator f =
|
||||
m_db.find(key);
|
||||
return f == m_db.end() ? std::vector<Unigram>() : (*f).second;
|
||||
}
|
||||
|
||||
bool hasUnigramsForKey(const string& key) override {
|
||||
map<string, vector<Unigram> >::const_iterator f = m_db.find(key);
|
||||
bool hasUnigramsForKey(const std::string& key) override {
|
||||
std::map<std::string, std::vector<Unigram> >::const_iterator f =
|
||||
m_db.find(key);
|
||||
return f != m_db.end();
|
||||
}
|
||||
|
||||
protected:
|
||||
map<string, vector<Unigram> > m_db;
|
||||
std::map<std::string, std::vector<Unigram> > m_db;
|
||||
};
|
||||
|
||||
TEST(GramambularTest, InputTest) {
|
||||
|
|
@ -200,15 +202,17 @@ TEST(GramambularTest, InputTest) {
|
|||
|
||||
Walker walker(&builder.grid());
|
||||
|
||||
vector<NodeAnchor> walked = walker.reverseWalk(builder.grid().width(), 0.0);
|
||||
std::vector<NodeAnchor> walked =
|
||||
walker.reverseWalk(builder.grid().width(), 0.0);
|
||||
reverse(walked.begin(), walked.end());
|
||||
|
||||
vector<string> composed;
|
||||
for (vector<NodeAnchor>::iterator wi = walked.begin(); wi != walked.end();
|
||||
++wi) {
|
||||
std::vector<std::string> composed;
|
||||
for (std::vector<NodeAnchor>::iterator wi = walked.begin();
|
||||
wi != walked.end(); ++wi) {
|
||||
composed.push_back((*wi).node->currentKeyValue().value);
|
||||
}
|
||||
ASSERT_EQ(composed, (vector<string>{"高科技", "公司", "的", "年中", "獎金"}));
|
||||
ASSERT_EQ(composed,
|
||||
(std::vector<std::string>{"高科技", "公司", "的", "年中", "獎金"}));
|
||||
}
|
||||
|
||||
TEST(GramambularTest, WordSegmentationTest) {
|
||||
|
|
@ -226,14 +230,18 @@ TEST(GramambularTest, WordSegmentationTest) {
|
|||
builder2.insertReadingAtCursor("金");
|
||||
Walker walker2(&builder2.grid());
|
||||
|
||||
vector<NodeAnchor> walked = walker2.reverseWalk(builder2.grid().width(), 0.0);
|
||||
std::vector<NodeAnchor> walked =
|
||||
walker2.reverseWalk(builder2.grid().width(), 0.0);
|
||||
reverse(walked.begin(), walked.end());
|
||||
|
||||
vector<string> segmented;
|
||||
for (vector<NodeAnchor>::iterator wi = walked.begin(); wi != walked.end();
|
||||
++wi) {
|
||||
std::vector<std::string> segmented;
|
||||
for (std::vector<NodeAnchor>::iterator wi = walked.begin();
|
||||
wi != walked.end(); ++wi) {
|
||||
segmented.push_back((*wi).node->currentKeyValue().key);
|
||||
}
|
||||
ASSERT_EQ(segmented,
|
||||
(vector<string>{"高科技", "公司", "的", "年終", "獎金"}));
|
||||
(std::vector<std::string>{"高科技", "公司", "的", "年終", "獎金"}));
|
||||
}
|
||||
|
||||
} // namespace Gramambular
|
||||
} // namespace Formosa
|
||||
|
|
|
|||
|
|
@ -43,34 +43,35 @@ class Grid {
|
|||
size_t inSpanningLength);
|
||||
bool hasNodeAtLocationSpanningLengthMatchingKey(size_t inLocation,
|
||||
size_t inSpanningLength,
|
||||
const string& inKey);
|
||||
const std::string& inKey);
|
||||
|
||||
void expandGridByOneAtLocation(size_t inLocation);
|
||||
void shrinkGridByOneAtLocation(size_t inLocation);
|
||||
|
||||
size_t width() const;
|
||||
vector<NodeAnchor> nodesEndingAt(size_t inLocation);
|
||||
vector<NodeAnchor> nodesCrossingOrEndingAt(size_t inLocation);
|
||||
std::vector<NodeAnchor> nodesEndingAt(size_t inLocation);
|
||||
std::vector<NodeAnchor> nodesCrossingOrEndingAt(size_t inLocation);
|
||||
|
||||
// "Freeze" the node with the unigram that represents the selected candidate
|
||||
// value. After this, the node that contains the unigram will always be
|
||||
// evaluated to that unigram, while all other overlapping nodes will be reset
|
||||
// to their initial state (that is, if any of those nodes were "frozen" or
|
||||
// fixed, they will be unfrozen.)
|
||||
NodeAnchor fixNodeSelectedCandidate(size_t location, const string& value);
|
||||
NodeAnchor fixNodeSelectedCandidate(size_t location,
|
||||
const std::string& value);
|
||||
|
||||
// Similar to fixNodeSelectedCandidate, but instead of "freezing" the node,
|
||||
// only boost the unigram that represents the value with an overriding score.
|
||||
// This has the same side effect as fixNodeSelectedCandidate, which is that
|
||||
// all other overlapping nodes will be reset to their initial state.
|
||||
void overrideNodeScoreForSelectedCandidate(size_t location,
|
||||
const string& value,
|
||||
const std::string& value,
|
||||
float overridingScore);
|
||||
|
||||
const string dumpDOT();
|
||||
const std::string dumpDOT();
|
||||
|
||||
protected:
|
||||
vector<Span> m_spans;
|
||||
std::vector<Span> m_spans;
|
||||
};
|
||||
|
||||
inline void Grid::clear() { m_spans.clear(); }
|
||||
|
|
@ -89,7 +90,7 @@ inline void Grid::insertNode(const Node& inNode, size_t inLocation,
|
|||
}
|
||||
|
||||
inline bool Grid::hasNodeAtLocationSpanningLengthMatchingKey(
|
||||
size_t inLocation, size_t inSpanningLength, const string& inKey) {
|
||||
size_t inLocation, size_t inSpanningLength, const std::string& inKey) {
|
||||
if (inLocation > m_spans.size()) {
|
||||
return false;
|
||||
}
|
||||
|
|
@ -128,8 +129,8 @@ inline void Grid::shrinkGridByOneAtLocation(size_t inLocation) {
|
|||
|
||||
inline size_t Grid::width() const { return m_spans.size(); }
|
||||
|
||||
inline vector<NodeAnchor> Grid::nodesEndingAt(size_t inLocation) {
|
||||
vector<NodeAnchor> result;
|
||||
inline std::vector<NodeAnchor> Grid::nodesEndingAt(size_t inLocation) {
|
||||
std::vector<NodeAnchor> result;
|
||||
|
||||
if (m_spans.size() && inLocation <= m_spans.size()) {
|
||||
for (size_t i = 0; i < inLocation; i++) {
|
||||
|
|
@ -151,8 +152,9 @@ inline vector<NodeAnchor> Grid::nodesEndingAt(size_t inLocation) {
|
|||
return result;
|
||||
}
|
||||
|
||||
inline vector<NodeAnchor> Grid::nodesCrossingOrEndingAt(size_t inLocation) {
|
||||
vector<NodeAnchor> result;
|
||||
inline std::vector<NodeAnchor> Grid::nodesCrossingOrEndingAt(
|
||||
size_t inLocation) {
|
||||
std::vector<NodeAnchor> result;
|
||||
|
||||
if (m_spans.size() && inLocation <= m_spans.size()) {
|
||||
for (size_t i = 0; i < inLocation; i++) {
|
||||
|
|
@ -184,8 +186,8 @@ inline vector<NodeAnchor> Grid::nodesCrossingOrEndingAt(size_t inLocation) {
|
|||
// For nodes found at the location, fix their currently-selected candidate using
|
||||
// the supplied string value.
|
||||
inline NodeAnchor Grid::fixNodeSelectedCandidate(size_t location,
|
||||
const string& value) {
|
||||
vector<NodeAnchor> nodes = nodesCrossingOrEndingAt(location);
|
||||
const std::string& value) {
|
||||
std::vector<NodeAnchor> nodes = nodesCrossingOrEndingAt(location);
|
||||
NodeAnchor node;
|
||||
for (auto nodeAnchor : nodes) {
|
||||
auto candidates = nodeAnchor.node->candidates();
|
||||
|
|
@ -205,10 +207,9 @@ inline NodeAnchor Grid::fixNodeSelectedCandidate(size_t location,
|
|||
return node;
|
||||
}
|
||||
|
||||
inline void Grid::overrideNodeScoreForSelectedCandidate(size_t location,
|
||||
const string& value,
|
||||
float overridingScore) {
|
||||
vector<NodeAnchor> nodes = nodesCrossingOrEndingAt(location);
|
||||
inline void Grid::overrideNodeScoreForSelectedCandidate(
|
||||
size_t location, const std::string& value, float overridingScore) {
|
||||
std::vector<NodeAnchor> nodes = nodesCrossingOrEndingAt(location);
|
||||
for (auto nodeAnchor : nodes) {
|
||||
auto candidates = nodeAnchor.node->candidates();
|
||||
|
||||
|
|
@ -225,11 +226,11 @@ inline void Grid::overrideNodeScoreForSelectedCandidate(size_t location,
|
|||
}
|
||||
}
|
||||
|
||||
inline const string Grid::dumpDOT() {
|
||||
stringstream sst;
|
||||
sst << "digraph {" << endl;
|
||||
sst << "graph [ rankdir=LR ];" << endl;
|
||||
sst << "BOS;" << endl;
|
||||
inline const std::string Grid::dumpDOT() {
|
||||
std::stringstream sst;
|
||||
sst << "digraph {" << std::endl;
|
||||
sst << "graph [ rankdir=LR ];" << std::endl;
|
||||
sst << "BOS;" << std::endl;
|
||||
|
||||
for (size_t p = 0; p < m_spans.size(); p++) {
|
||||
Span& span = m_spans[p];
|
||||
|
|
@ -237,10 +238,10 @@ inline const string Grid::dumpDOT() {
|
|||
Node* np = span.nodeOfLength(ni);
|
||||
if (np) {
|
||||
if (!p) {
|
||||
sst << "BOS -> " << np->currentKeyValue().value << ";" << endl;
|
||||
sst << "BOS -> " << np->currentKeyValue().value << ";" << std::endl;
|
||||
}
|
||||
|
||||
sst << np->currentKeyValue().value << ";" << endl;
|
||||
sst << np->currentKeyValue().value << ";" << std::endl;
|
||||
|
||||
if (p + ni < m_spans.size()) {
|
||||
Span& dstSpan = m_spans[p + ni];
|
||||
|
|
@ -248,20 +249,20 @@ inline const string Grid::dumpDOT() {
|
|||
Node* dn = dstSpan.nodeOfLength(q);
|
||||
if (dn) {
|
||||
sst << np->currentKeyValue().value << " -> "
|
||||
<< dn->currentKeyValue().value << ";" << endl;
|
||||
<< dn->currentKeyValue().value << ";" << std::endl;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (p + ni == m_spans.size()) {
|
||||
sst << np->currentKeyValue().value << " -> "
|
||||
<< "EOS;" << endl;
|
||||
<< "EOS;" << std::endl;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
sst << "EOS;" << endl;
|
||||
sst << "EOS;" << std::endl;
|
||||
sst << "}";
|
||||
return sst.str();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -33,18 +33,18 @@
|
|||
|
||||
namespace Formosa {
|
||||
namespace Gramambular {
|
||||
using namespace std;
|
||||
|
||||
class KeyValuePair {
|
||||
public:
|
||||
string key;
|
||||
string value;
|
||||
std::string key;
|
||||
std::string value;
|
||||
|
||||
bool operator==(const KeyValuePair& inAnother) const;
|
||||
bool operator<(const KeyValuePair& inAnother) const;
|
||||
};
|
||||
|
||||
inline ostream& operator<<(ostream& inStream, const KeyValuePair& inPair) {
|
||||
inline std::ostream& operator<<(std::ostream& inStream,
|
||||
const KeyValuePair& inPair) {
|
||||
inStream << "(" << inPair.key << "," << inPair.value << ")";
|
||||
return inStream;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -36,16 +36,14 @@
|
|||
namespace Formosa {
|
||||
namespace Gramambular {
|
||||
|
||||
using namespace std;
|
||||
|
||||
class LanguageModel {
|
||||
public:
|
||||
virtual ~LanguageModel() {}
|
||||
|
||||
virtual const vector<Bigram> bigramsForKeys(const string& preceedingKey,
|
||||
const string& key) = 0;
|
||||
virtual const vector<Unigram> unigramsForKey(const string& key) = 0;
|
||||
virtual bool hasUnigramsForKey(const string& key) = 0;
|
||||
virtual const std::vector<Bigram> bigramsForKeys(
|
||||
const std::string& preceedingKey, const std::string& key) = 0;
|
||||
virtual const std::vector<Unigram> unigramsForKey(const std::string& key) = 0;
|
||||
virtual bool hasUnigramsForKey(const std::string& key) = 0;
|
||||
};
|
||||
} // namespace Gramambular
|
||||
} // namespace Formosa
|
||||
|
|
|
|||
|
|
@ -35,47 +35,46 @@
|
|||
|
||||
namespace Formosa {
|
||||
namespace Gramambular {
|
||||
using namespace std;
|
||||
|
||||
class Node {
|
||||
public:
|
||||
Node();
|
||||
Node(const string& inKey, const vector<Unigram>& inUnigrams,
|
||||
const vector<Bigram>& inBigrams);
|
||||
Node(const std::string& inKey, const std::vector<Unigram>& inUnigrams,
|
||||
const std::vector<Bigram>& inBigrams);
|
||||
|
||||
void primeNodeWithPreceedingKeyValues(
|
||||
const vector<KeyValuePair>& inKeyValues);
|
||||
const std::vector<KeyValuePair>& inKeyValues);
|
||||
|
||||
bool isCandidateFixed() const;
|
||||
const vector<KeyValuePair>& candidates() const;
|
||||
const std::vector<KeyValuePair>& candidates() const;
|
||||
void selectCandidateAtIndex(size_t inIndex = 0, bool inFix = true);
|
||||
void resetCandidate();
|
||||
void selectFloatingCandidateAtIndex(size_t index, double score);
|
||||
|
||||
const string& key() const;
|
||||
const std::string& key() const;
|
||||
double score() const;
|
||||
double scoreForCandidate(string& candidate) const;
|
||||
double scoreForCandidate(std::string& candidate) const;
|
||||
const KeyValuePair currentKeyValue() const;
|
||||
double highestUnigramScore() const;
|
||||
|
||||
protected:
|
||||
const LanguageModel* m_LM;
|
||||
|
||||
string m_key;
|
||||
std::string m_key;
|
||||
double m_score;
|
||||
|
||||
vector<Unigram> m_unigrams;
|
||||
vector<KeyValuePair> m_candidates;
|
||||
map<string, size_t> m_valueUnigramIndexMap;
|
||||
map<KeyValuePair, vector<Bigram> > m_preceedingGramBigramMap;
|
||||
std::vector<Unigram> m_unigrams;
|
||||
std::vector<KeyValuePair> m_candidates;
|
||||
std::map<std::string, size_t> m_valueUnigramIndexMap;
|
||||
std::map<KeyValuePair, std::vector<Bigram> > m_preceedingGramBigramMap;
|
||||
|
||||
bool m_candidateFixed;
|
||||
size_t m_selectedUnigramIndex;
|
||||
|
||||
friend ostream& operator<<(ostream& inStream, const Node& inNode);
|
||||
friend std::ostream& operator<<(std::ostream& inStream, const Node& inNode);
|
||||
};
|
||||
|
||||
inline ostream& operator<<(ostream& inStream, const Node& inNode) {
|
||||
inline std::ostream& operator<<(std::ostream& inStream, const Node& inNode) {
|
||||
inStream << "(node,key:" << inNode.m_key
|
||||
<< ",fixed:" << (inNode.m_candidateFixed ? "true" : "false")
|
||||
<< ",selected:" << inNode.m_selectedUnigramIndex << ","
|
||||
|
|
@ -86,8 +85,9 @@ inline ostream& operator<<(ostream& inStream, const Node& inNode) {
|
|||
inline Node::Node()
|
||||
: m_candidateFixed(false), m_selectedUnigramIndex(0), m_score(0.0) {}
|
||||
|
||||
inline Node::Node(const string& inKey, const vector<Unigram>& inUnigrams,
|
||||
const vector<Bigram>& inBigrams)
|
||||
inline Node::Node(const std::string& inKey,
|
||||
const std::vector<Unigram>& inUnigrams,
|
||||
const std::vector<Bigram>& inBigrams)
|
||||
: m_key(inKey),
|
||||
m_unigrams(inUnigrams),
|
||||
m_candidateFixed(false),
|
||||
|
|
@ -100,7 +100,7 @@ inline Node::Node(const string& inKey, const vector<Unigram>& inUnigrams,
|
|||
}
|
||||
|
||||
size_t i = 0;
|
||||
for (vector<Unigram>::const_iterator ui = m_unigrams.begin();
|
||||
for (std::vector<Unigram>::const_iterator ui = m_unigrams.begin();
|
||||
ui != m_unigrams.end(); ++ui) {
|
||||
m_valueUnigramIndexMap[(*ui).keyValue.value] = i;
|
||||
i++;
|
||||
|
|
@ -108,30 +108,30 @@ inline Node::Node(const string& inKey, const vector<Unigram>& inUnigrams,
|
|||
m_candidates.push_back((*ui).keyValue);
|
||||
}
|
||||
|
||||
for (vector<Bigram>::const_iterator bi = inBigrams.begin();
|
||||
for (std::vector<Bigram>::const_iterator bi = inBigrams.begin();
|
||||
bi != inBigrams.end(); ++bi) {
|
||||
m_preceedingGramBigramMap[(*bi).preceedingKeyValue].push_back(*bi);
|
||||
}
|
||||
}
|
||||
|
||||
inline void Node::primeNodeWithPreceedingKeyValues(
|
||||
const vector<KeyValuePair>& inKeyValues) {
|
||||
const std::vector<KeyValuePair>& inKeyValues) {
|
||||
size_t newIndex = m_selectedUnigramIndex;
|
||||
double max = m_score;
|
||||
|
||||
if (!isCandidateFixed()) {
|
||||
for (vector<KeyValuePair>::const_iterator kvi = inKeyValues.begin();
|
||||
for (std::vector<KeyValuePair>::const_iterator kvi = inKeyValues.begin();
|
||||
kvi != inKeyValues.end(); ++kvi) {
|
||||
map<KeyValuePair, vector<Bigram> >::const_iterator f =
|
||||
std::map<KeyValuePair, std::vector<Bigram> >::const_iterator f =
|
||||
m_preceedingGramBigramMap.find(*kvi);
|
||||
if (f != m_preceedingGramBigramMap.end()) {
|
||||
const vector<Bigram>& bigrams = (*f).second;
|
||||
const std::vector<Bigram>& bigrams = (*f).second;
|
||||
|
||||
for (vector<Bigram>::const_iterator bi = bigrams.begin();
|
||||
for (std::vector<Bigram>::const_iterator bi = bigrams.begin();
|
||||
bi != bigrams.end(); ++bi) {
|
||||
const Bigram& bigram = *bi;
|
||||
if (bigram.score > max) {
|
||||
map<string, size_t>::const_iterator uf =
|
||||
std::map<std::string, size_t>::const_iterator uf =
|
||||
m_valueUnigramIndexMap.find((*bi).keyValue.value);
|
||||
if (uf != m_valueUnigramIndexMap.end()) {
|
||||
newIndex = (*uf).second;
|
||||
|
|
@ -154,7 +154,7 @@ inline void Node::primeNodeWithPreceedingKeyValues(
|
|||
|
||||
inline bool Node::isCandidateFixed() const { return m_candidateFixed; }
|
||||
|
||||
inline const vector<KeyValuePair>& Node::candidates() const {
|
||||
inline const std::vector<KeyValuePair>& Node::candidates() const {
|
||||
return m_candidates;
|
||||
}
|
||||
|
||||
|
|
@ -187,11 +187,11 @@ inline void Node::selectFloatingCandidateAtIndex(size_t index, double score) {
|
|||
m_score = score;
|
||||
}
|
||||
|
||||
inline const string& Node::key() const { return m_key; }
|
||||
inline const std::string& Node::key() const { return m_key; }
|
||||
|
||||
inline double Node::score() const { return m_score; }
|
||||
|
||||
inline double Node::scoreForCandidate(string& candidate) const {
|
||||
inline double Node::scoreForCandidate(std::string& candidate) const {
|
||||
for (auto unigram : m_unigrams) {
|
||||
if (unigram.keyValue.value == candidate) {
|
||||
return unigram.score;
|
||||
|
|
|
|||
|
|
@ -44,7 +44,8 @@ class NodeAnchor {
|
|||
inline NodeAnchor::NodeAnchor()
|
||||
: node(0), location(0), spanningLength(0), accumulatedScore(0.0) {}
|
||||
|
||||
inline ostream& operator<<(ostream& inStream, const NodeAnchor& inAnchor) {
|
||||
inline std::ostream& operator<<(std::ostream& inStream,
|
||||
const NodeAnchor& inAnchor) {
|
||||
inStream << "{@(" << inAnchor.location << "," << inAnchor.spanningLength
|
||||
<< "),";
|
||||
if (inAnchor.node) {
|
||||
|
|
@ -56,9 +57,9 @@ inline ostream& operator<<(ostream& inStream, const NodeAnchor& inAnchor) {
|
|||
return inStream;
|
||||
}
|
||||
|
||||
inline ostream& operator<<(ostream& inStream,
|
||||
const vector<NodeAnchor>& inAnchor) {
|
||||
for (vector<NodeAnchor>::const_iterator i = inAnchor.begin();
|
||||
inline std::ostream& operator<<(std::ostream& inStream,
|
||||
const std::vector<NodeAnchor>& inAnchor) {
|
||||
for (std::vector<NodeAnchor>::const_iterator i = inAnchor.begin();
|
||||
i != inAnchor.end(); ++i) {
|
||||
inStream << *i;
|
||||
if (i + 1 != inAnchor.end()) {
|
||||
|
|
|
|||
|
|
@ -48,7 +48,7 @@ class Span {
|
|||
size_t maximumLength() const;
|
||||
|
||||
protected:
|
||||
map<size_t, Node> m_lengthNodeMap;
|
||||
std::map<size_t, Node> m_lengthNodeMap;
|
||||
size_t m_maximumLength;
|
||||
};
|
||||
|
||||
|
|
@ -72,9 +72,9 @@ inline void Span::removeNodeOfLengthGreaterThan(size_t inLength) {
|
|||
}
|
||||
|
||||
size_t max = 0;
|
||||
set<size_t> removeSet;
|
||||
for (map<size_t, Node>::iterator i = m_lengthNodeMap.begin(),
|
||||
e = m_lengthNodeMap.end();
|
||||
std::set<size_t> removeSet;
|
||||
for (std::map<size_t, Node>::iterator i = m_lengthNodeMap.begin(),
|
||||
e = m_lengthNodeMap.end();
|
||||
i != e; ++i) {
|
||||
if ((*i).first > inLength) {
|
||||
removeSet.insert((*i).first);
|
||||
|
|
@ -85,8 +85,8 @@ inline void Span::removeNodeOfLengthGreaterThan(size_t inLength) {
|
|||
}
|
||||
}
|
||||
|
||||
for (set<size_t>::iterator i = removeSet.begin(), e = removeSet.end(); i != e;
|
||||
++i) {
|
||||
for (std::set<size_t>::iterator i = removeSet.begin(), e = removeSet.end();
|
||||
i != e; ++i) {
|
||||
m_lengthNodeMap.erase(*i);
|
||||
}
|
||||
|
||||
|
|
@ -94,7 +94,7 @@ inline void Span::removeNodeOfLengthGreaterThan(size_t inLength) {
|
|||
}
|
||||
|
||||
inline Node* Span::nodeOfLength(size_t inLength) {
|
||||
map<size_t, Node>::iterator f = m_lengthNodeMap.find(inLength);
|
||||
std::map<size_t, Node>::iterator f = m_lengthNodeMap.find(inLength);
|
||||
return f == m_lengthNodeMap.end() ? 0 : &(*f).second;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -47,20 +47,21 @@ class Unigram {
|
|||
static bool ScoreCompare(const Unigram& a, const Unigram& b);
|
||||
};
|
||||
|
||||
inline ostream& operator<<(ostream& inStream, const Unigram& inGram) {
|
||||
streamsize p = inStream.precision();
|
||||
inline std::ostream& operator<<(std::ostream& inStream, const Unigram& inGram) {
|
||||
std::streamsize p = inStream.precision();
|
||||
inStream.precision(6);
|
||||
inStream << "(" << inGram.keyValue << "," << inGram.score << ")";
|
||||
inStream.precision(p);
|
||||
return inStream;
|
||||
}
|
||||
|
||||
inline ostream& operator<<(ostream& inStream, const vector<Unigram>& inGrams) {
|
||||
inline std::ostream& operator<<(std::ostream& inStream,
|
||||
const std::vector<Unigram>& inGrams) {
|
||||
inStream << "[" << inGrams.size() << "]=>{";
|
||||
|
||||
size_t index = 0;
|
||||
|
||||
for (vector<Unigram>::const_iterator gi = inGrams.begin();
|
||||
for (std::vector<Unigram>::const_iterator gi = inGrams.begin();
|
||||
gi != inGrams.end(); ++gi, ++index) {
|
||||
inStream << index << "=>";
|
||||
inStream << *gi;
|
||||
|
|
|
|||
|
|
@ -34,13 +34,12 @@
|
|||
|
||||
namespace Formosa {
|
||||
namespace Gramambular {
|
||||
using namespace std;
|
||||
|
||||
class Walker {
|
||||
public:
|
||||
Walker(Grid* inGrid);
|
||||
const vector<NodeAnchor> reverseWalk(size_t inLocation,
|
||||
double inAccumulatedScore = 0.0);
|
||||
const std::vector<NodeAnchor> reverseWalk(size_t inLocation,
|
||||
double inAccumulatedScore = 0.0);
|
||||
|
||||
protected:
|
||||
Grid* m_grid;
|
||||
|
|
@ -48,17 +47,17 @@ class Walker {
|
|||
|
||||
inline Walker::Walker(Grid* inGrid) : m_grid(inGrid) {}
|
||||
|
||||
inline const vector<NodeAnchor> Walker::reverseWalk(size_t inLocation,
|
||||
double inAccumulatedScore) {
|
||||
inline const std::vector<NodeAnchor> Walker::reverseWalk(
|
||||
size_t inLocation, double inAccumulatedScore) {
|
||||
if (!inLocation || inLocation > m_grid->width()) {
|
||||
return vector<NodeAnchor>();
|
||||
return std::vector<NodeAnchor>();
|
||||
}
|
||||
|
||||
vector<vector<NodeAnchor> > paths;
|
||||
std::vector<std::vector<NodeAnchor> > paths;
|
||||
|
||||
vector<NodeAnchor> nodes = m_grid->nodesEndingAt(inLocation);
|
||||
std::vector<NodeAnchor> nodes = m_grid->nodesEndingAt(inLocation);
|
||||
|
||||
for (vector<NodeAnchor>::iterator ni = nodes.begin(); ni != nodes.end();
|
||||
for (std::vector<NodeAnchor>::iterator ni = nodes.begin(); ni != nodes.end();
|
||||
++ni) {
|
||||
if (!(*ni).node) {
|
||||
continue;
|
||||
|
|
@ -66,7 +65,7 @@ inline const vector<NodeAnchor> Walker::reverseWalk(size_t inLocation,
|
|||
|
||||
(*ni).accumulatedScore = inAccumulatedScore + (*ni).node->score();
|
||||
|
||||
vector<NodeAnchor> path =
|
||||
std::vector<NodeAnchor> path =
|
||||
reverseWalk(inLocation - (*ni).spanningLength, (*ni).accumulatedScore);
|
||||
path.insert(path.begin(), *ni);
|
||||
|
||||
|
|
@ -74,11 +73,11 @@ inline const vector<NodeAnchor> Walker::reverseWalk(size_t inLocation,
|
|||
}
|
||||
|
||||
if (!paths.size()) {
|
||||
return vector<NodeAnchor>();
|
||||
return std::vector<NodeAnchor>();
|
||||
}
|
||||
|
||||
vector<NodeAnchor>* result = &*(paths.begin());
|
||||
for (vector<vector<NodeAnchor> >::iterator pi = paths.begin();
|
||||
std::vector<NodeAnchor>* result = &*(paths.begin());
|
||||
for (std::vector<std::vector<NodeAnchor> >::iterator pi = paths.begin();
|
||||
pi != paths.end(); ++pi) {
|
||||
if ((*pi).back().accumulatedScore > result->back().accumulatedScore) {
|
||||
result = &*pi;
|
||||
|
|
|
|||
Loading…
Reference in New Issue