public void UnumToIntIsCorrect() { var unum1 = new Unum(_environment_3_4, 1); var one = (int)unum1; Assert.AreEqual(one, 1); var unum30 = new Unum(_environment_3_4, 30); var number30 = (int)unum30; Assert.AreEqual(number30, 30); var unum1000 = new Unum(_environment_3_4, 1000); var number1000 = (int)unum1000; Assert.AreEqual(number1000, 1000); var unumNegative30 = new Unum(_environment_3_4, -30); var numberNegative30 = (int)unumNegative30; Assert.AreEqual(numberNegative30, -30); var unumNegative1000 = new Unum(_environment_3_4, -1000); var numberNegative1000 = (int)unumNegative1000; Assert.AreEqual(numberNegative1000, -1000); }
public void UnumToUintIsCorrect() { var unum1 = new Unum(_environment_3_4, 1); var number1 = (uint)unum1; Assert.AreEqual(number1, 1); var unum2 = new Unum(_environment_3_4, 2); var number2 = (uint)unum2; Assert.AreEqual(number2, 2); var unum30 = new Unum(_environment_3_4, 30); var number30 = (uint)unum30; Assert.AreEqual(number30, 30); var unum1000 = new Unum(_environment_3_4, 1000); var number1000 = (uint)unum1000; Assert.AreEqual(number1000, 1000); var unum5000 = new Unum(_environment_3_4, 5000); var number5000 = (uint)unum5000; Assert.AreEqual(number5000, 5000); var unum6000 = new Unum(_environment_3_4, 6000); var number6000 = (uint)unum6000; Assert.AreEqual(number6000, 6000); }
public void FractionToUintArrayIsCorrect() { var unumZero = new Unum(_environment_4_8, new uint[] { 0 }); Assert.AreEqual(unumZero.FractionToUintArray(), new uint[] { 0, 0, 0, 0, 0, 0, 0, 0, 0 }); var unum1 = new Unum(_environment_4_8, new uint[] { 1 }); Assert.AreEqual(unum1.FractionToUintArray(), new uint[] { 1, 0, 0, 0, 0, 0, 0, 0, 0 }); var unum500000 = new Unum(_environment_4_8, new uint[] { 500000 }); //0xC7A1250C Assert.AreEqual(unum500000.FractionToUintArray(), new uint[] { 500000, 0, 0, 0, 0, 0, 0, 0, 0 }); var unumBig = new Unum(_environment_4_8, new uint[] { 594967295 }); Assert.AreEqual(unumBig.FractionToUintArray(), new uint[] { 594967295, 0, 0, 0, 0, 0, 0, 0, 0 }); var maxValue = new uint[8]; for (var i = 0; i < 8; i++) { maxValue[i] = uint.MaxValue; } maxValue[7] >>= 1; var unumMax = new Unum(_environment_4_8, maxValue); Assert.AreEqual(unumMax.FractionToUintArray(), new uint[] { 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x7FFFFFFF, 0 }); }
public void SubtractExactUnumsIsCorrect() { var bitMask1 = new BitMask(new uint[] { 0x7E012B }, 33); // 30.00390625 var bitMask2 = new BitMask(new uint[] { 0xE40 }, 33); // 0.00390625 var bitMask3 = new BitMask(new uint[] { 0x3F22 }, 33); // 30 var unum1 = new Unum(_environment_3_4, bitMask1); var unum2 = new Unum(_environment_3_4, bitMask2); var unum3 = Unum.SubtractExactUnums(unum1, unum2); Assert.AreEqual(unum3.UnumBits, bitMask3); var unum5000 = new Unum(_environment_3_4, 5000); var unum6000 = new Unum(_environment_3_4, 6000); var unum1000 = new Unum(_environment_3_4, 1000); var unumRes = Unum.SubtractExactUnums(unum6000, unum5000); Assert.AreEqual(unumRes.UnumBits, unum1000.UnumBits); Unum unum30 = new Unum(_environment_3_4, 30); Unum unumZero = new Unum(_environment_3_4, 0); Assert.AreEqual(Unum.SubtractExactUnums(unum30, unum30).UnumBits, unumZero.UnumBits); }
public void Init() { _warlpiriEnvironment = UnumEnvironment.FromStandardEnvironment(StandardEnvironment.Warlpiri); _environment_3_2 = new UnumEnvironment(3, 2); _environment_3_4 = new UnumEnvironment(3, 4); _unum_3_2 = new Unum(_environment_3_2); _unum_3_4 = new Unum(_environment_3_4); }
public void UnumIsCorrectlyConstructedFromUInt() { var unum0 = new Unum(_environment_3_4, (uint)0); var bitMask0 = new BitMask(new uint[] { 0 }, _environment_3_4.Size); Assert.AreEqual(bitMask0, unum0.UnumBits); var unum1 = new Unum(_environment_3_4, (uint)1); var bitMask1 = new BitMask(new uint[] { 0x100 }, _environment_3_4.Size); Assert.AreEqual(bitMask1, unum1.UnumBits); var unum2 = new Unum(_environment_3_4, (uint)2); var bitMask2 = new BitMask(new uint[] { 0x200 }, _environment_3_4.Size); Assert.AreEqual(bitMask2, unum2.UnumBits); var unum4 = new Unum(_environment_3_4, (uint)4); var bitMask4 = new BitMask(new uint[] { 0x610 }, _environment_3_4.Size); Assert.AreEqual(bitMask4, unum4.UnumBits); var unum8 = new Unum(_environment_3_4, (uint)8); var bitMask8 = new BitMask(new uint[] { 0xC20 }, _environment_3_4.Size); Assert.AreEqual(bitMask8, unum8.UnumBits); var unum10 = new Unum(_environment_2_2, (uint)10); var bitMask10 = new BitMask(new uint[] { 0x329 }, _environment_2_2.Size); Assert.AreEqual(bitMask10, unum10.UnumBits); var unum13 = new Unum(_environment_3_4, (uint)13); var bitMask13 = new BitMask(new uint[] { 0x3522 }, _environment_3_4.Size); Assert.AreEqual(bitMask13, unum13.UnumBits); var unum30 = new Unum(_environment_3_4, (uint)30); var bitMask30 = new BitMask(new uint[] { 0x3F22 }, _environment_3_4.Size); Assert.AreEqual(bitMask30, unum30.UnumBits); var unum1000 = new Unum(_environment_3_4, (uint)1000); var bitMask1000 = new BitMask(new uint[] { 0x63D45 }, _environment_3_4.Size); Assert.AreEqual(bitMask1000, unum1000.UnumBits); var unum5000 = new Unum(_environment_3_4, (uint)5000); var bitMask5000 = new BitMask(new uint[] { 0x367148 }, _environment_3_4.Size); Assert.AreEqual(bitMask5000, unum5000.UnumBits); var unum6000 = new Unum(_environment_3_4, (uint)6000); var bitMask6000 = new BitMask(new uint[] { 0x1B7747 }, _environment_3_4.Size); Assert.AreEqual(bitMask6000, unum6000.UnumBits); }
public void WarlpiriUnumValuesAndCalculationsAreCorrect() { var unumNegative2 = new Unum(_warlpiriEnvironment, -2); Assert.AreEqual(-2, (int)unumNegative2); var unumNegative1 = new Unum(_warlpiriEnvironment, -1); Assert.AreEqual(-1, (int)unumNegative1); var unumNegative0 = new Unum(_warlpiriEnvironment, new BitMask(new uint[] { 8 }, _warlpiriEnvironment.Size)); Assert.AreEqual(0, (int)unumNegative0); var unum0 = new Unum(_warlpiriEnvironment, 0); Assert.AreEqual(0, (int)unum0); var unum1 = new Unum(_warlpiriEnvironment, 1); Assert.AreEqual(1, (int)unum1); var unum2 = new Unum(_warlpiriEnvironment, 2); Assert.AreEqual(2, (int)unum2); Assert.AreEqual(unumNegative0, unumNegative2 + unum2); Assert.AreEqual(unumNegative0, unumNegative1 + unum1); Assert.AreEqual(unum0, unum2 - unum2); Assert.AreEqual(unum0, unum1 - unum1); Assert.AreEqual(unum2, unum1 + unum1); Assert.AreEqual(unumNegative2, unumNegative1 + unumNegative1); Assert.AreEqual(unumNegative1, unumNegative2 + unum1); Assert.AreEqual(unum1, unum2 + unumNegative1); Assert.AreEqual(unumNegative0, unumNegative1 - unumNegative1); Assert.AreEqual(unumNegative0, unumNegative2 - unumNegative2); Assert.AreEqual(unum1, unumNegative1 - unumNegative2); Assert.AreEqual(unum1, unum0 - unumNegative1); Assert.AreEqual(unum1, unumNegative0 - unumNegative1); Assert.AreEqual(unum2, unum0 - unumNegative2); Assert.AreEqual(unum2, unumNegative0 - unumNegative2); }
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 FractionSizeIsCorrect() { var bitMask_3_2_allOne = new BitMask(19, true); var unum_3_2_allOne = new Unum(_environment_3_2, bitMask_3_2_allOne); Assert.AreEqual(4, unum_3_2_allOne.FractionSize()); var bitMask_3_4_allOne = new BitMask(33, true); var unum_3_4_allOne = new Unum(_environment_3_4, bitMask_3_4_allOne); Assert.AreEqual(16, unum_3_4_allOne.FractionSize()); }
public void AddExactUnumsIsCorrect() { // First example from The End of Error p. 117. var bitMask1 = new BitMask(new uint[] { 0xE40 }, 33); var bitMask2 = new BitMask(new uint[] { 0x3F22 }, 33); var unumFirst = new Unum(_environment_3_4, bitMask1); var unumSecond = new Unum(_environment_3_4, bitMask2); var bitMaskSum = new BitMask(new uint[] { 0x7E012B }, 33); var unumSum1 = Unum.AddExactUnums(unumFirst, unumSecond); Assert.AreEqual(unumSum1.UnumBits, bitMaskSum); // Addition should be commutative. var unumSum2 = Unum.AddExactUnums(unumSecond, unumFirst); Assert.AreEqual(unumSum1.UnumBits, unumSum2.UnumBits); var unum0 = new Unum(_environment_3_4, 0); var unum1 = new Unum(_environment_3_4, 1); var unum0Plus1 = unum0 + unum1; var unum31 = new Unum(_environment_3_4, 30) + unum1; var unum0PlusUnum1 = Unum.AddExactUnums(unum0, unum1); Assert.AreEqual(unum31.UnumBits, (new Unum(_environment_3_4, 31).UnumBits)); Assert.AreEqual(unum1.UnumBits, unum0Plus1.UnumBits); Assert.AreEqual(unum1.UnumBits, unum0PlusUnum1.UnumBits); // Case of inexact result, second example from The End or Error, p. 117. var bitMask4 = new BitMask(new uint[] { 0x18F400CF }, 33); // 1000.0078125 var unum1000 = new Unum(_environment_3_4, 1000); var unum6 = Unum.AddExactUnums(unum1000, unumFirst); // 1/256 Assert.AreEqual(unum6.UnumBits, bitMask4); var unum5000 = new Unum(_environment_3_4, 5000); var unum6000 = new Unum(_environment_3_4, 6000); Assert.AreEqual(Unum.AddExactUnums(unum5000, unum1000).UnumBits, unum6000.UnumBits); //var unumTest = new Unum(_metaData_3_5, 30.401); //var unumTest2 = new Unum(_metaData_3_5, -30.300); //var res = unumTest + unumTest2; //var resF = (double)res; //Assert.AreEqual(resF, (30.401 - 30.300));// The result is correct, but the precision is too poor to show that. var unumNegativeThirty = new Unum(_environment_3_4, -30); var unum30 = new Unum(_environment_3_4, 30); Assert.AreEqual(Unum.AddExactUnums(unum30, unumNegativeThirty).UnumBits, unum0.UnumBits); }
public void AdditionIsCorrectForIntegers() { var result = new Unum(_environment_3_5, 0); var count = 100; for (int i = 1; i <= count; i++) { result += new Unum(_environment_3_5, i * 1000); } for (int i = 1; i <= count; i++) { result -= new Unum(_environment_3_5, i * 1000); } Assert.AreEqual(result.UnumBits, new Unum(_environment_3_5, 0).UnumBits); }
public void ExponentMaskIsCorrect() { // 0 1111 1111 0000 0 000 00 var bitMask_3_2_allOne = new BitMask(19, true); var unum_3_2_allOne = new Unum(_environment_3_2, bitMask_3_2_allOne); var bitMask_3_2_ExponentMask = new BitMask(new uint[] { 0x3FC00 }, 19); Assert.AreEqual(bitMask_3_2_ExponentMask, unum_3_2_allOne.ExponentMask()); // 0 1111 1111 0000 0000 0000 0000 0 000 0000 var bitMask_3_4_allOne = new BitMask(33, true); var unum_3_4_allOne = new Unum(_environment_3_4, bitMask_3_4_allOne); var bitMask_3_4_ExponentMask = new BitMask(new uint[] { 0xFF000000 }, 33); Assert.AreEqual(bitMask_3_4_ExponentMask, unum_3_4_allOne.ExponentMask()); }
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 ExponentSizeIsCorrect() { var bitMask_3_2_allOne = new BitMask(19, true); var unum_3_2_allOne = new Unum(_environment_3_2, bitMask_3_2_allOne); Assert.AreEqual(8, unum_3_2_allOne.ExponentSize()); var bitMask_3_4_allOne = new BitMask(33, true); var unum_3_4_allOne = new Unum(_environment_3_4, bitMask_3_4_allOne); Assert.AreEqual(8, unum_3_4_allOne.ExponentSize()); var bitMask_4_3_allOne = new BitMask(33, true); var unum_4_3_allOne = new Unum(_environment_4_3, bitMask_4_3_allOne); Assert.AreEqual(16, unum_4_3_allOne.ExponentSize()); }
public void IntToUnumIsCorrect() { var unum0 = new Unum(_environment_3_4, 0); var bitMask0 = new BitMask(new uint[] { 0 }, 33); Assert.AreEqual(unum0.UnumBits, bitMask0); var unum1 = new Unum(_environment_3_4, 1); Assert.AreEqual(unum1.UnumBits, new BitMask(new uint[] { 0x100 }, 33)); var unum2 = new Unum(_environment_3_4, 2); Assert.AreEqual(unum2.UnumBits, new BitMask(new uint[] { 0x200 }, 33)); var unum30 = new Unum(_environment_3_4, 30); var bitMask30 = new BitMask(new uint[] { 0x3F22 }, 33); Assert.AreEqual(unum30.UnumBits, bitMask30); var unum1000 = new Unum(_environment_3_4, 1000); var bitMask1000 = new BitMask(new uint[] { 0x63D45 }, 33); Assert.AreEqual(unum1000.UnumBits, bitMask1000); var unum5000 = new Unum(_environment_3_4, 5000); var bitMask5000 = new BitMask(new uint[] { 0x367148 }, 33); Assert.AreEqual(unum5000.UnumBits, bitMask5000); var bitMask6000 = new BitMask(new uint[] { 0x1B7747 }, 33); var unum6000 = new Unum(_environment_3_4, 6000); Assert.AreEqual(unum6000.UnumBits, bitMask6000); var unumNegative30 = new Unum(_environment_3_4, -30); var bitMaskNegative30 = new BitMask(new uint[] { 0x3F22, 1 }, 33); Assert.AreEqual(unumNegative30.UnumBits, bitMaskNegative30); var unumNegative1000 = new Unum(_environment_3_4, -1000); var bitMaskNegative1000 = new BitMask(new uint[] { 0x63D45, 1 }, 33); Assert.AreEqual(unumNegative1000.UnumBits, bitMaskNegative1000); }
public void UnumIsCorrectlyConstructedFromInt() { var unum0 = new Unum(_environment_3_4, 0); var bitMask0 = new BitMask(new uint[] { 0 }, _environment_3_4.Size); Assert.AreEqual(unum0.UnumBits, bitMask0); var unum1 = new Unum(_environment_3_4, 1); var bitMask1 = new BitMask(new uint[] { 0x100 }, _environment_3_4.Size); Assert.AreEqual(unum1.UnumBits, bitMask1); var unum30 = new Unum(_environment_3_4, 30); var bitMask30 = new BitMask(new uint[] { 0x3F22 }, _environment_3_4.Size); Assert.AreEqual(unum30.UnumBits, bitMask30); var unum1000 = new Unum(_environment_3_4, 1000); var bitMask1000 = new BitMask(new uint[] { 0x63D45 }, _environment_3_4.Size); Assert.AreEqual(unum1000.UnumBits, bitMask1000); var unum5000 = new Unum(_environment_3_4, 5000); var bitMask5000 = new BitMask(new uint[] { 0x367148 }, _environment_3_4.Size); Assert.AreEqual(unum5000.UnumBits, bitMask5000); var unum6000 = new Unum(_environment_3_4, 6000); var bitMask6000 = new BitMask(new uint[] { 0x1B7747 }, _environment_3_4.Size); Assert.AreEqual(unum6000.UnumBits, bitMask6000); var unumNegative30 = new Unum(_environment_3_4, -30); var bitMaskMinus30 = new BitMask(new uint[] { 0x3F22, 1 }, _environment_3_4.Size); Assert.AreEqual(unumNegative30.UnumBits, bitMaskMinus30); var unumNegative1000 = new Unum(_environment_3_4, -1000); var bitMaskMinus1000 = new BitMask(new uint[] { 0x63D45, 1 }, _environment_3_4.Size); Assert.AreEqual(unumNegative1000.UnumBits, bitMaskMinus1000); }
public void UnumToFloatIsCorrect() { var unum30 = new Unum(_environment_3_4, 30); var numbe30 = (float)unum30; Assert.AreEqual(numbe30, (float)30); var unum1000 = new Unum(_environment_3_4, 1000); var number1000 = (float)unum1000; Assert.AreEqual(number1000, 1000); var unumNegative30 = new Unum(_environment_3_4, -30); var numberNegative30 = (float)unumNegative30; Assert.AreEqual(numberNegative30, -30); var unumNegative1000 = new Unum(_environment_3_4, -1000); var numberNegative1000 = (float)unumNegative1000; Assert.AreEqual(numberNegative1000, -1000); }
public void IsExactIsCorrect() { // 0 0000 0000 0000 1 000 00 var bitMask_3_2_uncertain = new BitMask(new uint[] { 0x20 }, 19); var unum_3_2_uncertain = new Unum(_environment_3_2, bitMask_3_2_uncertain); Assert.AreEqual(false, unum_3_2_uncertain.IsExact()); var bitMask_3_2_certain = new BitMask(19, false); var unum_3_2_certain = new Unum(_environment_3_2, bitMask_3_2_certain); Assert.AreEqual(true, unum_3_2_certain.IsExact()); var bitMask_3_4_uncertain = new BitMask(new uint[] { 0x80, 0 }, 33); var unum_3_4_uncertain = new Unum(_environment_3_4, bitMask_3_4_uncertain); Assert.AreEqual(false, unum_3_4_uncertain.IsExact()); var bitMask_3_4_certain = new BitMask(33, false); var unum_3_4_certain = new Unum(_environment_3_4, bitMask_3_4_certain); Assert.AreEqual(true, unum_3_4_certain.IsExact()); }
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); }
private string TestFailureMessageBuilder(Unum unum, string propertyName) => $"Testing the \"{propertyName}\" property of the Unum ({unum.ExponentSizeSize}, {unum.FractionSizeSize}) environment failed.";