public void PersistenceTest()
{
var dawgBuilder = new DawgBuilder<int> ();
dawgBuilder.Insert ("cone", 10);
dawgBuilder.Insert ("bone", 10);
dawgBuilder.Insert ("gone", 9);
dawgBuilder.Insert ("go", 5);
var dawg = dawgBuilder.BuildDawg ();
var memoryStream = new MemoryStream ();
dawg.SaveTo (memoryStream, (w, p) => w.Write (p));
var buffer = memoryStream.GetBuffer ();
var rehydrated = Dawg<int>.Load (new MemoryStream (buffer), r => r.ReadInt32 ());
Assert.AreEqual (10, rehydrated ["cone"]);
Assert.AreEqual (10, rehydrated ["bone"]);
Assert.AreEqual (0, rehydrated ["cones"]);
Assert.AreEqual (9, rehydrated ["gone"]);
Assert.AreEqual (5, rehydrated ["go"]);
Assert.AreEqual (0, rehydrated ["god"]);
}
private static void DAWGTest()
{
DawgSharp.DawgBuilder <string> builder = new DawgBuilder <string>();
builder.Insert("МЕГА", "1");
builder.Insert("ГИГА", "2");
builder.Insert("СУПЕР", "3");
builder.Insert("ПРЕ", "4");
builder.Insert("ПРЕД", "5");
builder.Insert("СУПЕРГЕТЕРО", "6");
DawgSharp.Dawg <string> d = builder.BuildDawg();
string r1 = d["СУПЕР"]; // Есть, r1 = "3"
string r2 = d["НАНОФУСЬКА"]; // Нету, r2 = null
string r3 = d["СУПЕРШПИОН"]; // Есть начало, но слово не совпадает r3 = null
int commonPrefixLength = d.GetLongestCommonPrefixLength("СУПЕРШПИОН");
Console.WriteLine(commonPrefixLength); // 5 супер
string prefix = "СУПЕРШПИОН".Substring(0, commonPrefixLength);
string r4 = d[prefix]; // r4 = 3 есть
// поиск СУПЕР*
foreach (KeyValuePair <string, string> kvp in d.MatchPrefix(prefix))
{
Console.WriteLine("{0} {1}", kvp.Key, kvp.Value);
}
// поиск ПР*
foreach (KeyValuePair <string, string> kvp in d.MatchPrefix("ПР"))
{
Console.WriteLine("{0} {1}", kvp.Key, kvp.Value);
}
}
public void EmptyKey()
{
var db = new DawgBuilder <int>();
Assert.False(db.TryGetValue("", out int n));
Assert.AreEqual(0, n);
}
internal static DawgBuilder CreateBuilder(IEnumerable <string> words)
{
var dawg = new DawgBuilder(_provider);
dawg.AddToTrie(words);
return(dawg);
}
private static void Increment(DawgBuilder <int> db, string key)
{
int n;
db.TryGetValue(key, out n);
db.Insert(key, n + 1);
}
public void PersistenceTest()
{
var dawgBuilder = new DawgBuilder <int> ();
dawgBuilder.Insert("cone", 10);
dawgBuilder.Insert("bone", 10);
dawgBuilder.Insert("gone", 9);
dawgBuilder.Insert("go", 5);
var dawg = dawgBuilder.BuildDawg();
var memoryStream = new MemoryStream();
dawg.SaveTo(memoryStream, (w, p) => w.Write(p));
var buffer = memoryStream.GetBuffer();
var rehydrated = Dawg <int> .Load(new MemoryStream (buffer), r => r.ReadInt32());
Assert.AreEqual(10, rehydrated ["cone"]);
Assert.AreEqual(10, rehydrated ["bone"]);
Assert.AreEqual(0, rehydrated ["cones"]);
Assert.AreEqual(9, rehydrated ["gone"]);
Assert.AreEqual(5, rehydrated ["go"]);
Assert.AreEqual(0, rehydrated ["god"]);
}
public static Dawg <FormInterpretations> CreateDAWG(MRDFileReader mrdFile)
{
DateTime start = DateTime.Now;
Console.WriteLine("Inserting forms in DAWG... Please wait...");
DawgSharp.DawgBuilder <FormInterpretations> dawgBuilder = new DawgBuilder <FormInterpretations>();
UInt64 cntForms = 0;
foreach (WordForm f in mrdFile.AllForms)
{
string word = f.Prefix + f.Flexia.Prefix + f.Lemma.Base + f.Flexia.Flexion;
FormInterpretations payload = null;
dawgBuilder.TryGetValue(word, out payload);
if (payload == null)
{
payload = new FormInterpretations();
dawgBuilder.Insert(word, payload);
}
payload.Add(f);
cntForms++;
}
Console.WriteLine("All forms count: " + cntForms);
Console.WriteLine("Building... please wait...");
Dawg <FormInterpretations> dawg = dawgBuilder.BuildDawg();
Console.WriteLine("DAWG create time: {0}", DateTime.Now - start);
return(dawg);
}
public void Build_UnorderedWords_CreatesDawgFromUnorderedWords(DawgType dawgType)
{
var words = new[] { "¿ywo", "hip", "s³abo", "hy¿o", "kaper" };
var result = new DawgBuilder().WithUnorderedWords(words).BuildDawg(dawgType);
AssertHaveProvidedWords(result, words);
}
public void Build_OrderedWords_CreatesDawgFromOrderedWords(DawgType dawgType)
{
var orderedWords = new[] { "b¹k", "chrz¹szcz", "hy¿o" };
var result = new DawgBuilder().WithOrderedWords(orderedWords).BuildDawg(dawgType);
AssertHaveProvidedWords(result, orderedWords);
}
public void EmptyKey()
{
var db = new DawgBuilder<int>();
int n;
Assert.AreEqual(true, db.TryGetValue("", out n));
Assert.AreEqual(0, n);
}
public void WordCount_WithOrderedWords_ShouldProvideWordCount()
{
var words = new[] { "hop", "hup" };
var result = new DawgBuilder().WithOrderedWords(words).WordsCount;
Assert.Equal((ulong)2, result);
}
public void GetPrefixesOnEmptyGraph()
{
var dawgBuilder = new DawgBuilder <bool>();
var rehydrated = GetDawg(dawgBuilder);
Assert.AreEqual(0, rehydrated.GetPrefixes("readings").Count());
}
public void Build_HandleNonTreeWords_CreateDawgFromOrderedWords(DawgType dawgType)
{
var orderedWords = new[] { "hip", "hop" };
var result = new DawgBuilder().WithOrderedWords(orderedWords).BuildDawg(dawgType);
AssertHaveProvidedWords(result, orderedWords);
}
public void EmptyDictioinaryTest()
{
var dawgBuilder = new DawgBuilder <bool> ();
var dawg = dawgBuilder.BuildDawg();
Assert.IsTrue(dawg.MatchPrefix("boot").Count() == 0);
Assert.IsTrue(dawg.MatchPrefix("").Count() == 0);
}
public void EmptyDictioinaryTest()
{
var dawgBuilder = new DawgBuilder<bool> ();
var dawg = dawgBuilder.BuildDawg ();
Assert.IsTrue (dawg.MatchPrefix ("boot").Count () == 0);
Assert.IsTrue (dawg.MatchPrefix ("").Count () == 0);
}
public bool IsURLInList(string url)
{
if (dawg == null)
{
dawg = dawgBuilder.BuildDawg();
dawgBuilder = null;
}
return dawg["url"];
}
public void EmptyKey()
{
var dawgBuilder = new DawgBuilder<int> ();
dawgBuilder.Insert ("", 5);
var dawg = dawgBuilder.BuildDawg ();
Assert.AreEqual (5, dawg [""]);
}
public void TryGetValueOnPartialKey()
{
var builder = new DawgBuilder <bool>();
builder.Insert("dates", true);
bool b = builder.TryGetValue("date", out var v);
Assert.False(v);
Assert.False(b);
}
public void GetPrefixesWithKeySameLengthAsItem()
{
var dawgBuilder = new DawgBuilder <bool>();
dawgBuilder.Insert("ab", true);
var rehydrated = GetDawg(dawgBuilder);
Assert.AreEqual("ab", string.Join(",", rehydrated.GetPrefixes("ab").Select(kvp => kvp.Key)));
}
public void EmptyNodeTest()
{
var dawgBuilder = new DawgBuilder <int> ();
dawgBuilder.Insert("tip", 0);
var rehydrated = GetDawg(dawgBuilder);
Assert.AreEqual(0, rehydrated ["tip"]);
}
public void EmptyKey()
{
var dawgBuilder = new DawgBuilder <int> ();
dawgBuilder.Insert("", 5);
var dawg = dawgBuilder.BuildDawg();
Assert.AreEqual(5, dawg [""]);
}
public void EmptyKey()
{
var dawgBuilder = new DawgBuilder <int> ();
dawgBuilder.Insert("", 5);
var rehydrated = GetDawg(dawgBuilder);
Assert.AreEqual(5, rehydrated [""]);
}
public void GetPrefixesOnEmptyString()
{
var dawgBuilder = new DawgBuilder <bool>();
dawgBuilder.Insert("", true);
var rehydrated = GetDawg(dawgBuilder);
Assert.AreEqual("", rehydrated.GetPrefixes("readings").Single().Key);
}
public void AssertNodeCount()
{
var dawgBuilder = new DawgBuilder<int> ();
dawgBuilder.Insert ("taps", 10);
dawgBuilder.Insert ("tops", 10);
var dawg = dawgBuilder.BuildDawg ();
Assert.AreEqual (6, dawg.GetNodeCount ());
}
public void AssertNodeCount()
{
var dawgBuilder = new DawgBuilder <int> ();
dawgBuilder.Insert("taps", 10);
dawgBuilder.Insert("tops", 10);
var dawg = dawgBuilder.BuildDawg();
Assert.AreEqual(6, dawg.GetNodeCount());
}
public void TryGetValueUnexpectedBehaviour()
{
var builder = new DawgBuilder <string>();
builder.Insert("dates", "dates");
bool b = builder.TryGetValue("date", out var v);
Assert.True(b);
Assert.Null(v);
}
public void AssertNodeCount()
{
var dawgBuilder = new DawgBuilder <int> ();
dawgBuilder.Insert("tip", 3);
dawgBuilder.Insert("tap", 3);
var rehydrated = GetDawg(dawgBuilder);
Assert.AreEqual(4, rehydrated.GetNodeCount());
}
public void AssertNodeCount2()
{
var dawgBuilder = new DawgBuilder <int> ();
dawgBuilder.Insert("probability", 10);
dawgBuilder.Insert("stability", 10);
var dawg = dawgBuilder.BuildDawg();
Assert.AreEqual(14, dawg.GetNodeCount());
}
public void EmptyDictionaryTest()
{
var dawgBuilder = new DawgBuilder <bool> ();
var dawg = GetDawg(dawgBuilder);
Assert.IsTrue(dawg.MatchPrefix("boot").Count() == 0);
Assert.IsTrue(dawg.MatchPrefix("").Count() == 0);
Assert.IsFalse(dawg [""]);
Assert.IsFalse(dawg ["boot"]);
}
public void GetPrefixesTest()
{
var dawgBuilder = new DawgBuilder <bool>();
dawgBuilder.Insert("read", true);
dawgBuilder.Insert("reading", true);
var rehydrated = GetDawg(dawgBuilder);
Assert.AreEqual("read,reading", string.Join(",", rehydrated.GetPrefixes("readings").Select(kvp => kvp.Key)));
}
public void AssertNodeCount2()
{
var dawgBuilder = new DawgBuilder<int> ();
dawgBuilder.Insert ("probability", 10);
dawgBuilder.Insert ( "stability", 10);
var dawg = dawgBuilder.BuildDawg ();
Assert.AreEqual (14, dawg.GetNodeCount ());
}
public void SuffixMatchTest()
{
var dawgBuilder = new DawgBuilder <bool> ();
dawgBuilder.Insert("visibility".Reverse(), true);
dawgBuilder.Insert("possibility".Reverse(), true);
dawgBuilder.Insert("dexterity".Reverse(), true);
var dawg = dawgBuilder.BuildDawg();
Assert.IsTrue(dawg.MatchPrefix("ility".Reverse()).Count() == 2);
}
public void LongStringTest()
{
var longString = Enumerable.Repeat('a', 200 * 1000);
var dawgBuilder = new DawgBuilder <bool> ();
dawgBuilder.Insert(longString, true);
var rehydrated = GetDawg(dawgBuilder);
Assert.IsTrue(rehydrated [longString]);
}
public void TestMethod1()
{
string longString = new string ('a', 200 * 1000);
var builder = new DawgBuilder <bool> ();
builder.Insert(longString, true);
var dawg = builder.BuildDawg();
Assert.IsTrue(dawg [longString]);
}
public void TipTapTest()
{
var dawgBuilder = new DawgBuilder <int> ();
dawgBuilder.Insert("tip", 3);
dawgBuilder.Insert("tap", 3);
var rehydrated = GetDawg(dawgBuilder);
Assert.AreEqual(3, rehydrated ["tap"]);
Assert.AreEqual(3, rehydrated ["tip"]);
}
public void TestMethod1()
{
string longString = new string ('a', 200 * 1000);
var builder = new DawgBuilder<bool> ();
builder.Insert (longString, true);
var dawg = builder.BuildDawg ();
Assert.IsTrue (dawg [longString]);
}
public void IncrementValue()
{
var db = new DawgBuilder<int>();
Increment(db, "test");
Increment(db, "test");
Increment(db, "test");
int n;
Assert.AreEqual(true, db.TryGetValue("test", out n));
Assert.AreEqual(3, n);
}
static void Main(string[] args)
{
Directory.SetCurrentDirectory(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location));
Console.WriteLine("Building dictionary...");
var matcher = new DawgBuilder()
.WithOrderedWordsFromFile("scrabble-polish-words.txt")
.BuildCompactDawg();
var query = "";
while (true)
{
Console.CursorVisible = false;
Console.Clear();
var prompt = "Type to see completions> ";
Console.WriteLine(prompt + query + "_");
var indent = new string(' ', prompt.Length);
if (query.Length > 0)
{
var matches = matcher.GetWordsByPrefix(query).Take(10);
if (!matches.Any())
{
Console.WriteLine(indent + "<No matches>");
}
else
{
foreach (var match in matches)
{
Console.WriteLine(indent + match);
}
}
}
Console.WriteLine("\nPress esc to exit.");
var key = Console.ReadKey();
if (key.Key == ConsoleKey.Backspace && query.Length > 0)
{
query = query.Substring(0, query.Length - 1);
}
else if (key.Key == ConsoleKey.Escape)
{
return;
}
else
{
query += key.KeyChar;
}
}
}
public void SuffixMatchTest()
{
var dawgBuilder = new DawgBuilder<bool> ();
dawgBuilder.Insert ( "visibility".Reverse (), true);
dawgBuilder.Insert ("possibility".Reverse (), true);
dawgBuilder.Insert ("dexterity".Reverse (), true);
var dawg = dawgBuilder.BuildDawg ();
Assert.IsTrue (dawg.MatchPrefix ("ility".Reverse ()).Count () == 2);
}
public void TestMethod1()
{
var dawgBuilder = new DawgBuilder<int> ();
dawgBuilder.Insert ("cone", 10);
var dawg = dawgBuilder.BuildDawg ();
Assert.AreEqual (10, dawg ["cone"]);
Assert.AreEqual (0, dawg ["con"]);
Assert.AreEqual (0, dawg ["cones"]);
Assert.AreEqual (0, dawg ["pit"]);
}
public void Build_OrderedWordsFile_CreatesDawgFromOrderedWords(DawgType dawgType)
{
string[] subset;
using (var source = new WordListFileSource("scrabble-polish-words.txt"))
{
subset = source.Take(1000).ToArray();
File.WriteAllLines("tmp-words-subset.txt", subset);
}
var result = new DawgBuilder().WithOrderedWordsFromFile("tmp-words-subset.txt").BuildDawg(dawgType);
AssertHaveProvidedWords(result, subset);
}
public void TestMethod1()
{
var words = File.ReadAllLines (@"..\..\..\..\..\eneko-words.txt");
var builder = new DawgBuilder<bool> ();
foreach (var word in words)
{
builder.Insert (word, true);
}
builder.BuildDawg ();
}
public void AgoEgo()
{
var dawgBuilder = new DawgBuilder<int> ();
dawgBuilder.Insert ("ago", 9);
dawgBuilder.Insert ("ego", 10);
var dawg = dawgBuilder.BuildDawg ();
Assert.AreEqual (9, dawg ["ago"]);
Assert.AreEqual (10, dawg ["ego"]);
Assert.AreEqual (0, dawg ["ag"]);
Assert.AreEqual (0, dawg ["eg"]);
}
public void TestMethod1()
{
var dawgBuilder = new DawgBuilder<bool> ();
dawgBuilder.Insert ("cat", true);
dawgBuilder.Insert ("caterpillar", true);
dawgBuilder.Insert ("dog", true);
var dawg = dawgBuilder.BuildDawg ();
Assert.IsTrue (dawg.MatchPrefix ("cat").Select (kvp => kvp.Key).SequenceEqual (new [] {"cat", "caterpillar"}));
Assert.IsTrue (dawg.MatchPrefix ("ca").Select (kvp => kvp.Key).SequenceEqual (new [] {"cat", "caterpillar"}));
Assert.IsTrue (dawg.MatchPrefix ("").Select (kvp => kvp.Key).SequenceEqual (new [] {"cat", "caterpillar", "dog"}));
Assert.IsTrue (dawg.MatchPrefix ("boot").Count () == 0);
Assert.IsTrue (dawg.MatchPrefix ("cats").Count () == 0);
}
/// <summary>
/// Inserts a word into the dictionary
/// </summary>
/// <param name="word"></param>
/// <returns>TRUE if the words is saved</returns>
public static bool InsertWord(String word)
{
var dawgBuilder = new DawgBuilder<bool>();
dawgBuilder.Insert(word, true);
var dawg = dawgBuilder.BuildDawg();
using (Stream stream = new MemoryStream(100))
{
Action<BinaryWriter, bool> writePayload = null;
dawg.SaveTo(stream, writePayload);
//bool saved = FileHelper.Save(_BASEPATH + _FILENAME, stream);
return WordExists(word, stream);
}
}
private static void Increment(DawgBuilder<int> db, string key)
{
int n;
db.TryGetValue(key, out n);
db.Insert(key, n + 1);
}
