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 <ulong>(links, unaryOne);
var unaryNumberIncrementer = new UnaryNumberIncrementer <ulong>(links, unaryOne);
var frequencyIncrementer = new FrequencyIncrementer <ulong>(links, frequencyMarker, unaryOne, unaryNumberIncrementer);
var frequencyPropertyOperator = new PropertyOperator <ulong>(links, frequencyPropertyMarker, frequencyMarker);
var index = new FrequencyIncrementingSequenceIndex <ulong>(links, frequencyPropertyOperator, frequencyIncrementer);
var linkToItsFrequencyNumberConverter = new LinkToItsFrequencyNumberConveter <ulong>(links, frequencyPropertyOperator, unaryNumberToAddressConverter);
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);
}
}
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);
}
}
private static void ExecuteTest(Sequences.Sequences sequences, ulong[] sequence, SequenceToItsLocalElementLevelsConverter <ulong> sequenceToItsLocalElementLevelsConverter, ISequenceIndex <ulong> index, OptimalVariantConverter <ulong> optimalVariantConverter)
{
index.Add(sequence);
var optimalVariant = optimalVariantConverter.Convert(sequence);
var readSequence1 = sequences.ToList(optimalVariant);
Assert.True(sequence.SequenceEqual(readSequence1));
}
public TempLinksTestScope(SequencesOptions <ulong> sequencesOptions, bool deleteFiles = true, bool useSequences = false, bool useLog = false)
{
_deleteFiles = deleteFiles;
TempFilename = Path.GetTempFileName();
TempTransactionLogFilename = Path.GetTempFileName();
//var coreMemoryAdapter = new UInt64UnitedMemoryLinks(TempFilename);
var coreMemoryAdapter = new UInt64SplitMemoryLinks(new FileMappedResizableDirectMemory(TempFilename), new FileMappedResizableDirectMemory(Path.ChangeExtension(TempFilename, "indexes")), UInt64SplitMemoryLinks.DefaultLinksSizeStep, new LinksConstants <ulong>(), Memory.IndexTreeType.Default, useLinkedList: true);
MemoryAdapter = useLog ? (ILinks <ulong>) new UInt64LinksTransactionsLayer(coreMemoryAdapter, TempTransactionLogFilename) : coreMemoryAdapter;
Links = new SynchronizedLinks <ulong>(new UInt64Links(MemoryAdapter));
if (useSequences)
{
Sequences = new Sequences.Sequences(Links, sequencesOptions);
}
}
public static void ReadSequenceTest()
{
const long sequenceLength = 2000;
using (var scope = new TempLinksTestScope(useSequences: false))
{
var links = scope.Links;
var sequences = new Sequences.Sequences(links, new SequencesOptions <ulong> {
Walker = new LeveledSequenceWalker <ulong>(links)
});
var sequence = new ulong[sequenceLength];
for (var i = 0; i < sequenceLength; i++)
{
sequence[i] = links.Create();
}
var balancedVariantConverter = new BalancedVariantConverter <ulong>(links);
var sw1 = Stopwatch.StartNew();
var balancedVariant = balancedVariantConverter.Convert(sequence); sw1.Stop();
var sw2 = Stopwatch.StartNew();
var readSequence1 = sequences.ToList(balancedVariant); sw2.Stop();
var sw3 = Stopwatch.StartNew();
var readSequence2 = new List <ulong>();
SequenceWalker.WalkRight(balancedVariant,
links.GetSource,
links.GetTarget,
links.IsPartialPoint,
readSequence2.Add);
sw3.Stop();
Assert.True(sequence.SequenceEqual(readSequence1));
Assert.True(sequence.SequenceEqual(readSequence2));
// Assert.True(sw2.Elapsed < sw3.Elapsed);
Console.WriteLine($"Stack-based walker: {sw3.Elapsed}, Level-based reader: {sw2.Elapsed}");
for (var i = 0; i < sequenceLength; i++)
{
links.Delete(sequence[i]);
}
}
}
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);
}
}
