public void Levenshtein_distance_throws_exception_if_input_string__is_null()
{
var levenshtein = new Levenshtein();
Assert.ThrowsException <ArgumentNullException>(() => levenshtein.CalculateDistance("test", null));
Assert.ThrowsException <ArgumentNullException>(() => levenshtein.CalculateDistance(null, "test"));
Assert.ThrowsException <ArgumentNullException>(() => levenshtein.CalculateDistance(null, null));
}
public void Levenshtein_distance_calculation_if_strings_are_different()
{
var levenshtein = new Levenshtein();
Assert.AreEqual(1, levenshtein.CalculateDistance("test1", "test2"));
Assert.AreEqual(1, levenshtein.CalculateDistance("test", "tst"));
Assert.AreEqual(2, levenshtein.CalculateDistance("test", "tset"));
Assert.AreEqual(2, levenshtein.CalculateDistance("test", "tste"));
Assert.AreEqual(3, levenshtein.CalculateDistance("test", "etts"));
}
public void Test_grid_over_2GB()
{
var webClient = new WebClient();
var html1 = webClient.DownloadString("http://www.google.com");
var s = html1.Substring(0, 23743); // 4*23743^2 = 2.1gb memory
var distance = Levenshtein.CalculateDistance(s, s, 1);
distance.Should().Be(0);
}
public void Levenshtein_distance_calculation_with_specified_equality_comparer()
{
var equalityComparer = new Mock <IEqualityComparer <char> >(MockBehavior.Strict);
equalityComparer
.Setup(t => t.Equals(It.IsAny <char>(), It.IsAny <char>()))
.Returns <char, char>((x, y) => x == 't' || y == 't');
var levenshtein = new Levenshtein(equalityComparer.Object);
Assert.AreEqual(2, levenshtein.CalculateDistance("test", "test"));
}
public async Task <List <Tag> > SearchTagsAsync(Snowflake guildId, string searchQuery)
{
var tags = await RetrieveTagsAsync(guildId);
return(tags
.Select(x => (Levenshtein.CalculateDistance(x.Name, searchQuery, 2), x))
.Where(x => x.Item1 <= 5)
.OrderBy(x => x.Item1)
.Select(x => x.Item2)
.ToList());
}
public void WhatDoTheNumbersMean()
{
const string input = "339 E 200 S";
const string candidate1 = "339 E 200 S";
const string candidate2 = "339 E 200 N";
var xDistance = Levenshtein.CalculateDistance(input, candidate1, 1);
var yDistance = Levenshtein.CalculateDistance(input, candidate2, 1);
var comparison = xDistance.CompareTo(yDistance);
// since smaller is better
Assert.That(comparison, Is.EqualTo(-1));
}
private static string hidden = "germany lost"; //Only for lowercase chars and numbers, you can customize accordingly.
public static int Try(string text, int found)
{
Random rand = new Random();
int fix = rand.Next(-1, 0);
switch (found)
{
case 1: break;
case 2: Console.Write("Fixed: " + (fix + Levenshtein.CalculateDistance(hidden, text, 1)) + " ");
Console.Write("Original: " + Levenshtein.CalculateDistance(hidden, text, 1) + "\n");
break;
}
return(fix + Levenshtein.CalculateDistance(hidden, text, 1));
}
public static Card GetCardByName(string input, ICollection <Card> collection)
{
float closest = float.MaxValue;
Card closestCard = null;
foreach (var card in collection)
{
float distance = Levenshtein.CalculateDistance(input, card.name, 1) / (float)card.name.Length;
if (distance < closest)
{
closest = distance;
closestCard = card;
}
}
return(closestCard);
}
public int Compare(Candidate x, Candidate y)
{
var compareTo = y.Score.CompareTo(x.Score);
if (compareTo != 0)
{
return(compareTo);
}
var weight = y.Weight.CompareTo(x.Weight);
if (weight != 0)
{
return(weight);
}
var xDistance = Levenshtein.CalculateDistance(_address, x.Address, 1);
var yDistance = Levenshtein.CalculateDistance(_address, y.Address, 1);
return(xDistance.CompareTo(yDistance));
}
public DplSearchResult SearchDpl(DplSearch searchQuery)
{
if (searchQuery == null)
{
throw new ArgumentNullException(nameof(searchQuery));
}
var clauses = searchQuery.GetClauses();
if (!clauses.Any())
{
throw new ArgumentException("DPL Search does not contain any clauses.", nameof(searchQuery));
}
IEnumerable <DplEntry> entries = Repository.DplEntries;
foreach (var clause in clauses)
{
switch (clause.MatchType)
{
case DplSearchMatchType.Exact:
switch (clause.DplField)
{
case DplFields.City:
entries = entries.Where(x => string.Equals(x.City, clause.Value, StringComparison.OrdinalIgnoreCase));
break;
case DplFields.CountryCode:
entries = entries.Where(x => string.Equals(x.CountryCode, clause.Value, StringComparison.OrdinalIgnoreCase));
break;
case DplFields.Name:
entries = entries.Where(x => string.Equals(x.Name, clause.Value, StringComparison.OrdinalIgnoreCase));
break;
case DplFields.Notes:
entries = entries.Where(x => string.Equals(x.Notes, clause.Value, StringComparison.OrdinalIgnoreCase));
break;
case DplFields.StateCode:
entries = entries.Where(x => string.Equals(x.StateCode, clause.Value, StringComparison.OrdinalIgnoreCase));
break;
}
break;
case DplSearchMatchType.Similar:
float threshold = 0.3125f;
switch (clause.DplField)
{
case DplFields.City:
entries = entries.Where(x => (Levenshtein.CalculateDistance(x.City, clause.Value, 1) / (float)clause.Value.Length) < threshold);
break;
case DplFields.CountryCode:
entries = entries.Where(x => (Levenshtein.CalculateDistance(x.CountryCode, clause.Value, 1) / (float)clause.Value.Length) < threshold);
break;
case DplFields.Name:
entries = entries.Where(x => (Levenshtein.CalculateDistance(x.Name, clause.Value, 1) / (float)clause.Value.Length) < threshold);
break;
case DplFields.Notes:
entries = entries.Where(x => (Levenshtein.CalculateDistance(x.Notes, clause.Value, 1) / (float)clause.Value.Length) < threshold);
break;
case DplFields.StateCode:
entries = entries.Where(x => (Levenshtein.CalculateDistance(x.StateCode, clause.Value, 1) / (float)clause.Value.Length) < threshold);
break;
}
break;
case DplSearchMatchType.Contains:
switch (clause.DplField)
{
case DplFields.City:
entries = entries.Where(x => x.City.IndexOf(clause.Value, StringComparison.OrdinalIgnoreCase) != -1);
break;
case DplFields.CountryCode:
entries = entries.Where(x => x.CountryCode.IndexOf(clause.Value, StringComparison.OrdinalIgnoreCase) != -1);
break;
case DplFields.Name:
entries = entries.Where(x => x.Name.IndexOf(clause.Value, StringComparison.OrdinalIgnoreCase) != -1);
break;
case DplFields.Notes:
entries = entries.Where(x => x.Notes.IndexOf(clause.Value, StringComparison.OrdinalIgnoreCase) != -1);
break;
case DplFields.StateCode:
entries = entries.Where(x => x.StateCode.IndexOf(clause.Value, StringComparison.OrdinalIgnoreCase) != -1);
break;
}
break;
default:
throw new ArgumentException($"{nameof(DplSearchMatchType)} value not defined.", nameof(searchQuery));
}
}
var hits = entries.ToList();
var result = new DplSearchResult()
{
Hits = hits,
TotalHits = hits.Count,
ReportDateTime = DateTime.Now
};
return(result);
}
public void One_letter_to_empty()
{
Levenshtein.CalculateDistance("a", "", 2).Should().Be(1);
}
public void One_substitution_cost2()
{
Levenshtein.CalculateDistance("a", "b", 2).Should().Be(2);
}
public void Levenshtein_distance_is_zero_if_the_two_string_are_equal()
{
var levenshtein = new Levenshtein();
Assert.AreEqual(0, levenshtein.CalculateDistance("test", "test"));
}
public void Three_substitutions_cost2()
{
Levenshtein.CalculateDistance("abc", "def", 2).Should().Be(6);
}
public void Kitten_to_sitting_substitutions_cost_1()
{
Levenshtein.CalculateDistance("kitten", "sitting", 1).Should().Be(3);
}
public void Empty_to_1_letter()
{
Levenshtein.CalculateDistance("", "s", 2).Should().Be(1);
}
public void ArbitrateBetweenTags()
{
/*
* Arbitrage de quels tags sont gardés pour le nouveau fichier.
* Si l'ancien est vide, on met le nouveau.
* Si l'ancien n'est pas vide, on garde Artiste / Album / Titre (probablement fiable),
* et on update les genres si on a plus d'infos que avant (plus riche probablement)
*
* Todo:
+ Checker plus fin pour les genres (comparer la liste, et garder tous les tags, sans doublons
*/
string emptyTag = string.Empty;
List <string> compareTags = new List <string>();
PropertyInfo[] tagsProps = typeof(TagHandler).GetProperties();
foreach (var propName in Enum.GetValues(typeof(PropertiesForUser)))
{
foreach (PropertyInfo p in tagsProps)
{
if (propName.ToString() == p.Name)
{
// S'il le tag n'a pas changé, on ne fait rien.
if (p.GetValue(NewTags) != p.GetValue(AcrTags))
{
// Pour tous, on check si l'ancien est vide. Dans ce cas on overide le nouveau
if (p.GetValue(NewTags).ToString() == emptyTag)
{
p.SetValue(NewTags, p.GetValue(AcrTags));
compareTags.Add($"{p.GetValue(OriginalTags)} to {p.GetValue(AcrTags)}");
}
else
{
// Puis on gère les cas particuliers
switch (p.Name)
{
case "Genre":
if (p.GetValue(NewTags).ToString().Length < p.GetValue(AcrTags).ToString().Length)
{
p.SetValue(NewTags, p.GetValue(AcrTags));
compareTags.Add($"{p.GetValue(OriginalTags)} to {p.GetValue(AcrTags)}");
}
break;
}
if (p.Name != "Year")
{
string s1 = p.GetValue(NewTags).ToString();
string s2 = p.GetValue(AcrTags).ToString();
if (s1 != s2)
{
float ratio = 1 - (float)Levenshtein.CalculateDistance(s1, s2, 1) / (float)s2.Length;
if (ratio >= 0.75)
{
p.SetValue(NewTags, p.GetValue(AcrTags));
compareTags.Add($"{p.GetValue(OriginalTags)} to {p.GetValue(AcrTags)}");
}
}
}
}
}
}
}
}
Logger.Instance.ArbitrateNewTagsLog(this, compareTags);
}
