public static Meaning FindEntityForMeaning(Entity meaning)
        {
            var result = new List <Meaning>();

            foreach (var worldEntity in Data)
            {
                var patterns = SequenceProcessor.CalculateSimillarPatterns(meaning.Sequence, worldEntity.Sequence, Settings.MinimumPatternLength);
                if (!patterns.Any())
                {
                    continue;
                }
                result.Add(new Meaning {
                    Left = worldEntity, Right = meaning, Pattern = patterns
                });
            }
            result.Sort();
            return(result.Any() ? result.First() : null);
        }
        public static List <Meaning> FindMeanings(Entity entity)
        {
            var result = new List <Meaning>();

            foreach (var worldEntity in Wisdom)
            {
                var patterns = SequenceProcessor.CalculateSimillarPatterns(entity.Sequence, worldEntity.Sequence, Settings.MinimumPatternLength);
                if (!patterns.Any())
                {
                    continue;
                }
                result.Add(new Meaning {
                    Left = entity, Right = worldEntity, Pattern = patterns
                });
            }
            result.Sort();
            return(result);
        }
        public static List <Link> FindLinks(Entity entity)
        {
            var result = new List <Link>();

            foreach (var worldEntity in Data)
            {
                if (worldEntity.Name.Equals(entity.Name))
                {
                    continue;
                }
                var patterns = SequenceProcessor.CalculateSimillarPatterns(entity.Sequence, worldEntity.Sequence, Settings.MinimumPatternLength);
                if (!patterns.Any())
                {
                    continue;
                }
                result.Add(new Link {
                    Left = entity, Right = worldEntity, Pattern = patterns
                });
            }
            result.Sort();
            return(result);
        }
        public static void AddDefinition(Entity entity, string definition, int getDefinitionInvardsUpToLayer = 0, LinkSeverity severity = LinkSeverity.Weak, bool shouldAddAsWisdom = false)
        {
            var sentenceWords = TextProcessor.GetWords(definition);

            foreach (var sentenceWord in sentenceWords)
            {
                if (string.IsNullOrEmpty(sentenceWord))
                {
                    continue;
                }

                //get or create entity for word
                var sentenceWordEntity = GetOrCreate(sentenceWord, getDefinitionInvardsUpToLayer - 1);

                //calculate if a link between entities already exists
                var currentPatterns = SequenceProcessor.CalculateSimillarPatterns(entity.Sequence, sentenceWordEntity.Sequence, Settings.MinimumPatternLength);
                //if link already exists, strengthen
                if (currentPatterns.Any())
                {
                    sentenceWordEntity.StrengthenLink(entity, currentPatterns);
                }
                //else link word to it
                else
                {
                    sentenceWordEntity.CreateLink(entity, severity);
                }
            }

            if (shouldAddAsWisdom)
            {
                Wisdom.Add(new Entity(definition, false)
                {
                    Sequence = (BitArray)entity.Sequence.Clone()
                });
            }
        }