//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;
}
}
