public static Searcher GetInstance()
{
if (instance == null)
{
instance = new Searcher(WordComparer.GetInstance());
}
return(instance);
}
protected int FindMatchedEntry(string partialWord, out bool hasMismatches)
{
// default - word with highest match rating in the list.
hasMismatches = true;
int idx = -1;
List <KeyValuePair <int, string> > words = new List <KeyValuePair <int, string> > ();
if (!string.IsNullOrEmpty(partialWord))
{
for (int i = 0; i < list.filteredItems.Count; i++)
{
int index = list.filteredItems[i];
string text = DataProvider.GetCompletionText(index);
if (!ListWidget.Matches(partialWord, text))
{
continue;
}
words.Add(new KeyValuePair <int, string> (i, text));
}
}
ListWindow.WordComparer comparer = new WordComparer(partialWord);
if (words.Count > 0)
{
words.Sort(comparer);
idx = words[0].Key;
hasMismatches = false;
// exact match found.
if (words[0].Value.ToUpper() == (partialWord ?? "").ToUpper())
{
return(idx);
}
}
if (string.IsNullOrEmpty(partialWord) || partialWord.Length <= 2)
{
// Search for history matches.
for (int i = 0; i < wordHistory.Count; i++)
{
string historyWord = wordHistory[i];
if (ListWidget.Matches(partialWord, historyWord))
{
for (int xIndex = 0; xIndex < list.filteredItems.Count; xIndex++)
{
string currentWord = DataProvider.GetCompletionText(list.filteredItems[xIndex]);
if (currentWord == historyWord)
{
idx = xIndex;
break;
}
}
}
}
}
return(idx);
}
public VerbChoiceVariable(string name, List <string> options, PluginEnvironment plugenv, WordComparer comparer)
: base(name, 100.0, new POSTagger(plugenv), new GrammarParser(plugenv))
{
this.options = options;
this.verbs = new Verbs(plugenv);
this.comparer = comparer;
this.bases = new List <string>();
foreach (string option in options)
{
bases.Add(verbs.InputToBase(option));
}
}
public int[] Optimize()
{
if (!this.Indexed)
{
Reindex();
}
int[] remapping = new int[Count];
int[] indices = new int[Count];
for (int i = 0; i < indices.Length; ++i)
{
indices[i] = i;
}
// First, sort words in descending frequency order
Array.Sort(indices, new CountDescendingComparer(this));
// Next, within each set with the same byte length, sort by ordinal
IComparer <int> wordComparer = new WordComparer(this);
int countDone = 0;
int countForLength = 1 << WordCompressor.BitsPerByte;
do
{
int countToDo = Math.Min(countForLength, Count - countDone);
Array.Sort(indices, countDone, countToDo, wordComparer);
countDone += countToDo;
countForLength = countForLength << WordCompressor.BitsPerByte;
} while (countDone < Count);
// Look up the old index for each word to map to the new index
for (int i = 0; i < Count; ++i)
{
remapping[indices[i]] = i;
}
// Rebuild the word set
String8Set newSet = new String8Set(Count, Words.LengthBytes);
for (int i = 0; i < Count; ++i)
{
newSet.Add(Words[indices[i]]);
}
Words = newSet;
// Clear the index (rebuild if needed later)
Index.Clear();
Indexed = false;
return(remapping);
}
public static HashSet <Word> Solver(List <string> Words)
{
WordComparer comparer = new WordComparer();
HashSet <Word> accepted = new HashSet <Word>(comparer);
HashSet <Word> rejected = new HashSet <Word>(comparer);
foreach (string word in Words)
{
Word newWord = new Word();
UInt64 hash = 3074457345618258791ul;
foreach (char letter in word)
{
newWord.Letters[letter - 97] += 1;
hash = hash ^ (letter ^ 3074457345618258799ul);
}
newWord.Hash = hash;
newWord.origin = word;
if (rejected.Contains(newWord))
{
continue;
}
else
{
if (accepted.Contains(newWord))
{
accepted.Remove(newWord);
rejected.Add(newWord);
}
else
{
accepted.Add(newWord);
}
}
}
return(accepted);
}
public void SetUp()
{
_comparer = new WordComparer();
}
public void PrepareAttack()
{
// Test input
if (this.calpha == null || this.ctext == null || this.freq == null || this.lDic == null)
{
return;
}
List <Byte[]> text_in_words = this.ctext.ToSingleWords(this.calpha);
// Add only unigue words
WordComparer word_comparer = new WordComparer();
for (int i = 0; i < text_in_words.Count; i++)
{
Word w = new Word(i, text_in_words[i]);
bool vorhanden = false;
for (int j = 0; j < this.words.Count; j++)
{
if (word_comparer.Compare(w, this.words[j]) == 0)
{
vorhanden = true;
}
}
if (vorhanden == false)
{
this.words.Add(w);
}
if (this.stopFlag == true)
{
return;
}
}
// Look up words with same pattern in dictionary
foreach (Word w in words)
{
w.Candidates = GetCandidates(w);
if (w.Candidates == null || w.Candidates.Length == 0)
{
w.Enabled = false;
}
}
// Generate order of ciphertext letters
int[] letter_frequencies = new int[this.calpha.GetAlphabetQuantity()];
foreach (Word w in this.words)
{
for (int i = 0; i < w.ByteValue.Length; i++)
{
letter_frequencies[w.ByteValue[i]]++;
}
}
this.histogram = letter_frequencies;
this.historder = new byte[letter_frequencies.Length];
for (int i = 0; i < this.historder.Length; i++)
{
this.historder[i] = (byte)i;
}
for (int i = 0; i < letter_frequencies.Length; i++)
{
for (int j = i + 1; j < letter_frequencies.Length; j++)
{
if (letter_frequencies[j] > letter_frequencies[i])
{
int helper = letter_frequencies[i];
letter_frequencies[i] = letter_frequencies[j];
letter_frequencies[j] = helper;
helper = this.historder[i];
this.historder[i] = this.historder[j];
this.historder[j] = (byte)helper;
}
}
}
// Calculate max progress
int nr = this.words.Count;
int v1 = 0;
int v2 = 0;
if (nr < 200)
{
for (int i = 0; i < nr; i++)
{
if (nr < 70)
{
for (int j = i + 1; j < nr; j++)
{
if (nr < 30)
{
for (int t = j + 1; t < nr; t++)
{
v2++;
}
}
v1++;
}
}
}
}
this.maxProgressIt = (1 + nr + v1 + v2 + 300);
}
public PhraseChoiceVariable(string name, List <List <string> > options, PluginEnvironment plugenv, WordComparer comparer)
: base(name, 100.0, new POSTagger(plugenv), new GrammarParser(plugenv))
{
this.options = options;
this.comparer = comparer;
}
public WordChoiceVariable(string name, List <string> options, WordComparer comparer)
: base(name)
{
this.options = options;
this.comparer = comparer;
}
