private List <string> GetKeywords()
{
Console.WriteLine("Keywords:");
string keywords = Console.ReadLine();
keywords = keywords.ToLower() + " ";
IList <string> tokens = StandartSplitter.Split(keywords);
List <string> stems = new List <string>();
Language tr = LanguageFactory.Create(LanguageType.Turkish);
int ind = 0;
foreach (string token in tokens)
{
if (token.Equals("dokuz"))
{
ind = tokens.IndexOf(token);
}
}
tokens[ind] = "eylül";
foreach (string token in tokens)
{
IList <Word> solutions = tr.Analyze(token);
if (solutions.Count > 0)
{
if (!IsStopWord(solutions[solutions.Count - 1].GetStem().GetSurface()))
{
stems.Add(solutions[solutions.Count - 1].GetStem().GetSurface());
}
}
}
return(stems);
}
private static Word GetSolution(ConjugationLine entry, Language language)
{
foreach (Word solution in language.Analyze(entry.Verb))
{
if (solution.ToString() == entry.Solution)
{
return(solution);
}
}
throw new Exception("Çekimli Fiil için çözüm bulunamadı");
}
public static void Analyze(Language language, IEnumerable<string> words)
{
foreach (string word in words)
{
IList<Word> solutions = language.Analyze(word);
Console.WriteLine("\n{0} için {1} çözüm bulundu:", word, solutions.Count);
foreach (Word solution in solutions)
{
Console.WriteLine($"\t{solution}\n");
//Console.WriteLine($"\t{solution.ToString(WordFormat.MyFormat)}\n");
}
}
}
public static void Analyze(Language language, IEnumerable <string> words)
{
foreach (string word in words)
{
IList <Word> solutions = language.Analyze(word);
Console.WriteLine("\n{0} için {1} çözüm bulundu:", word, solutions.Count);
foreach (Word solution in solutions)
{
Console.WriteLine($"\t{solution}\n");
//Console.WriteLine($"\t{solution.ToString(WordFormat.MyFormat)}\n");
}
}
}
/// <summary>
/// Kelimelerin sadece ilk çözümlerini kullanan bir ContainsAnalysis(token, analysis) testi üretir.
/// Kelimelerden birinin çözümünün olmaması halinde exception verir.
/// </summary>
/// <param name="words"></param>
/// <param name="testName"></param>
/// <returns></returns>
public static string GenerateContainsAnalysisTest(string[] words, string testName)
{
var sb = new StringBuilder("");
foreach (string word in words)
{
IList <Word> solutions = Language.Analyze(word);
try
{
sb.AppendFormat("[TestCase(\"{0}\", \"{1}\"", word, solutions[0]);
}
catch (Exception)
{
Console.WriteLine(word + " çözümlenemedi.");
}
sb.Append(")]").Append("\n");
}
sb.AppendFormat("public void {0}Test(string token, string analysis)", testName).AppendLine();
sb.Append("{").AppendLine();
sb.Append("\tTester.ContainsAnalysis(token, analysis);").AppendLine();
sb.Append("}").AppendLine();
return(sb.ToString());
}
private string DeleteSuffixes(string text)
{
var words = text.Split(' ');
string result = "";
foreach (var word in words)
{
IList <Word> solutions = tr.Analyze(word);
if (solutions.Any())
{
result += solutions[0].GetStem().GetSurface() + "_";
}
}
return(result);
}
/// <summary>
/// Aranan çözümlerin hepsinin kelimenin çözümleri içerisinde bir ve yalnız bir adet mevcut olup olmadığına
/// bakar. Mesela aranan çözümler {a,b}, kelimenin çözümleri {a,b,c} olsun test başarılıdır.
/// aranan çözümler {a,b}, kelimenin çözümleri {a,c,d} olsun test başarısızdır.
/// Aranan çözümler {a,b}, kelimenin çözümleri {a,a,b} ise test başarısızdır.
/// Aranan çözüm tek ise {a} ContainsAnalysis metodu ile aynı çıktıyı üretir.
/// Aranan çözümlerin hangi sırada verildiği önemli değildir.
/// </summary>
/// <param name="token">kelime</param>
/// <param name="expectedAnalyses">aranan çözümler</param>
public static void ContainsAnalyses(string token, string[] expectedAnalyses)
{
IList <Word> words = Language.Analyze(token);
foreach (string expectedAnalysis in expectedAnalyses)
{
int matchingAnalysisCount = words.Count(w => w.Analysis.Equals(expectedAnalysis));
Assert.AreEqual(1, matchingAnalysisCount);
}
}
string CekimEkleriniTemizle(string metin) // çekim eklerini temizler
{
string[] kelimeler = metin.Split(' '); //metindeki her kelimeyi alır
Language tr = LanguageFactory.Create(LanguageType.Turkish); //nuve kütüphanesi
string sonhali = "";
for (int i = 0; i < kelimeler.Length; i++)
{
IList <Word> kokler = tr.Analyze(kelimeler[i]); // kelimenin analizi
if (kokler.Count > 0) // sonuc varsa
{
sonhali += kokler[0].GetStem().GetSurface() + "_"; // kelimenin govdesini al(GetStem) ve stringe çevir(GetSurface)
}
}
return(sonhali);
}
public static string[] ReplaceRoots(string root, string[] words)
{
Language turkish = LanguageFactory.Create(LanguageType.Turkish);
var replacedWords = new List <string>();
foreach (string word in words)
{
IEnumerable <Word> solutions = turkish.Analyze(word);
foreach (Word solution in solutions)
{
string output = solution.GetSurface();
solution.Root = turkish.GetRootsHavingSurface(root).First();
output += "\t" + solution.GetSurface();
replacedWords.Add(output);
}
}
return(replacedWords.ToArray());
}
private void KelimeKokleriniBul()
{
bool girdi = false;
Language tr = LanguageFactory.Create(LanguageType.Turkish);
IList <Word> words;
foreach (string gelen in DosyaKelimeler)
{
girdi = false;
//Console.WriteLine(gelen);
words = tr.Analyze(gelen);
if (words.Count != 0)
{
if (sozluk.ContainsKey(words[0].GetStem().ToString().Split('/')[0]))
{
sozluk[words[0].GetStem().ToString().Split('/')[0]]++;
girdi = true;
}
if (!girdi)
{
sozluk.Add(words[0].GetStem().ToString().Split('/')[0], 1);
girdi = false;
}
}
else
{
if (sozluk.ContainsKey(gelen))
{
sozluk[gelen]++;
girdi = true;
}
if (!girdi)
{
sozluk.Add(gelen, 1);
girdi = false;
}
}
}
}
private void Create()
{
for (int k = 0; k < uniNames.Length; k++)
{
int uniPageCounter = 0;
foreach (string filePath in Directory.GetFiles(@"C:\Users\Gokce\Desktop\" + uniNames[k]))
{
int pageIndex = Convert.ToInt32(Path.GetFileName(filePath).Split('.')[0]);
pageCount++;
uniPageCounter++;
pageIndexes[k].Add(Convert.ToInt32(Path.GetFileName(filePath).Split('.')[0]));
// Sayfalar okundu ve kucuk harfe cevrildi.
byte[] byteArray = File.ReadAllBytes(filePath);
string page = Encoding.UTF8.GetString(byteArray);
page = page.ToLower();
// Kelimeler birbirinden ayrildi.
IList <string> tokens = StandartSplitter.Split(page);
// Kelimeler kok haline getirildi.
List <string> stems = new List <string>();
Language tr = LanguageFactory.Create(LanguageType.Turkish);
foreach (string token in tokens)
{
IList <Word> solutions = tr.Analyze(token);
if (solutions.Count > 0)
{
if (!IsStopWord(solutions[solutions.Count - 1].GetStem().GetSurface()))
{
stems.Add(solutions[solutions.Count - 1].GetStem().GetSurface());
}
}
}
// Vocabulary - inverted index olusturuldu.
bool found = false;
for (int i = 0; i < stems.Count; i++)
{
found = false;
for (int j = 0; j < i; j++)
{
if (stems[j] == stems[i])
{
found = true;
break;
}
}
if (!found)
{
if (vocabulary.Count != 0)
{
foreach (VocabItem item in vocabulary)
{
if (item.word.Equals(stems[i]))
{
found = true;
List <int> indexes = Enumerable.Range(0, stems.Count).Where(x => stems[x] == stems[i]).ToList();
item.AddIndexes(uniNames[k], pageIndex, indexes); //
break;
}
}
}
if (!found)
{
VocabItem myVocabItem = new VocabItem(stems[i], uniNames[k]);
List <int> indexes = Enumerable.Range(0, stems.Count).Where(x => stems[x] == stems[i]).ToList();
myVocabItem.AddIndexes(uniNames[k], pageIndex, indexes);
vocabulary.Add(myVocabItem);
}
}
}
}
uniPageCounts.Add(uniPageCounter);
}
}
private static Word GetSolution(ConjugationLine entry, Language language)
{
foreach (Word solution in language.Analyze(entry.Verb))
{
if (solution.ToString() == entry.Solution)
{
return solution;
}
}
throw new Exception("Çekimli Fiil için çözüm bulunamadı");
}
public void tokenize(string path, int classIndex)
{
StreamReader r = new StreamReader(path, Encoding.GetEncoding("windows-1254"));
Language tr = LanguageFactory.Create(LanguageType.Turkish);
string line;
string[] rawWords;
string[] token;
string analyzMax = "";
int analyzMaxL = Int32.MinValue;
string temp;
int tempL;
int docMax = Int32.MinValue;
int docMax2 = Int32.MinValue;
int analyzL;
int tokenL;
Dictionary <string, int> document = new Dictionary <string, int>();
while (!r.EndOfStream)//tokenizer kısımları
{
line = r.ReadLine();
rawWords = Regex.Split(line, @"((\)('|’)\w+)|\W('|’)|('|’)\W|^('|’)|$('|’)|\d+('|’)\w+|\d+\w+|\d+[^a-zA-Z ]+\w+|\w+\d+|\d+|(\)|\())|[^\w('|’)]", RegexOptions.ExplicitCapture | RegexOptions.Compiled);
//Büyülü regex'e göre metini parçalara ayırır
foreach (string w in rawWords)
{
//boş stringler ve istenmeyen bazı durumlar da -örneğin sayılar- atılır
if (w != "" && Regex.IsMatch(w, @"\D\w", RegexOptions.Compiled))
{
analyzMaxL = Int32.MinValue;
analyzMax = "";
//daha çok büyülü regex
token = Regex.Split(w, @"(\W*)('|’)(\w+|\W+)", RegexOptions.ExplicitCapture | RegexOptions.Compiled);
token[0] = token[0].ToLower();
IList <Word> solutions = tr.Analyze(token[0]);//morfolojik analiz
foreach (var solution in solutions)
{
temp = solution.GetStem().GetSurface(); //Stemming
tempL = temp.Length;
//Genel olarak köke ne kadar az yaklaşırsa metinle o kadar alakalı
//olduğunu tespit ettik bu yüzden en uzun stemi aldık
if (tempL > analyzMaxL)
{
analyzMaxL = tempL;
analyzMax = temp;
}
}
analyzL = analyzMax.Length;
tokenL = token[0].Length;
//stop words leri eliyor
if (analyzMax != "")
{
if (analyzL > 2 && !stopWords.Contains(analyzMax))
{
if (corpus.ContainsKey(analyzMax))
{
corpus[analyzMax]++;
}
else
{
corpus.Add(analyzMax, 1);
wordIndex.Add(analyzMax, Index);
Index++;
}
if (document.ContainsKey(analyzMax))
{
document[analyzMax]++;
}
else
{
document.Add(analyzMax, 1);
}
}
}
else
{
if (token[0].Length > 2 && !stopWords.Contains(token[0]))
{
if (corpus.ContainsKey(token[0]))
{
corpus[token[0]]++;
}
else
{
corpus.Add(token[0], 1);
wordIndex.Add(token[0], Index);
Index++;
}
if (document.ContainsKey(token[0]))
{
document[token[0]]++;
}
else
{
document.Add(token[0], 1);
}
}
}
if (analyzL > 2 && !stopWords.Contains(analyzMax))
{
if (document[analyzMax] > docMax)
{
docMax2 = docMax;
docMax = document[analyzMax];
}
else if (document[analyzMax] > docMax2)
{
docMax2 = document[analyzMax];
}
else
{
if (tokenL > 2 && !stopWords.Contains(token[0]) && analyzMax == "")
{
if (document[token[0]] > docMax)
{
docMax2 = docMax;
docMax = document[token[0]];
}
else if (document[token[0]] > docMax2)
{
docMax2 = document[token[0]];
}
}
}
}
}
}
}
DocumentMax.Add(new int[] { docMax, docMax2 });
DocumentClassIndex.Add(classIndex);
DocumentWordFreq.Add(document);
}
