//public static void DeleteSequence(Link sequence) //{ //} public static string FormatSequence(Link sequence) { int visitedElements = 0; StringBuilder sb = new StringBuilder(); sb.Append('{'); var walker = StopableSequenceWalker.WalkRight(sequence, x => x.Source, x => x.Target, x => x.Linker != Net.And, element => { if (visitedElements > 0) sb.Append(','); sb.Append(element.ToString()); visitedElements++; if (visitedElements < MaxSequenceFormatSize) { return true; } else { sb.Append(", ..."); return false; } }); sb.Append('}'); return sb.ToString(); }
public static char ToChar(Link link) { char c; if (!LinksToCharacters.TryGetValue(link, out c)) { throw new ArgumentOutOfRangeException("charLink", "Указанная связь не являяется символом."); } return c; }
public static LinkModel CreateLinkModel(Link link, int nestingLevel = 5) { //ThreadHelpers.SyncInvokeWithExtendedStack(() => //{ const int currentLevel = 0; var visitedLinks = new HashSet<Link>(); LinkModel result = CreateLinkModel(link, visitedLinks, currentLevel, nestingLevel); //}); return result; }
private static void RegisterExistingCharacter(Link character) { if (character.Source == Net.Character && character.Linker == Net.ThatHas) { var code = character.Target; if (code.Source == Net.Code && code.Linker == Net.ThatIsRepresentedBy) { var charCode = (char)LinkConverter.ToNumber(code.Target); CharactersToLinks[charCode] = character; LinksToCharacters[character] = charCode; } } }
public static Link[] GetLeftElements(Link startLink, Link leftLink) { var result = new Link[4]; TryStepLeft(startLink, leftLink, result, 0); startLink.WalkThroughReferersBySource(couple => { if (couple.Linker == Net.And) if (TryStepLeft(couple, leftLink, result, 2)) return Link.Stop; return Link.Continue; }); return result; }
public static List<Link> CollectMatchingSequences(Link[] links) { if (links.Length == 1) { throw new Exception("Подпоследовательности с одним элементом не поддерживаются."); } int leftBound = 0; int rightBound = links.Length - 1; Link left = links[leftBound++]; Link right = links[rightBound--]; List<Link> results = new List<Link>(); CollectMatchingSequences(left, leftBound, links, right, rightBound, ref results); return results; }
public static Link FromNumber(long number) { if (number == 0) return Net.Zero; if (number == 1) return Net.One; var links = new Link[CountBits(number)]; if (number >= 0) { for (long key = 1, powerOf2 = 0, i = 0; key <= number; key += key, powerOf2++) if ((number & key) == key) links[i++] = FromPowerOf2(powerOf2); } else throw new NotSupportedException("Negative numbers are not supported yet."); Link sum = Link.Create(Net.Sum, Net.Of, LinkConverter.FromList(links)); return sum; }
public static long ToNumber(Link link) { if (link == Net.Zero) return 0; if (link == Net.One) return 1; if (link.IsSum()) { List<Link> numberParts = LinkConverter.ToList(link.Target); long number = 0; for (var i = 0; i < numberParts.Count; i++) { long numberPart; GoDownAndTakeIt(numberParts[i], out numberPart); number += numberPart; } return number; } throw new ArgumentOutOfRangeException("link", "Specified link is not a number."); }
private static LinkModel CreateLinkModel(Link link, HashSet<Link> visitedLinks, int currentLevel, int maxLevel) { var model = new LinkModel(link); if (currentLevel < maxLevel) { if (currentLevel == 0 || link.TotalReferers < 10) { currentLevel++; link.WalkThroughReferers(referer => { if (link != referer && visitedLinks.Add(referer)) { model.ReferersModels.Add(CreateLinkModel(referer, visitedLinks, currentLevel, maxLevel)); } }); model.ReferersModels.Sort((x, y) => x.Link.ToInt().CompareTo(y.Link.ToInt())); } } return model; }
private static void Create() { #region Core if (!Link.TryGetMapped(NetMapping.IsA, out IsA) || !Link.TryGetMapped(NetMapping.IsNotA, out IsNotA) || !Link.TryGetMapped(NetMapping.Link, out Link) || !Link.TryGetMapped(NetMapping.Thing, out Thing)) { // Наивная инициализация (Не является корректным объяснением). IsA = Link.CreateMapped(Link.Itself, Link.Itself, Link.Itself, NetMapping.IsA); // Стоит переделать в "[x] is a member|instance|element of the class [y]" IsNotA = Link.CreateMapped(Link.Itself, Link.Itself, IsA, NetMapping.IsNotA); Link = Link.CreateMapped(Link.Itself, IsA, Link.Itself, NetMapping.Link); Thing = Link.CreateMapped(Link.Itself, IsNotA, Link, NetMapping.Thing); Link.Update(ref IsA, IsA, IsA, Link); // Исключение, позволяющие завершить систему } #endregion Of = CreateMappedLink(NetMapping.Of); And = CreateMappedLink(NetMapping.And); ThatConsistsOf = CreateMappedLink(NetMapping.ThatConsistsOf); Has = CreateMappedLink(NetMapping.Has); Contains = CreateMappedLink(NetMapping.Contains); ContainedBy = CreateMappedLink(NetMapping.ContainedBy); One = CreateMappedThing(NetMapping.One); Zero = CreateMappedThing(NetMapping.Zero); Sum = CreateMappedThing(NetMapping.Sum); Character = CreateMappedThing(NetMapping.Character); String = CreateMappedThing(NetMapping.String); Name = Link.CreateMapped(Link.Itself, IsA, String, NetMapping.Name); Set = CreateMappedThing(NetMapping.Set); Group = CreateMappedThing(NetMapping.Group); ParsedFrom = CreateMappedLink(NetMapping.ParsedFrom); ThatIs = CreateMappedLink(NetMapping.ThatIs); ThatIsBefore = CreateMappedLink(NetMapping.ThatIsBefore); ThatIsAfter = CreateMappedLink(NetMapping.ThatIsAfter); ThatIsBetween = CreateMappedLink(NetMapping.ThatIsBetween); ThatIsRepresentedBy = CreateMappedLink(NetMapping.ThatIsRepresentedBy); ThatHas = CreateMappedLink(NetMapping.ThatHas); Text = CreateMappedThing(NetMapping.Text); Path = CreateMappedThing(NetMapping.Path); Content = CreateMappedThing(NetMapping.Content); Empty = CreateMappedThing(NetMapping.Empty); EmptyContent = Link.CreateMapped(Content, ThatIs, Empty, NetMapping.EmptyContent); Alphabet = CreateMappedThing(NetMapping.Alphabet); Letter = Link.CreateMapped(Link.Itself, IsA, Character, NetMapping.Letter); Case = CreateMappedThing(NetMapping.Case); Upper = CreateMappedThing(NetMapping.Upper); UpperCase = Link.CreateMapped(Case, ThatIs, Upper, NetMapping.UpperCase); Lower = CreateMappedThing(NetMapping.Lower); LowerCase = Link.CreateMapped(Case, ThatIs, Lower, NetMapping.LowerCase); Code = CreateMappedThing(NetMapping.Code); SetNames(); }
private static void RegisterExistingLetter(Link letter) { letter.WalkThroughReferersAsSource(referer => { if (referer.Linker == Net.Has) { var target = referer.Target; if (target.Source == Net.Code && target.Linker == Net.ThatIsRepresentedBy) { var charCode = (char)LinkConverter.ToNumber(target.Target); CharactersToLinks[charCode] = letter; LinksToCharacters[letter] = charCode; } } }); }
public static bool TryStepRight(Link startLink, Link rightLink, Link[] result, int offset) { int added = 0; startLink.WalkThroughReferersBySource(couple => { if (couple.Linker == Net.And) { var coupleTarget = couple.Target; if (coupleTarget == rightLink) { result[offset] = couple; if (++added == 2) return Link.Stop; } else if (coupleTarget.Linker == Net.And && coupleTarget.Source == rightLink) { result[offset + 1] = couple; if (++added == 2) return Link.Stop; } } return Link.Continue; }); return added > 0; }
private static void CollectMatchingSequences(Link leftLink, int leftBound, Link[] middleLinks, Link rightLink, int rightBound, ref List<Link> results) { long leftLinkTotalReferers = leftLink.ReferersBySourceCount + leftLink.ReferersByTargetCount; long rightLinkTotalReferers = rightLink.ReferersBySourceCount + rightLink.ReferersByTargetCount; if (leftLinkTotalReferers <= rightLinkTotalReferers) { var nextLeftLink = middleLinks[leftBound]; Link[] elements = GetRightElements(leftLink, nextLeftLink); if (leftBound <= rightBound) { for (int i = elements.Length - 1; i >= 0; i--) { var element = elements[i]; if (element != null) { CollectMatchingSequences(element, leftBound + 1, middleLinks, rightLink, rightBound, ref results); } } } else { for (int i = elements.Length - 1; i >= 0; i--) { var element = elements[i]; if (element != null) { results.Add(element); } } } } else { var nextRightLink = middleLinks[rightBound]; Link[] elements = GetLeftElements(rightLink, nextRightLink); if (leftBound <= rightBound) { for (int i = elements.Length - 1; i >= 0; i--) { var element = elements[i]; if (element != null) { CollectMatchingSequences(leftLink, leftBound, middleLinks, elements[i], rightBound - 1, ref results); } } } else { for (int i = elements.Length - 1; i >= 0; i--) { var element = elements[i]; if (element != null) { results.Add(element); } } } } }
public static Link CombinedJoin(ref Link first, ref Link second) { // Перестроение работает хорошо только когда одна из связей является парой и аккумулятором одновременно // Когда обе связи - пары - нужно использовать другой алгоритм, иначе сжатие будет отсутствовать. //if ((first.Linker == Net.And && second.Linker != Net.And) // || (second.Linker == Net.And && first.Linker != Net.And)) //{ // Link connection = TryReconstructConnection(first, second); // if (connection != null) // { // CompressionsCount++; // return connection; // } //} //return first & second; //long totalPairs = Net.And.ReferersByLinkerCount; if (first == null || second == null) { } Link directConnection = Link.Search(first, Net.And, second); if (directConnection == null) { directConnection = TryReconstructConnection(first, second); } Link rightCrossConnection = null; if (second.Linker == Net.And) { Link assumedRightCrossConnection = Link.Search(first, Net.And, second.Source); if (assumedRightCrossConnection != null && second != assumedRightCrossConnection) { rightCrossConnection = assumedRightCrossConnection; } else { rightCrossConnection = TryReconstructConnection(first, second.Source); } } Link leftCrossConnection = null; if (first.Linker == Net.And) { Link assumedLeftCrossConnection = Link.Search(first.Target, Net.And, second); if (assumedLeftCrossConnection != null && first != assumedLeftCrossConnection) { leftCrossConnection = assumedLeftCrossConnection; } else { leftCrossConnection = TryReconstructConnection(first.Target, second); } } // Наверное имеет смысл только в "безвыходной" ситуации //if (directConnection == null && rightCrossConnection == null && leftCrossConnection == null) //{ // directConnection = TryReconstructConnection(first, second); // // Может давать более агрессивное сжатие, но теряется стабильность // //if (directConnection == null) // //{ // // //if (second.Linker == Net.And) // // //{ // // // Link assumedRightCrossConnection = TryReconstructConnection(first, second.Source); // // // if (assumedRightCrossConnection != null && second != assumedRightCrossConnection) // // // { // // // rightCrossConnection = assumedRightCrossConnection; // // // } // // //} // // //if (rightCrossConnection == null) // // //{ // // //if (first.Linker == Net.And) // // //{ // // // Link assumedLeftCrossConnection = TryReconstructConnection(first.Target, second); // // // if (assumedLeftCrossConnection != null && first != assumedLeftCrossConnection) // // // { // // // leftCrossConnection = assumedLeftCrossConnection; // // // } // // //} // // //} // //} //} //Link middleCrossConnection = null; //if (second.Linker == Net.And && first.Linker == Net.And) //{ // Link assumedMiddleCrossConnection = Link.Search(first.Target, Net.And, second.Source); // if (assumedMiddleCrossConnection != null && first != assumedMiddleCrossConnection && second != assumedMiddleCrossConnection) // { // middleCrossConnection = assumedMiddleCrossConnection; // } //} //Link rightMiddleCrossConnectinon = null; //if (middleCrossConnection != null) //{ //} if (directConnection != null && (rightCrossConnection == null || directConnection.TotalReferers >= rightCrossConnection.TotalReferers) && (leftCrossConnection == null || directConnection.TotalReferers >= leftCrossConnection.TotalReferers)) { if (rightCrossConnection != null) { var prev = Link.Search(rightCrossConnection, Net.And, second.Target); if (prev != null && directConnection != prev) Link.Update(ref prev, first, Net.And, second); if (rightCrossConnection.TotalReferers == 0) Link.Delete(ref rightCrossConnection); } if (leftCrossConnection != null) { var prev = Link.Search(first.Source, Net.And, leftCrossConnection); if (prev != null && directConnection != prev) Link.Update(ref prev, first, Net.And, second); if (leftCrossConnection.TotalReferers == 0) Link.Delete(ref leftCrossConnection); } TryReconstructConnection(first, second); return directConnection; } else if (rightCrossConnection != null && (directConnection == null || rightCrossConnection.TotalReferers >= directConnection.TotalReferers) && (leftCrossConnection == null || rightCrossConnection.TotalReferers >= leftCrossConnection.TotalReferers)) { if (directConnection != null) { var prev = Link.Search(first, Net.And, second); if (prev != null && rightCrossConnection != prev) Link.Update(ref prev, rightCrossConnection, Net.And, second.Target); } if (leftCrossConnection != null) { var prev = Link.Search(first.Source, Net.And, leftCrossConnection); if (prev != null && rightCrossConnection != prev) Link.Update(ref prev, rightCrossConnection, Net.And, second.Target); } //TryReconstructConnection(first, second.Source); //TryReconstructConnection(rightCrossConnection, second.Target); // ухудшает стабильность Link resultConnection = rightCrossConnection & second.Target; //if (second.TotalReferers == 0) // Link.Delete(ref second); return resultConnection; } else if (leftCrossConnection != null && (directConnection == null || leftCrossConnection.TotalReferers >= directConnection.TotalReferers) && (rightCrossConnection == null || leftCrossConnection.TotalReferers >= rightCrossConnection.TotalReferers)) { if (directConnection != null) { var prev = Link.Search(first, Net.And, second); if (prev != null && leftCrossConnection != prev) Link.Update(ref prev, first.Source, Net.And, leftCrossConnection); } if (rightCrossConnection != null) { var prev = Link.Search(rightCrossConnection, Net.And, second.Target); if (prev != null && rightCrossConnection != prev) Link.Update(ref prev, first.Source, Net.And, leftCrossConnection); } //TryReconstructConnection(first.Target, second); //TryReconstructConnection(first.Source, leftCrossConnection); // ухудшает стабильность Link resultConnection = first.Source & leftCrossConnection; //if (first.TotalReferers == 0) // Link.Delete(ref first); return resultConnection; } else { if (directConnection != null) { return directConnection; } if (rightCrossConnection != null) { return rightCrossConnection & second.Target; } if (leftCrossConnection != null) { return first.Source & leftCrossConnection; } } // Можно фиксировать по окончанию каждой из веток, какой эффект от неё происходит (на сколько уменьшается/увеличивается количество связей) directConnection = first & second; //long difference = Net.And.ReferersByLinkerCount - totalPairs; //if (difference != 1) //{ // Console.WriteLine(Net.And.ReferersByLinkerCount - totalPairs); //} return directConnection; }
private static void CreateAlphabet(char[] lettersCharacters, string alphabetName, CharacterMapping mapping) { Link alphabet; if (Link.TryGetMapped(mapping, out alphabet)) { var letters = alphabet.Target; letters.WalkThroughSequence(letter => { var lowerCaseLetter = Link.Search(Net.LowerCase, Net.Of, letter); var upperCaseLetter = Link.Search(Net.UpperCase, Net.Of, letter); if (lowerCaseLetter != null && upperCaseLetter != null) { RegisterExistingLetter(lowerCaseLetter); RegisterExistingLetter(upperCaseLetter); } else { RegisterExistingLetter(letter); } }); } else { alphabet = Net.CreateMappedThing(mapping); var letterOfAlphabet = Link.Create(Net.Letter, Net.Of, alphabet); var lettersLinks = new Link[lettersCharacters.Length]; GenerateAlphabetBasis(ref alphabet, ref letterOfAlphabet, lettersLinks); for (var i = 0; i < lettersCharacters.Length; i++) { var lowerCaseCharacter = lettersCharacters[i]; Link lowerCaseLink, upperCaseLink; SetLetterCodes(lettersLinks[i], lowerCaseCharacter, out lowerCaseLink, out upperCaseLink); CharactersToLinks[lowerCaseCharacter] = lowerCaseLink; LinksToCharacters[lowerCaseLink] = lowerCaseCharacter; if (upperCaseLink != null) { var upperCaseCharacter = char.ToUpper(lowerCaseCharacter); CharactersToLinks[upperCaseCharacter] = upperCaseLink; LinksToCharacters[upperCaseLink] = upperCaseCharacter; } } alphabet.SetName(alphabetName); for (var i = 0; i < lettersCharacters.Length; i++) { var lowerCaseCharacter = lettersCharacters[i]; var upperCaseCharacter = Char.ToUpper(lowerCaseCharacter); if (lowerCaseCharacter != upperCaseCharacter) lettersLinks[i].SetName("{" + upperCaseCharacter + " " + lowerCaseCharacter + "}"); else lettersLinks[i].SetName("{" + lowerCaseCharacter + "}"); } } }
public static Link FromList(Link[] links) { int i = links.Length - 1; Link element = links[i]; while (--i >= 0) element = CombinedJoin(ref links[i], ref element); // LeftJoin(ref element, links[i]); return element; }
public static bool IsChar(Link link) => link != null && LinksToCharacters.ContainsKey(link);
//public static Link RightJoinUnsafe(Link subject, Link @object) //{ // if (subject.Linker == Net.And && subject.ReferersBySourceCount == 0 && subject.ReferersByTargetCount == 0) // { // Link subJoint = Link.Search(subject.Target, Net.And, @object); // if (subJoint != null && subJoint != subject) // { // Link.Update(ref subject, subject.Source, Net.And, subJoint); // return subject; // } // } // return Link.Create(subject, Net.And, @object); //} ////public static void LeftJoin(ref Link subject, Link @object) ////{ //// if (subject.Linker == Net.And && subject.ReferersBySourceCount == 0 && subject.ReferersByTargetCount == 0) //// { //// Link subJoint = Link.Search(@object, Net.And, subject.Source); //// if (subJoint != null && subJoint != subject) //// { //// Link.Update(ref subject, subJoint, Net.And, subject.Target); //// return; //// } //// } //// subject = Link.Create(@object, Net.And, subject); ////} public static void LeftJoin(ref Link subject, Link @object) { if (subject.Linker == Net.And && subject.ReferersBySourceCount == 0 && subject.ReferersByTargetCount == 0) { Link subJoint = Link.Search(@object, Net.And, subject.Source); if (subJoint != null && subJoint != subject) { Link.Update(ref subject, subJoint, Net.And, subject.Target); //var prev = Link.Search(@object, Net.And, subject); //if (prev != null) //{ // Link.Update(ref prev, subJoint, Net.And, subject.Target); //} return; } } subject = Link.Create(@object, Net.And, subject); }
public LinkModel(Link link) : this(link, new List<LinkModel>()) { }
public static void RightJoin(ref Link subject, Link @object) { if (subject.Linker == Net.And && subject.ReferersBySourceCount == 0 && subject.ReferersByTargetCount == 0) { Link subJoint = Link.Search(subject.Target, Net.And, @object); if (subJoint != null && subJoint != subject) { Link.Update(ref subject, subject.Source, Net.And, subJoint); return; } } subject = Link.Create(subject, Net.And, @object); }
//public static Link FromList(List<Link> links) //{ // Link element = links[0]; // for (int i = 1; i < links.Count; i += ChunkSize) // { // int j = (i + ChunkSize - 1); // j = j < links.Count ? j : (links.Count - 1); // Link subElement = links[j]; // while (--j >= i) LeftJoin(ref subElement, links[j]); // RightJoin(ref element, subElement); // } // return element; //} //public static Link FromList(Link[] links) //{ // Link element = links[0]; // for (int i = 1; i < links.Length; i += ChunkSize) // { // int j = (i + ChunkSize - 1); // j = j < links.Length ? j : (links.Length - 1); // Link subElement = links[j]; // while (--j >= i) LeftJoin(ref subElement, links[j]); // RightJoin(ref element, subElement); // } // return element; //} //public static Link FromList(IList<Link> links) //{ // Link element = links[0]; // for (int i = 1; i < links.Count; i += ChunkSize) // { // int j = (i + ChunkSize - 1); // j = j < links.Count ? j : (links.Count - 1); // Link subElement = links[j]; // while (--j >= i) // { // Link x = links[j]; // subElement = CombinedJoin(ref x, ref subElement); // } // element = CombinedJoin(ref element, ref subElement); // } // return element; //} //public static Link FromList(IList<Link> links) //{ // int i = 0; // Link element = links[i++]; // if (links.Count % 2 == 0) // { // element = CombinedJoin(element, links[i++]); // } // for (; i < links.Count; i += 2) // { // Link pair = CombinedJoin(links[i], links[i + 1]); // element = CombinedJoin(ref element, ref pair); // } // return element; //} // Заглушка, возможно опасная private static Link CombinedJoin(Link element, Link link) { return CombinedJoin(ref element, ref link); }
private static Link TryReconstructConnection(Link first, Link second) { Link directConnection = null; if (second.ReferersBySourceCount < first.ReferersBySourceCount) { // o_| x_o ... // x_| |___| // // <- second.WalkThroughReferersBySource(couple => { if (couple.Linker == Net.And && couple.ReferersByTargetCount == 1 && couple.ReferersBySourceCount == 0) { Link neighbour = couple.FirstRefererByTarget; if (neighbour.Linker == Net.And && neighbour.Source == first) { if (directConnection == null) directConnection = first & second; Link.Update(ref neighbour, directConnection, Net.And, couple.Target); //Link.Delete(ref couple); // Можно заменить удалением couple } } if (couple.Linker == Net.And) { Link neighbour = couple.FirstRefererByTarget; if (neighbour.Linker == Net.And && neighbour.Source == first) { } } }); } else { // o_| x_o ... // x_| |___| // // -> first.WalkThroughReferersBySource(couple => { if (couple.Linker == Net.And) { Link neighbour = couple.Target; if (neighbour.Linker == Net.And && neighbour.Source == second) { if (neighbour.ReferersByTargetCount == 1 && neighbour.ReferersBySourceCount == 0) { if (directConnection == null) directConnection = first & second; Link.Update(ref couple, directConnection, Net.And, neighbour.Target); //Link.Delete(ref neighbour); } } } }); } if (second.ReferersByTargetCount < first.ReferersByTargetCount) { // |_x ... x_o // |_o |___| // // <- second.WalkThroughReferersByTarget(couple => { if (couple.Linker == Net.And) { Link neighbour = couple.Source; if (neighbour.Linker == Net.And && neighbour.Target == first) { if (neighbour.ReferersByTargetCount == 0 && neighbour.ReferersBySourceCount == 1) { if (directConnection == null) directConnection = first & second; Link.Update(ref couple, neighbour.Source, Net.And, directConnection); //Link.Delete(ref neighbour); } } } }); } else { // |_x ... x_o // |_o |___| // // -> first.WalkThroughReferersByTarget((couple) => { if (couple.Linker == Net.And && couple.ReferersByTargetCount == 0 && couple.ReferersBySourceCount == 1) { Link neighbour = couple.FirstRefererBySource; if (neighbour.Linker == Net.And && neighbour.Target == second) { if (directConnection == null) directConnection = first & second; Link.Update(ref neighbour, couple.Source, Net.And, directConnection); Link.Delete(ref couple); } } }); } if (directConnection != null) { CompressionsCount++; } return directConnection; }
public static Link[] GetRightElements(Link startLink, Link rightLink) { var result = new Link[4]; TryStepRight(startLink, rightLink, result, 0); startLink.WalkThroughReferersByTarget(couple => { if (couple.Linker == Net.And) if (TryStepRight(couple, rightLink, result, 2)) return Link.Stop; return Link.Continue; }); return result; }
private static void GenerateAlphabetBasis(ref Link alphabet, ref Link letterOfAlphabet, Link[] letters) { // Принцип, на примере латинского алфавита. //latin alphabet: alphabet that consists of a and b and c and ... and z. //a: letter of latin alphabet that is before b. //b: letter of latin alphabet that is between (a and c). //c: letter of latin alphabet that is between (b and e). //... //y: letter of latin alphabet that is between (x and z). //z: letter of latin alphabet that is after y. const int firstLetterIndex = 0; for (var i = firstLetterIndex; i < letters.Length; i++) letters[i] = Net.CreateThing(); var lastLetterIndex = letters.Length - 1; Link.Update(ref letters[firstLetterIndex], letterOfAlphabet, Net.ThatIsBefore, letters[firstLetterIndex + 1]); Link.Update(ref letters[lastLetterIndex], letterOfAlphabet, Net.ThatIsAfter, letters[lastLetterIndex - 1]); const int secondLetterIndex = firstLetterIndex + 1; for (var i = secondLetterIndex; i < lastLetterIndex; i++) Link.Update(ref letters[i], letterOfAlphabet, Net.ThatIsBetween, letters[i - 1] & letters[i + 1]); Link.Update(ref alphabet, Net.Alphabet, Net.ThatConsistsOf, LinkConverter.FromList(letters)); }
public LinkModel(Link link, List<LinkModel> referersModels) { Link = link; ReferersModels = referersModels; }
private static void SetLetterCodes(Link letter, char lowerCaseCharacter, out Link lowerCase, out Link upperCase) { var upperCaseCharacter = char.ToUpper(lowerCaseCharacter); if (upperCaseCharacter != lowerCaseCharacter) { lowerCase = Link.Create(Net.LowerCase, Net.Of, letter); var lowerCaseCharacterCode = Link.Create(Net.Code, Net.ThatIsRepresentedBy, LinkConverter.FromNumber(lowerCaseCharacter)); Link.Create(lowerCase, Net.Has, lowerCaseCharacterCode); upperCase = Link.Create(Net.UpperCase, Net.Of, letter); var upperCaseCharacterCode = Link.Create(Net.Code, Net.ThatIsRepresentedBy, LinkConverter.FromNumber(upperCaseCharacter)); Link.Create(upperCase, Net.Has, upperCaseCharacterCode); } else { lowerCase = letter; upperCase = null; Link.Create(letter, Net.Has, Link.Create(Net.Code, Net.ThatIsRepresentedBy, LinkConverter.FromNumber(lowerCaseCharacter))); } }
public static char ToChar(Link link) { char @char; if (!LinksToCharacters.TryGetValue(link, out @char)) throw new ArgumentOutOfRangeException(nameof(link), "Указанная связь не являяется символом."); return @char; }
private static void GoDownAndTakeIt(Link link, out long number) { if (!LinksToNumbers.TryGetValue(link, out number)) { Link previousNumberLink = link.Target.Source; GoDownAndTakeIt(previousNumberLink, out number); var previousNumberIndex = (int)Math.Log(number, 2); int newNumberIndex = previousNumberIndex + 1; Link newNumberLink = Link.Create(Net.Sum, Net.Of, previousNumberLink & previousNumberLink); number = number + number; NumbersToLinks[newNumberIndex] = newNumberLink; LinksToNumbers[newNumberLink] = number; } }