public void ExponentValueWithBiasIsCorrect()
{
var bitMask1 = new BitMask(new uint[] { 0xE40 }, 33);
var unum1 = new Unum(_environment_3_4, bitMask1);
Assert.AreEqual(unum1.ExponentValueWithBias(), -8);
var unumZero = new Unum(_environment_3_4, 0);
Assert.AreEqual(unumZero.ExponentValueWithBias(), 1);
}
public void UnumIsCorrectlyConstructedFromUintArray()
{
var unum0 = new Unum(_environment_4_8, new uint[] { 0 });
Assert.AreEqual(unum0.IsZero(), true);
var unumMinus1 = new Unum(_environment_4_8, new uint[] { 1 }, true);
var bitMaskMinus1 = new BitMask(new uint[] { 0x2000, 0, 0, 0, 0, 0, 0, 0, 0x20000000 }, _environment_4_8.Size);
Assert.AreEqual(unumMinus1.UnumBits, bitMaskMinus1);
var unum10 = new Unum(_environment_2_2, new uint[] { 10 });
var bitMask10 = new BitMask(new uint[] { 0x329 }, _environment_2_2.Size);
Assert.AreEqual(unum10.UnumBits, bitMask10);
var unum500000 = new Unum(_environment_4_8, new uint[] { 500000 }); // 0xC7A1250C9
var bitMask500000 = new BitMask(new uint[] { 0xC7A1250C }, _environment_4_8.Size);
Assert.AreEqual(unum500000.UnumBits, bitMask500000);
var unumBig = new Unum(_environment_4_8, new uint[] { 594967295 });
var bitMaskBig = new BitMask(new uint[] { 0xCF5FE51C, 0xF06E }, _environment_4_8.Size);
Assert.AreEqual(unumBig.UnumBits, bitMaskBig);
var minValue = new uint[8];
for (var i = 0; i < 8; i++)
{
minValue[i] = uint.MaxValue;
}
minValue[7] >>= 1;
var unumMin = new Unum(_environment_4_8, minValue, true); // This is negative.
var bitMaskMinValue = new BitMask(new uint[]
{
0xFFFFE8FD, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
0xFFFFFFFF, 0xFFFFFFFF, 0x200FEFFF
}, _environment_4_8.Size);
Assert.AreEqual(unumMin.UnumBits, bitMaskMinValue);
var maxValue = new uint[8];
for (int i = 0; i < 8; i++)
{
maxValue[i] = uint.MaxValue;
}
maxValue[7] >>= 1;
var bitMaskMaxValue = new BitMask(new uint[]
{
0xFFFFE8FD, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
0xFFFFFFFF, 0xFFFFFFFF, 0xFEFFF
}, _environment_4_8.Size);
var unumMax = new Unum(_environment_4_8, maxValue);
Assert.AreEqual(unumMax.IsPositive(), true);
Assert.AreEqual(unumMax.Size, _environment_4_8.Size);
Assert.AreEqual(unumMax.FractionSizeWithHiddenBit(), 255);
Assert.AreEqual(unumMax.ExponentValueWithBias(), 254);
Assert.AreEqual(unumMax.FractionWithHiddenBit(), new BitMask(maxValue, _environment_4_8.Size));
Assert.AreEqual(unumMax.UnumBits, bitMaskMaxValue);
var tooBigUnum_warlpiri = new Unum(_warlpiriEnvironment, 3);
var tooBigBitMask_warlpiri = _warlpiriEnvironment.LargestPositive | _warlpiriEnvironment.UncertaintyBitMask;
Assert.AreEqual(tooBigUnum_warlpiri.UnumBits, tooBigBitMask_warlpiri);
var tooBigNegativeUnum_warlpiri = new Unum(_warlpiriEnvironment, -3);
var tooBigNegativeBitMask_warlpiri = _warlpiriEnvironment.LargestNegative | _warlpiriEnvironment.UncertaintyBitMask;
Assert.AreEqual(tooBigNegativeUnum_warlpiri.UnumBits, tooBigNegativeBitMask_warlpiri);
var maxValue_2_2 = new Unum(_environment_2_2, 480);
var maxBitMask_2_2 = new BitMask(new uint[] { 0xFEE }, _environment_2_2.Size);
Assert.AreEqual(maxValue_2_2.UnumBits, maxBitMask_2_2);
var minValue_2_2 = new Unum(_environment_2_2, -480);
var bitMaskMinValue_2_2 = new BitMask(new uint[] { 0x2FEE }, _environment_2_2.Size);
Assert.AreEqual(minValue_2_2.UnumBits, bitMaskMinValue_2_2);
var tooBigUnum_2_2 = new Unum(_environment_2_2, 481);
var tooBigBitMask_2_2 = _environment_2_2.LargestPositive | _environment_2_2.UncertaintyBitMask;
Assert.AreEqual(tooBigUnum_2_2.UnumBits, tooBigBitMask_2_2);
var tooBigNegativeUnum_2_2 = new Unum(_environment_2_2, -481);
var tooBigNegativeBitMask_2_2 = _environment_2_2.LargestNegative | _environment_2_2.UncertaintyBitMask;
Assert.AreEqual(tooBigNegativeUnum_2_2.UnumBits, tooBigNegativeBitMask_2_2);
var maxValue_2_3 = new Unum(_environment_2_3, 510);
var maxBitMask_2_3 = new BitMask(new uint[] { 0x1FFDE }, _environment_2_3.Size);
Assert.AreEqual(maxValue_2_3.UnumBits, maxBitMask_2_3);
var minValue_2_3 = new Unum(_environment_2_3, -510);
var bitMaskMinValue_2_3 = new BitMask(new uint[] { 0x5FFDE }, _environment_2_3.Size);
Assert.AreEqual(minValue_2_3.UnumBits, bitMaskMinValue_2_3);
var tooBigUnum_2_3 = new Unum(_environment_2_3, 511);
var tooBigBitMask_2_3 = _environment_2_3.LargestPositive | _environment_2_3.UncertaintyBitMask;
Assert.AreEqual(tooBigUnum_2_3.UnumBits, tooBigBitMask_2_3);
var tooBigNegativeUnum_2_3 = new Unum(_environment_2_3, -511);
var tooBigNegativeBitMask_2_3 = _environment_2_3.LargestNegative | _environment_2_3.UncertaintyBitMask;
Assert.AreEqual(tooBigNegativeUnum_2_3.UnumBits, tooBigNegativeBitMask_2_3);
// Testing in an environment where the biggest representable value isn't an integer.
var maxValue_2_4 = new Unum(_environment_2_4, 511);
var maxBitMask_2_4 = new BitMask(new uint[] { 0x7FFB7 }, _environment_2_4.Size);
Assert.AreEqual(maxValue_2_4.UnumBits, maxBitMask_2_4);
var minValue_2_4 = new Unum(_environment_2_4, -511);
var bitMaskMinValue_2_4 = new BitMask(new uint[] { 0x807FFB7 }, _environment_2_4.Size);
Assert.AreEqual(minValue_2_4.UnumBits, bitMaskMinValue_2_4);
var tooBigUnum_2_4 = new Unum(_environment_2_4, 512);
var tooBigBitMask_2_4 = _environment_2_4.LargestPositive | _environment_2_4.UncertaintyBitMask;
Assert.AreEqual(tooBigUnum_2_4.UnumBits, tooBigBitMask_2_4);
var tooBigNegativeUnum_2_4 = new Unum(_environment_2_4, -512);
var tooBigNegativeBitMask_2_4 = _environment_2_4.LargestNegative | _environment_2_4.UncertaintyBitMask;
Assert.AreEqual(tooBigNegativeUnum_2_4.UnumBits, tooBigNegativeBitMask_2_4);
}