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));
}
private ulong SaveRow(int y, int width)
{
var row = GetRow(y, width);
return(_optimalVariantConverter.Convert(row));
}
public static void CompressionEfficiencyTest()
{
var strings = _exampleLoremIpsumText.Split(new[] { '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries);
var arrays = strings.Select(UnicodeMap.FromStringToLinkArray).ToArray();
var totalCharacters = arrays.Select(x => x.Length).Sum();
using (var scope1 = new TempLinksTestScope(useSequences: true))
using (var scope2 = new TempLinksTestScope(useSequences: true))
using (var scope3 = new TempLinksTestScope(useSequences: true))
{
scope1.Links.Unsync.UseUnicode();
scope2.Links.Unsync.UseUnicode();
scope3.Links.Unsync.UseUnicode();
var balancedVariantConverter1 = new BalancedVariantConverter <ulong>(scope1.Links.Unsync);
var totalSequenceSymbolFrequencyCounter = new TotalSequenceSymbolFrequencyCounter <ulong>(scope1.Links.Unsync);
var linkFrequenciesCache1 = new LinkFrequenciesCache <ulong>(scope1.Links.Unsync, totalSequenceSymbolFrequencyCounter);
var compressor1 = new CompressingConverter <ulong>(scope1.Links.Unsync, balancedVariantConverter1, linkFrequenciesCache1, doInitialFrequenciesIncrement: false);
//var compressor2 = scope2.Sequences;
var compressor3 = scope3.Sequences;
var constants = Default <LinksConstants <ulong> > .Instance;
var sequences = compressor3;
//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 FrequencyPropertyOperator<ulong>(links, frequencyPropertyMarker, frequencyMarker);
//var linkFrequencyIncrementer = new LinkFrequencyIncrementer<ulong>(links, frequencyPropertyOperator, frequencyIncrementer);
//var linkToItsFrequencyNumberConverter = new LinkToItsFrequencyNumberConveter<ulong>(links, frequencyPropertyOperator, unaryNumberToAddressConverter);
var linkFrequenciesCache3 = new LinkFrequenciesCache <ulong>(scope3.Links.Unsync, totalSequenceSymbolFrequencyCounter);
var linkToItsFrequencyNumberConverter = new FrequenciesCacheBasedLinkToItsFrequencyNumberConverter <ulong>(linkFrequenciesCache3);
var sequenceToItsLocalElementLevelsConverter = new SequenceToItsLocalElementLevelsConverter <ulong>(scope3.Links.Unsync, linkToItsFrequencyNumberConverter);
var optimalVariantConverter = new OptimalVariantConverter <ulong>(scope3.Links.Unsync, sequenceToItsLocalElementLevelsConverter);
var compressed1 = new ulong[arrays.Length];
var compressed2 = new ulong[arrays.Length];
var compressed3 = new ulong[arrays.Length];
var START = 0;
var END = arrays.Length;
//for (int i = START; i < END; i++)
// linkFrequenciesCache1.IncrementFrequencies(arrays[i]);
var initialCount1 = scope2.Links.Unsync.Count();
var sw1 = Stopwatch.StartNew();
for (int i = START; i < END; i++)
{
linkFrequenciesCache1.IncrementFrequencies(arrays[i]);
compressed1[i] = compressor1.Convert(arrays[i]);
}
var elapsed1 = sw1.Elapsed;
var balancedVariantConverter2 = new BalancedVariantConverter <ulong>(scope2.Links.Unsync);
var initialCount2 = scope2.Links.Unsync.Count();
var sw2 = Stopwatch.StartNew();
for (int i = START; i < END; i++)
{
compressed2[i] = balancedVariantConverter2.Convert(arrays[i]);
}
var elapsed2 = sw2.Elapsed;
for (int i = START; i < END; i++)
{
linkFrequenciesCache3.IncrementFrequencies(arrays[i]);
}
var initialCount3 = scope3.Links.Unsync.Count();
var sw3 = Stopwatch.StartNew();
for (int i = START; i < END; i++)
{
//linkFrequenciesCache3.IncrementFrequencies(arrays[i]);
compressed3[i] = optimalVariantConverter.Convert(arrays[i]);
}
var elapsed3 = sw3.Elapsed;
Console.WriteLine($"Compressor: {elapsed1}, Balanced variant: {elapsed2}, Optimal variant: {elapsed3}");
// Assert.True(elapsed1 > elapsed2);
// Checks
for (int i = START; i < END; i++)
{
var sequence1 = compressed1[i];
var sequence2 = compressed2[i];
var sequence3 = compressed3[i];
var decompress1 = UnicodeMap.FromSequenceLinkToString(sequence1, scope1.Links.Unsync);
var decompress2 = UnicodeMap.FromSequenceLinkToString(sequence2, scope2.Links.Unsync);
var decompress3 = UnicodeMap.FromSequenceLinkToString(sequence3, scope3.Links.Unsync);
var structure1 = scope1.Links.Unsync.FormatStructure(sequence1, link => link.IsPartialPoint());
var structure2 = scope2.Links.Unsync.FormatStructure(sequence2, link => link.IsPartialPoint());
var structure3 = scope3.Links.Unsync.FormatStructure(sequence3, link => link.IsPartialPoint());
//if (sequence1 != Constants.Null && sequence2 != Constants.Null && arrays[i].Length > 3)
// Assert.False(structure1 == structure2);
//if (sequence3 != Constants.Null && sequence2 != Constants.Null && arrays[i].Length > 3)
// Assert.False(structure3 == structure2);
Assert.True(strings[i] == decompress1 && decompress1 == decompress2);
Assert.True(strings[i] == decompress3 && decompress3 == decompress2);
}
Assert.True((int)(scope1.Links.Unsync.Count() - initialCount1) < totalCharacters);
Assert.True((int)(scope2.Links.Unsync.Count() - initialCount2) < totalCharacters);
Assert.True((int)(scope3.Links.Unsync.Count() - initialCount3) < totalCharacters);
Console.WriteLine($"{(double)(scope1.Links.Unsync.Count() - initialCount1) / totalCharacters} | {(double)(scope2.Links.Unsync.Count() - initialCount2) / totalCharacters} | {(double)(scope3.Links.Unsync.Count() - initialCount3) / totalCharacters}");
Assert.True(scope1.Links.Unsync.Count() - initialCount1 < scope2.Links.Unsync.Count() - initialCount2);
Assert.True(scope3.Links.Unsync.Count() - initialCount3 < scope2.Links.Unsync.Count() - initialCount2);
var duplicateProvider1 = new DuplicateSegmentsProvider <ulong>(scope1.Links.Unsync, scope1.Sequences);
var duplicateProvider2 = new DuplicateSegmentsProvider <ulong>(scope2.Links.Unsync, scope2.Sequences);
var duplicateProvider3 = new DuplicateSegmentsProvider <ulong>(scope3.Links.Unsync, scope3.Sequences);
var duplicateCounter1 = new DuplicateSegmentsCounter <ulong>(duplicateProvider1);
var duplicateCounter2 = new DuplicateSegmentsCounter <ulong>(duplicateProvider2);
var duplicateCounter3 = new DuplicateSegmentsCounter <ulong>(duplicateProvider3);
var duplicates1 = duplicateCounter1.Count();
ConsoleHelpers.Debug("------");
var duplicates2 = duplicateCounter2.Count();
ConsoleHelpers.Debug("------");
var duplicates3 = duplicateCounter3.Count();
Console.WriteLine($"{duplicates1} | {duplicates2} | {duplicates3}");
linkFrequenciesCache1.ValidateFrequencies();
linkFrequenciesCache3.ValidateFrequencies();
}
}