diff --git a/csharp/Platform.Data.Doublets.Sequences.Tests/BalancedVarianeSequenceTests.cs b/csharp/Platform.Data.Doublets.Sequences.Tests/BalancedVarianeSequenceTests.cs new file mode 100644 index 0000000..7940442 --- /dev/null +++ b/csharp/Platform.Data.Doublets.Sequences.Tests/BalancedVarianeSequenceTests.cs @@ -0,0 +1,218 @@ +using System; +using System.Linq; +using Xunit; +using Platform.Collections.Stacks; +using Platform.Collections.Arrays; +using Platform.Memory; +using Platform.Data.Numbers.Raw; +using Platform.Data.Doublets.Sequences; +using Platform.Data.Doublets.Sequences.Frequencies.Cache; +using Platform.Data.Doublets.Sequences.Frequencies.Counters; +using Platform.Data.Doublets.Sequences.Converters; +using Platform.Data.Doublets.PropertyOperators; +using Platform.Data.Doublets.Sequences.Walkers; +using Platform.Data.Doublets.Sequences.Indexes; +// using Platform.Data.Doublets.Unicode; +// using Platform.Data.Doublets.Numbers.Unary; +using Platform.Data.Doublets.Decorators; +// using Platform.Data.Doublets.Memory.United.Specific; +using Platform.Data.Doublets.Memory; + +namespace Platform.Data.Doublets.Sequences.Tests +{ + public static class BalancedVariantSequenceTests + { + private static readonly string _sequenceExample = "зеленела зелёная зелень"; + + [Fact] + public static void ConstructorTest() + { + var converter = new BalancedVariantConverter(null); + Assert.NotNull(converter); + } + + // private static readonly string _loremIpsumExample = @"Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. + // Facilisi nullam vehicula ipsum a arcu cursus vitae congue mauris. + // Et malesuada fames ac turpis egestas sed. + // Eget velit aliquet sagittis id consectetur purus. + // Dignissim cras tincidunt lobortis feugiat vivamus. + // Vitae aliquet nec ullamcorper sit. + // Lectus quam id leo in vitae. + // Tortor dignissim convallis aenean et tortor at risus viverra adipiscing. + // Sed risus ultricies tristique nulla aliquet enim tortor at auctor. + // Integer eget aliquet nibh praesent tristique. + // Vitae congue eu consequat ac felis donec et odio. + // Tristique et egestas quis ipsum suspendisse. + // Suspendisse potenti nullam ac tortor vitae purus faucibus ornare. + // Nulla facilisi etiam dignissim diam quis enim lobortis scelerisque. + // Imperdiet proin fermentum leo vel orci. + // In ante metus dictum at tempor commodo. + // Nisi lacus sed viverra tellus in. + // Quam vulputate dignissim suspendisse in. + // Elit scelerisque mauris pellentesque pulvinar pellentesque habitant morbi tristique senectus. + // Gravida cum sociis natoque penatibus et magnis dis parturient. + // Risus quis varius quam quisque id diam. + // Congue nisi vitae suscipit tellus mauris a diam maecenas. + // Eget nunc scelerisque viverra mauris in aliquam sem fringilla. + // Pharetra vel turpis nunc eget lorem dolor sed viverra. + // Mattis pellentesque id nibh tortor id aliquet. + // Purus non enim praesent elementum facilisis leo vel. + // Etiam sit amet nisl purus in mollis nunc sed. + // Tortor at auctor urna nunc id cursus metus aliquam. + // Volutpat odio facilisis mauris sit amet. + // Turpis egestas pretium aenean pharetra magna ac placerat. + // Fermentum dui faucibus in ornare quam viverra orci sagittis eu. + // Porttitor leo a diam sollicitudin tempor id eu. + // Volutpat sed cras ornare arcu dui. + // Ut aliquam purus sit amet luctus venenatis lectus magna. + // Aliquet risus feugiat in ante metus dictum at. + // Mattis nunc sed blandit libero. + // Elit pellentesque habitant morbi tristique senectus et netus. + // Nibh sit amet commodo nulla facilisi nullam vehicula ipsum a. + // Enim sit amet venenatis urna cursus eget nunc scelerisque viverra. + // Amet venenatis urna cursus eget nunc scelerisque viverra mauris in. + // Diam donec adipiscing tristique risus nec feugiat. + // Pulvinar mattis nunc sed blandit libero volutpat. + // Cras fermentum odio eu feugiat pretium nibh ipsum. + // In nulla posuere sollicitudin aliquam ultrices sagittis orci a. + // Mauris pellentesque pulvinar pellentesque habitant morbi tristique senectus et. + // A iaculis at erat pellentesque. + // Morbi blandit cursus risus at ultrices mi tempus imperdiet nulla. + // Eget lorem dolor sed viverra ipsum nunc. + // Leo a diam sollicitudin tempor id eu. + // Interdum consectetur libero id faucibus nisl tincidunt eget nullam non."; + + // [Fact] + // public static void LinksBasedFrequencyStoredOptimalVariantSequenceTest() + // { + // using (var scope = new TempLinksTestScope(useSequences: false)) + // { + // var links = scope.Links; + // var constants = links.Constants; + + // links.UseUnicode(); + + // var sequence = UnicodeMap.FromStringToLinkArray(_sequenceExample); + + // var meaningRoot = links.CreatePoint(); + // var unaryOne = links.CreateAndUpdate(meaningRoot, constants.Itself); + // var frequencyMarker = links.CreateAndUpdate(meaningRoot, constants.Itself); + // var frequencyPropertyMarker = links.CreateAndUpdate(meaningRoot, constants.Itself); + + // var unaryNumberToAddressConverter = new UnaryNumberToAddressAddOperationConverter(links, unaryOne); + // var unaryNumberIncrementer = new UnaryNumberIncrementer(links, unaryOne); + // var frequencyIncrementer = new FrequencyIncrementer(links, frequencyMarker, unaryOne, unaryNumberIncrementer); + // var frequencyPropertyOperator = new PropertyOperator(links, frequencyPropertyMarker, frequencyMarker); + // var index = new FrequencyIncrementingSequenceIndex(links, frequencyPropertyOperator, frequencyIncrementer); + // var linkToItsFrequencyNumberConverter = new LinkToItsFrequencyNumberConveter(links, frequencyPropertyOperator, unaryNumberToAddressConverter); + // var sequenceToItsLocalElementLevelsConverter = new SequenceToItsLocalElementLevelsConverter(links, linkToItsFrequencyNumberConverter); + // var optimalVariantConverter = new OptimalVariantConverter(links, sequenceToItsLocalElementLevelsConverter); + + // var sequences = new Sequences(links, new SequencesOptions() { Walker = new LeveledSequenceWalker(links) }); + + // ExecuteTest(sequences, sequence, sequenceToItsLocalElementLevelsConverter, index, optimalVariantConverter); + // } + // } + + // [Fact] + // public static void DictionaryBasedFrequencyStoredOptimalVariantSequenceTest() + // { + // using (var scope = new TempLinksTestScope(useSequences: false)) + // { + // var links = scope.Links; + + // links.UseUnicode(); + + // var sequence = UnicodeMap.FromStringToLinkArray(_sequenceExample); + + // var totalSequenceSymbolFrequencyCounter = new TotalSequenceSymbolFrequencyCounter(links); + + // var linkFrequenciesCache = new LinkFrequenciesCache(links, totalSequenceSymbolFrequencyCounter); + + // var index = new CachedFrequencyIncrementingSequenceIndex(linkFrequenciesCache); + // var linkToItsFrequencyNumberConverter = new FrequenciesCacheBasedLinkToItsFrequencyNumberConverter(linkFrequenciesCache); + + // var sequenceToItsLocalElementLevelsConverter = new SequenceToItsLocalElementLevelsConverter(links, linkToItsFrequencyNumberConverter); + // var optimalVariantConverter = new OptimalVariantConverter(links, sequenceToItsLocalElementLevelsConverter); + + // var sequences = new Sequences(links, new SequencesOptions() { Walker = new LeveledSequenceWalker(links) }); + + // ExecuteTest(sequences, sequence, sequenceToItsLocalElementLevelsConverter, index, optimalVariantConverter); + // } + // } + // private static void ExecuteTest(Sequences sequences, ulong[] sequence, SequenceToItsLocalElementLevelsConverter sequenceToItsLocalElementLevelsConverter, ISequenceIndex index, OptimalVariantConverter optimalVariantConverter) + // { + // index.Add(sequence); + + // var optimalVariant = optimalVariantConverter.Convert(sequence); + + // var readSequence1 = sequences.ToList(optimalVariant); + + // Assert.True(sequence.SequenceEqual(readSequence1)); + // } + + // [Fact] + // public static void SavedSequencesOptimizationTest() + // { + // LinksConstants constants = new LinksConstants((1, long.MaxValue), (long.MaxValue + 1UL, ulong.MaxValue)); + + // using (var memory = new HeapResizableDirectMemory()) + // using (var disposableLinks = new UInt64UnitedMemoryLinks(memory, UInt64UnitedMemoryLinks.DefaultLinksSizeStep, constants, IndexTreeType.Default)) + // { + // var links = new UInt64Links(disposableLinks); + + // var root = links.CreatePoint(); + + // //var numberToAddressConverter = new RawNumberToAddressConverter(); + // var addressToNumberConverter = new AddressToRawNumberConverter(); + + // var unicodeSymbolMarker = links.GetOrCreate(root, addressToNumberConverter.Convert(1)); + // var unicodeSequenceMarker = links.GetOrCreate(root, addressToNumberConverter.Convert(2)); + + // var totalSequenceSymbolFrequencyCounter = new TotalSequenceSymbolFrequencyCounter(links); + // var linkFrequenciesCache = new LinkFrequenciesCache(links, totalSequenceSymbolFrequencyCounter); + // var index = new CachedFrequencyIncrementingSequenceIndex(linkFrequenciesCache); + // var linkToItsFrequencyNumberConverter = new FrequenciesCacheBasedLinkToItsFrequencyNumberConverter(linkFrequenciesCache); + // var sequenceToItsLocalElementLevelsConverter = new SequenceToItsLocalElementLevelsConverter(links, linkToItsFrequencyNumberConverter); + // var optimalVariantConverter = new OptimalVariantConverter(links, sequenceToItsLocalElementLevelsConverter); + + // var walker = new RightSequenceWalker(links, new DefaultStack(), (link) => constants.IsExternalReference(link) || links.IsPartialPoint(link)); + + // var unicodeSequencesOptions = new SequencesOptions() + // { + // UseSequenceMarker = true, + // SequenceMarkerLink = unicodeSequenceMarker, + // UseIndex = true, + // Index = index, + // LinksToSequenceConverter = optimalVariantConverter, + // Walker = walker, + // UseGarbageCollection = true + // }; + + // var unicodeSequences = new Sequences(new SynchronizedLinks(links), unicodeSequencesOptions); + + // // Create some sequences + // var strings = _loremIpsumExample.Split(new[] { '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries); + // var arrays = strings.Select(x => x.Select(y => addressToNumberConverter.Convert(y)).ToArray()).ToArray(); + // for (int i = 0; i < arrays.Length; i++) + // { + // unicodeSequences.Create(arrays[i].ShiftRight()); + // } + + // var linksCountAfterCreation = links.Count(); + + // // get list of sequences links + // // for each sequence link + // // create new sequence version + // // if new sequence is not the same as sequence link + // // delete sequence link + // // collect garbadge + // unicodeSequences.CompactAll(); + + // var linksCountAfterCompactification = links.Count(); + + // Assert.True(linksCountAfterCompactification < linksCountAfterCreation); + // } + // } + } +}