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 <ulong>(links);

                var linkFrequenciesCache = new LinkFrequenciesCache <ulong>(links, totalSequenceSymbolFrequencyCounter);

                var index = new CachedFrequencyIncrementingSequenceIndex <ulong>(linkFrequenciesCache);
                var linkToItsFrequencyNumberConverter = new FrequenciesCacheBasedLinkToItsFrequencyNumberConverter <ulong>(linkFrequenciesCache);

                var sequenceToItsLocalElementLevelsConverter = new SequenceToItsLocalElementLevelsConverter <ulong>(links, linkToItsFrequencyNumberConverter);
                var optimalVariantConverter = new OptimalVariantConverter <ulong>(links, sequenceToItsLocalElementLevelsConverter);

                var sequences = new Sequences.Sequences(links, new SequencesOptions <ulong>()
                {
                    Walker = new LeveledSequenceWalker <ulong>(links)
                });

                ExecuteTest(sequences, sequence, sequenceToItsLocalElementLevelsConverter, index, optimalVariantConverter);
            }
        }
Exemple #2
0
        public Patterns(string sourceImagePath)
        {
            _sourceImagePath = Path.GetFullPath(sourceImagePath);
            _image           = new MagickImage(sourceImagePath);
            _pixels          = _image.GetPixels();
            _linksPath       = Path.ChangeExtension(_sourceImagePath, ".links");
            var memory    = new HeapResizableDirectMemory(); //new FileMappedResizableDirectMemory(_linksPath);
            var constants = new LinksConstants <ulong>(enableExternalReferencesSupport: true);

            _links = new UInt64Links(new UInt64UnitedMemoryLinks(memory, UInt64UnitedMemoryLinks.DefaultLinksSizeStep, constants, Platform.Data.Doublets.Memory.IndexTreeType.SizedAndThreadedAVLBalancedTree));
            _addressToRawNumberConverter         = new AddressToRawNumberConverter <ulong>();
            _rawNumberToAddressConverter         = new RawNumberToAddressConverter <ulong>();
            _totalSequenceSymbolFrequencyCounter = new TotalSequenceSymbolFrequencyCounter <ulong>(_links);
            _linkFrequenciesCache = new LinkFrequenciesCache <ulong>(_links, _totalSequenceSymbolFrequencyCounter);
            _index = new CachedFrequencyIncrementingSequenceIndex <ulong>(_linkFrequenciesCache);
            _linkToItsFrequencyNumberConverter        = new FrequenciesCacheBasedLinkToItsFrequencyNumberConverter <ulong>(_linkFrequenciesCache);
            _sequenceToItsLocalElementLevelsConverter = new SequenceToItsLocalElementLevelsConverter <ulong>(_links, _linkToItsFrequencyNumberConverter);
            _optimalVariantConverter = new OptimalVariantConverter <ulong>(_links, _sequenceToItsLocalElementLevelsConverter);
        }
        public static void SavedSequencesOptimizationTest()
        {
            LinksConstants <ulong> constants = new LinksConstants <ulong>((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<ulong>();
                    var addressToNumberConverter = new AddressToRawNumberConverter <ulong>();

                    var unicodeSymbolMarker   = links.GetOrCreate(root, addressToNumberConverter.Convert(1));
                    var unicodeSequenceMarker = links.GetOrCreate(root, addressToNumberConverter.Convert(2));

                    var totalSequenceSymbolFrequencyCounter = new TotalSequenceSymbolFrequencyCounter <ulong>(links);
                    var linkFrequenciesCache = new LinkFrequenciesCache <ulong>(links, totalSequenceSymbolFrequencyCounter);
                    var index = new CachedFrequencyIncrementingSequenceIndex <ulong>(linkFrequenciesCache);
                    var linkToItsFrequencyNumberConverter        = new FrequenciesCacheBasedLinkToItsFrequencyNumberConverter <ulong>(linkFrequenciesCache);
                    var sequenceToItsLocalElementLevelsConverter = new SequenceToItsLocalElementLevelsConverter <ulong>(links, linkToItsFrequencyNumberConverter);
                    var optimalVariantConverter = new OptimalVariantConverter <ulong>(links, sequenceToItsLocalElementLevelsConverter);

                    var walker = new RightSequenceWalker <ulong>(links, new DefaultStack <ulong>(), (link) => constants.IsExternalReference(link) || links.IsPartialPoint(link));

                    var unicodeSequencesOptions = new SequencesOptions <ulong>()
                    {
                        UseSequenceMarker  = true,
                        SequenceMarkerLink = unicodeSequenceMarker,
                        UseIndex           = true,
                        Index = index,
                        LinksToSequenceConverter = optimalVariantConverter,
                        Walker = walker,
                        UseGarbageCollection = true
                    };

                    var unicodeSequences = new Sequences.Sequences(new SynchronizedLinks <ulong>(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);
                }
        }