Пример #1
0
        public double Match(SearchWord searchWord, ResultTerm resultTerm)
        {
            double bestConfidenceSoFar = 0;

            foreach (string resultValue in resultTerm.Term.Values)
            {
                double weightedDistance;
                if (!searchWord.IsPartial || searchWord.Value.Length >= resultValue.Length)
                {
                    int distance = LevenshteinDistance.Compute(searchWord.Value, resultValue);

                    weightedDistance = (double)distance / (double)resultValue.Length;
                }
                else
                {
                    string partialValue = resultValue.Substring(0, searchWord.Value.Length);

                    int distance = LevenshteinDistance.Compute(searchWord.Value, partialValue);

                    weightedDistance = ((double)distance / (double)partialValue.Length);
                }

                double confidence = 1 / (1 + weightedDistance);

                if (confidence > bestConfidenceSoFar)
                {
                    bestConfidenceSoFar = confidence;
                }
            }

            return(bestConfidenceSoFar);
        }
Пример #2
0
        public ResultMetadata ParseResult(T result)
        {
            List <ResultTerm> resultTerms = new List <ResultTerm>();

            IEnumerable <string> words = Split(result);

            foreach (string word in words)
            {
                ITerm  term      = null;
                double relevance = 1;

                foreach (Synonym synonym in Synonyms)
                {
                    if (synonym.Values.Any(v => v == word))
                    {
                        term = synonym;
                        break;
                    }
                }

                if (term != null)
                {
                    foreach (CommonTerm commonTerm in CommonTerms)
                    {
                        if (commonTerm.Term == term)
                        {
                            relevance = commonTerm.Relevance;
                            break;
                        }
                    }
                }
                else
                {
                    term = new Word(word);
                }

                ResultTerm resultTerm = new ResultTerm(term, relevance);
                resultTerms.Add(resultTerm);
            }

            return(new ResultMetadata(resultTerms));
        }