public void FractionWithHiddenBitIsCorrect() { var bitMask1 = new BitMask(new uint[] { 0xE40 }, 33); var unum1 = new Unum(_environment_3_4, bitMask1); Assert.AreEqual(new BitMask(new uint[] { 2 }, 33), unum1.FractionWithHiddenBit()); var bitMask2 = new BitMask(new uint[] { 0x3F22 }, 33); var unum2 = new Unum(_environment_3_4, bitMask2); Assert.AreEqual(new BitMask(new uint[] { 0xF }, 33), unum2.FractionWithHiddenBit()); var bitMask3 = new BitMask(new uint[] { 0x7E012B }, 33); var unum3 = new Unum(_environment_3_4, bitMask3); Assert.AreEqual(new BitMask(new uint[] { 0x1E01 }, 33), unum3.FractionWithHiddenBit()); }
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); }