public static Dictionary <T, BitCode64> GenerateGammaCoding <T>(this IEnumerator <T> enumerator,
T encodingSwitch, out int count, int predictCount = 0)
{
var _dict = GenerateFrequencyDictionary(enumerator, out count, predictCount);
int sfre = _switchProcess <T>(_dict);
var sortedFrequency = _dict.OrderBy(n => n.Value);
var dict2 = new Dictionary <T, BitCode64>(sortedFrequency.Count());
int num = 0;
int sfreProcessed = 0;
T key;
foreach (var pair in sortedFrequency)
{
if (sfreProcessed == 0 && sfre > pair.Value)
{
key = encodingSwitch;
sfreProcessed = 1;
}
else
{
key = pair.Key;
}
begin:
int l = (int)Math.Floor(Math.Log(num));
UInt64 code = 0;
for (int a = 0; a <= l; a++)
{
code.SetBit(63 - a, false); //put 0s to indicate how many bits will follow
}
code.SetBit(62 - l, true); //mark the end of the 0s
for (int a = l - 1, i = 61 - l; a >= 0; a--, i--) //Write the bits as plain binary
{
if ((code & (ulong)1 << a) > 0)
{
code.SetBit(i, true);
}
else
{
code.SetBit(i, false);
}
}
dict2.Add(key, new BitCode64(code, 2 * l + 1, true));
num++;
if (sfreProcessed == 1)
{
key = pair.Key;
sfreProcessed = 2;
goto begin;
}
}
return(dict2);
}
public void TestUInt64()
{
for (var n = 0; n < sizeof(UInt64) * 8; n++)
{
UInt64 a = (UInt64) ~(1L << n);
UInt64 i = unchecked ((UInt64) ~0);
i.SetBit(n, false);
Assert.Equal(a, i);
}
}
public UInt64 CreateBitSet(params T[] elements)
{
UInt64 set = 0UL;
foreach (var element in elements)
{
set = set.SetBit(IndexOf(element));
}
return(set);
}
public UInt64 CreateBitSetFromIndices(params int[] indices)
{
UInt64 set = 0UL;
foreach (var index in indices)
{
set = set.SetBit(index);
}
return(set);
}
public UInt64 CreateFullBitSet()
{
UInt64 set = 0UL;
for (int i = 0; i < _elements.Count; i++)
{
set = set.SetBit(i);
}
return(set);
}
private UInt64 FindPlausibleFiniteDomainValues()
{
MultiInterval score = Score.AllowableValues.First;
int[] setBits = FiniteDomainVariable.AllowableValues.GetSetIndices();
UInt64 mask = 0UL;
for (int i = 0; i < setBits.Length; i++)
{
if (MultiInterval.Intersects(score, _scoreMapping[setBits[i]]))
{
mask = mask.SetBit(setBits[i]);
}
}
return(mask);
}
public static Dictionary <T, BitCode64> GenerateDeltaCoding <T>(this IEnumerator <T> enumerator, T encodingSwitch,
out int count, int predictCount = 0)
{
var _dict = GenerateFrequencyDictionary(enumerator, out count, predictCount);
int sfre = _switchProcess <T>(_dict);
var sortedFrequency = _dict.OrderBy(n => n.Value);
var dict2 = new Dictionary <T, BitCode64>(sortedFrequency.Count());
int num = 0;
int sfreProcessed = 0;
T key;
foreach (var pair in sortedFrequency)
{
if (sfreProcessed == 0 && sfre > pair.Value)
{
key = encodingSwitch;
sfreProcessed = 1;
}
else
{
key = pair.Key;
}
begin:
int len = 0;
int lengthOfLen = 0;
UInt64 code = 0;
for (int temp = num; temp > 0; temp >>= 1) // calculate 1+floor(log2(num))
{
len++;
}
for (int temp = len; temp > 1; temp >>= 1) // calculate floor(log2(len))
{
lengthOfLen++;
}
int j = sizeof(int);
for (int i = lengthOfLen; i > 0; --i)
{
code.SetBit(--j, false);
}
for (int i = lengthOfLen; i >= 0; --i)
{
code.SetBit(--j, Convert.ToBoolean(((len >> i) & 1)));
}
for (int i = len - 2; i >= 0; i--)
{
code.SetBit(--j, Convert.ToBoolean((num >> i) & 1));
}
dict2.Add(key, new BitCode64(code, sizeof(int) - j, true));
num++;
if (sfreProcessed == 1)
{
key = pair.Key;
sfreProcessed = 2;
goto begin;
}
}
return(dict2);
}
