public void CatchWordSwaps() {
var source = SimpleTokeniser.Tokenise("how now brown cow");
var target = SimpleTokeniser.Tokenise("how brown now cow");
var ld2 = new LevenshteinDistance();
Assert.AreEqual(1, ld2.DamerauLevenshteinDistance(source.ToArray(), target.ToArray()));
LevenshteinDistance ld = new LevenshteinDistance();
Assert.AreEqual(2, ld.Computer(source.ToArray(), target.ToArray()));
}
static void Main(string[] args) {
//Console.ReadLine();
var source = SimpleTokeniser.Tokenise("how now brown cow").ToArray();
var target = SimpleTokeniser.Tokenise("how brown now cow").ToArray();
const int reps = 1000000;
var ld = new LevenshteinDistance();
for (int i = 0; i < reps; i++) {
ld.DamerauLevenshteinDistance(source, target);
}
Console.Out.WriteLine(".");
Console.ReadLine();
}
public string GetCode()
{
LevenshteinDistance ld = new LevenshteinDistance();
DataTable dt = SingleCodes.Instance.DataTable;
string value = string.Empty;
for (int i = 0; i < dt.Rows.Count; i++)
{
value = dt.Rows[i][2].ToString();
decimal parent = ld.LevenshteinDistancePercent(value, code01);
if (parent > 0.85m)
{
if (!sl.ContainsKey(parent))
{
sl.Add(parent, dt.Rows[i][1]);
}
}
}
return sl.GetByIndex(sl.Count - 1).ToString();
}
public void DistanceTest() {
string source = "how now brown cow";
string target = "how now brown crow";
// segment
var sourceSegs = source.Split(new char[] {' '});
var targetSegs = target.Split(new char[] {' '});
DateTime a = DateTime.Now;
int reps = 10000;
for (int i = 0; i < reps; i++ ) {
LevenshteinDistance.EditDistance(sourceSegs, targetSegs);
}
Assert.AreEqual(1, LevenshteinDistance.EditDistance(sourceSegs, targetSegs));
var b = DateTime.Now - a;
DateTime c = DateTime.Now;
var ld = new LevenshteinDistance();
for (int i = 0; i < reps; i++ ) {
ld.Computer(sourceSegs, targetSegs);
}
Assert.AreEqual(1, ld.Computer(sourceSegs, targetSegs));
var d = DateTime.Now - c;
// the static way is slower
Assert.IsTrue(b > d);
// no matter the order
a = DateTime.Now;
for (int i = 0; i < reps; i++) {
LevenshteinDistance.EditDistance(sourceSegs, targetSegs);
}
Assert.AreEqual(1, LevenshteinDistance.EditDistance(sourceSegs, targetSegs));
b = DateTime.Now - a;
Assert.IsTrue(b > d);
var sourceChars = CharacterTokeniser.Tokenise(source);
var targetChars = CharacterTokeniser.Tokenise(target);
Assert.AreEqual(1, ld.Computer(sourceChars.ToArray(), targetChars.ToArray()));
}
/// <summary>
/// 根据样本识别并计算结果
/// </summary>
/// <param name="pics"></param>
public int Calculate(Bitmap[] pics)
{
List <code> codes = new List <code>();
LevenshteinDistance ld = new LevenshteinDistance();
string result = string.Empty;
int a = 0;
int b = 0;
int total = 0;
string option = string.Empty;
codes.Clear();
using (StreamReader sr = new StreamReader(path + @"\DigitalDotMatrix.ini"))
{
while (!sr.EndOfStream)
{
string[] temp = sr.ReadLine().Split(':');
code c = new code();
c.Key = temp[1];
c.Value = temp[0];
codes.Add(c);
}
}
for (int i = 0; i < 3; i++)
{
string code = vfc.GetSingleBmpCode(pics[i], 128);//得到代码串
decimal max = 0.0M;
string value = "";
for (int m = 0; m < codes.Count; m++)
{
code c = codes[m];
decimal parent = ld.LevenshteinDistancePercent(code, c.Key);
if (parent > max)
{
max = parent;
value = c.Value;
}
}
if (IsNumeric(value) && i == 0)
{
a = int.Parse(value);
}
else if (IsNumeric(value) && i == 2)
{
b = int.Parse(value);
}
else
{
option = value;
}
result = result + value;
}
switch (option)
{
case "-":
{
total = a - b;
break;
}
case "+":
{
total = a + b;
break;
}
default:
break;
}
return(total);
}
public void RaceTime() {
var source = SimpleTokeniser.Tokenise("how now brown cow").ToArray();
var target = SimpleTokeniser.Tokenise("how brown now cow").ToArray();
const int reps = 1000000;
DateTime a = DateTime.Now;
LevenshteinDistance ldd = new LevenshteinDistance();
for (int i = 0; i < reps; i++) {
ldd.DamerauLevenshteinDistance(source, target);
}
var b = DateTime.Now - a;
DateTime c = DateTime.Now;
LevenshteinDistance ld = new LevenshteinDistance();
for (int i = 0; i < reps; i++) {
ld.Computer(source, target);
}
var d = DateTime.Now - c;
Assert.IsTrue(b > d);
}
public KeyValuePair <string, bool> SynonymMatch(List <string> vocabList, List <ChatIntent> intentList)
{
bool hasMatch = false;
string responseMessage = contentManager.IntentPossibleMatchedResponse;
int counter = 0;
AskMezPossibleMatch possibleMatch = new AskMezPossibleMatch(Message, Node);
LevenshteinDistance dist = new LevenshteinDistance();
TFIDF getVocab = new TFIDF();
List <string> responseList = new List <string>();
foreach (string vocab in vocabList)
{
string json;
url = url + vocab;
List <string> synonymList = new List <string>();
using (WebClient client = new WebClient())
{
try
{
json = client.DownloadString(url);
SynonymDto synonym = Newtonsoft.Json.JsonConvert.DeserializeObject <SynonymDto>(json);
foreach (var def in synonym.def)
{
foreach (var tr in def.tr)
{
foreach (var mean in tr.mean)
{
synonymList.Add(mean.text);
}
}
}
}
catch (Exception)
{
}
}
foreach (ChatIntent intent in intentList)
{
if (possibleMatch.CheckIfRedirect(intent, intentList))
{
continue;
}
string intentDesc = intent.IntentDescription;
List <string> intentvocabList = getVocab.GetVocabulary(intentDesc);
bool hasSynonm = synonymList.Intersect(intentvocabList).Any();
if (hasSynonm && counter <= 3)
{
counter = counter + 1;
responseList.Add(intentDesc);
}
}
}
responseList = (responseList.Count > 1) ? responseList.Distinct().Take(3).ToList() : responseList;
foreach (string response in responseList)
{
responseMessage = responseMessage + "<br>";
responseMessage = responseMessage + response;
}
responseMessage = responseMessage + "<br>" + contentManager.IntentSuggestionResponse;
if (counter > 0)
{
return(new KeyValuePair <string, bool>(responseMessage, true));
}
return(new KeyValuePair <string, bool>(responseMessage, hasMatch));
}
/// <summary>
/// Executes all mappings in this adapter and logs timing information.
/// </summary>
public void ExecuteProcessMappingsDebugTimer()
{
//Log.Info($"Processing message using adapter: {AdapterName}.");
var s = new Stopwatch();
s.Start();
Mappings.ToList().ForEach(x => x.ProcessMappings(this));
s.Stop();
var timeTaken = s.Elapsed.TotalSeconds.ToString(CultureInfo.InvariantCulture);
var allLeafNodes = OpenEhrRecord.All(new List <Component>()).Where(x =>
x.GetType() == typeof(Leaf) &&
Mappings.Any(y => LevenshteinDistance.Compute(y.OpenEhrFieldPath, x.Parent.Name) <= 10)).ToList();
var totalNodeCount = allLeafNodes.Count;
double confidence = (double)SuccessfulMappingCount / (double)totalNodeCount * 100;
ConfidenceScore = confidence;
//Log.Info($"Completed processing of message in {timeTaken} seconds using adapter: {AdapterName}, generated confidence of {confidence}%.\n");
}
public void RunAutoComplete(string input, List <string> corpus, AutocompleterInteractable[] autocompleters)
{
if (input.Length > 0)
{
char[] lastChar = input.Substring(input.Length - 1).ToCharArray();
string lastWord = input.Split(' ').Last();
char[] firstCharOfLastWord = lastWord.Substring(0).ToCharArray();
if (firstCharOfLastWord.Length >= 1)
{
if (firstCharOfLastWord[0].ToString().Any(char.IsUpper))
{
IsFirstLetterUpper = true;
}
else
{
IsFirstLetterUpper = false;
}
}
if (!char.IsWhiteSpace(lastChar[0]))
{
if (lastWord.Length < MaxWordLength)
{
if (input.Length >= 0)
{
Dictionary <int, int> dict = new Dictionary <int, int> ();
for (int i = 0; i < corpus.Count; i++)
{
int cost = LevenshteinDistance.Compute(lastWord.ToLower(), corpus[i]);
if (cost >= MinLevenshteinCost && cost <= MaxLevenshteinCost)
{
dict.Add(i, cost);
}
}
if (lastWord.All(char.IsUpper))
{
IsUppercase = true;
}
if (lastWord.Any(char.IsLower))
{
IsUppercase = false;
}
List <int> distanceOrder = dict.OrderBy(kp => kp.Value).Select(kp => kp.Key).ToList();
for (int i = 0; i < distanceOrder.Count; i++)
{
if (i < autocompleters.Length)
{
if (IsUppercase)
{
autocompleters [i].SetText(corpus [distanceOrder [i]].ToUpper());
}
else if (IsFirstLetterUpper && IsUppercase == false)
{
autocompleters [i].SetText(char.ToUpper(corpus [distanceOrder [i]][0]) + corpus [distanceOrder [i]].Substring(1));
}
else if (!IsUppercase && IsFirstLetterUpper == false)
{
autocompleters [i].SetText(corpus [distanceOrder [i]].ToLower());
}
}
}
}
}
}
}
}
public Dictionary <string, string> GetListByStr(string str)
{
Dictionary <string, string> dic = new();
List <Idiom> items;
bool queryPrevDailyIdioms = false;//查询往日成语
Dictionary <string, List <long> > kv = new();
//if (str == "我全都要")
//{
// items = _idioms.Find(new BsonDocument()).Sort(Builders<Idiom>.Sort.Ascending("Name")).ToList();
//}
if (str == "试试手气")
{
items = _idioms.Aggregate().AppendStage <Idiom>("{$sample:{size:5}}").ToList();
}
else if (str == "有待订正")
{
items = _idioms.Find(x => x.ToBeCorrected == true).ToList();
}
else if (str.StartsWith("标签："))
{
items = _idioms.Find(x => x.Tags.Contains(str.Replace("标签：", ""))).ToList();
}
else if (str == "往日成语")
{
//除去deft
List <LaunchInfo> info = _launchInfo.Find(Builders <LaunchInfo> .Filter.Ne("DateUT", DateTimeOffset.MinValue.ToUnixTimeSeconds())).Sort(Builders <LaunchInfo> .Sort.Ascending("DateUT")).ToList();
items = new List <Idiom>();
queryPrevDailyIdioms = true;
if (info.Count > 1)
{
foreach (LaunchInfo itemInfo in info)
{
if (itemInfo.DailyIdiom != null)
{
if (!kv.ContainsKey(itemInfo.DailyIdiom.Id + "_" + itemInfo.DailyIdiom.Name))
{
kv.Add(itemInfo.DailyIdiom.Id + "_" + itemInfo.DailyIdiom.Name, new List <long> {
itemInfo.DateUT
});
}
else
{
kv[itemInfo.DailyIdiom.Id + "_" + itemInfo.DailyIdiom.Name].Add(itemInfo.DateUT);
}
}
}
}
}
else
{
items = _idioms.Find(Builders <Idiom> .Filter.Regex("Name", new BsonRegularExpression(str))).Sort(Builders <Idiom> .Sort.Ascending("Name")).ToList();
}
if (queryPrevDailyIdioms)
{
foreach (var it in kv)
{
StringBuilder sb = new();
foreach (long i in it.Value)
{
DateTimeOffset time = DateTimeOffset.FromUnixTimeSeconds(i);
sb.Append(string.Format("{0:D}", time.ToLocalTime()) + "、");
}
sb.Remove(sb.Length - 1, 1);
string[] strArr = it.Key.Split("_");
dic.Add(strArr[0], sb + "：" + strArr[1]);
}
}
else
{
if (items.Count == 0 && str != "试试手气" && str != "有待订正" && !str.StartsWith("标签：") && str != "往日成语")
{
AutoCollect(str);
ProjectionDefinition <Idiom> definition = Builders <Idiom> .Projection.Include(doc => doc.Name);
Dictionary <string, int> res = LevenshteinDistance.Extract(str, _idioms.Find(new BsonDocument()).ToList().Select(x => x.Name).ToList(), 5);
foreach (var item in res)
{
Idiom tmp = _idioms.Find(x => x.Name == item.Key).FirstOrDefault();
dic.Add(tmp.Id, tmp.Name);
}
}
foreach (Idiom item in items)
{
dic.Add(item.Id, item.Name);
}
}
if (dic.Count == 0)
{
//rtn = new StandardReturn(20001);
throw new EasyException(20001);
}
else
{
return(dic);
}
}
public static int FindMatch(string a, string b)
{
return(LevenshteinDistance.Compute(a, b));
}
public static async Task RecognizeSpeechAsync(bool auth)
{
var config = SpeechConfig.FromSubscription("YOUR SUBSCRIPTION KEY", "region");
// Creates a speech recognizer.
using (var recognizer = new SpeechRecognizer(config))
{
string pathPrograms = "c:\\Users\\bedir\\OneDrive\\Masaüstü\\Programlar"; //
string pathGames = "c:\\Users\\bedir\\OneDrive\\Masaüstü\\Oyunlar";
string[] commands = { "open", "close", "search", "google", "play" }; // "Open" runs an application. "Search" opens a website. "Google" makes a search on google. "Play" opens a game.
string[] programs = Directory.GetFiles(@pathPrograms); //Getting list of all files in the programs directory
string[] games = Directory.GetFiles(@pathGames); //Getting list of all files in the games directory
// Starts speech recognition, and returns after a single utterance is recognized. The end of a
// single utterance is determined by listening for silence at the end or until a maximum of 15
// seconds of audio is processed. The task returns the recognition text as result.
// Note: Since RecognizeOnceAsync() returns only a single utterance, it is suitable only for single
// shot recognition like command or query.
// For long-running multi-utterance recognition, use StartContinuousRecognitionAsync() instead.
var result = await recognizer.RecognizeOnceAsync();
if (result.Text == "")
{
RecognizeSpeechAsync(false).Wait();
}
string speech = result.Text.Substring(0, result.Text.Length - 1).ToLowerInvariant(); //Getting the phrase as text. Removing the last charachter which is a dot.
if (speech == "hello") // First you need to say "Hello" before giving a command.
{
SynthesisToSpeakerAsync("Hello sir. Tell me what to do!").Wait();
RecognizeSpeechAsync(true).Wait();
}
else if (auth)
{
if (speech == "exit")
{
SynthesisToSpeakerAsync("Terminating the program").Wait();
Environment.Exit(1);
}
int firstIndex = speech.IndexOf(" "); // Divide the phrase to two from first space charachter.
if (firstIndex == -1)
{
SynthesisToSpeakerAsync("Please use more than one word to give a command!").Wait();
}
else
{
string[] phrase = { speech.Substring(0, firstIndex), speech.Substring(firstIndex + 1) }; // First phrase is command. Second phrase is the desired app to run.
// Example: if the phrase is "Open Google Chrome" then "Open" is the command and the "Google Chrome" is the app to run.
double maxDistanceComm = 999; // In Levenshtein algorithm, lower the score means higher similarity. So i set max distance 999.
double maxDistanceApp = 999;
int selectedCommand = 0;
string desiredApp = "";
double jaro;
int commandsLength = commands.Length;
for (int i = 0; i < commandsLength; i++)
{
jaro = LevenshteinDistance.Compute(commands[i], phrase[0]);
if (jaro < 3 && jaro < maxDistanceComm)
{
maxDistanceComm = jaro;
selectedCommand = i;
}
}
if (maxDistanceComm > 2)
{
SynthesisToSpeakerAsync("Command: " + phrase[0] + " does not exist!").Wait();
}
else
{
string fileName = "";
string gameName = "";
string selectedFileName = "";
string selectedGameName = "";
if (selectedCommand == 0 || selectedCommand == 1) // If the command is "Open" or "Close"
{
int programsLength = programs.Length;
for (int i = 0; i < programsLength; i++)
{
int lastIndex = programs[i].LastIndexOf("\\");
fileName = programs[i].Substring(lastIndex).ToLowerInvariant(); //Application names come with directory so i remove it
jaro = LevenshteinDistance.Compute(fileName, phrase[1]); //Getting similarity score between phrase and applications
if (jaro < maxDistanceApp)
{
maxDistanceApp = jaro;
desiredApp = programs[i];
selectedFileName = fileName; // Getting the most similar application to phrase that given.
}
}
CmdExecuter(desiredApp, selectedFileName, selectedCommand);
/*
* 1.parameter = App name with path
* 2.parameter = App name
* 3.parameter = "Open" command
*/
}
else if (selectedCommand == 4) // If the command is "Play"
{
int gamesLength = games.Length;
for (int i = 0; i < gamesLength; i++)
{
int lastIndex = games[i].LastIndexOf("\\");
gameName = games[i].Substring(lastIndex).ToLowerInvariant();
jaro = LevenshteinDistance.Compute(gameName, phrase[1]);
if (jaro < maxDistanceApp)
{
maxDistanceApp = jaro;
desiredApp = games[i];
selectedGameName = gameName;
}
}
CmdExecuter(desiredApp, selectedGameName, selectedCommand);
/*
* 1.parameter = Game name with path
* 2.parameter = Game name
* 3.parameter = "Play" command
*/
}
else // If the command is "Google" or "Search"
{
CmdExecuter(pathPrograms + "\\Google Chrome.lnk", phrase[1], selectedCommand);
/*
* 1.parameter = browser path
* 2.parameter = search phrase or website
* 3.parameter = "Google" or "Search" command
*/
}
}
}
}
}
RecognizeSpeechAsync(false).Wait();
}
public async Task <List <RemoteSearchResult> > Search(int[] siteNum, string searchTitle, DateTime?searchDate, CancellationToken cancellationToken)
{
var result = new List <RemoteSearchResult>();
if (siteNum == null || string.IsNullOrEmpty(searchTitle))
{
return(result);
}
string searchJAVID = null;
var splitedTitle = searchTitle.Split();
if (splitedTitle.Length > 1 && int.TryParse(splitedTitle[1], out _))
{
searchJAVID = $"{splitedTitle[0]}-{splitedTitle[1]}";
}
if (!string.IsNullOrEmpty(searchJAVID))
{
searchTitle = searchJAVID;
}
for (var i = 0; i < Database.SiteList.Sites[siteNum[0]].Count; i++)
{
siteNum[1] = i;
var url = Helper.GetSearchSearchURL(siteNum) + searchTitle;
var data = await HTML.ElementFromURL(url, cancellationToken).ConfigureAwait(false);
var searchResults = data.SelectNodesSafe("//div[@class='videos']//div[@class='video']");
if (searchResults.Any())
{
foreach (var searchResult in searchResults)
{
var sceneURL = new Uri(Helper.GetSearchBaseURL(siteNum) + $"/en/?v={searchResult.SelectSingleText(".//a/@id")}");
string curID = Helper.Encode(sceneURL.PathAndQuery),
sceneName = searchResult.SelectSingleText(".//div[@class='title']"),
scenePoster = $"http:{searchResult.SelectSingleText(".//img/@src").Replace("ps.", "pl.", StringComparison.OrdinalIgnoreCase)}",
javID = searchResult.SelectSingleText(".//div[@class='id']");
var res = new RemoteSearchResult
{
ProviderIds = { { Plugin.Instance.Name, curID } },
Name = $"{javID} {sceneName}",
ImageUrl = scenePoster,
};
if (!string.IsNullOrEmpty(searchJAVID))
{
res.IndexNumber = 100 - LevenshteinDistance.Calculate(searchJAVID, javID, StringComparison.OrdinalIgnoreCase);
}
result.Add(res);
}
}
else
{
var sceneURL = new Uri(Helper.GetSearchBaseURL(siteNum) + data.SelectSingleText("//div[@id='video_title']//a/@href"));
var sceneID = new string[] { Helper.Encode(sceneURL.PathAndQuery) };
var searchResult = await Helper.GetSearchResultsFromUpdate(this, siteNum, sceneID, searchDate, cancellationToken).ConfigureAwait(false);
if (searchResult.Any())
{
result.AddRange(searchResult);
}
}
if (result.Any())
{
break;
}
}
return(result);
}
public void Test_Leveinstein_Return_1_When_Called_With_FRA_And_FRâ()
{
Assert.AreEqual(1, LevenshteinDistance.Compute("FRA", "FRâ"));
}
public async Task RunAsync(string[] args)
{
// {{ parameters:
string repository = args[0];
DateTime start = DateTime.Parse(args[1]);
DateTime end = DateTime.Parse(args[2]);
string targetCollection = args[3];
// }}
var distance = new LevenshteinDistance();
var client = new MongoClient(_mongoconnectionStringProvider.GetConnectionString(repository));
var database = client.GetDatabase(repository);
var dup_detection = database.GetCollection <BsonDocument>(targetCollection);
using (var connection = new System.Data.SqlClient.SqlConnection(_mssqlconnectionStringProvider.GetConnectionString()))
{
var threads = connection.Query(SqlQueryFactory.Instance.Get(QUERY_GET_THREAD_PROFILE),
new
{
repository = repository.ToUpper(),
start = start,
end = end
})
.Select(m => new { Title = m.Title, Id = m.Id })
.ToList();
for (int i = 0; i < threads.Count - 1; i++)
{
for (int j = i + 1; j < threads.Count; j++)
{
var left = (threads[i].Title as string).ToLower();
var right = (threads[j].Title as string).ToLower();
var percentage = distance.LevenshteinDistancePercent(left, right) * 100;
// list all the percentage >= 50%
if (percentage >= 50m)
{
var md5 = Utils.ComputeStringPairMD5Hash(left, right);
var count = await dup_detection.Find("{_id: '" + md5 + "'}").CountAsync();
if (count == 0)
{
var dict = new Dictionary <string, object>()
{
{ "_id", md5 },
{ "left", new Dictionary <string, string> {
{ "thread_id", threads[i].Id as string },
{ "text", left as string }
} },
{ "right", new Dictionary <string, string> {
{ "thread_id", threads[j].Id as string },
{ "text", right as string }
} },
{ "percentage", (int)percentage }
};
var document = new BsonDocument(dict);
await dup_detection.InsertOneAsync(document);
}
}
}
}
}
}
public void Test_Leveinstein_Return_0_When_Called_With_Two_Null_Arguments()
{
Assert.AreEqual(0, LevenshteinDistance.Compute(null, null));
}
public void Test_Leveinstein_Return_0_When_Called_With_Two_Identical_Arguments()
{
Assert.AreEqual(0, LevenshteinDistance.Compute("FRA", "FRA"));
}
/// <summary>
/// Wrapper around all sub-mapping execute method; executes all mappings in this adapter.
/// </summary>
public void ExecuteProcessMappings()
{
//Log.Info($"Processing message using adapter: {AdapterName}.");
Mappings.ToList().ForEach(x => x.ProcessMappings(this));
//Log.Info($"Completed processing of message using adapter: {AdapterName}.\n");
var allLeafNodes = OpenEhrRecord.All(new List <Component>()).Where(x =>
x.GetType() == typeof(Leaf) &&
Mappings.Any(y => LevenshteinDistance.Compute(y.OpenEhrFieldPath, x.Parent.Name) <= 10)).ToList();
var totalNodeCount = allLeafNodes.Count;
var confidence = (double)SuccessfulMappingCount / (double)totalNodeCount * 100;
ConfidenceScore = confidence;
//Log.Info($"Completed processing of message using adapter: {AdapterName}, generated confidence of {confidence}%.\n");
}
public static IOrderedEnumerable <TSource> OrderBySimilarity <TSource>(this IEnumerable <TSource> sequence, Func <TSource, string> selector, string pattern)
{
return(sequence.OrderBy(item => LevenshteinDistance.Calculate(selector(item), pattern)));
}
public Task <List <LiteTag> > FindTagsAsync(ulong guildId, string name, int stop)
{
int tolerance = LiteConfiguration.Load().RelatedTagsLimit;
var tags = Tags.Where(x => x.GuildId == guildId && x.Aliases.Any(y => LevenshteinDistance.Compute(name, y) <= tolerance));
var selected = tags.OrderBy(x => x.Aliases.Sum(y => LevenshteinDistance.Compute(name, y))).Take(stop);
return(Task.FromResult(selected.ToList()));
}
public void Invoke(ShPlayer player, string name)
{
var vehicle = Core.Instance.EntityHandler.Vehicles.OrderByDescending(x => LevenshteinDistance.CalculateSimilarity(x.Key, name)).FirstOrDefault().Value;
var pos = player.GetPosition();
Core.Instance.SvManager.AddNewEntity(vehicle, player.GetPlace(), new Vector3(pos.x, pos.y + 7F, pos.z), player.GetRotation(), respawnable: false);
player.TS("player_vehicle_spawned", vehicle.name);
}
public async Task Normalize(IReadOnlyCollection <string> recordKeys, CancellationToken cancellationToken)
{
await Task.Factory.StartNew(() =>
{
using (var autoSave = Context.I.DbContainerAutoSave)
{
var dbContainer = autoSave.DBContainer;
var records = dbContainer.AudioBookSet.GetRecordsAllWithCache();
var sw = new Stopwatch();
sw.Start();
var genres = new Dictionary <string, string>(StringComparer.InvariantCultureIgnoreCase);
// Case SENSITIVE!!! As Designed.
var referenceGenres = new HashSet <string>();
var genreParts = new List <GenrePart>();
foreach (var genre in _referenceGenres)
{
var referenceGenre = genre;
var iofReference = genre.IndexOf('|');
if (iofReference > 0)
{
referenceGenre = genre.Substring(0, iofReference);
}
referenceGenres.Add(referenceGenre);
var genreVariants = genre.ToLower().ReplaceAll("", " ", "-", ".").Split('|');
foreach (var genreVariant in genreVariants)
{
if (GenrePart.TryParse(genreVariant, referenceGenre, out var genrePart))
{
genreParts.Add(genrePart);
}
else
{
genres[genreVariant] = referenceGenre;
}
}
}
var abQuantity = 0;
foreach (var audioBook in records)
{
var audioBookGenres = audioBook.GetGenres();
var genresNormalized = new List <string>();
foreach (var audioBookGenre in audioBookGenres.Where(item => item.Length > 3))
{
var genre4Resolve = _mixedCyrLatRegex.Replace(audioBookGenre, CyrLatToCyrConverter);
if (referenceGenres.Contains(genre4Resolve))
{
genresNormalized.Add(genre4Resolve);
}
else
{
var genreForCompare = genre4Resolve.ToLower().ReplaceAll("", " ", "-", ",", ".");
var results = new List <Tuple <string, int, string> >();
if (genres.TryGetValue(genreForCompare, out var referenceGenre))
{
results.Add(Tuple.Create(referenceGenre, 0, "Variant"));
}
else
{
foreach (var genreVariant in genres.Where(item =>
Math.Abs(item.Key.Length - genreForCompare.Length) < 3))
{
var distance = LevenshteinDistance.Compute(genreVariant.Key, genreForCompare);
if (distance <= 2)
{
results.Add(Tuple.Create(genreVariant.Value, distance,
$"Distance to {genreVariant.Key}"));
}
}
}
if (results.Any())
{
var candidate = results.OrderBy(item => item.Item2).First();
genresNormalized.Add(candidate.Item1);
}
else
{
var fitParts = genreParts.Where(gp => gp.IsFit(genre4Resolve))
.OrderBy(item => item.Priority).ToArray();
if (fitParts.Any())
{
var minPriority = fitParts.Min(item => item.Priority);
var res = minPriority < int.MaxValue
? fitParts.Where(item => item.Priority == minPriority).ToArray()
: fitParts;
genresNormalized.Add(genre4Resolve);
foreach (var genrePart in res)
{
genresNormalized.Add(genrePart.ReferenceGenre);
}
}
else if (genre4Resolve != audioBookGenre)
{
genresNormalized.Add(genre4Resolve);
}
}
}
}
if (genresNormalized.Any())
{
audioBook.Genre = string.Join(", ", genresNormalized.Distinct().OrderBy(item => item));
dbContainer.AudioBookSet.AddChangedRecords(audioBook);
}
cancellationToken.ThrowIfCancellationRequested();
ProgressMessage.ReportComplex(abQuantity++, records.Count);
if (sw.Elapsed > SaveTimer)
{
dbContainer.SaveChanges();
sw.Restart();
}
}
ProgressMessage.ReportComplex(records.Count, records.Count);
}
}, cancellationToken);
}
public ActionResult Index22()
{
AskCaro_QuestionnaireAspirateur.StackOverflowAspirateur main = new AskCaro_QuestionnaireAspirateur.StackOverflowAspirateur();
var target = "Is there a best practice and recommended alternative to Session variables in MVC";
var text = AskCaro_Web_MVC.Tools.WordsAnalyzer.StringWords2Remove(target);
var targetHS = text.Split(' ').ToHashSet();
var closeNeighbors = from h in _dbContext.Questions.AsEnumerable() // bring into memory
// query continued below as linq-to-objects
let score = (0.15 * LevenshteinDistance.Calculate(text, h.Tag) + 0.35 * LevenshteinDistance.Calculate(text.ToLower(), h.Tag.ToLower())) / Math.Max(text.Length, h.Tag.Length)
//let lD = Tools.Class1.LevenshteinDistance(target, h.Tag)
//let length = Math.Max(h.Tag.Length, target.Length)
//let score = 1.0 - (double)lD / length
where score > 0.25
select new { h, score };
var listttt = closeNeighbors.OrderByDescending(x => x.score).Take(10).ToList();
return(View());
}
public void Test_Compute_Returns_Distance_Long_Word()
{
Assert.AreEqual(3, LevenshteinDistance.Compute("encyclopedia", "edcyclipexia"));
}
public void Invoke(ShPlayer player, string warp)
{
var file = Path.Combine(Core.Instance.Paths.WarpsFolder, $"{warp}.json");
if (!File.Exists(file))
{
player.TS("expFileHandler_error_notFound", player.T(Core.Instance.WarpHandler.Name), warp);
player.TS("levenshteinSuggest", Core.Instance.WarpHandler.List.OrderByDescending(x => LevenshteinDistance.CalculateSimilarity(x.Name, warp)).FirstOrDefault().Name);
return;
}
Core.Instance.WarpHandler.DeleteExisting(warp);
player.TS("expFileHandler_deleted", player.T(Core.Instance.WarpHandler.Name), warp);
}
/// <summary>
/// Fairly hefty method that looks for best match using string starts, case insensitive string starts and Levenshtein
/// distance
/// </summary>
/// <param name="choiceToValidate"></param>
/// <returns></returns>
public string FindNearestMatch(string choiceToValidate)
{
var livingContenderList = Contenders.FindAll(o => o.Score > 0);
var beginsWithMatches = livingContenderList.FindAll(o => o.Name.StartsWith(choiceToValidate));
var beginsWithMatchesCaseInsensitive =
livingContenderList.FindAll(o => o.Name.ToLower().StartsWith(choiceToValidate.ToLower()));
var containsMatches = livingContenderList.FindAll(o => o.Name.Contains(choiceToValidate));
var containsMatchesCaseInsensitive =
livingContenderList.FindAll(o => o.Name.ToLower().Contains(choiceToValidate.ToLower()));
var bestMatch = "ERROR";
// look for matches at the start of the word
if (beginsWithMatches.Count == 1)
{
return(beginsWithMatches.First().Name);
}
// look for case insensitive matches at the start of the word
if (beginsWithMatchesCaseInsensitive.Count == 1)
{
return(beginsWithMatchesCaseInsensitive.First().Name);
}
if (containsMatches.Count == 1)
{
return(containsMatches.First().Name);
}
if (containsMatchesCaseInsensitive.Count == 1)
{
return(containsMatchesCaseInsensitive.First().Name);
}
// fuzzy matching
if (choiceToValidate.Length > 15)
{
var bestLScore = 1000;
foreach (var c in livingContenderList)
{
var lScore = LevenshteinDistance.Compute(choiceToValidate, c.Name);
if (lScore < bestLScore)
{
bestLScore = lScore;
bestMatch = c.Name;
}
}
Console.WriteLine($"Best LScore {bestLScore} for {bestMatch}");
if (bestLScore > 10)
{
bestMatch = "ERROR";
}
}
if (choiceToValidate.Length > 8)
{
var bestLScore = 1000;
foreach (var c in livingContenderList)
{
var lScore = LevenshteinDistance.Compute(choiceToValidate, c.Name);
if (lScore >= bestLScore)
{
continue;
}
bestLScore = lScore;
bestMatch = c.Name;
}
Console.WriteLine($"Best LScore {bestLScore} for {bestMatch}");
if (bestLScore > 6)
{
bestMatch = "ERROR";
}
}
if (choiceToValidate.Length <= 8)
{
var bestLScore = 1000;
foreach (var c in livingContenderList)
{
var lScore = LevenshteinDistance.Compute(choiceToValidate, c.Name);
if (lScore < bestLScore)
{
bestLScore = lScore;
bestMatch = c.Name;
}
}
Console.WriteLine($"Best LScore {bestLScore} for {bestMatch}");
if (bestLScore > 2)
{
bestMatch = "ERROR";
}
}
return(bestMatch);
}
public void Test_Compute_Returns_Distance()
{
Assert.AreEqual(1, LevenshteinDistance.Compute("car", "bar"));
}
public void LengthTests() {
var shorter = SimpleTokeniser.Tokenise("foo bar baz bone dog cow cat frog").ToArray();
var longer = SimpleTokeniser.Tokenise("foo bar baz bone dog sheep cow cat frog").ToArray();
LevenshteinDistance ld = new LevenshteinDistance();
Assert.AreEqual(1, ld.DamerauLevenshteinDistance(shorter, longer));
Assert.AreEqual(1, ld.DamerauLevenshteinDistance(longer, shorter));
var x = longer.ToList();
x.Add(new Token("mouse", 0, 0));
x.RemoveAt(1);
longer = x.ToArray();
Assert.AreEqual(3, ld.DamerauLevenshteinDistance(shorter, longer));
Assert.AreEqual(3, ld.DamerauLevenshteinDistance(longer, shorter));
}
/// <summary>
/// Calculates the similarity of two strings with a normalized Levenshtein distance
/// </summary>
/// <param name="firstLiteral">First literal to compare</param>
/// <param name="secondLiteral">Second literal to compare</param>
/// <returns>The similarity between two incoming literals between 0 and 1</returns>
public static double CalculateStringSimilarity(string firstLiteral, string secondLiteral)
{
return(LevenshteinDistance.CalculateNormalized(firstLiteral, secondLiteral));
}
/// <summary>
/// Gets the reference hub belonging to the player who's name most closely matches the string given, if any.
/// </summary>
/// <param name="args">Player's Name</param>
/// <returns>ReferenceHub or null</returns>
public static ReferenceHub GetPlayer(string args)
{
try
{
if (StrHubs.ContainsKey(args))
{
return(StrHubs[args]);
}
ReferenceHub playerFound = null;
if (short.TryParse(args, out short playerId))
{
return(GetPlayer(playerId));
}
if (args.EndsWith("@steam") || args.EndsWith("@discord") || args.EndsWith("@northwood") || args.EndsWith("@patreon"))
{
Log.Debug("Trying to find by UserID...");
foreach (ReferenceHub player in GetHubs())
{
if (player.GetUserId() == args)
{
playerFound = player;
Log.Debug("Found UserID match.");
}
}
}
else
{
Log.Debug($"Trying to find by name... {args}");
if (args == "WORLD" || args == "SCP-018" || args == "SCP-575" || args == "SCP-207")
{
return(null);
}
int maxNameLength = 31, lastnameDifference = 31;
string str1 = args.ToLower();
foreach (ReferenceHub player in GetHubs())
{
if (!player.GetNickname().ToLower().Contains(args.ToLower()))
{
continue;
}
if (str1.Length < maxNameLength)
{
int x = maxNameLength - str1.Length;
int y = maxNameLength - player.GetNickname().Length;
string str2 = player.GetNickname();
for (int i = 0; i < x; i++)
{
str1 += "z";
}
for (int i = 0; i < y; i++)
{
str2 += "z";
}
int nameDifference = LevenshteinDistance.Compute(str1, str2);
if (nameDifference < lastnameDifference)
{
lastnameDifference = nameDifference;
playerFound = player;
Log.Debug("Found name match.");
}
}
}
}
if (playerFound != null)
{
StrHubs.Add(args, playerFound);
}
return(playerFound);
}
catch (Exception exception)
{
Log.Error($"GetPlayer error: {exception}");
return(null);
}
}
public void CharacterTest() {
var s = CharacterTokeniser.Tokenise("abcdef").ToArray();
var t = CharacterTokeniser.Tokenise("abdcef").ToArray();
LevenshteinDistance ld = new LevenshteinDistance();
Assert.AreEqual(1, ld.DamerauLevenshteinDistance(s, t));
}
static void Main()
{
Console.WriteLine(LevenshteinDistance.Compute("aunt", "ant"));
Console.WriteLine(LevenshteinDistance.Compute("Sam", "Samantha"));
Console.WriteLine(LevenshteinDistance.Compute("flomax", "volmax"));
}
public async Task <IEnumerable <RemoteSearchResult> > GetSearchResults(MovieInfo searchInfo, CancellationToken cancellationToken)
{
var result = new List <RemoteSearchResult>();
if (searchInfo == null || string.IsNullOrEmpty(searchInfo.Name))
{
return(result);
}
Logger.Info($"searchInfo.Name: {searchInfo.Name}");
var title = Helper.ReplaceAbbrieviation(searchInfo.Name);
var site = Helper.GetSiteFromTitle(title);
if (site.siteNum == null)
{
string newTitle;
if (!string.IsNullOrEmpty(Plugin.Instance.Configuration.DefaultSiteName))
{
newTitle = $"{Plugin.Instance.Configuration.DefaultSiteName} {searchInfo.Name}";
}
else
{
newTitle = Helper.GetSiteNameFromTitle(searchInfo.Name);
}
if (!string.IsNullOrEmpty(newTitle) && !newTitle.Equals(searchInfo.Name, StringComparison.OrdinalIgnoreCase))
{
Logger.Info($"newTitle: {newTitle}");
title = Helper.ReplaceAbbrieviation(newTitle);
site = Helper.GetSiteFromTitle(title);
}
if (site.siteNum == null)
{
return(result);
}
}
string searchTitle = Helper.GetClearTitle(title, site.siteName),
searchDate = string.Empty;
DateTime?searchDateObj;
var titleAfterDate = Helper.GetDateFromTitle(searchTitle);
searchTitle = titleAfterDate.searchTitle;
searchDateObj = titleAfterDate.searchDateObj;
if (searchDateObj.HasValue)
{
searchDate = searchDateObj.Value.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture);
}
else
{
if (searchInfo.PremiereDate.HasValue)
{
#if __EMBY__
searchDateObj = searchInfo.PremiereDate.Value.DateTime;
#else
searchDateObj = searchInfo.PremiereDate.Value;
#endif
searchDate = searchInfo.PremiereDate.Value.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture);
}
}
if (string.IsNullOrEmpty(searchTitle))
{
return(result);
}
Logger.Info($"site: {site.siteNum[0]}:{site.siteNum[1]} ({site.siteName})");
Logger.Info($"searchTitle: {searchTitle}");
Logger.Info($"searchDate: {searchDate}");
var provider = Helper.GetProviderBySiteID(site.siteNum[0]);
if (provider != null)
{
Logger.Info($"provider: {provider}");
try
{
result = await provider.Search(site.siteNum, searchTitle, searchDateObj, cancellationToken).ConfigureAwait(false);
}
catch (Exception e)
{
Logger.Error($"Search error: \"{e}\"");
await Analitycs.Send(searchInfo.Name, site.siteNum, site.siteName, searchTitle, searchDateObj, provider.ToString(), e, cancellationToken).ConfigureAwait(false);
}
if (result.Any())
{
foreach (var scene in result)
{
scene.ProviderIds[this.Name] = $"{site.siteNum[0]}#{site.siteNum[1]}#" + scene.ProviderIds[this.Name];
scene.Name = scene.Name.Trim();
if (scene.PremiereDate.HasValue)
{
scene.ProductionYear = scene.PremiereDate.Value.Year;
}
}
if (result.Any(scene => scene.IndexNumber.HasValue))
{
result = result.OrderByDescending(o => o.IndexNumber.HasValue).ThenByDescending(o => o.IndexNumber).ToList();
}
else if (!string.IsNullOrEmpty(searchDate) && result.All(o => o.PremiereDate.HasValue) && result.Any(o => o.PremiereDate.Value != searchDateObj))
{
result = result.OrderBy(o => Math.Abs((searchDateObj - o.PremiereDate).Value.TotalDays)).ToList();
}
else
{
result = result.OrderByDescending(o => 100 - LevenshteinDistance.Calculate(searchTitle, o.Name, StringComparison.OrdinalIgnoreCase)).ToList();
}
}
}
return(result);
}
/// <summary>
/// Launch the analyze function for selected files.
/// </summary>
private void Analyse()
{
// If the analyze process is not running, launch it.
if (!isAnalyzeRunning)
{
int nbMusics = 0;
foreach (MusicItem music in Musics)
{
if (music.IsChecked)
{
nbMusics++;
}
}
if (nbMusics > 0)
{
PercentProgress = 0;
isAnalyzeRunning = true;
AnalyseButtonText = "Arrêter";
Task.Factory.StartNew(() =>
{
double nbAnalysed = 0;
foreach (MusicItem music in Musics)
{
if (!isAnalyzeRunning)
{
Console.WriteLine("Stop process");
break;
}
if (music.IsChecked)
{
IEnumerable <MusicDao> results = null;
try
{
Settings settings = Settings.Instance;
results = new MusicTagDetector(settings.ApiHost, settings.ApiKey, settings.SecretKey).Recognize(music.Path);
}
catch
{
music.Status = MusicItemStatus.Error;
}
nbAnalysed++;
PercentProgress = nbAnalysed / nbMusics * 100;
if (results != null)
{
App.Current.Dispatcher.BeginInvoke(() =>
{
music.Results.Clear();
foreach (MusicDao result in results)
{
AnalyzeResult aResult = new AnalyzeResult(result);
aResult.MatchLevel = LevenshteinDistance.Compute(aResult.Title, SelectedMusic.Title);
music.AddResult(aResult);
}
music.Status = MusicItemStatus.Analysed;
if (AutoSet)
{
music.SetBestResult();
}
});
}
}
}
PercentProgress = 100;
isAnalyzeRunning = false;
AnalyseButtonText = "Analyser";
});
}
else
{
MessageBox.Show("Veuillez cocher au moins une musique.", "Information", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
else // If the analyze process is running, stop it.
{
isAnalyzeRunning = false;
AnalyseButtonText = "Analyser";
PercentProgress = 0;
}
}
private string GetCode(string code01)
{
n++;
SortedList s = new SortedList();
string code = string.Empty;
string[] arrcode = Consts.ArrCode();
LevenshteinDistance ld = new LevenshteinDistance();
decimal parcent;
for (int i = 0; i < arrcode.Length; i++)
{
parcent = ld.LevenshteinDistancePercent(arrcode[i], code01);
Console.WriteLine("parcent{1}={0}", parcent, n);
if (parcent > 0.8m)
{
if (!s.ContainsKey(parcent))
s.Add(parcent, i);
//code = i.ToString();
//break;
}
}
dic.Add(n, s);
return code;
}
public T GetSpecificWithName(string name, List <T> elements)
{
name = name.ToLower();
// Match 1:1
var elementByFullNameExactMatch = elements.FirstOrDefault(t => t.ComparableString.ToLower().Trim() == name.Trim());
if (elementByFullNameExactMatch != null)
{
return(elementByFullNameExactMatch);
}
// Find closest match using Levenshtein Distance algorithm based on full name
var closestElementOnFullName = getElementClosestToName(name, elements);
if (closestElementOnFullName != null)
{
return(closestElementOnFullName);
}
string[] possibleNamesToLookFor = StringHelpers.GetAllArrayCombinations_Recursive(name.Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries));
// Look for any exact matches with any combination of names
var possibleMatches = 0;
T matchingElement = null;
foreach (var possibleName in possibleNamesToLookFor)
{
// Skip if only one name
if (possibleName.Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries).Length <= 1)
{
continue;
}
foreach (var element in elements)
{
// Skip if only one name
if (element.ComparableString.Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries).Length <= 1)
{
continue;
}
var elementName = element.ComparableString.ToLower();
string[] possibleElementNames = StringHelpers.GetAllArrayCombinations_Recursive(elementName.Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries));
foreach (var matchingName in possibleElementNames)
{
if (matchingName.Equals(possibleName))
{
possibleMatches++;
matchingElement = element;
break;
}
}
}
}
if (matchingElement != null && possibleMatches == 1)
{
return(matchingElement);
}
// Look for any matches with any combination of names, with up to X errors
possibleMatches = 0;
matchingElement = null;
foreach (var possibleName in possibleNamesToLookFor)
{
// Skip if only one name
if (possibleName.Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries).Length <= 1)
{
continue;
}
foreach (var element in elements)
{
// Skip if only one name
if (element.ComparableString.Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries).Length <= 1)
{
continue;
}
var elementName = element.ComparableString.ToLower();
string[] possibleElementNames = StringHelpers.GetAllArrayCombinations_Recursive(elementName.Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries));
foreach (var matchingName in possibleElementNames)
{
var distance = LevenshteinDistance.Calculate(possibleName, matchingName);
if (distance <= _settings.AcceptedNumberOfErrors)
{
if (matchingElement != null && matchingElement == element)
{
continue;
}
matchingElement = element;
possibleMatches++;
}
}
}
}
if (matchingElement != null && (possibleMatches == 1 || _settings.AcceptMultipleResults))
{
return(matchingElement);
}
return(null);
}
