From 878d0d7b682f753220c6d5453e05671920338cf7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Fri, 25 Jun 2021 00:22:16 +0200 Subject: [PATCH 01/49] Fix documentation and spacing issues in Lombiq.Arithmetics. --- BitMask/BitMask.cs | 11 +-- Posit/Posit.cs | 19 +++-- Posit/Posit32.cs | 32 +++++--- Posit/PositEnvironment.cs | 1 - Posit/Quire.cs | 11 +-- Properties/AssemblyInfo.cs | 10 +-- Unum/Unum.cs | 163 +++++++++---------------------------- Unum/UnumConfiguration.cs | 3 - Unum/UnumEnvironment.cs | 47 +++++------ Unum/UnumHelper.cs | 9 +- 10 files changed, 112 insertions(+), 194 deletions(-) diff --git a/BitMask/BitMask.cs b/BitMask/BitMask.cs index 7ac8168..22ff6e3 100644 --- a/BitMask/BitMask.cs +++ b/BitMask/BitMask.cs @@ -1,4 +1,4 @@ -using System; +using System; using System.Collections.Immutable; namespace Lombiq.Arithmetics @@ -9,10 +9,8 @@ public struct BitMask public ushort SegmentCount { get; } public ImmutableArray<uint> Segments { get; } - #region Constructors - public BitMask(uint segment, ushort size) { Size = size; @@ -53,7 +51,7 @@ public BitMask(ushort size, bool allOne = false) SegmentCount = (ushort)((size >> 5) + (partialSegment == 0 ? 0 : 1)); Size = size; - // Creating a temporary array, so the items aren't added using ImmutableArray.Add, because that instantiates + // Creating a temporary array, so the items aren't added using ImmutableArray.Add, because that instantiates // a new array for each execution. var segments = new uint[SegmentCount]; @@ -109,6 +107,7 @@ public BitMask SetOne(ushort index) return new BitMask(this); } + /// <summary> /// Returns a new BitMask, where the given bit is set to zero. /// </summary> @@ -139,6 +138,7 @@ public BitMask ShiftOutLeastSignificantZeros() return mask >> leastSignificantOnePosition - 1; } + /// <summary> /// Sets the segment on the given index to the segment given as an argument. /// </summary> @@ -427,10 +427,10 @@ public ushort LengthOfRunOfBits(ushort startingPosition) mask <<= 1; length++; } + return (length > startingPosition) ? startingPosition : length; } - /// <summary> /// Finds the least significant 1-bit. /// </summary> @@ -452,6 +452,7 @@ public ushort GetLeastSignificantOnePosition() position++; currentSegment >>= 1; } + if (currentSegment % 2 == 1) return position; } } diff --git a/Posit/Posit.cs b/Posit/Posit.cs index 3920225..d70dbbd 100644 --- a/Posit/Posit.cs +++ b/Posit/Posit.cs @@ -84,7 +84,7 @@ public Posit(PositEnvironment environment, int value) #endregion - #region Methods to handle parts of the Posit + #region Methods to handle parts of the Posit public BitMask EncodeRegimeBits(int regimeKValue) { @@ -101,7 +101,7 @@ public BitMask EncodeRegimeBits(int regimeKValue) private BitMask AssemblePositBits(bool signBit, int regimeKValue, BitMask exponentBits, BitMask fractionBits) { - // Calculating the regime. + // Calculating the regime. var wholePosit = EncodeRegimeBits(regimeKValue); // Attaching the exponent @@ -110,7 +110,7 @@ private BitMask AssemblePositBits(bool signBit, int regimeKValue, BitMask expone var fractionMostSignificantOneIndex = fractionBits.GetMostSignificantOnePosition() - 1; - // Hiding the hidden bit. (It is always one.) + // Hiding the hidden bit. (It is always one.) fractionBits = fractionBits.SetZero((ushort)fractionMostSignificantOneIndex); wholePosit += fractionBits << _environment.Size - 2 - fractionMostSignificantOneIndex - (regimeLength) - @@ -121,7 +121,7 @@ private BitMask AssemblePositBits(bool signBit, int regimeKValue, BitMask expone private BitMask AssemblePositBitsWithRounding(bool signBit, int regimeKValue, BitMask exponentBits, BitMask fractionBits) { - // Calculating the regime. + // Calculating the regime. var wholePosit = EncodeRegimeBits(regimeKValue); // Attaching the exponent. @@ -142,12 +142,13 @@ private BitMask AssemblePositBitsWithRounding(bool signBit, int regimeKValue, Bi } else wholePosit += 1; } + return !signBit ? wholePosit : wholePosit.GetTwosComplement(_environment.Size); } var fractionMostSignificantOneIndex = fractionBits.GetMostSignificantOnePosition() - 1; - // Hiding the hidden bit. (It is always one.) + // Hiding the hidden bit. (It is always one.) fractionBits = fractionBits.SetZero((ushort)fractionMostSignificantOneIndex); var fractionShiftedLeftBy = _environment.Size - 2 - fractionMostSignificantOneIndex - (regimeLength) - @@ -167,6 +168,7 @@ private BitMask AssemblePositBitsWithRounding(bool signBit, int regimeKValue, Bi else wholePosit += 1; } } + return !signBit ? wholePosit : wholePosit.GetTwosComplement(_environment.Size); } @@ -255,6 +257,7 @@ public static int CalculateScaleFactor(int regimeKValue, uint exponentValue, byt leftRegimeKValue = left.GetRegimeKValue(); leftExponentValue = left.GetExponentValue(); } + if (!rightIsPositive) { var negatedRight = -right; @@ -272,6 +275,7 @@ public static int CalculateScaleFactor(int regimeKValue, uint exponentValue, byt { return leftIsPositive ? right : left; } + if (rightRegimeKValue == -(right.Size - 1)) { return rightIsPositive ? left : right; @@ -339,6 +343,7 @@ public static int CalculateScaleFactor(int regimeKValue, uint exponentValue, byt scaleFactor += resultFractionBits.GetMostSignificantOnePosition() - (right.Size - 1); } + if (resultFractionBits.GetMostSignificantOnePosition() == 0) return new Posit(left._environment, left.EmptyBitMask); var resultRegimeKValue = scaleFactor / (1 << left.MaximumExponentSize); @@ -354,12 +359,12 @@ public static int CalculateScaleFactor(int regimeKValue, uint exponentValue, byt public static Posit operator -(Posit left, int right) => left - new Posit(left._environment, right); - public static Posit operator -(Posit x) { if (x.IsNaN() || x.IsZero()) return new Posit(x._environment, x.PositBits); return new Posit(x._environment, x.PositBits.GetTwosComplement(x.Size)); } + public static bool operator ==(Posit left, Posit right) => left.PositBits == right.PositBits; public static bool operator >(Posit left, Posit right) @@ -369,11 +374,11 @@ public static int CalculateScaleFactor(int regimeKValue, uint exponentValue, byt return (left.PositBits + right.PositBits).GetMostSignificantOnePosition() > left.PositBits.Size; } + public static bool operator <(Posit left, Posit right) => !(left.PositBits > right.PositBits); public static bool operator !=(Posit left, Posit right) => !(left == right); - public static explicit operator int(Posit x) { uint result; diff --git a/Posit/Posit32.cs b/Posit/Posit32.cs index 2adc425..4412e4c 100644 --- a/Posit/Posit32.cs +++ b/Posit/Posit32.cs @@ -51,9 +51,6 @@ namespace Lombiq.Arithmetics public const ulong Double64HiddenBitMask = 0x0010_0000_0000_0000; - - - #endregion #region Posit constructors @@ -73,6 +70,7 @@ public Posit32(Quire q) q += 1; sign = true; } + firstSegment = (ulong)(q >> (QuireSize - 64)); while (firstSegment < 0x8000000000000000) { @@ -87,6 +85,7 @@ public Posit32(Quire q) PositBits = 0; return; } + var resultRegimeKValue = scaleFactor / (1 << MaximumExponentSize); var resultExponentBits = (uint)(scaleFactor % (1 << MaximumExponentSize)); if (resultExponentBits < 0) @@ -127,6 +126,7 @@ public Posit32(float floatBits) { return; } + if (floatBits == 0) { PositBits = 0; @@ -163,11 +163,13 @@ public Posit32(float floatBits) regimeKValue = -(Size - 2); exponentValue = 0; } + if (regimeKValue > (Size - 2)) { regimeKValue = (Size - 2); exponentValue = 0; } + PositBits = AssemblePositBitsWithRounding(signBit, regimeKValue, exponentValue, fractionBits); } @@ -178,6 +180,7 @@ public Posit32(double doubleBits) { return; } + if (doubleBits == 0) { PositBits = 0; @@ -214,11 +217,13 @@ public Posit32(double doubleBits) regimeKValue = -(Size - 2); exponentValue = 0; } + if (regimeKValue > (Size - 2)) { regimeKValue = (Size - 2); exponentValue = 0; } + PositBits = AssemblePositBitsWithRounding(signBit, regimeKValue, exponentValue, fractionBits); } @@ -237,7 +242,7 @@ public Posit32(double doubleBits) #endregion - #region Methods to handle parts of the Posit + #region Methods to handle parts of the Posit [MethodImpl(MethodImplOptions.AggressiveInlining)] public static uint EncodeRegimeBits(int regimeKValue) @@ -255,7 +260,7 @@ public static uint EncodeRegimeBits(int regimeKValue) private uint AssemblePositBits(bool signBit, int regimeKValue, uint exponentBits, uint fractionBits) { - // Calculating the regime. + // Calculating the regime. var wholePosit = EncodeRegimeBits(regimeKValue); // Attaching the exponent @@ -265,7 +270,7 @@ private uint AssemblePositBits(bool signBit, int regimeKValue, uint exponentBits var fractionMostSignificantOneIndex = GetMostSignificantOnePosition(fractionBits) - 1; - // Hiding the hidden bit. (It is always one.) + // Hiding the hidden bit. (It is always one.) fractionBits = SetZero(fractionBits, (ushort)fractionMostSignificantOneIndex); wholePosit += fractionBits << SizeMinusFixedBits - fractionMostSignificantOneIndex - regimeLength; @@ -275,7 +280,7 @@ private uint AssemblePositBits(bool signBit, int regimeKValue, uint exponentBits public static uint AssemblePositBitsWithRounding(bool signBit, int regimeKValue, uint exponentBits, uint fractionBits) { - // Calculating the regime. + // Calculating the regime. var wholePosit = EncodeRegimeBits(regimeKValue); // Attaching the exponent. @@ -300,7 +305,7 @@ public static uint AssemblePositBitsWithRounding(bool signBit, int regimeKValue, var fractionMostSignificantOneIndex = GetMostSignificantOnePosition(fractionBits) - 1; - // Hiding the hidden bit. (It is always one.) + // Hiding the hidden bit. (It is always one.) fractionBits = SetZero(fractionBits, (ushort)fractionMostSignificantOneIndex); var fractionShiftedLeftBy = SizeMinusFixedBits - (fractionMostSignificantOneIndex) - (regimeLength); @@ -522,6 +527,7 @@ public static byte GetMostSignificantOnePosition(uint bits) bits >>= 1; position++; } + return position; } @@ -534,6 +540,7 @@ public static byte GetMostSignificantOnePosition(ulong bits) bits >>= 1; position++; } + return position; } @@ -564,6 +571,7 @@ public static byte LengthOfRunOfBits(uint bits, byte startingPosition) bits <<= 1; length++; } + return length; } @@ -587,6 +595,7 @@ public static Posit32 Sqrt(Posit32 number) inputScaleFactor -= 1; inputFractionWithHiddenBit += inputFractionWithHiddenBit; } + inputScaleFactor >>= 1; uint resultFractionBits = 0; //q @@ -650,7 +659,6 @@ public static Quire FusedSum(Posit32[] posits, Quire startingValue) return startingValue; } - public static Posit32 FusedDotProduct(Posit32[] positArray1, Posit32[] positArray2) { if (positArray1.Length != positArray2.Length) return new Posit32(NaNBitMask, true); @@ -708,7 +716,7 @@ public static Posit32 FusedMultiplyMultiplySubtract(Posit32 a, Posit32 b, Posit3 } #endregion - #region Operators + #region Operators public static Posit32 operator +(Posit32 left, Posit32 right) { @@ -738,7 +746,6 @@ public static Posit32 FusedMultiplyMultiplySubtract(Posit32 a, Posit32 b, Posit3 sbyte rightRegimeKValue = rightAbsoluteValue.GetRegimeKValueWithoutSignCheck(rightLengthOfRunOfBits); uint rightExponentValue = rightAbsoluteValue.GetExponentValueWithoutSignCheck(rightFractionSize); - var resultSignBit = leftAbsoluteValue > rightAbsoluteValue ? leftSignBit == 1 : rightSignBit == 1; uint resultFractionBits = 0; @@ -822,6 +829,7 @@ public static Posit32 FusedMultiplyMultiplySubtract(Posit32 a, Posit32 b, Posit3 scaleFactor += (short)(GetMostSignificantOnePosition(resultFractionBits) - FirstRegimeBitPosition); } + if (resultFractionBits == 0) return new Posit32(0, true); var resultRegimeKValue = scaleFactor / (1 << MaximumExponentSize); @@ -1021,6 +1029,7 @@ public static explicit operator double(Posit32 x) double* doublePointer = (double*)&doubleBits; doubleRepresentation = *doublePointer; } + return doubleRepresentation; } @@ -1097,7 +1106,6 @@ public TypeCode GetTypeCode() public bool ToBoolean(IFormatProvider provider) => !IsZero(); - public char ToChar(IFormatProvider provider) { throw new InvalidCastException(); diff --git a/Posit/PositEnvironment.cs b/Posit/PositEnvironment.cs index 4c9e9f2..0bab491 100644 --- a/Posit/PositEnvironment.cs +++ b/Posit/PositEnvironment.cs @@ -30,7 +30,6 @@ public class PositEnvironment public uint QuireSize { get; } - public PositEnvironment(byte size, byte maximumExponentSize) { Size = size; diff --git a/Posit/Quire.cs b/Posit/Quire.cs index bd54b7c..fb1a633 100644 --- a/Posit/Quire.cs +++ b/Posit/Quire.cs @@ -1,7 +1,6 @@ using System; using System.Collections.Immutable; - namespace Lombiq.Arithmetics { public class Quire @@ -29,6 +28,7 @@ public Quire(ulong[] segments, ushort size = 0) SegmentCount = (ushort)((size >> 6) + (size % 32 == 0 ? 0 : 1)); } + Segments = new ulong[SegmentCount]; Array.Copy(segments, Segments, segments.Length); @@ -54,7 +54,6 @@ public Quire(uint firstSegment, ushort size) byte buffer; ushort segmentPosition = 0, position = 0; - for (ushort i = 0; i < left.SegmentCount << 6; i++) { leftBit = ((left.Segments[segmentPosition] >> position) & 1) == 1; @@ -103,17 +102,17 @@ public Quire(uint firstSegment, ushort size) segmentPosition++; } } + return new Quire(result); } - - public static Quire operator ~(Quire q) { for (ushort i = 0; i < q.SegmentCount; i++) { q.Segments[i] = ~q.Segments[i]; } + return q; } @@ -122,10 +121,12 @@ public Quire(uint firstSegment, ushort size) if (left.SegmentCount != right.SegmentCount) return false; for (ushort i = 0; i < left.SegmentCount; i++) { - if (left.Segments[i] != right.Segments[i]) return false; + if (left.Segments[i] != right.Segments[i]) return false; } + return true; } + public static bool operator !=(Quire left, Quire right) => !(left == right); public static Quire operator >>(Quire left, int right) diff --git a/Properties/AssemblyInfo.cs b/Properties/AssemblyInfo.cs index 422efc0..823ba80 100644 --- a/Properties/AssemblyInfo.cs +++ b/Properties/AssemblyInfo.cs @@ -2,7 +2,7 @@ using System.Runtime.CompilerServices; using System.Runtime.InteropServices; -// General Information about an assembly is controlled through the following +// General Information about an assembly is controlled through the following // set of attributes. Change these attribute values to modify the information // associated with an assembly. [assembly: AssemblyTitle("Lombiq.Arithmetics")] @@ -14,8 +14,8 @@ [assembly: AssemblyTrademark("")] [assembly: AssemblyCulture("")] -// Setting ComVisible to false makes the types in this assembly not visible -// to COM components. If you need to access a type in this assembly from +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from // COM, set the ComVisible attribute to true on that type. [assembly: ComVisible(false)] @@ -25,11 +25,11 @@ // Version information for an assembly consists of the following four values: // // Major Version -// Minor Version +// Minor Version // Build Number // Revision // -// You can specify all the values or you can default the Build and Revision Numbers +// You can specify all the values or you can default the Build and Revision Numbers // by using the '*' as shown below: // [assembly: AssemblyVersion("1.0.*")] [assembly: AssemblyVersion("1.0.0.0")] diff --git a/Unum/Unum.cs b/Unum/Unum.cs index cd4d0a1..b8219b7 100644 --- a/Unum/Unum.cs +++ b/Unum/Unum.cs @@ -1,4 +1,4 @@ -using System; +using System; namespace Lombiq.Arithmetics { @@ -12,32 +12,32 @@ public struct Unum #region Unum structure /// <summary> - /// The number of bits allocated to store the maximum number of bits in the exponent field of a unum. + /// Gets the number of bits allocated to store the maximum number of bits in the exponent field of a unum. /// </summary> public byte ExponentSizeSize => _environment.ExponentSizeSize; // "esizesize" /// <summary> - /// The number of bits allocated to store the maximum number of bits in the fraction field of a unum. + /// Gets the number of bits allocated to store the maximum number of bits in the fraction field of a unum. /// </summary> public byte FractionSizeSize => _environment.FractionSizeSize; // "fsizesize" /// <summary> - /// The maximum number of bits usable to store the exponent. + /// Gets the maximum number of bits usable to store the exponent. /// </summary> public byte ExponentSizeMax => _environment.ExponentSizeMax; // "esizemax" /// <summary> - /// The maximum number of bits usable to store the fraction. + /// Gets the maximum number of bits usable to store the fraction. /// </summary> public ushort FractionSizeMax => _environment.FractionSizeMax; // "fsizemax" /// <summary> - /// The number of bits that are used storing the utag. + /// Gets the number of bits that are used storing the utag. /// </summary> public byte UnumTagSize => _environment.UnumTagSize; // "utagsize" /// <summary> - /// The maximum number of bits used by the environment. + /// Gets the maximum number of bits used by the environment. /// </summary> public ushort Size => _environment.Size; // "maxubits" @@ -46,32 +46,32 @@ public struct Unum #region Unum masks /// <summary> - /// A BitMask for picking out the UncertainityBit. + /// Gets a BitMask for picking out the UncertainityBit. /// </summary> public BitMask UncertaintyBitMask => _environment.UncertaintyBitMask; // "ubitmask" /// <summary> - /// A BitMask for picking out the ExponentSize. + /// Gets a BitMask for picking out the ExponentSize. /// </summary> public BitMask ExponentSizeMask => _environment.ExponentSizeMask; // "esizemask" /// <summary> - /// A BitMask for picking out the FractionSize. + /// Gets a BitMask for picking out the FractionSize. /// </summary> public BitMask FractionSizeMask => _environment.FractionSizeMask; // "fsizemask" /// <summary> - /// A BitMask for picking out the ExponentSize and FractionSize. + /// Gets a BitMask for picking out the ExponentSize and FractionSize. /// </summary> public BitMask ExponentAndFractionSizeMask => _environment.ExponentAndFractionSizeMask; // "efsizemask" /// <summary> - /// A BitMask for picking out the utag. + /// Gets a BitMask for picking out the utag. /// </summary> public BitMask UnumTagMask => _environment.UnumTagMask; // "utagmask" /// <summary> - /// A BitMask for picking out the SignBit. + /// Gets a BitMask for picking out the SignBit. /// </summary> public BitMask SignBitMask => _environment.SignBitMask; // "signbigu" @@ -80,47 +80,47 @@ public struct Unum #region Unum environment /// <summary> - /// A BitMask for the Unit in the Last Place or Unit of Least Precision. + /// Gets a BitMask for the Unit in the Last Place or Unit of Least Precision. /// </summary> public BitMask ULP => _environment.ULP; /// <summary> - /// A BitMask for the unum notation of positive infinity. + /// Gets a BitMask for the unum notation of positive infinity. /// </summary> public BitMask PositiveInfinity => _environment.PositiveInfinity; // "posinfu" /// <summary> - /// A BitMask for the unum notation of negative infinity. + /// Gets a BitMask for the unum notation of negative infinity. /// </summary> public BitMask NegativeInfinity => _environment.NegativeInfinity; // "neginfu" /// <summary> - /// A BitMask for the unum notation of a quiet NaN value. + /// Gets a BitMask for the unum notation of a quiet NaN value. /// </summary> public BitMask QuietNotANumber => _environment.QuietNotANumber; // "qNaNu" /// <summary> - /// A BitMask for the unum notation of a signaling NaN value. + /// Gets a BitMask for the unum notation of a signaling NaN value. /// </summary> public BitMask SignalingNotANumber => _environment.SignalingNotANumber; // "sNaNu" /// <summary> - /// A BitMask for the largest expressable finite positive unum in the environment. + /// Gets a BitMask for the largest expressable finite positive unum in the environment. /// </summary> public BitMask LargestPositive => _environment.LargestPositive; // "maxrealu" /// <summary> - /// A BitMask for the smallest expressable positive real unum in the environment. + /// Gets a BitMask for the smallest expressable positive real unum in the environment. /// </summary> public BitMask SmallestPositive => _environment.SmallestPositive; // "smallsubnormalu" /// <summary> - /// A BitMask for the largest expressable finite negative unum in the environment. + /// Gets a BitMask for the largest expressable finite negative unum in the environment. /// </summary> public BitMask LargestNegative => _environment.LargestNegative; // "negbigu" /// <summary> - /// A BitMask for the largest magnitude negative unum in the environment. + /// Gets a BitMask for the largest magnitude negative unum in the environment. /// </summary> public BitMask MinRealU => _environment.MinRealU; // "minrealu" @@ -143,88 +143,8 @@ public Unum(UnumEnvironment environment, BitMask bits) UnumBits = BitMask.FromImmutableArray(bits.Segments, _environment.Size); } - // This doesn't work for all cases yet. - //public Unum(UnumEnvironment environment, float number) - //{ - // _environment = environment; - - // // Handling special cases first. - // if (float.IsNaN(number)) - // { - // UnumBits = _environment.QuietNotANumber; - // return; - // } - // if (float.IsPositiveInfinity(number)) - // { - // UnumBits = _environment.PositiveInfinity; - // return; - // } - // if (float.IsNegativeInfinity(number)) - // { - // UnumBits = _environment.NegativeInfinity; - // return; - // } - - - // UnumBits = new BitMask(_environment.Size); - // var floatExponentBits = (BitConverter.ToUInt32(BitConverter.GetBytes(number), 0) << 1) >> 24; - - // // These are the only uncertain cases that we can safely handle without Ubounds. - // if (ExponentSizeMax < ExponentValueToExponentSize((int)floatExponentBits - 127)) - // { - // // The exponent is too big, so we express the number as the largest possible signed value, - // // but the Unum is uncertain, meaning that it's finite, but too big to express. - // if (floatExponentBits - 127 > 0) - // UnumBits = IsPositive() ? LargestPositive : LargestNegative; - // else // If the exponent is too small, we will handle it as a signed uncertain zero. - // { - // UnumBits = new BitMask(Size); - // if (!IsPositive()) Negate(); - // } - - // SetUncertainityBit(true); - - // return; - // } - - - // var floatFractionBits = (BitConverter.ToUInt32(BitConverter.GetBytes(number), 0) << 9) >> 9; - // uint resultFractionSize = 23; - // uint floatFractionBitsSize = 23; - - // if (floatFractionBits == 0) resultFractionSize = 0; - // else - // while (floatFractionBits % 2 == 0) - // { - // resultFractionSize -= 1; - // floatFractionBits >>= 1; - // floatFractionBitsSize = resultFractionSize; - // } - - - // var uncertainty = false; - - // if (FractionSizeMax + 1 < resultFractionSize) - // { - // resultFractionSize = ((uint)FractionSizeMax - 1); - // uncertainty = true; - // } - // else if (resultFractionSize > 0) resultFractionSize = (resultFractionSize - 1); - - // var resultFraction = uncertainty ? - // new BitMask(new uint[] { floatFractionBits >> (int)floatFractionBitsSize - FractionSizeMax }, Size) : - // new BitMask(new uint[] { floatFractionBits }, Size); - // var resultExponent = ExponentValueToExponentBits((int)(floatExponentBits - 127), Size); - // var floatBits = BitConverter.ToUInt32(BitConverter.GetBytes(number), 0); - // var resultSignBit = (floatBits > uint.MaxValue / 2); - // var resultExponentSize = (ExponentValueToExponentSize((int)floatExponentBits - 127) - 1); - - - // AssembleUnumBits(resultSignBit, resultExponent, resultFraction, - // uncertainty, resultExponentSize, resultFractionSize); - //} - /// <summary> + /// Initializes a new instance of the <see cref="Unum"/> struct. /// Creates a Unum of the given environment initialized with the value of the uint. /// </summary> /// <param name="environment">The Unum environment.</param> @@ -241,6 +161,7 @@ public Unum(UnumEnvironment environment, uint value) } /// <summary> + /// Initializes a new instance of the <see cref="Unum"/> struct. /// Creates a Unum initialized with a value that is defined by the bits in a uint array. /// </summary> /// <param name="environment">The Unum environment.</param> @@ -266,6 +187,7 @@ public Unum(UnumEnvironment environment, uint[] value, bool negative = false) return; } } + var uncertainityBit = false; // Putting the actual value in a BitMask. @@ -288,6 +210,7 @@ public Unum(UnumEnvironment environment, uint[] value, bool negative = false) : (environment.LargestPositive | environment.UncertaintyBitMask) - 1; return; } + // Calculating the bias from the number of bits representing the exponent. var bias = exponentSize == 0 ? 0 : (1 << exponentSize - 1) - 1; @@ -303,7 +226,6 @@ public Unum(UnumEnvironment environment, uint[] value, bool negative = false) // Calculating the number of bits needed to represent the fraction. var fractionSize = fraction.GetMostSignificantOnePosition(); - /* If there's a hidden bit and it's 1, * then the most significant 1-bit of the fraction is stored there, * so we're removing it from the fraction and decreasing fraction size accordingly. */ @@ -312,6 +234,7 @@ public Unum(UnumEnvironment environment, uint[] value, bool negative = false) fractionSize--; fraction = fraction.SetZero(fractionSize); } + // Handling input numbers that fit in the range, but are too big to represent exactly. if (fractionSize > FractionSizeMax) { @@ -367,11 +290,9 @@ public Unum(UnumEnvironment environment, int value) // return; // } - // var doubleBits = BitConverter.ToUInt64(BitConverter.GetBytes(x), 0); // SetSignBit((doubleBits > ulong.MaxValue / 2)); - // var doubleFractionBits = (BitConverter.ToUInt64(BitConverter.GetBytes(x), 0) << 12) >> 12; // uint resultFractionSize = 52; @@ -386,7 +307,6 @@ public Unum(UnumEnvironment environment, int value) // } - // var uncertainty = false; // if (FractionSizeMax < resultFractionSize - 1) @@ -396,7 +316,6 @@ public Unum(UnumEnvironment environment, int value) // } // else SetFractionSizeBits(resultFractionSize - 1); - // var doubleExponentBits = (BitConverter.ToUInt64(BitConverter.GetBytes(x), 0) << 1) >> 53; // // These are the only uncertain cases that we can safely handle without Ubounds. @@ -417,7 +336,6 @@ public Unum(UnumEnvironment environment, int value) // return; // } - // var exponentSizeBits = ExponentValueToExponentSize((int)doubleExponentBits - 1023) - 1; // SetExponentSizeBits(exponentSizeBits); @@ -442,7 +360,6 @@ public Unum(UnumEnvironment environment, int value) // // The lower 32 bits wouldn't fit in anyway. // new BitMask(new uint[] { doubleFraction[1] }, Size)); - // SetExponentBits(ExponentValueToExponentBits((int)(doubleExponentBits - 1023), Size)); //} @@ -450,8 +367,6 @@ public Unum(UnumEnvironment environment, int value) #region Methods to set the values of individual Unum structure elements - - /// <summary> /// Assembles the Unum from its pre-computed parts. /// </summary> @@ -512,7 +427,6 @@ public Unum SetExponentBits(BitMask exponent) return new Unum(_environment, newUnumBits); } - /// <summary> /// Sets the fraction to the given value and leaves everything else as is. /// </summary> @@ -558,11 +472,11 @@ public Unum SetExponentSizeBits(byte exponentSize) #region Binary data extraction /// <summary> - /// Copies the actual integer value represented by the Unum into an array of unsigned integers with the + /// Copies the actual integer value represented by the Unum into an array of unsigned integers with the /// most significant bit of the last element functioning as the signbit. /// </summary> /// <returns> - /// An array of unsigned integers that together represent the integer value of the Unum with the most + /// An array of unsigned integers that together represent the integer value of the Unum with the most /// significant bit of the last uint functioning as a signbit. /// </returns> public uint[] FractionToUintArray() @@ -681,12 +595,11 @@ public static Unum AddExactUnums(Unum left, Unum right) var smallerBitsMovedToLeft = 0; var resultExponentValue = 0; - if (exponentValueDifference == 0) // Exponents are equal. { resultExponentValue = left.ExponentValueWithBias(); - // We align the fractions so their Most Significant Bit gets to the leftmost position that the + // We align the fractions so their Most Significant Bit gets to the leftmost position that the // FractionSize allows. This way the digits that won't fit automatically get lost. biggerBitsMovedToLeft = left.FractionSizeMax + 1 - (left.FractionSize() + 1); smallerBitsMovedToLeft = left.FractionSizeMax + 1 - (right.FractionSize() + 1); @@ -696,7 +609,6 @@ public static Unum AddExactUnums(Unum left, Unum right) right.FractionWithHiddenBit() << smallerBitsMovedToLeft, signBitsMatch); - if (!signBitsMatch) { // If the value of the Hidden Bits match we just compare the fractions, @@ -708,6 +620,7 @@ public static Unum AddExactUnums(Unum left, Unum right) : !right.IsPositive(); // Right Fraction is bigger. } + // Otherwise we get the Sign of the number that has a Hidden Bit set. else resultSignBit = left.HiddenBitIsOne() ? !left.IsPositive() : !right.IsPositive(); } @@ -716,8 +629,8 @@ public static Unum AddExactUnums(Unum left, Unum right) } else if (exponentValueDifference > 0) // Left Exponent is bigger. { - // We align the fractions according to their exponent values so the Most Significant Bit of the bigger - // number gets to the leftmost position that the FractionSize allows. + // We align the fractions according to their exponent values so the Most Significant Bit of the bigger + // number gets to the leftmost position that the FractionSize allows. // This way the digits that won't fit automatically get lost. resultSignBit = !left.IsPositive(); resultExponentValue = left.ExponentValueWithBias(); @@ -732,8 +645,8 @@ public static Unum AddExactUnums(Unum left, Unum right) else // Right Exponent is bigger. { - // We align the fractions according to their exponent values so the Most Significant Bit of the bigger - // number gets to the leftmost position that the FractionSize allows. + // We align the fractions according to their exponent values so the Most Significant Bit of the bigger + // number gets to the leftmost position that the FractionSize allows. // This way the digits that won't fit automatically get lost. resultSignBit = !right.IsPositive(); resultExponentValue = right.ExponentValueWithBias(); @@ -750,7 +663,7 @@ public static Unum AddExactUnums(Unum left, Unum right) var exponentChange = scratchPad.GetMostSignificantOnePosition() - (left.FractionSizeMax + 1); var resultExponent = new BitMask(left._environment.Size) + ExponentValueToExponentBits(resultExponentValue + exponentChange, left.Size); - // Calculating the ExponentSize needed to the excess-k notation of the results Exponent value. + // Calculating the ExponentSize needed to the excess-k notation of the results Exponent value. var resultExponentSize = (byte)(ExponentValueToExponentSize(resultExponentValue + exponentChange) - 1); var resultUbit = false; @@ -768,7 +681,6 @@ public static Unum AddExactUnums(Unum left, Unum right) } else resultFractionSize = (ushort)(scratchPad.GetMostSignificantOnePosition() - 1); - if (resultExponent.GetMostSignificantOnePosition() != 0) // Erase the hidden bit if it is set. { scratchPad = scratchPad.SetZero((ushort)(scratchPad.GetMostSignificantOnePosition() - 1)); @@ -793,7 +705,6 @@ public static Unum AddExactUnums(Unum left, Unum right) public static bool AreEqualExactUnums(Unum left, Unum right) => left.IsZero() && right.IsZero() ? true : left.UnumBits == right.UnumBits; - #endregion #region Helper methods for operations and conversions @@ -805,7 +716,7 @@ public static BitMask ExponentValueToExponentBits(int value, ushort size) var exponentSize = ExponentValueToExponentSize(value); exponent += (uint)(1 << (exponentSize - 1)) - 1; // Applying bias - if (value < 0) // In case of a negative exponent the + if (value < 0) // In case of a negative exponent the { exponent -= (uint)(-2 * value); diff --git a/Unum/UnumConfiguration.cs b/Unum/UnumConfiguration.cs index 6bae623..bb1d249 100644 --- a/Unum/UnumConfiguration.cs +++ b/Unum/UnumConfiguration.cs @@ -12,14 +12,12 @@ public class UnumConfiguration /// </summary> public readonly byte FractionSize; - public UnumConfiguration(byte exponentSize, byte fractionSize) { ExponentSize = exponentSize; FractionSize = fractionSize; } - public static UnumConfiguration FromIeeeConfiguration(IeeeConfiguration configuration) { switch (configuration) @@ -40,7 +38,6 @@ public static UnumConfiguration FromIeeeConfiguration(IeeeConfiguration configur } } - public enum IeeeConfiguration { HalfPrecision, // 16-bit. diff --git a/Unum/UnumEnvironment.cs b/Unum/UnumEnvironment.cs index 927454d..f40b920 100644 --- a/Unum/UnumEnvironment.cs +++ b/Unum/UnumEnvironment.cs @@ -5,32 +5,32 @@ public class UnumEnvironment #region Unum structure /// <summary> - /// The number of bits allocated to store the maximum number of bits in the exponent field of a unum. + /// Gets the number of bits allocated to store the maximum number of bits in the exponent field of a unum. /// </summary> public byte ExponentSizeSize { get; } // "esizesize" /// <summary> - /// The number of bits allocated to store the maximum number of bits in the fraction field of a unum. + /// Gets the number of bits allocated to store the maximum number of bits in the fraction field of a unum. /// </summary> public byte FractionSizeSize { get; } // "fsizesize" /// <summary> - /// The maximum number of bits usable to store the exponent. + /// Gets the maximum number of bits usable to store the exponent. /// </summary> public byte ExponentSizeMax { get; } // "esizemax" /// <summary> - /// The maximum number of bits usable to store the fraction. + /// Gets the maximum number of bits usable to store the fraction. /// </summary> public ushort FractionSizeMax { get; } // "fsizemax" /// <summary> - /// The number of bits that are used for storing the utag. + /// Gets the number of bits that are used for storing the utag. /// </summary> public byte UnumTagSize { get; } // "utagsize" /// <summary> - /// The maximum number of bits used by the environment. + /// Gets the maximum number of bits used by the environment. /// </summary> public ushort Size { get; } // "maxubits" #endregion @@ -38,37 +38,37 @@ public class UnumEnvironment #region Unum masks /// <summary> - /// An empty BitMask the size of the environment. + /// Gets an empty BitMask the size of the environment. /// </summary> public BitMask EmptyBitMask { get; } /// <summary> - /// A BitMask for picking out the UncertainityBit. + /// Gets a BitMask for picking out the UncertainityBit. /// </summary> public BitMask UncertaintyBitMask { get; } // "ubitmask" /// <summary> - /// A BitMask for picking out the ExponentSize. + /// Gets a BitMask for picking out the ExponentSize. /// </summary> public BitMask ExponentSizeMask { get; } // "esizemask" /// <summary> - /// A BitMask for picking out the FractionSize. + /// Gets a BitMask for picking out the FractionSize. /// </summary> public BitMask FractionSizeMask { get; } // "fsizemask" /// <summary> - /// A BitMask for picking out the ExponentSize and FractionSize. + /// Gets a BitMask for picking out the ExponentSize and FractionSize. /// </summary> public BitMask ExponentAndFractionSizeMask { get; } // "efsizemask" /// <summary> - /// A BitMask for picking out the utag. + /// Gets a BitMask for picking out the utag. /// </summary> public BitMask UnumTagMask { get; } // "utagmask" /// <summary> - /// A BitMask for picking out the SignBit. + /// Gets a BitMask for picking out the SignBit. /// </summary> public BitMask SignBitMask { get; } // "signbigu" #endregion @@ -76,53 +76,52 @@ public class UnumEnvironment #region Unum special values /// <summary> - /// A BitMask for the Unit in the Last Place or Unit of Least Precision. + /// Gets a BitMask for the Unit in the Last Place or Unit of Least Precision. /// </summary> public BitMask ULP { get; } /// <summary> - /// The positive infinity for the given unum environment. + /// Gets the positive infinity for the given unum environment. /// </summary> public BitMask PositiveInfinity { get; } // "posinfu" /// <summary> - /// The negative infinity for the given unum environment. + /// Gets the negative infinity for the given unum environment. /// </summary> public BitMask NegativeInfinity { get; } // "neginfu" /// <summary> - /// A BitMask for the notation of a quiet NaN value in the environment. + /// Gets a BitMask for the notation of a quiet NaN value in the environment. /// </summary> public BitMask QuietNotANumber { get; } // "qNaNu" /// <summary> - /// A BitMask for the notation of a signaling NaN value in the environment. + /// Gets a BitMask for the notation of a signaling NaN value in the environment. /// </summary> public BitMask SignalingNotANumber { get; } // "sNaNu" /// <summary> - /// The largest magnitude positive real number. One ULP less than infinity. + /// Gets the largest magnitude positive real number. One ULP less than infinity. /// </summary> public BitMask LargestPositive { get; } // "maxrealu" /// <summary> - /// The smallest magnitude positive real number. One ULP more than 0. + /// Gets the smallest magnitude positive real number. One ULP more than 0. /// </summary> public BitMask SmallestPositive { get; } // "smallsubnormalu" /// <summary> - /// The largest magnitude negative real number. One ULP more than negative infinity. + /// Gets the largest magnitude negative real number. One ULP more than negative infinity. /// </summary> public BitMask LargestNegative { get; } // "negbigu" /// <summary> - /// A BitMask for the largest magnitude negative unum in the environment. + /// Gets a BitMask for the largest magnitude negative unum in the environment. /// </summary> public BitMask MinRealU { get; } // "minrealu" #endregion - public UnumEnvironment(byte exponentSizeSize, byte fractionSizeSize) { // Initializing structure. @@ -168,7 +167,6 @@ public UnumEnvironment(byte exponentSizeSize, byte fractionSizeSize) } - public static UnumEnvironment FromConfigurationValues(byte eSize, ushort fSize) => new UnumEnvironment(UnumHelper.SegmentSizeToSegmentSizeSize(eSize), UnumHelper.SegmentSizeToSegmentSizeSize(fSize)); @@ -199,7 +197,6 @@ public static UnumEnvironment FromStandardEnvironment(StandardEnvironment enviro public static UnumEnvironment GetDefaultEnvironment() => FromStandardEnvironment(StandardEnvironment.SinglePrecisionLike); } - public enum StandardEnvironment { Warlpiri, // 4-bit. diff --git a/Unum/UnumHelper.cs b/Unum/UnumHelper.cs index f285f50..ef9875c 100644 --- a/Unum/UnumHelper.cs +++ b/Unum/UnumHelper.cs @@ -1,4 +1,4 @@ -namespace Lombiq.Arithmetics +namespace Lombiq.Arithmetics { public static class UnumHelper { @@ -78,15 +78,14 @@ public static ushort EnvironmentRequiredMaximumBits(byte eSizeSize, byte fSizeSi public static int BitsRequiredByLargestExpressablePositiveInteger(UnumEnvironment environment) => (1 << (environment.ExponentSizeMax - 1)) + 1; - /// <summary> - /// Calculates the biggest expressible integer in the given environment in an integer-like notation. - /// Returns an empty BitMask if the calculated number would be too big to fit in a BitMask of + /// Calculates the biggest expressible integer in the given environment in an integer-like notation. + /// Returns an empty BitMask if the calculated number would be too big to fit in a BitMask of /// the size of the environment. /// </summary> /// <param name="environment">The environment thats Largest Expressible Integer needs to be calculated </param> /// <returns> - /// The biggest expressible integer in the given environment if it fits in a BitMask the size of the + /// The biggest expressible integer in the given environment if it fits in a BitMask the size of the /// environment, an empty BitMask otherwise. /// </returns> public static BitMask LargestExpressablePositiveInteger(UnumEnvironment environment) From 7722912f8e3527ef40e1a5a2dafb3c6c71b82995 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Fri, 25 Jun 2021 09:39:28 +0200 Subject: [PATCH 02/49] Fix all missing parenthesis. --- BitMask/BitMask.cs | 6 +++--- Posit/Posit.cs | 30 +++++++++++++++--------------- Posit/Posit32.cs | 34 +++++++++++++++++----------------- Posit/PositEnvironment.cs | 2 +- Unum/Unum.cs | 18 +++++++++--------- Unum/UnumEnvironment.cs | 2 +- Unum/UnumHelper.cs | 6 +++--- 7 files changed, 49 insertions(+), 49 deletions(-) diff --git a/BitMask/BitMask.cs b/BitMask/BitMask.cs index 22ff6e3..73a6277 100644 --- a/BitMask/BitMask.cs +++ b/BitMask/BitMask.cs @@ -136,7 +136,7 @@ public BitMask ShiftOutLeastSignificantZeros() var mask = new BitMask(this); if (leastSignificantOnePosition == 0) return mask; - return mask >> leastSignificantOnePosition - 1; + return mask >> (leastSignificantOnePosition - 1); } /// <summary> @@ -402,7 +402,7 @@ public ushort GetMostSignificantOnePosition() { currentSegment >>= 1; position++; - if (currentSegment == 0) return (ushort)((SegmentCount - i) * 32 + position); + if (currentSegment == 0) return (ushort)(((SegmentCount - i) * 32) + position); } } @@ -412,7 +412,7 @@ public ushort GetMostSignificantOnePosition() public BitMask GetTwosComplement(ushort size) { var mask = new BitMask(this); - return ((~mask + 1) << (SegmentCount * 32 - size)) >> (SegmentCount * 32 - size); + return ((~mask + 1) << ((SegmentCount * 32) - size)) >> ((SegmentCount * 32) - size); } public ushort LengthOfRunOfBits(ushort startingPosition) diff --git a/Posit/Posit.cs b/Posit/Posit.cs index d70dbbd..97e276c 100644 --- a/Posit/Posit.cs +++ b/Posit/Posit.cs @@ -91,7 +91,7 @@ public BitMask EncodeRegimeBits(int regimeKValue) BitMask regimeBits; if (regimeKValue > 0) { - regimeBits = (new BitMask(1, _environment.Size) << regimeKValue + 1) - 1; + regimeBits = (new BitMask(1, _environment.Size) << (regimeKValue + 1)) - 1; regimeBits <<= _environment.Size - regimeBits.GetMostSignificantOnePosition() - 1; } else regimeBits = (_environment.FirstRegimeBitBitMask << regimeKValue); @@ -106,15 +106,15 @@ private BitMask AssemblePositBits(bool signBit, int regimeKValue, BitMask expone // Attaching the exponent var regimeLength = wholePosit.LengthOfRunOfBits((ushort)(_environment.FirstRegimeBitIndex + 1)); - wholePosit += exponentBits << _environment.Size - (regimeLength + 2) - _environment.MaximumExponentSize; + wholePosit += exponentBits << (_environment.Size - (regimeLength + 2) - _environment.MaximumExponentSize); var fractionMostSignificantOneIndex = fractionBits.GetMostSignificantOnePosition() - 1; // Hiding the hidden bit. (It is always one.) fractionBits = fractionBits.SetZero((ushort)fractionMostSignificantOneIndex); - wholePosit += fractionBits << _environment.Size - 2 - fractionMostSignificantOneIndex - (regimeLength) - - _environment.MaximumExponentSize; + wholePosit += fractionBits << (_environment.Size - 2 - fractionMostSignificantOneIndex - (regimeLength) - + _environment.MaximumExponentSize); return !signBit ? wholePosit : wholePosit.GetTwosComplement(_environment.Size); } @@ -184,7 +184,7 @@ public int CalculateScaleFactor() { if (GetRegimeKValue() == -(Size - 1)) return 0; //return (int)((GetRegimeKValue() == 0) ? 1 + GetExponentValue() : (GetRegimeKValue() * (1 << MaximumExponentSize) + GetExponentValue())); - return (int)(GetRegimeKValue() * (1 << MaximumExponentSize) + GetExponentValue()); + return (int)((GetRegimeKValue() * (1 << MaximumExponentSize)) + GetExponentValue()); } public uint ExponentSize() @@ -200,8 +200,8 @@ public uint GetExponentValue() var fsize = (int)FractionSize(); var esize = ExponentSize(); exponentMask = (exponentMask >> (int)FractionSize()) - << (int)(PositBits.SegmentCount * 32 - ExponentSize()) - >> (int)(PositBits.SegmentCount * 32 - MaximumExponentSize); + << (int)((PositBits.SegmentCount * 32) - ExponentSize()) + >> (int)((PositBits.SegmentCount * 32) - MaximumExponentSize); return exponentMask.GetLowest32Bits(); } @@ -219,14 +219,14 @@ public uint FractionSize() public BitMask FractionWithHiddenBit() { var bits = IsPositive() ? PositBits : PositBits.GetTwosComplement(Size); - var result = bits << (int)(PositBits.SegmentCount * 32 - FractionSize()) - >> (int)(PositBits.SegmentCount * 32 - FractionSize()); + var result = bits << (int)((PositBits.SegmentCount * 32) - FractionSize()) + >> (int)((PositBits.SegmentCount * 32) - FractionSize()); return result.SetOne((ushort)FractionSize()); } public static int CalculateScaleFactor(int regimeKValue, uint exponentValue, byte maximumExponentSize) { - return (int)(regimeKValue * (1 << maximumExponentSize) + exponentValue); + return (int)((regimeKValue * (1 << maximumExponentSize)) + exponentValue); } #endregion @@ -321,10 +321,10 @@ public static int CalculateScaleFactor(int regimeKValue, uint exponentValue, byt if (signBitsMatch) { - resultFractionBits += right.FractionWithHiddenBit() << biggerPositMovedToLeft - scaleFactorDifference + fractionSizeDifference; + resultFractionBits += right.FractionWithHiddenBit() << (biggerPositMovedToLeft - scaleFactorDifference + fractionSizeDifference); } - else resultFractionBits -= right.FractionWithHiddenBit() << biggerPositMovedToLeft - scaleFactorDifference + fractionSizeDifference; + else resultFractionBits -= right.FractionWithHiddenBit() << (biggerPositMovedToLeft - scaleFactorDifference + fractionSizeDifference); scaleFactor += resultFractionBits.GetMostSignificantOnePosition() - (left.Size - 1); } @@ -337,9 +337,9 @@ public static int CalculateScaleFactor(int regimeKValue, uint exponentValue, byt if (signBitsMatch) { - resultFractionBits += left.FractionWithHiddenBit() << biggerPositMovedToLeft + scaleFactorDifference + fractionSizeDifference; + resultFractionBits += left.FractionWithHiddenBit() << (biggerPositMovedToLeft + scaleFactorDifference + fractionSizeDifference); } - else resultFractionBits -= left.FractionWithHiddenBit() << biggerPositMovedToLeft + scaleFactorDifference + fractionSizeDifference; + else resultFractionBits -= left.FractionWithHiddenBit() << (biggerPositMovedToLeft + scaleFactorDifference + fractionSizeDifference); scaleFactor += resultFractionBits.GetMostSignificantOnePosition() - (right.Size - 1); } @@ -385,7 +385,7 @@ public static explicit operator int(Posit x) if ((x.GetRegimeKValue() * (1 << x.MaximumExponentSize)) + x.GetExponentValue() + 1 < 31) // The posit fits into the range { - result = (x.FractionWithHiddenBit() << (int)((x.GetRegimeKValue() * (1 << x.MaximumExponentSize)) + x.GetExponentValue()) - x.FractionWithHiddenBit().GetMostSignificantOnePosition() + 1) + result = (x.FractionWithHiddenBit() << ((int)((x.GetRegimeKValue() * (1 << x.MaximumExponentSize)) + x.GetExponentValue()) - x.FractionWithHiddenBit().GetMostSignificantOnePosition() + 1)) .GetLowest32Bits(); } else return (x.IsPositive()) ? int.MaxValue : int.MinValue; diff --git a/Posit/Posit32.cs b/Posit/Posit32.cs index 4412e4c..e48712d 100644 --- a/Posit/Posit32.cs +++ b/Posit/Posit32.cs @@ -27,9 +27,9 @@ namespace Lombiq.Arithmetics #region Posit Masks - public const uint SignBitMask = (uint)1 << Size - 1; + public const uint SignBitMask = (uint)1 << (Size - 1); - public const uint FirstRegimeBitBitMask = (uint)1 << Size - 2; + public const uint FirstRegimeBitBitMask = (uint)1 << (Size - 2); public const uint EmptyBitMask = 0; @@ -94,7 +94,7 @@ public Posit32(Quire q) resultExponentBits += 1 << MaximumExponentSize; } - PositBits = AssemblePositBitsWithRounding(sign, resultRegimeKValue, resultExponentBits, (uint)(q >> QuireSize - 32)); + PositBits = AssemblePositBitsWithRounding(sign, resultRegimeKValue, resultExponentBits, (uint)(q >> (QuireSize - 32))); } public Posit32(uint value) @@ -151,7 +151,7 @@ public Posit32(float floatBits) var regimeKValue = scaleFactor / (1 << MaximumExponentSize); if (scaleFactor < 0) regimeKValue = regimeKValue - 1; - var exponentValue = (uint)(scaleFactor - regimeKValue * (1 << MaximumExponentSize)); + var exponentValue = (uint)(scaleFactor - (regimeKValue * (1 << MaximumExponentSize))); if (exponentValue == 1 << MaximumExponentSize) { regimeKValue += 1; @@ -205,7 +205,7 @@ public Posit32(double doubleBits) var regimeKValue = scaleFactor / (1 << MaximumExponentSize); if (scaleFactor < 0) regimeKValue = regimeKValue - 1; - var exponentValue = (uint)(scaleFactor - regimeKValue * (1 << MaximumExponentSize)); + var exponentValue = (uint)(scaleFactor - (regimeKValue * (1 << MaximumExponentSize))); if (exponentValue == 1 << MaximumExponentSize) { regimeKValue += 1; @@ -250,7 +250,7 @@ public static uint EncodeRegimeBits(int regimeKValue) uint regimeBits; if (regimeKValue > 0) { - regimeBits = (uint)(1 << regimeKValue + 1) - 1; + regimeBits = (uint)(1 << (regimeKValue + 1)) - 1; regimeBits <<= Size - GetMostSignificantOnePosition(regimeBits) - 1; } else regimeBits = (FirstRegimeBitBitMask >> -regimeKValue); @@ -266,14 +266,14 @@ private uint AssemblePositBits(bool signBit, int regimeKValue, uint exponentBits // Attaching the exponent var regimeLength = LengthOfRunOfBits(wholePosit, FirstRegimeBitPosition); - wholePosit += exponentBits << SizeMinusFixedBits - regimeLength; + wholePosit += exponentBits << (SizeMinusFixedBits - regimeLength); var fractionMostSignificantOneIndex = GetMostSignificantOnePosition(fractionBits) - 1; // Hiding the hidden bit. (It is always one.) fractionBits = SetZero(fractionBits, (ushort)fractionMostSignificantOneIndex); - wholePosit += fractionBits << SizeMinusFixedBits - fractionMostSignificantOneIndex - regimeLength; + wholePosit += fractionBits << (SizeMinusFixedBits - fractionMostSignificantOneIndex - regimeLength); return signBit ? GetTwosComplement(wholePosit) : wholePosit; } @@ -354,7 +354,7 @@ public short CalculateScaleFactor() { var regimeKvalue = GetRegimeKValue(); //return (int)((GetRegimeKValue() == 0) ? 1 + GetExponentValue() : (GetRegimeKValue() * (1 << MaximumExponentSize) + GetExponentValue())); - return (regimeKvalue == -FirstRegimeBitPosition) ? (short)0 : (short)(regimeKvalue * (1 << MaximumExponentSize) + GetExponentValue()); + return (regimeKvalue == -FirstRegimeBitPosition) ? (short)0 : (short)((regimeKvalue * (1 << MaximumExponentSize)) + GetExponentValue()); } [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -481,7 +481,7 @@ public uint FractionWithHiddenBitWithoutSignCheck(uint fractionSize) [MethodImpl(MethodImplOptions.AggressiveInlining)] public static short CalculateScaleFactor(sbyte regimeKValue, uint exponentValue, byte maximumExponentSize) => - (short)(regimeKValue * (1 << maximumExponentSize) + exponentValue); + (short)((regimeKValue * (1 << maximumExponentSize)) + exponentValue); public static Quire MultiplyIntoQuire(Posit32 left, Posit32 right) { @@ -547,7 +547,7 @@ public static byte GetMostSignificantOnePosition(ulong bits) [MethodImpl(MethodImplOptions.AggressiveInlining)] public static Posit32 Abs(Posit32 input) { - var signBit = input.PositBits >> Size - 1; + var signBit = input.PositBits >> (Size - 1); var maskOfSignBits = 0 - signBit; return new Posit32((input.PositBits ^ maskOfSignBits) + signBit, true); } @@ -563,7 +563,7 @@ public static byte LengthOfRunOfBits(uint bits, byte startingPosition) { byte length = 1; bits <<= Size - startingPosition; - var startingBit = bits >> 31 & 1; + var startingBit = (bits >> 31) & 1; bits <<= 1; for (var i = 0; i < startingPosition; i++) { @@ -726,11 +726,11 @@ public static Posit32 FusedMultiplyMultiplySubtract(Posit32 a, Posit32 b, Posit3 if (left.IsZero()) return right; if (right.IsZero()) return left; - var leftSignBit = left.PositBits >> Size - 1; + var leftSignBit = left.PositBits >> (Size - 1); var leftMaskOfSignBits = 0 - leftSignBit; var leftAbsoluteValue = new Posit32((left.PositBits ^ leftMaskOfSignBits) + leftSignBit, true); - var rightSignBit = right.PositBits >> Size - 1; + var rightSignBit = right.PositBits >> (Size - 1); var rightMaskOfSignBits = 0 - rightSignBit; var rightAbsoluteValue = new Posit32((right.PositBits ^ rightMaskOfSignBits) + rightSignBit, true); @@ -944,7 +944,7 @@ public static explicit operator int(Posit32 x) uint result; if (x.PositBits == 0) return 0; - var scaleFactor = x.GetRegimeKValue() * (1 << MaximumExponentSize) + x.GetExponentValue(); + var scaleFactor = (x.GetRegimeKValue() * (1 << MaximumExponentSize)) + x.GetExponentValue(); if (scaleFactor + 1 <= 31) // The posit fits into the range { @@ -973,7 +973,7 @@ public static explicit operator float(Posit32 x) var floatBits = x.IsPositive() ? EmptyBitMask : SignBitMask; float floatRepresentation; - var scaleFactor = x.GetRegimeKValue() * (1 << MaximumExponentSize) + x.GetExponentValue(); + var scaleFactor = (x.GetRegimeKValue() * (1 << MaximumExponentSize)) + x.GetExponentValue(); if (scaleFactor > 127) return x.IsPositive() ? float.MaxValue : float.MinValue; if (scaleFactor < -127) return x.IsPositive() ? float.Epsilon : -float.Epsilon; @@ -1015,7 +1015,7 @@ public static explicit operator double(Posit32 x) ulong doubleBits = x.IsPositive() ? EmptyBitMask : ((ulong)SignBitMask) << 32; double doubleRepresentation; - var scaleFactor = x.GetRegimeKValue() * (1 << MaximumExponentSize) + x.GetExponentValue(); + var scaleFactor = (x.GetRegimeKValue() * (1 << MaximumExponentSize)) + x.GetExponentValue(); var fraction = (ulong)x.Fraction(); diff --git a/Posit/PositEnvironment.cs b/Posit/PositEnvironment.cs index 0bab491..a3b7dd2 100644 --- a/Posit/PositEnvironment.cs +++ b/Posit/PositEnvironment.cs @@ -43,7 +43,7 @@ public PositEnvironment(byte size, byte maximumExponentSize) MaxValueBitMask = new BitMask(Size, true) >> 1; MinValueBitMask = SignBitMask + 1; NaNBitMask = SignBitMask; - QuireSize = new BitMask((uint)((Size - 2) * (1 << MaximumExponentSize) + 5),size).GetMostSignificantOnePosition(); + QuireSize = new BitMask((uint)(((Size - 2) * (1 << MaximumExponentSize)) + 5),size).GetMostSignificantOnePosition(); } } } diff --git a/Unum/Unum.cs b/Unum/Unum.cs index b8219b7..a07884b 100644 --- a/Unum/Unum.cs +++ b/Unum/Unum.cs @@ -201,7 +201,7 @@ public Unum(UnumEnvironment environment, uint[] value, bool negative = false) // If the value of the exponent is not a power of 2, // then one more bit is needed to represent the biased value. - if ((exponentValue.GetLowest32Bits() & exponentValue.GetLowest32Bits() - 1) > 0) exponentSize++; + if ((exponentValue.GetLowest32Bits() & (exponentValue.GetLowest32Bits() - 1)) > 0) exponentSize++; // Handling input numbers that don't fit in the range of the given environment. if (exponentSize > ExponentSizeMax) @@ -212,7 +212,7 @@ public Unum(UnumEnvironment environment, uint[] value, bool negative = false) } // Calculating the bias from the number of bits representing the exponent. - var bias = exponentSize == 0 ? 0 : (1 << exponentSize - 1) - 1; + var bias = exponentSize == 0 ? 0 : (1 << (exponentSize - 1)) - 1; // Applying the bias to the exponent. exponent = exponentValue + (uint)bias; @@ -238,7 +238,7 @@ public Unum(UnumEnvironment environment, uint[] value, bool negative = false) // Handling input numbers that fit in the range, but are too big to represent exactly. if (fractionSize > FractionSizeMax) { - fraction = fraction >> FractionSizeMax - fractionSize; + fraction = fraction >> (FractionSizeMax - fractionSize); uncertainityBit = true; } @@ -435,7 +435,7 @@ public Unum SetExponentBits(BitMask exponent) public Unum SetFractionBits(BitMask fraction) { var newUnumBits = (UnumBits & (new BitMask(Size, true) ^ FractionMask())) | - (fraction << FractionSizeSize + ExponentSizeSize + 1); + (fraction << (FractionSizeSize + ExponentSizeSize + 1)); return new Unum(_environment, newUnumBits); } @@ -462,7 +462,7 @@ public Unum SetFractionSizeBits(byte fractionSize) /// <returns>The BitMask representing the Unum with its exponentSize set to the given value.</returns> public Unum SetExponentSizeBits(byte exponentSize) { - var newUnumBits = (UnumBits & (new BitMask(Size, true) ^ ExponentSizeMask) | + var newUnumBits = ((UnumBits & (new BitMask(Size, true) ^ ExponentSizeMask)) | (new BitMask(exponentSize, Size) << FractionSizeSize)); return new Unum(_environment, newUnumBits); } @@ -481,7 +481,7 @@ public Unum SetExponentSizeBits(byte exponentSize) /// </returns> public uint[] FractionToUintArray() { - var resultMask = FractionWithHiddenBit() << ExponentValueWithBias() - (int)FractionSize(); + var resultMask = FractionWithHiddenBit() << (ExponentValueWithBias() - (int)FractionSize()); var result = new uint[resultMask.SegmentCount]; for (var i = 0; i < resultMask.SegmentCount; i++) result[i] = resultMask.Segments[i]; @@ -813,14 +813,14 @@ public static explicit operator int(Unum x) uint result; if ((x.ExponentValueWithBias() + (int)x.FractionSizeWithHiddenBit()) < 31) //The Unum fits into the range. - result = (x.FractionWithHiddenBit() << x.ExponentValueWithBias() - (int)x.FractionSize()).GetLowest32Bits(); + result = (x.FractionWithHiddenBit() << (x.ExponentValueWithBias() - (int)x.FractionSize())).GetLowest32Bits(); else return (x.IsPositive()) ? int.MaxValue : int.MinValue; // The absolute value of the Unum is too large. return x.IsPositive() ? (int)result : -(int)result; } public static explicit operator uint(Unum x) => - (x.FractionWithHiddenBit() << x.ExponentValueWithBias() - ((int)x.FractionSize())).GetLowest32Bits(); + (x.FractionWithHiddenBit() << (x.ExponentValueWithBias() - ((int)x.FractionSize()))).GetLowest32Bits(); // This is not well tested yet. public static explicit operator float(Unum x) @@ -833,7 +833,7 @@ public static explicit operator float(Unum x) return (x.IsPositive()) ? float.PositiveInfinity : float.NegativeInfinity; if (x.ExponentValueWithBias() < -126) return (x.IsPositive()) ? 0 : -0; // Exponent is too small for float format. - var result = (x.Fraction() << 23 - ((int)x.FractionSize())).GetLowest32Bits(); + var result = (x.Fraction() << (23 - ((int)x.FractionSize()))).GetLowest32Bits(); result |= (uint)(x.ExponentValueWithBias() + 127) << 23; return x.IsPositive() ? diff --git a/Unum/UnumEnvironment.cs b/Unum/UnumEnvironment.cs index f40b920..7bf5a44 100644 --- a/Unum/UnumEnvironment.cs +++ b/Unum/UnumEnvironment.cs @@ -160,7 +160,7 @@ public UnumEnvironment(byte exponentSizeSize, byte fractionSizeSize) LargestNegative = NegativeInfinity - ULP; - MinRealU = LargestPositive + ((uint)1 << Size - 1); + MinRealU = LargestPositive + ((uint)1 << (Size - 1)); QuietNotANumber = PositiveInfinity + UncertaintyBitMask; SignalingNotANumber = NegativeInfinity + UncertaintyBitMask; diff --git a/Unum/UnumHelper.cs b/Unum/UnumHelper.cs index ef9875c..3d3f59d 100644 --- a/Unum/UnumHelper.cs +++ b/Unum/UnumHelper.cs @@ -83,7 +83,7 @@ public static int BitsRequiredByLargestExpressablePositiveInteger(UnumEnvironmen /// Returns an empty BitMask if the calculated number would be too big to fit in a BitMask of /// the size of the environment. /// </summary> - /// <param name="environment">The environment thats Largest Expressible Integer needs to be calculated </param> + /// <param name="environment">The environment thats Largest Expressible Integer needs to be calculated.</param> /// <returns> /// The biggest expressible integer in the given environment if it fits in a BitMask the size of the /// environment, an empty BitMask otherwise. @@ -93,8 +93,8 @@ public static BitMask LargestExpressablePositiveInteger(UnumEnvironment environm if (BitsRequiredByLargestExpressablePositiveInteger(environment) > environment.EmptyBitMask.SegmentCount * 32) return environment.EmptyBitMask; - return environment.EmptyBitMask.SetOne((ushort)(environment.FractionSizeMax)) - 1 << - (1 << (environment.ExponentSizeMax - 1)) - environment.FractionSizeMax + 1; + return (environment.EmptyBitMask.SetOne((ushort)(environment.FractionSizeMax)) - 1) << + ((1 << (environment.ExponentSizeMax - 1)) - environment.FractionSizeMax + 1); } } } From 71809b1c21aa5bb2547fc72a380f88c6c9eed4ed Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Tue, 14 Dec 2021 15:20:46 +0100 Subject: [PATCH 03/49] Remove trailing whitespace across the solution. --- Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs | 2 +- Lombiq.Arithmetics.Tests/PositTests/PositTests.cs | 4 ++-- Lombiq.Arithmetics.Tests/Properties/AssemblyInfo.cs | 10 +++++----- Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs | 4 ++-- 4 files changed, 10 insertions(+), 10 deletions(-) diff --git a/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs b/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs index 5a51ab6..abb5650 100644 --- a/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs +++ b/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs @@ -148,7 +148,7 @@ public void Posit32MultiplicationIsCorrect() Assert.AreEqual(pr3.PositBits, 0b01000000000000000110100011011101); } - + [Fact] public void Posit32DivisionIsCorrect() { diff --git a/Lombiq.Arithmetics.Tests/PositTests/PositTests.cs b/Lombiq.Arithmetics.Tests/PositTests/PositTests.cs index dd2f833..a5522a9 100644 --- a/Lombiq.Arithmetics.Tests/PositTests/PositTests.cs +++ b/Lombiq.Arithmetics.Tests/PositTests/PositTests.cs @@ -83,7 +83,7 @@ public void PositIsCorrectlyConstructedFromUint() new Posit(_environment_8_2, (uint)82).PositBits.ShouldBe(new BitMask(0x69, _environment_12_2.Size)); // Numbers out of range don't get rounded up infinity. They get rounded to the biggest representable - // finite value (MaxValue). + // finite value (MaxValue). new Posit(_environment_6_1, (uint)500).PositBits.ShouldBe(_environment_6_1.MaxValueBitMask); } @@ -287,7 +287,7 @@ public void AdditionIsCorrect() public void AdditionIsCorrectForPositives() { var posit1 = new Posit(_environment_32_3, 1); - + for (var i = 1; i < 10000; i++) { diff --git a/Lombiq.Arithmetics.Tests/Properties/AssemblyInfo.cs b/Lombiq.Arithmetics.Tests/Properties/AssemblyInfo.cs index afdd73b..4cdc889 100644 --- a/Lombiq.Arithmetics.Tests/Properties/AssemblyInfo.cs +++ b/Lombiq.Arithmetics.Tests/Properties/AssemblyInfo.cs @@ -2,7 +2,7 @@ using System.Runtime.CompilerServices; using System.Runtime.InteropServices; -// General Information about an assembly is controlled through the following +// General Information about an assembly is controlled through the following // set of attributes. Change these attribute values to modify the information // associated with an assembly. [assembly: AssemblyTitle("Lombiq.Arithmetics.Tests")] @@ -14,8 +14,8 @@ [assembly: AssemblyTrademark("")] [assembly: AssemblyCulture("")] -// Setting ComVisible to false makes the types in this assembly not visible -// to COM components. If you need to access a type in this assembly from +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from // COM, set the ComVisible attribute to true on that type. [assembly: ComVisible(false)] @@ -25,11 +25,11 @@ // Version information for an assembly consists of the following four values: // // Major Version -// Minor Version +// Minor Version // Build Number // Revision // -// You can specify all the values or you can default the Build and Revision Numbers +// You can specify all the values or you can default the Build and Revision Numbers // by using the '*' as shown below: // [assembly: AssemblyVersion("1.0.*")] [assembly: AssemblyVersion("1.0.0.0")] diff --git a/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs b/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs index dd346a7..0a8ae0c 100644 --- a/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs +++ b/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs @@ -97,7 +97,7 @@ public void UnumIsCorrectlyConstructedFromUintArray() 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 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); @@ -582,7 +582,7 @@ public void SubtractExactUnumsIsCorrect() Unum unumZero = new Unum(_environment_3_4, 0); Assert.AreEqual(Unum.SubtractExactUnums(unum30, unum30).UnumBits, unumZero.UnumBits); } - + [Fact] public void IntToUnumIsCorrect() { From 0e3ed7182bc3a618cd081bf85b477a3fb148ecb8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Tue, 14 Dec 2021 22:59:15 +0100 Subject: [PATCH 04/49] Fix S103 across the solution. --- Lombiq.Arithmetics.Tests/BitMaskTests.cs | 22 ++++++++++++------- .../PositTests/Posit32Tests.cs | 19 +++++++++++----- Posit/Posit.cs | 20 ++++++++++++----- 3 files changed, 42 insertions(+), 19 deletions(-) diff --git a/Lombiq.Arithmetics.Tests/BitMaskTests.cs b/Lombiq.Arithmetics.Tests/BitMaskTests.cs index 16362ba..a689df5 100644 --- a/Lombiq.Arithmetics.Tests/BitMaskTests.cs +++ b/Lombiq.Arithmetics.Tests/BitMaskTests.cs @@ -1,4 +1,4 @@ -using Shouldly; +using Shouldly; using System; using Xunit; @@ -177,12 +177,18 @@ public void FindLeastSignificantOneIsCorrect() [Fact] public void ShiftToRightEndIsCorrect() { - new BitMask(new uint[] { 0x00000000, 0x00000000 }).ShouldBe(new BitMask(new uint[] { 0x00000000, 0x00000000 }).ShiftOutLeastSignificantZeros()); - new BitMask(new uint[] { 0x00000001, 0x00000000 }).ShiftOutLeastSignificantZeros().ShouldBe(new BitMask(new uint[] { 0x00000001, 0x00000000 }).ShiftOutLeastSignificantZeros()); - new BitMask(new uint[] { 0x00000001, 0x00000000 }).ShiftOutLeastSignificantZeros().ShouldBe(new BitMask(new uint[] { 0x00000002, 0x00000000 }).ShiftOutLeastSignificantZeros()); - new BitMask(new uint[] { 0x00000001, 0x00000000 }).ShiftOutLeastSignificantZeros().ShouldBe(new BitMask(new uint[] { 0x00000000, 0x00000001 }).ShiftOutLeastSignificantZeros()); - new BitMask(new uint[] { 0x00001001, 0x00000000 }).ShiftOutLeastSignificantZeros().ShouldBe(new BitMask(new uint[] { 0x10010000, 0x00000000 }).ShiftOutLeastSignificantZeros()); - new BitMask(new uint[] { 0x00001001, 0x00000000 }).ShiftOutLeastSignificantZeros().ShouldBe(new BitMask(new uint[] { 0x00000000, 0x10010000 }).ShiftOutLeastSignificantZeros()); + new BitMask(new uint[] { 0x00000000, 0x00000000 }) + .ShouldBe(new BitMask(new uint[] { 0x00000000, 0x00000000 }).ShiftOutLeastSignificantZeros()); + new BitMask(new uint[] { 0x00000001, 0x00000000 }).ShiftOutLeastSignificantZeros() + .ShouldBe(new BitMask(new uint[] { 0x00000001, 0x00000000 }).ShiftOutLeastSignificantZeros()); + new BitMask(new uint[] { 0x00000001, 0x00000000 }).ShiftOutLeastSignificantZeros() + .ShouldBe(new BitMask(new uint[] { 0x00000002, 0x00000000 }).ShiftOutLeastSignificantZeros()); + new BitMask(new uint[] { 0x00000001, 0x00000000 }).ShiftOutLeastSignificantZeros() + .ShouldBe(new BitMask(new uint[] { 0x00000000, 0x00000001 }).ShiftOutLeastSignificantZeros()); + new BitMask(new uint[] { 0x00001001, 0x00000000 }).ShiftOutLeastSignificantZeros() + .ShouldBe(new BitMask(new uint[] { 0x10010000, 0x00000000 }).ShiftOutLeastSignificantZeros()); + new BitMask(new uint[] { 0x00001001, 0x00000000 }).ShiftOutLeastSignificantZeros() + .ShouldBe(new BitMask(new uint[] { 0x00000000, 0x10010000 }).ShiftOutLeastSignificantZeros()); } [Fact] @@ -204,4 +210,4 @@ public void LengthOfRunOfBitsIsCorrect() } } -} \ No newline at end of file +} diff --git a/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs b/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs index abb5650..0390f75 100644 --- a/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs +++ b/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs @@ -1,4 +1,4 @@ -using Shouldly; +using Shouldly; using System.Diagnostics; using System.Globalization; using Xunit; @@ -227,7 +227,9 @@ public void Posit32IsCorrectlyConstructedFromFloat() Assert.AreEqual(new Posit32((float)100000.5).PositBits, 0b0_111110_00_10000110101000001000000); Assert.AreEqual(new Posit32((float)-2000000.5).PositBits, 0b1_0000001_11_0001011110110111111110); - Assert.AreEqual(new Posit32((float)1.065291755432698054096667486857660145523165660824704316367306233814815641380846500396728515625E-38).PositBits, 0b0_0000000000000000000000000000001); + Assert.AreEqual(new Posit32( + (float)1.065291755432698054096667486857660145523165660824704316367306233814815641380846500396728515625E-38).PositBits, + 0b0_0000000000000000000000000000001); Assert.AreEqual(new Posit32((float)2.7647944E+38).PositBits, 0b0_1111111111111111111111111111111); } @@ -245,7 +247,9 @@ public void Posit32IsCorrectlyConstructedFromDouble() Assert.AreEqual(new Posit32(100000.5).PositBits, 0b0_111110_00_10000110101000001000000); Assert.AreEqual(new Posit32(-2000000.5).PositBits, 0b1_0000001_11_0001011110110111111110); - Assert.AreEqual(new Posit32(1.065291755432698054096667486857660145523165660824704316367306233814815641380846500396728515625E-38).PositBits, 0b0_0000000000000000000000000000001); + Assert.AreEqual(new Posit32( + 1.065291755432698054096667486857660145523165660824704316367306233814815641380846500396728515625E-38).PositBits, + 0b0_0000000000000000000000000000001); Assert.AreEqual(new Posit32(2.7647944E+38).PositBits, 0b0_1111111111111111111111111111111); } @@ -435,11 +439,14 @@ public void Posit32FusedMultiplyMultiplySubtractIsCorrect() var posit3 = new Posit32(-2); var posit4 = new Posit32((float)125.125); - Assert.AreEqual((Posit32.FusedMultiplyMultiplySubtract(posit1, posit2, posit3, posit4)).PositBits, new Posit32((float)250.625).PositBits); - Assert.AreEqual((Posit32.FusedMultiplyMultiplySubtract(posit2, posit3, posit1, posit4)).PositBits, new Posit32((float)-94.84375).PositBits); + Assert.AreEqual( + Posit32.FusedMultiplyMultiplySubtract(posit1, posit2, posit3, posit4).PositBits, + new Posit32((float)250.625).PositBits); + Assert.AreEqual( + Posit32.FusedMultiplyMultiplySubtract(posit2, posit3, posit1, posit4).PositBits, + new Posit32((float)-94.84375).PositBits); } - [Fact] public void Posit32SquareRootIsCorrect() { diff --git a/Posit/Posit.cs b/Posit/Posit.cs index 97e276c..ef15f83 100644 --- a/Posit/Posit.cs +++ b/Posit/Posit.cs @@ -1,4 +1,4 @@ -namespace Lombiq.Arithmetics +namespace Lombiq.Arithmetics { //signbit regime exponent(?) fraction(?) public struct Posit @@ -237,7 +237,9 @@ public static int CalculateScaleFactor(int regimeKValue, uint exponentValue, byt { var leftIsPositive = left.IsPositive(); var rightIsPositive = right.IsPositive(); - var resultSignBit = (left.PositBits + right.PositBits).GetMostSignificantOnePosition() < left.PositBits.Size ? !leftIsPositive : !rightIsPositive; + var resultSignBit = (left.PositBits + right.PositBits).GetMostSignificantOnePosition() < left.PositBits.Size + ? !leftIsPositive + : !rightIsPositive; var signBitsMatch = leftIsPositive == rightIsPositive; @@ -383,12 +385,20 @@ public static explicit operator int(Posit x) { uint result; - if ((x.GetRegimeKValue() * (1 << x.MaximumExponentSize)) + x.GetExponentValue() + 1 < 31) // The posit fits into the range + // The posit fits into the range + if ((x.GetRegimeKValue() * (1 << x.MaximumExponentSize)) + x.GetExponentValue() + 1 < 31) { - result = (x.FractionWithHiddenBit() << ((int)((x.GetRegimeKValue() * (1 << x.MaximumExponentSize)) + x.GetExponentValue()) - x.FractionWithHiddenBit().GetMostSignificantOnePosition() + 1)) + result = (x.FractionWithHiddenBit() << ( + (int)((x.GetRegimeKValue() * (1 << x.MaximumExponentSize)) + x.GetExponentValue()) - + x.FractionWithHiddenBit().GetMostSignificantOnePosition() + + 1)) .GetLowest32Bits(); } - else return (x.IsPositive()) ? int.MaxValue : int.MinValue; + else + { + return (x.IsPositive()) ? int.MaxValue : int.MinValue; + } + return x.IsPositive() ? (int)result : (int)-result; } From f5685a6d1e7b6bf8b4c0b60694a3ad89f79bec05 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Wed, 15 Dec 2021 01:40:37 +0100 Subject: [PATCH 05/49] Fix SA1507 (spacing). --- Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs | 4 ---- Lombiq.Arithmetics.Tests/PositTests/PositTests.cs | 4 ---- .../UnumTests/UnumEnvironmentTests.cs | 3 --- Lombiq.Arithmetics.Tests/UnumTests/UnumHelperTests.cs | 1 - Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs | 11 ----------- 5 files changed, 23 deletions(-) diff --git a/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs b/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs index 0390f75..c8c0215 100644 --- a/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs +++ b/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs @@ -294,7 +294,6 @@ public void Posit32ToFloatIsCorrect() //Debug.WriteLine((float)0.707106781); } - [Fact] public void Posit32ToDoubleIsCorrect() { @@ -362,7 +361,6 @@ public void Posit32ToQuireIsCorrect() Assert.AreEqual(QuireNaN.Segments, QuireNaNFromMask.Segments); } - [Fact] public void Posit32FusedSumIsCorrect() { @@ -487,13 +485,11 @@ public void Posit32ToStringIsCorrect() var posit3 = new Posit32((float)125.12545); var posit4 = new Posit32((double)0.999); - posit1.ToString(CultureInfo.InvariantCulture).ShouldBe("0.75"); posit2.ToString(CultureInfo.InvariantCulture).ShouldBe("-200000"); posit3.ToString("0.############", CultureInfo.InvariantCulture).ShouldBe("125.125450134277"); posit4.ToString("0.###############", CultureInfo.InvariantCulture).ShouldBe("0.998999997973442"); - } } } diff --git a/Lombiq.Arithmetics.Tests/PositTests/PositTests.cs b/Lombiq.Arithmetics.Tests/PositTests/PositTests.cs index a5522a9..cb184c4 100644 --- a/Lombiq.Arithmetics.Tests/PositTests/PositTests.cs +++ b/Lombiq.Arithmetics.Tests/PositTests/PositTests.cs @@ -29,7 +29,6 @@ public PositTests() _environment_32_2 = new PositEnvironment(32, 2); } - [Fact] public void EncodeRegimeBitsIsCorrect() { @@ -227,7 +226,6 @@ public void CalculateScaleFactorIsCorrect() new Posit(_environment_16_3, 2).CalculateScaleFactor().ShouldBe(1); } - [Fact] public void AdditionIsCorrect() { @@ -288,7 +286,6 @@ public void AdditionIsCorrectForPositives() { var posit1 = new Posit(_environment_32_3, 1); - for (var i = 1; i < 10000; i++) { posit1 += 1; @@ -297,7 +294,6 @@ public void AdditionIsCorrectForPositives() var posit1_32_2 = new Posit(_environment_32_2, 1); - for (var i = 1; i < 10000; i++) { posit1_32_2 += 1; diff --git a/Lombiq.Arithmetics.Tests/UnumTests/UnumEnvironmentTests.cs b/Lombiq.Arithmetics.Tests/UnumTests/UnumEnvironmentTests.cs index bbcfddb..fa0becd 100644 --- a/Lombiq.Arithmetics.Tests/UnumTests/UnumEnvironmentTests.cs +++ b/Lombiq.Arithmetics.Tests/UnumTests/UnumEnvironmentTests.cs @@ -12,7 +12,6 @@ public class UnumEnvironmentTests private Unum _unum_3_2; private Unum _unum_3_4; - public UnumEnvironmentTests() { _warlpiriEnvironment = UnumEnvironment.FromStandardEnvironment(StandardEnvironment.Warlpiri); @@ -22,7 +21,6 @@ public UnumEnvironmentTests() _unum_3_4 = new Unum(_environment_3_4); } - [Fact] public void WarlpiriUnumEnvironmentIsCorrect() { @@ -234,7 +232,6 @@ public void UnumLargestNegativeIsCorrect() TestFailureMessageBuilder(_unum_3_4, nameof(_unum_3_4.LargestNegative))); } - private string TestFailureMessageBuilder(Unum unum, string propertyName) => $"Testing the \"{propertyName}\" property of the Unum ({unum.ExponentSizeSize}, {unum.FractionSizeSize}) environment failed."; } diff --git a/Lombiq.Arithmetics.Tests/UnumTests/UnumHelperTests.cs b/Lombiq.Arithmetics.Tests/UnumTests/UnumHelperTests.cs index d9f4702..6591208 100644 --- a/Lombiq.Arithmetics.Tests/UnumTests/UnumHelperTests.cs +++ b/Lombiq.Arithmetics.Tests/UnumTests/UnumHelperTests.cs @@ -23,7 +23,6 @@ public UnumHelperTests() _environment_4_8 = new UnumEnvironment(4, 8); } - [Fact] public void BitsRequiredByLargestExpressablePositiveIntegerIsCorrect() { diff --git a/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs b/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs index 0a8ae0c..fdab5c2 100644 --- a/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs +++ b/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs @@ -29,7 +29,6 @@ public UnumTests() _environment_4_8 = new UnumEnvironment(4, 8); } - [Fact] public void WarlpiriUnumValuesAndCalculationsAreCorrect() { @@ -160,7 +159,6 @@ public void UnumIsCorrectlyConstructedFromUintArray() 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); @@ -230,7 +228,6 @@ public void FractionToUintArrayIsCorrect() // var five = new Unum(_metaData_3_5, (float)5); // var fourth = new Unum(_metaData_3_5, 0.75F); - // var bitMask_1 = new BitMask(new uint[] { 0x3F22 }, _metaData_3_4.Size); // var bitMask_2 = new BitMask(new uint[] { 0x6A2309EF }, _metaData_3_4.Size); // var bitMask_5 = new BitMask(new uint[] { 0x1A21 }, _metaData_3_5.Size); @@ -335,27 +332,22 @@ public void UnumIsCorrectlyConstructedFromUInt() // var first = new Unum(_metaData_3_4, (double)30.0); // var second = new Unum(_metaData_3_4, (double)9999999999999); - // var bitMask_1 = new BitMask(new uint[] { 0x3F22 }, _metaData_3_4.Size); // var bitMask_2 = new BitMask(new uint[] { 0x6A2309EF }, _metaData_3_4.Size); - // Assert.AreEqual(first.UnumBits, bitMask_1); // Assert.AreEqual(second.UnumBits, bitMask_2); //} - //[Fact] //public void UnumIsCorrectlyConstructedFromLong() //{ // var first = new Unum(_metaData_3_4, (long)30); // var second = new Unum(_metaData_3_4, (long)9999999999999); - // var bitMask_1 = new BitMask(new uint[] { 0x3F22 }, _metaData_3_4.Size); // var bitMask_2 = new BitMask(new uint[] { 0x6A2309EF }, _metaData_3_4.Size); - // Assert.AreEqual(first.UnumBits, bitMask_1); // Assert.AreEqual(second.UnumBits, bitMask_2); //} @@ -679,11 +671,9 @@ public void UnumToIntIsCorrect() // var first = new Unum(_environment_3_4, (float)30.0); // var second = new Unum(_environment_3_4, (float)9999999999999); - // var bitMask_1 = new BitMask(new uint[] { 0x3F22 }, 33); // var bitMask_2 = new BitMask(new uint[] { 0x6A2309EF }, 33); - // Assert.AreEqual(first.UnumBits, bitMask_1); // Assert.AreEqual(second.UnumBits, bitMask_2); //} @@ -726,7 +716,6 @@ public void UnumToFloatIsCorrect() // var tooBig = (double)tooBigUnum; // var tooBigNegative = (double)tooBigNegativeUnum; - // Assert.AreEqual(thirty, (double)30); // Assert.AreEqual(thousand, (double)1000); // Assert.AreEqual(negativeThirty, (double)-30); From a13041f5bc6f07f94e77ffdd6863d51fb83d9c13 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Wed, 15 Dec 2021 01:58:53 +0100 Subject: [PATCH 06/49] Fix SA1139 (Use literal suffix notation instead of casting). --- BitMask/BitMask.cs | 2 +- Lombiq.Arithmetics.Tests/BitMaskTests.cs | 26 ++--- .../PositTests/Posit32Tests.cs | 106 +++++++++--------- .../PositTests/PositTests.cs | 30 ++--- .../UnumTests/UnumTests.cs | 24 ++-- Posit/Posit.cs | 2 +- Posit/Posit32.cs | 6 +- Posit/PositEnvironment.cs | 2 +- Posit/Quire.cs | 4 +- Unum/UnumEnvironment.cs | 2 +- 10 files changed, 102 insertions(+), 102 deletions(-) diff --git a/BitMask/BitMask.cs b/BitMask/BitMask.cs index 73a6277..16b8831 100644 --- a/BitMask/BitMask.cs +++ b/BitMask/BitMask.cs @@ -121,7 +121,7 @@ public BitMask SetZero(ushort index) var segmentPosition = index >> 5; if ((Segments[segmentPosition] >> bitPosition) % 2 == 1) - return FromImmutableArray(Segments.SetItem(segmentPosition, Segments[segmentPosition] & ~((uint)1 << bitPosition)), Size); + return FromImmutableArray(Segments.SetItem(segmentPosition, Segments[segmentPosition] & ~(1U << bitPosition)), Size); return new BitMask(this); } diff --git a/Lombiq.Arithmetics.Tests/BitMaskTests.cs b/Lombiq.Arithmetics.Tests/BitMaskTests.cs index a689df5..8ae30f9 100644 --- a/Lombiq.Arithmetics.Tests/BitMaskTests.cs +++ b/Lombiq.Arithmetics.Tests/BitMaskTests.cs @@ -13,13 +13,13 @@ public void BitMaskSegmentCountIsCorrectlyCalculatedFromSize() { var sizesAndSegmentCounts = new Tuple<BitMask, uint>[] { - Tuple.Create(new BitMask(0), (uint)0), - Tuple.Create(new BitMask(31), (uint)1), - Tuple.Create(new BitMask(32), (uint)1), - Tuple.Create(new BitMask(33), (uint)2), - Tuple.Create(new BitMask(1023), (uint)32), - Tuple.Create(new BitMask(1024), (uint)32), - Tuple.Create(new BitMask(1025), (uint)33) + Tuple.Create(new BitMask(0), 0U), + Tuple.Create(new BitMask(31), 1U), + Tuple.Create(new BitMask(32), 1U), + Tuple.Create(new BitMask(33), 2U), + Tuple.Create(new BitMask(1023), 32U), + Tuple.Create(new BitMask(1024), 32U), + Tuple.Create(new BitMask(1025), 33U), }; foreach (var item in sizesAndSegmentCounts) item.Item2.ShouldBe(item.Item1.SegmentCount, $"Size: {item.Item1.Size}"); @@ -30,12 +30,12 @@ public void BitMaskSizeIsCorrectlySetWithSegments() { var sizesAndSegmentCounts = new Tuple<BitMask, uint>[] { - Tuple.Create(new BitMask(new uint[0]), (uint)0), - Tuple.Create(new BitMask(new uint[] { 1 }), (uint)32), - Tuple.Create(new BitMask(new uint[] { 2, 2 }), (uint)64), - Tuple.Create(new BitMask(new uint[] { 3, 3, 3 }), (uint)96), - Tuple.Create(new BitMask(new uint[] { 4, 4, 4, 4 }), (uint)128), - Tuple.Create(new BitMask(new uint[] { 0 }, 222), (uint)222) + Tuple.Create(new BitMask(new uint[0]), 0U), + Tuple.Create(new BitMask(new uint[] { 1 }), 32U), + Tuple.Create(new BitMask(new uint[] { 2, 2 }), 64U), + Tuple.Create(new BitMask(new uint[] { 3, 3, 3 }), 96U), + Tuple.Create(new BitMask(new uint[] { 4, 4, 4, 4 }), 128U), + Tuple.Create(new BitMask(new uint[] { 0 }, 222), 222U) }; foreach (var item in sizesAndSegmentCounts) item.Item2.ShouldBe(item.Item1.Size, $"Mask: {item.Item1}"); diff --git a/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs b/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs index c8c0215..32c3768 100644 --- a/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs +++ b/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs @@ -71,15 +71,15 @@ public void Posit32AdditionIsCorrect() var positNegative_2 = positNegative_1 - 1; positNegative_2.PositBits.ShouldBe(new Posit32(-2).PositBits); - var posit3 = new Posit32((float)100.0125); + var posit3 = new Posit32(100.0125F); var posit4 = posit3 - 100; posit4.PositBits.ShouldBe(new Posit32(0b00010110011001100000000000000000, true).PositBits); (new Posit32(500) + new Posit32(-500)).PositBits.ShouldBe(new Posit32(0).PositBits); (new Posit32(99988) + new Posit32(-88999)).PositBits.ShouldBe(new Posit32(10989).PositBits); - (new Posit32((float)0.75) + new Posit32((float)0.75)).PositBits.ShouldBe(new Posit32((float)1.5).PositBits); - (new Posit32((float)4) + new Posit32((float)-3.75)).PositBits.ShouldBe(new Posit32((float)0.25).PositBits); + (new Posit32(0.75F) + new Posit32(0.75F)).PositBits.ShouldBe(new Posit32(1.5F).PositBits); + (new Posit32(4F) + new Posit32(-3.75F)).PositBits.ShouldBe(new Posit32(0.25F).PositBits); } [Fact] @@ -128,15 +128,15 @@ public void Posit32MultiplicationIsCorrect() posit1.PositBits.ShouldBe(new Posit32(5).PositBits); var posit2 = new Posit32(2); - posit2 *= new Posit32((float)0.25); - posit2.PositBits.ShouldBe(new Posit32((float)0.5).PositBits); + posit2 *= new Posit32(0.25F); + posit2.PositBits.ShouldBe(new Posit32(0.5F).PositBits); - var posit3 = new Posit32((float)0.1); - posit3 *= new Posit32((float)0.01); + var posit3 = new Posit32(0.1F); + posit3 *= new Posit32(0.01F); posit3.PositBits.ShouldBe(new Posit32(0b00001100000011000100100110111010, true).PositBits); var posit55 = new Posit32(int.MaxValue - 1); - posit55 *= new Posit32((float)0.25); + posit55 *= new Posit32(0.25F); posit55.PositBits.ShouldBe(new Posit32((int.MaxValue - 1) / 4).PositBits); posit55 *= new Posit32(0); @@ -154,11 +154,11 @@ public void Posit32DivisionIsCorrect() { var posit6 = new Posit32(6); posit6 /= 4; - posit6.PositBits.ShouldBe(new Posit32((float)1.5).PositBits); + posit6.PositBits.ShouldBe(new Posit32(1.5F).PositBits); var posit2 = new Posit32(2); posit2 /= 4; - posit2.PositBits.ShouldBe(new Posit32((float)0.5).PositBits); + posit2.PositBits.ShouldBe(new Posit32(0.5F).PositBits); var posit55 = new Posit32(int.MaxValue - 1); posit55 /= new Posit32(4); @@ -179,11 +179,11 @@ public void Posit32DivisionIsCorrect() positBig2 /= 50000000; positBig2.PositBits.ShouldBe(new Posit32(1).PositBits); - var positSmall = new Posit32((float)0.02); - positSmall /= new Posit32((float)0.05); + var positSmall = new Posit32(0.02F); + positSmall /= new Posit32(0.05F); positSmall.PositBits.ShouldBe(new Posit32(0b00110100110011001100110011000101, true).PositBits); - var positSmall2 = new Posit32((float)0.1); + var positSmall2 = new Posit32(0.1F); positSmall2 /= 100; positSmall2.PositBits.ShouldBe(new Posit32(0b00001100000011000100100110111011, true).PositBits); @@ -216,28 +216,28 @@ public void Posit32ToIntIsCorrect() [Fact] public void Posit32IsCorrectlyConstructedFromFloat() { - Assert.AreEqual(new Posit32((float)0).PositBits, 0x00000000); - Assert.AreEqual(new Posit32((float)-0).PositBits, 0x00000000); - Assert.AreEqual(new Posit32((float)0.75).PositBits, 0b0_01111_00_000000000000000000000000); + Assert.AreEqual(new Posit32(0F).PositBits, 0x00000000); + Assert.AreEqual(new Posit32(-0F).PositBits, 0x00000000); + Assert.AreEqual(new Posit32(0.75F).PositBits, 0b0_01111_00_000000000000000000000000); - Assert.AreEqual(new Posit32((float)0.0500000007450580596923828125).PositBits, 0b0_001_11_10011001100110011001101000); - Assert.AreEqual(new Posit32((float)-0.00179999996908009052276611328125).PositBits, 0b1_1110_01_0010100000100100000011000); + Assert.AreEqual(new Posit32(0.0500000007450580596923828125F).PositBits, 0b0_001_11_10011001100110011001101000); + Assert.AreEqual(new Posit32(-0.00179999996908009052276611328125F).PositBits, 0b1_1110_01_0010100000100100000011000); - Assert.AreEqual(new Posit32((float)-134.75).PositBits, 0x93CA0000); - Assert.AreEqual(new Posit32((float)100000.5).PositBits, 0b0_111110_00_10000110101000001000000); - Assert.AreEqual(new Posit32((float)-2000000.5).PositBits, 0b1_0000001_11_0001011110110111111110); + Assert.AreEqual(new Posit32(-134.75F).PositBits, 0x93CA0000); + Assert.AreEqual(new Posit32(100000.5F).PositBits, 0b0_111110_00_10000110101000001000000); + Assert.AreEqual(new Posit32(-2000000.5F).PositBits, 0b1_0000001_11_0001011110110111111110); Assert.AreEqual(new Posit32( - (float)1.065291755432698054096667486857660145523165660824704316367306233814815641380846500396728515625E-38).PositBits, +1.065291755432698054096667486857660145523165660824704316367306233814815641380846500396728515625E-38F).PositBits, 0b0_0000000000000000000000000000001); - Assert.AreEqual(new Posit32((float)2.7647944E+38).PositBits, 0b0_1111111111111111111111111111111); + Assert.AreEqual(new Posit32(2.7647944E+38F).PositBits, 0b0_1111111111111111111111111111111); } [Fact] public void Posit32IsCorrectlyConstructedFromDouble() { - Assert.AreEqual(new Posit32((double)0).PositBits, 0x00000000); - Assert.AreEqual(new Posit32((double)-0).PositBits, 0x00000000); + Assert.AreEqual(new Posit32(0D).PositBits, 0x00000000); + Assert.AreEqual(new Posit32(-0D).PositBits, 0x00000000); Assert.AreEqual(new Posit32(0.75).PositBits, 0b0_01111_00_000000000000000000000000); Assert.AreEqual(new Posit32(0.0500000007450580596923828125).PositBits, 0b00011110011001100110011001101000); @@ -262,35 +262,35 @@ public void Posit32ToFloatIsCorrect() var positNegative_1234 = new Posit32(-1234); Assert.AreEqual((float)positNegative_1234, -1234); - var posit3 = new Posit32((float)0.75); + var posit3 = new Posit32(0.75F); Assert.AreEqual((float)posit3, 0.75); - var posit4 = new Posit32((float)-134.75); + var posit4 = new Posit32(-134.75F); Assert.AreEqual((float)posit4, -134.75); - var posit5 = new Posit32((float)100000.5); + var posit5 = new Posit32(100000.5F); Assert.AreEqual((float)posit5, 100000.5); - var posit6 = new Posit32((float)-2000000.5); + var posit6 = new Posit32(-2000000.5F); Assert.AreEqual((float)posit6, -2000000.5); - var posit7 = new Posit32((float)-0.00179999996908009052276611328125); + var posit7 = new Posit32(-0.00179999996908009052276611328125F); Assert.AreEqual((float)posit7, -0.00179999996908009052276611328125); - var posit8 = new Posit32((float)0.0500000007450580596923828125); + var posit8 = new Posit32(0.0500000007450580596923828125F); Assert.AreEqual((float)posit8, 0.0500000007450580596923828125); - var posit11 = new Posit32((float)0.002); - Assert.AreEqual((float)posit11, (float)0.002); + var posit11 = new Posit32(0.002F); + Assert.AreEqual((float)posit11, 0.002F); - var posit9 = new Posit32((float)0.005); - Assert.AreEqual((float)posit9, (float)0.005); + var posit9 = new Posit32(0.005F); + Assert.AreEqual((float)posit9, 0.005F); - var posit10 = new Posit32((float)0.1); - Assert.AreEqual((float)posit10, (float)0.1); + var posit10 = new Posit32(0.1F); + Assert.AreEqual((float)posit10, 0.1F); - var posit12 = new Posit32((float)0.707106781); - Assert.AreEqual((float)posit12, (float)0.707106781); + var posit12 = new Posit32(0.707106781F); + Assert.AreEqual((float)posit12, 0.707106781F); //Debug.WriteLine((float)0.707106781); } @@ -411,38 +411,38 @@ public void Posit32FusedDotProductIsCorrect() public void Posit32FusedMultiplyAddIsCorrect() { var posit1 = new Posit32(300); - var posit2 = new Posit32((float)0.5); + var posit2 = new Posit32(0.5F); var posit3 = new Posit32(-1); Assert.AreEqual((Posit32.FusedMultiplyAdd(posit1, posit2, posit3)).PositBits, new Posit32(149).PositBits); - Assert.AreEqual((Posit32.FusedMultiplyAdd(posit1, posit3, posit2)).PositBits, new Posit32((float)-299.5).PositBits); + Assert.AreEqual((Posit32.FusedMultiplyAdd(posit1, posit3, posit2)).PositBits, new Posit32(-299.5F).PositBits); } [Fact] public void Posit32FusedAddMultiplyIsCorrect() { - var posit1 = new Posit32((float)0.75); - var posit2 = new Posit32((float)0.5); + var posit1 = new Posit32(0.75F); + var posit2 = new Posit32(0.5F); var posit3 = new Posit32(-2); - Assert.AreEqual((Posit32.FusedAddMultiply(posit1, posit2, posit3)).PositBits, new Posit32((float)-2.5).PositBits); - Assert.AreEqual((Posit32.FusedAddMultiply(posit2, posit3, posit1)).PositBits, new Posit32((float)-1.125).PositBits); + Assert.AreEqual((Posit32.FusedAddMultiply(posit1, posit2, posit3)).PositBits, new Posit32(-2.5F).PositBits); + Assert.AreEqual((Posit32.FusedAddMultiply(posit2, posit3, posit1)).PositBits, new Posit32(-1.125F).PositBits); } [Fact] public void Posit32FusedMultiplyMultiplySubtractIsCorrect() { - var posit1 = new Posit32((float)0.75); - var posit2 = new Posit32((float)0.5); + var posit1 = new Posit32(0.75F); + var posit2 = new Posit32(0.5F); var posit3 = new Posit32(-2); - var posit4 = new Posit32((float)125.125); + var posit4 = new Posit32(125.125F); Assert.AreEqual( Posit32.FusedMultiplyMultiplySubtract(posit1, posit2, posit3, posit4).PositBits, - new Posit32((float)250.625).PositBits); + new Posit32(250.625F).PositBits); Assert.AreEqual( Posit32.FusedMultiplyMultiplySubtract(posit2, posit3, posit1, posit4).PositBits, - new Posit32((float)-94.84375).PositBits); + new Posit32(-94.84375F).PositBits); } [Fact] @@ -469,7 +469,7 @@ public void Posit32SquareRootIsCorrect() var posit625 = new Posit32(625); Posit32.Sqrt(posit625).PositBits.ShouldBe(new Posit32(25).PositBits); - var positSmallerThanOne1 = new Posit32((float)0.5); + var positSmallerThanOne1 = new Posit32(0.5F); Debug.WriteLine(((float)Posit32.Sqrt(positSmallerThanOne1)).ToString("0.0000000000")); Posit32.Sqrt(positSmallerThanOne1).PositBits.ShouldBe(new Posit32(0b00111011010100000100111100110011, true).PositBits); @@ -480,9 +480,9 @@ public void Posit32SquareRootIsCorrect() [Fact] public void Posit32ToStringIsCorrect() { - var posit1 = new Posit32((float)0.75); + var posit1 = new Posit32(0.75F); var posit2 = new Posit32(-200000); - var posit3 = new Posit32((float)125.12545); + var posit3 = new Posit32(125.12545F); var posit4 = new Posit32((double)0.999); posit1.ToString(CultureInfo.InvariantCulture).ShouldBe("0.75"); diff --git a/Lombiq.Arithmetics.Tests/PositTests/PositTests.cs b/Lombiq.Arithmetics.Tests/PositTests/PositTests.cs index cb184c4..f110b17 100644 --- a/Lombiq.Arithmetics.Tests/PositTests/PositTests.cs +++ b/Lombiq.Arithmetics.Tests/PositTests/PositTests.cs @@ -51,39 +51,39 @@ public void EncodeRegimeBitsIsCorrect() public void PositIsCorrectlyConstructedFromUint() { - new Posit(_environment_6_3, (uint)0).PositBits.ShouldBe(new BitMask(0x0, _environment_6_3.Size)); + new Posit(_environment_6_3, 0U).PositBits.ShouldBe(new BitMask(0x0, _environment_6_3.Size)); new Posit(_environment_6_3, 2).PositBits.ShouldBe(new BitMask(17, _environment_6_3.Size)); - new Posit(_environment_6_3, (uint)8).PositBits.ShouldBe(new BitMask(0x13, _environment_6_3.Size)); + new Posit(_environment_6_3, 8U).PositBits.ShouldBe(new BitMask(0x13, _environment_6_3.Size)); - new Posit(_environment_6_3, (uint)16384).PositBits.ShouldBe(new BitMask(0x1B, _environment_6_3.Size)); + new Posit(_environment_6_3, 16384U).PositBits.ShouldBe(new BitMask(0x1B, _environment_6_3.Size)); - new Posit(_environment_6_3, (uint)1048576).PositBits.ShouldBe(new BitMask(0x1D, _environment_6_3.Size)); + new Posit(_environment_6_3, 1048576U).PositBits.ShouldBe(new BitMask(0x1D, _environment_6_3.Size)); - new Posit(_environment_8_2, (uint)13).PositBits.ShouldBe(new BitMask(0x5D, _environment_8_2.Size)); + new Posit(_environment_8_2, 13U).PositBits.ShouldBe(new BitMask(0x5D, _environment_8_2.Size)); - new Posit(_environment_32_2, (uint)17).PositBits.ShouldBe(new BitMask(0x60400000, _environment_32_2.Size)); + new Posit(_environment_32_2, 17U).PositBits.ShouldBe(new BitMask(0x60400000, _environment_32_2.Size)); - new Posit(_environment_12_2, (uint)172).PositBits.ShouldBe(new BitMask(0x6D6, _environment_12_2.Size)); + new Posit(_environment_12_2, 172U).PositBits.ShouldBe(new BitMask(0x6D6, _environment_12_2.Size)); - new Posit(_environment_12_2, (uint)173).PositBits.ShouldBe(new BitMask(0x6D6, _environment_12_2.Size)); + new Posit(_environment_12_2, 173U).PositBits.ShouldBe(new BitMask(0x6D6, _environment_12_2.Size)); - new Posit(_environment_16_3, (uint)48).PositBits.ShouldBe(new BitMask(22016, _environment_16_3.Size)); + new Posit(_environment_16_3, 48U).PositBits.ShouldBe(new BitMask(22016, _environment_16_3.Size)); - new Posit(_environment_16_3, (uint)13200).PositBits.ShouldBe(new BitMask(27449, _environment_16_3.Size)); + new Posit(_environment_16_3, 13200U).PositBits.ShouldBe(new BitMask(27449, _environment_16_3.Size)); - new Posit(_environment_16_3, (uint)500).PositBits.ShouldBe(new BitMask(25064, _environment_16_3.Size)); + new Posit(_environment_16_3, 500U).PositBits.ShouldBe(new BitMask(25064, _environment_16_3.Size)); - new Posit(_environment_32_3, (uint)1).PositBits.ShouldBe(new BitMask(0x40000000, _environment_32_3.Size)); + new Posit(_environment_32_3, 1U).PositBits.ShouldBe(new BitMask(0x40000000, _environment_32_3.Size)); // examples of Posit rounding - new Posit(_environment_8_2, (uint)90).PositBits.ShouldBe(new BitMask(0x6A, _environment_12_2.Size)); - new Posit(_environment_8_2, (uint)82).PositBits.ShouldBe(new BitMask(0x69, _environment_12_2.Size)); + new Posit(_environment_8_2, 90U).PositBits.ShouldBe(new BitMask(0x6A, _environment_12_2.Size)); + new Posit(_environment_8_2, 82U).PositBits.ShouldBe(new BitMask(0x69, _environment_12_2.Size)); // Numbers out of range don't get rounded up infinity. They get rounded to the biggest representable // finite value (MaxValue). - new Posit(_environment_6_1, (uint)500).PositBits.ShouldBe(_environment_6_1.MaxValueBitMask); + new Posit(_environment_6_1, 500U).PositBits.ShouldBe(_environment_6_1.MaxValueBitMask); } [Fact] diff --git a/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs b/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs index fdab5c2..6c7d1f5 100644 --- a/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs +++ b/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs @@ -281,47 +281,47 @@ public void UnumIsCorrectlyConstructedFromInt() [Fact] public void UnumIsCorrectlyConstructedFromUInt() { - var unum0 = new Unum(_environment_3_4, (uint)0); + var unum0 = new Unum(_environment_3_4, 0U); 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 unum1 = new Unum(_environment_3_4, 1U); 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 unum2 = new Unum(_environment_3_4, 2U); 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 unum4 = new Unum(_environment_3_4, 4U); 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 unum8 = new Unum(_environment_3_4, 8U); 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 unum10 = new Unum(_environment_2_2, 10U); 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 unum13 = new Unum(_environment_3_4, 13U); 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 unum30 = new Unum(_environment_3_4, 30U); 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 unum1000 = new Unum(_environment_3_4, 1000U); 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 unum5000 = new Unum(_environment_3_4, 5000U); 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 unum6000 = new Unum(_environment_3_4, 6000U); var bitMask6000 = new BitMask(new uint[] { 0x1B7747 }, _environment_3_4.Size); Assert.AreEqual(bitMask6000, unum6000.UnumBits); } @@ -683,7 +683,7 @@ public void UnumToFloatIsCorrect() { var unum30 = new Unum(_environment_3_4, 30); var numbe30 = (float)unum30; - Assert.AreEqual(numbe30, (float)30); + Assert.AreEqual(numbe30, 30F); var unum1000 = new Unum(_environment_3_4, 1000); var number1000 = (float)unum1000; diff --git a/Posit/Posit.cs b/Posit/Posit.cs index ef15f83..572c07b 100644 --- a/Posit/Posit.cs +++ b/Posit/Posit.cs @@ -58,7 +58,7 @@ public Posit(PositEnvironment environment, uint value) ushort kValue = 0; while (exponentValue >= 1 << environment.MaximumExponentSize && kValue < _environment.Size - 1) { - exponentValue -= (uint)1 << environment.MaximumExponentSize; + exponentValue -= 1U << environment.MaximumExponentSize; kValue++; } diff --git a/Posit/Posit32.cs b/Posit/Posit32.cs index e48712d..40e0c54 100644 --- a/Posit/Posit32.cs +++ b/Posit/Posit32.cs @@ -27,9 +27,9 @@ namespace Lombiq.Arithmetics #region Posit Masks - public const uint SignBitMask = (uint)1 << (Size - 1); + public const uint SignBitMask = 1U << (Size - 1); - public const uint FirstRegimeBitBitMask = (uint)1 << (Size - 2); + public const uint FirstRegimeBitBitMask = 1U << (Size - 2); public const uint EmptyBitMask = 0; @@ -601,7 +601,7 @@ public static Posit32 Sqrt(Posit32 number) uint resultFractionBits = 0; //q uint startingEstimate = 0; //s0 uint temporaryEstimate; //t - uint estimateMaskingBit = (uint)1 << (int)number.FractionSizeWithoutSignCheck(); //r + uint estimateMaskingBit = 1U << (int)number.FractionSizeWithoutSignCheck(); //r while (estimateMaskingBit != 0) { diff --git a/Posit/PositEnvironment.cs b/Posit/PositEnvironment.cs index a3b7dd2..b61e60f 100644 --- a/Posit/PositEnvironment.cs +++ b/Posit/PositEnvironment.cs @@ -35,7 +35,7 @@ public PositEnvironment(byte size, byte maximumExponentSize) Size = size; MaximumExponentSize = maximumExponentSize; - Useed = (uint)1 << (1 << MaximumExponentSize); + Useed = 1U << (1 << MaximumExponentSize); SignBitMask = new BitMask(Size).SetOne((ushort)(Size - 1)); FirstRegimeBitIndex = (ushort)(Size - 2); FirstRegimeBitBitMask = new BitMask(Size).SetOne(FirstRegimeBitIndex); diff --git a/Posit/Quire.cs b/Posit/Quire.cs index fb1a633..cde8e20 100644 --- a/Posit/Quire.cs +++ b/Posit/Quire.cs @@ -61,7 +61,7 @@ public Quire(uint firstSegment, ushort size) buffer = (byte)((leftBit ? 1 : 0) + (rightBit ? 1 : 0) + (carry ? 1 : 0)); - if ((buffer & 1) == 1) result[segmentPosition] += ((ulong)1 << position); + if ((buffer & 1) == 1) result[segmentPosition] += (1UL << position); carry = buffer >> 1 == 1; position++; @@ -92,7 +92,7 @@ public Quire(uint firstSegment, ushort size) buffer = (byte)(2 + (leftBit ? 1 : 0) - (rightBit ? 1 : 0) - (carry ? 1 : 0)); - if ((buffer & 1) == 1) result[segmentPosition] += ((ulong)1 << position); + if ((buffer & 1) == 1) result[segmentPosition] += (1UL << position); carry = buffer >> 1 == 0; position++; diff --git a/Unum/UnumEnvironment.cs b/Unum/UnumEnvironment.cs index 7bf5a44..0cb42e2 100644 --- a/Unum/UnumEnvironment.cs +++ b/Unum/UnumEnvironment.cs @@ -160,7 +160,7 @@ public UnumEnvironment(byte exponentSizeSize, byte fractionSizeSize) LargestNegative = NegativeInfinity - ULP; - MinRealU = LargestPositive + ((uint)1 << (Size - 1)); + MinRealU = LargestPositive + (1U << (Size - 1)); QuietNotANumber = PositiveInfinity + UncertaintyBitMask; SignalingNotANumber = NegativeInfinity + UncertaintyBitMask; From bb7c8fb82f11aecf8c8b2f1ce56e87108d74ca1a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Thu, 16 Dec 2021 18:23:59 +0100 Subject: [PATCH 07/49] Remove unnecessary usings. --- Lombiq.Arithmetics.Tests/Properties/AssemblyInfo.cs | 1 - Posit/PositEnvironment.cs | 8 +------- Posit/Quire.cs | 1 - Properties/AssemblyInfo.cs | 1 - 4 files changed, 1 insertion(+), 10 deletions(-) diff --git a/Lombiq.Arithmetics.Tests/Properties/AssemblyInfo.cs b/Lombiq.Arithmetics.Tests/Properties/AssemblyInfo.cs index 4cdc889..e4c2189 100644 --- a/Lombiq.Arithmetics.Tests/Properties/AssemblyInfo.cs +++ b/Lombiq.Arithmetics.Tests/Properties/AssemblyInfo.cs @@ -1,5 +1,4 @@ using System.Reflection; -using System.Runtime.CompilerServices; using System.Runtime.InteropServices; // General Information about an assembly is controlled through the following diff --git a/Posit/PositEnvironment.cs b/Posit/PositEnvironment.cs index b61e60f..18eac98 100644 --- a/Posit/PositEnvironment.cs +++ b/Posit/PositEnvironment.cs @@ -1,10 +1,4 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; - -namespace Lombiq.Arithmetics +namespace Lombiq.Arithmetics { public class PositEnvironment { diff --git a/Posit/Quire.cs b/Posit/Quire.cs index cde8e20..b563662 100644 --- a/Posit/Quire.cs +++ b/Posit/Quire.cs @@ -1,5 +1,4 @@ using System; -using System.Collections.Immutable; namespace Lombiq.Arithmetics { diff --git a/Properties/AssemblyInfo.cs b/Properties/AssemblyInfo.cs index 823ba80..8304a8a 100644 --- a/Properties/AssemblyInfo.cs +++ b/Properties/AssemblyInfo.cs @@ -1,5 +1,4 @@ using System.Reflection; -using System.Runtime.CompilerServices; using System.Runtime.InteropServices; // General Information about an assembly is controlled through the following From e86fbe159d006f5948d744d7fd3d108ef209ddae Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Thu, 16 Dec 2021 18:47:24 +0100 Subject: [PATCH 08/49] Fix SA1116 (The parameters should begin on the line after the declaration, whenever the parameter span across multiple lines. --- .../PositTests/Posit32Tests.cs | 18 ++++-- .../PositTests/QuireTests.cs | 57 ++++++++++++------- .../UnumTests/UnumTests.cs | 6 +- Posit/Posit.cs | 3 +- Unum/Unum.cs | 6 +- 5 files changed, 60 insertions(+), 30 deletions(-) diff --git a/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs b/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs index 32c3768..3c55718 100644 --- a/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs +++ b/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs @@ -227,7 +227,8 @@ public void Posit32IsCorrectlyConstructedFromFloat() Assert.AreEqual(new Posit32(100000.5F).PositBits, 0b0_111110_00_10000110101000001000000); Assert.AreEqual(new Posit32(-2000000.5F).PositBits, 0b1_0000001_11_0001011110110111111110); - Assert.AreEqual(new Posit32( + Assert.AreEqual( + new Posit32( 1.065291755432698054096667486857660145523165660824704316367306233814815641380846500396728515625E-38F).PositBits, 0b0_0000000000000000000000000000001); Assert.AreEqual(new Posit32(2.7647944E+38F).PositBits, 0b0_1111111111111111111111111111111); @@ -247,7 +248,8 @@ public void Posit32IsCorrectlyConstructedFromDouble() Assert.AreEqual(new Posit32(100000.5).PositBits, 0b0_111110_00_10000110101000001000000); Assert.AreEqual(new Posit32(-2000000.5).PositBits, 0b1_0000001_11_0001011110110111111110); - Assert.AreEqual(new Posit32( + Assert.AreEqual( + new Posit32( 1.065291755432698054096667486857660145523165660824704316367306233814815641380846500396728515625E-38).PositBits, 0b0_0000000000000000000000000000001); Assert.AreEqual(new Posit32(2.7647944E+38).PositBits, 0b0_1111111111111111111111111111111); @@ -342,13 +344,17 @@ public void Posit32ToQuireIsCorrect() Assert.AreEqual(((Quire)posit1).Segments, (new Quire(new ulong[] { 1 }, 512) << 240).Segments); var positNegative1 = new Posit32(-1); - Assert.AreEqual(((Quire)positNegative1).Segments, - (new Quire(new ulong[] { 0, 0, 0, 0xFFFF000000000000, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, + Assert.AreEqual( + ((Quire)positNegative1).Segments, + (new Quire( + new ulong[] { 0, 0, 0, 0xFFFF000000000000, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue }, 512)).Segments); var positNegative3 = new Posit32(-3); - Assert.AreEqual(((Quire)positNegative3).Segments, - (new Quire(new ulong[] { 0, 0, 0, 0xFFFD000000000000, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, + Assert.AreEqual( + ((Quire)positNegative3).Segments, + (new Quire( + new ulong[] { 0, 0, 0, 0xFFFD000000000000, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue }, 512)).Segments); var positMax = new Posit32(0x7FFFFFFF, true); diff --git a/Lombiq.Arithmetics.Tests/PositTests/QuireTests.cs b/Lombiq.Arithmetics.Tests/PositTests/QuireTests.cs index 4edbfae..ceecbc3 100644 --- a/Lombiq.Arithmetics.Tests/PositTests/QuireTests.cs +++ b/Lombiq.Arithmetics.Tests/PositTests/QuireTests.cs @@ -10,63 +10,82 @@ public class QuireTests [Fact] public void QuireBitShiftLeftIsCorrect() { - Assert.AreEqual(new Quire(new ulong[] { 0x80000000 }).Segments, + Assert.AreEqual( + new Quire(new ulong[] { 0x80000000 }).Segments, (new Quire(new ulong[] { 1 }) << 31).Segments); - Assert.AreEqual(new Quire(new ulong[] { 0 }).Segments, + Assert.AreEqual( + new Quire(new ulong[] { 0 }).Segments, (new Quire(new ulong[] { 6 }) << -1).Segments); - Assert.AreEqual(new Quire(new ulong[] { 0, 0x8000000000000000 }).Segments, + Assert.AreEqual( + new Quire(new ulong[] { 0, 0x8000000000000000 }).Segments, (new Quire(new ulong[] { 1, 0 }) << 127).Segments); - Assert.AreEqual(new Quire(new ulong[] { 1 }).Segments, + Assert.AreEqual( + new Quire(new ulong[] { 1 }).Segments, (new Quire(new ulong[] { 0x00000001 }) << 64).Segments); - Assert.AreEqual(new Quire(new ulong[] { 0x80000000, 0x00000000 }).Segments, + Assert.AreEqual( + new Quire(new ulong[] { 0x80000000, 0x00000000 }).Segments, (new Quire(new ulong[] { 0x00800000, 0x00000000 }) << 8).Segments); - Assert.AreEqual(new Quire(new ulong[] { 0x200000000 }).Segments, + Assert.AreEqual( + new Quire(new ulong[] { 0x200000000 }).Segments, (new Quire(new ulong[] { 0x00000001 }) << -31).Segments); } [Fact] public void QuireBitShiftRightIsCorrect() { - Assert.AreEqual(new Quire(new ulong[] { 0x00800000, 0x00000000 }).Segments, + Assert.AreEqual( + new Quire(new ulong[] { 0x00800000, 0x00000000 }).Segments, (new Quire(new ulong[] { 0x80000000, 0x00000000 }) >> 8).Segments); - Assert.AreEqual(new Quire(new ulong[] { 1 }).Segments, + Assert.AreEqual( + new Quire(new ulong[] { 1 }).Segments, (new Quire(new ulong[] { 0x80000000 }) >> 31).Segments); - Assert.AreEqual(new Quire(new ulong[] { 1, 0 }).Segments, + Assert.AreEqual( + new Quire(new ulong[] { 1, 0 }).Segments, (new Quire(new ulong[] { 0, 0x8000000000000000 }) >> 127).Segments); - Assert.AreEqual(new Quire(new ulong[] { 0x1000000000000010, 0 }).Segments, + Assert.AreEqual( + new Quire(new ulong[] { 0x1000000000000010, 0 }).Segments, (new Quire(new ulong[] { 0x0000000000000100, 0x0000000000000001 }) >> 4).Segments); - Assert.AreEqual(new Quire(new ulong[] { 0x8000000000000000 }).Segments, + Assert.AreEqual( + new Quire(new ulong[] { 0x8000000000000000 }).Segments, (new Quire(new ulong[] { 0x8000000000000000 }) >> 64).Segments); - Assert.AreEqual(new Quire(new ulong[] { 0x4000000000000000 }).Segments, + Assert.AreEqual( + new Quire(new ulong[] { 0x4000000000000000 }).Segments, (new Quire(new ulong[] { 0x8000000000000000 }) >> -63).Segments); } [Fact] public void QuireAdditionIsCorrect() { - Assert.AreEqual(new Quire(new ulong[] { 5 }).Segments, + Assert.AreEqual( + new Quire(new ulong[] { 5 }).Segments, (new Quire(new ulong[] { 4 }) + new Quire(new ulong[] { 1 })).Segments); - Assert.AreEqual(new Quire(new ulong[] { 0, 2 }).Segments, + Assert.AreEqual( + new Quire(new ulong[] { 0, 2 }).Segments, (new Quire(new ulong[] { ulong.MaxValue, 1 }) + new Quire(new ulong[] { 1, 0 })).Segments); - Assert.AreEqual(new Quire(new ulong[] { 2, 0, 0, 1, 2 }).Segments, + Assert.AreEqual( + new Quire(new ulong[] { 2, 0, 0, 1, 2 }).Segments, (new Quire(new ulong[] { 1, 0, 0, 0, 1 }) + new Quire(new ulong[] { 1, 0, 0, 1, 1 })).Segments); } [Fact] public void QuireToIntegerAdditionIsCorrect() { - Assert.AreEqual(new Quire(new ulong[] { 5 }).Segments, + Assert.AreEqual( + new Quire(new ulong[] { 5 }).Segments, (new Quire(new ulong[] { 4 }) + 1).Segments); } [Fact] public void QuireSubtractionIsCorrect() { - Assert.AreEqual(new Quire(new ulong[] { 4 }).Segments, + Assert.AreEqual( + new Quire(new ulong[] { 4 }).Segments, (new Quire(new ulong[] { 5 }) - new Quire(new ulong[] { 1 })).Segments); - Assert.AreEqual(new Quire(new ulong[] { 1, 0, 0, 0, 1 }).Segments, + Assert.AreEqual( + new Quire(new ulong[] { 1, 0, 0, 0, 1 }).Segments, (new Quire(new ulong[] { 2, 0, 0, 1, 2 }) - new Quire(new ulong[] { 1, 0, 0, 1, 1 })).Segments); - Assert.AreEqual(new Quire(new ulong[] { ulong.MaxValue, 1 }).Segments, + Assert.AreEqual( + new Quire(new ulong[] { ulong.MaxValue, 1 }).Segments, (new Quire(new ulong[] { 0, 2 }) - new Quire(new ulong[] { 1, 0 })).Segments); } } diff --git a/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs b/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs index 6c7d1f5..4708396 100644 --- a/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs +++ b/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs @@ -108,7 +108,8 @@ public void UnumIsCorrectlyConstructedFromUintArray() 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[] + var bitMaskMinValue = new BitMask( + new uint[] { 0xFFFFE8FD , 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF , 0xFFFFFFFF, 0x200FEFFF @@ -120,7 +121,8 @@ public void UnumIsCorrectlyConstructedFromUintArray() for (int i = 0; i < 8; i++) maxValue[i] = uint.MaxValue; maxValue[7] >>= 1; - var bitMaskMaxValue = new BitMask(new uint[] + var bitMaskMaxValue = new BitMask( + new uint[] { 0xFFFFE8FD , 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF , 0xFFFFFFFF, 0xFEFFF diff --git a/Posit/Posit.cs b/Posit/Posit.cs index 572c07b..0e4530a 100644 --- a/Posit/Posit.cs +++ b/Posit/Posit.cs @@ -351,7 +351,8 @@ public static int CalculateScaleFactor(int regimeKValue, uint exponentValue, byt var resultRegimeKValue = scaleFactor / (1 << left.MaximumExponentSize); var resultExponentBits = new BitMask((uint)((scaleFactor % (1 << left.MaximumExponentSize))), left._environment.Size); - return new Posit(left._environment, + return new Posit( + left._environment, left.AssemblePositBitsWithRounding(resultSignBit, resultRegimeKValue, resultExponentBits, resultFractionBits)); } diff --git a/Unum/Unum.cs b/Unum/Unum.cs index a07884b..a3763f4 100644 --- a/Unum/Unum.cs +++ b/Unum/Unum.cs @@ -639,7 +639,8 @@ public static Unum AddExactUnums(Unum left, Unum right) scratchPad = left.FractionWithHiddenBit() << biggerBitsMovedToLeft; // Adding the aligned Fractions. - scratchPad = AddAlignedFractions(scratchPad, + scratchPad = AddAlignedFractions( + scratchPad, right.FractionWithHiddenBit() << smallerBitsMovedToLeft, signBitsMatch); } else // Right Exponent is bigger. @@ -655,7 +656,8 @@ public static Unum AddExactUnums(Unum left, Unum right) scratchPad = right.FractionWithHiddenBit() << biggerBitsMovedToLeft; // Adding the aligned Fractions. - scratchPad = AddAlignedFractions(scratchPad, + scratchPad = AddAlignedFractions( + scratchPad, left.FractionWithHiddenBit() << smallerBitsMovedToLeft, signBitsMatch); } From 87cf9f42b178a74ace253bad2c611074ed4bdc8a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Thu, 16 Dec 2021 19:40:14 +0100 Subject: [PATCH 09/49] Fix SA1117(The parameters should all be placed on the same line or each parameter should be placed on its own line). --- .../PositTests/Posit32Tests.cs | 8 +- .../UnumTests/UnumEnvironmentTests.cs | 106 +++++++++++++----- .../UnumTests/UnumTests.cs | 26 ++--- 3 files changed, 96 insertions(+), 44 deletions(-) diff --git a/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs b/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs index 3c55718..efc743a 100644 --- a/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs +++ b/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs @@ -347,15 +347,15 @@ public void Posit32ToQuireIsCorrect() Assert.AreEqual( ((Quire)positNegative1).Segments, (new Quire( - new ulong[] { 0, 0, 0, 0xFFFF000000000000, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, - ulong.MaxValue }, 512)).Segments); + new ulong[] { 0, 0, 0, 0xFFFF000000000000, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue }, 512)) + .Segments); var positNegative3 = new Posit32(-3); Assert.AreEqual( ((Quire)positNegative3).Segments, (new Quire( - new ulong[] { 0, 0, 0, 0xFFFD000000000000, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, - ulong.MaxValue }, 512)).Segments); + new ulong[] { 0, 0, 0, 0xFFFD000000000000, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue }, 512)) + .Segments); var positMax = new Posit32(0x7FFFFFFF, true); Assert.AreEqual(((Quire)positMax).Segments, (new Quire(new ulong[] { 1 }, 512) << 360).Segments); diff --git a/Lombiq.Arithmetics.Tests/UnumTests/UnumEnvironmentTests.cs b/Lombiq.Arithmetics.Tests/UnumTests/UnumEnvironmentTests.cs index fa0becd..a5a78b9 100644 --- a/Lombiq.Arithmetics.Tests/UnumTests/UnumEnvironmentTests.cs +++ b/Lombiq.Arithmetics.Tests/UnumTests/UnumEnvironmentTests.cs @@ -1,4 +1,4 @@ -using Xunit; +using Xunit; using Assert = Lombiq.Arithmetics.Tests.CompatibilityAssert; @@ -80,11 +80,15 @@ public void UnumSizeIsCorrect() public void UnumUncertaintyBitMaskIsCorrect() { // 0 0000 0000 0000 1 000 00 - Assert.AreEqual(new BitMask(new uint[] { 0x20 }, _unum_3_2.Size), _unum_3_2.UncertaintyBitMask, + Assert.AreEqual( + new BitMask(new uint[] { 0x20 }, _unum_3_2.Size), + _unum_3_2.UncertaintyBitMask, TestFailureMessageBuilder(_unum_3_2, nameof(_unum_3_2.UncertaintyBitMask))); // 0 0000 0000 0000 0000 0000 0000 1 000 0000 - Assert.AreEqual(new BitMask(new uint[] { 0x80, 0 }, _unum_3_4.Size), _unum_3_4.UncertaintyBitMask, + Assert.AreEqual( + new BitMask(new uint[] { 0x80, 0 }, _unum_3_4.Size), + _unum_3_4.UncertaintyBitMask, TestFailureMessageBuilder(_unum_3_4, nameof(_unum_3_4.UncertaintyBitMask))); } @@ -92,11 +96,15 @@ public void UnumUncertaintyBitMaskIsCorrect() public void UnumExponentSizeMaskIsCorrect() { // 0 0000 0000 0000 0 111 00 - Assert.AreEqual(new BitMask(new uint[] { 0x1C }, _unum_3_2.Size), _unum_3_2.ExponentSizeMask, + Assert.AreEqual( + new BitMask(new uint[] { 0x1C }, _unum_3_2.Size), + _unum_3_2.ExponentSizeMask, TestFailureMessageBuilder(_unum_3_2, nameof(_unum_3_2.ExponentSizeMask))); // 0 0000 0000 0000 0000 0000 0000 0 111 0000 - Assert.AreEqual(new BitMask(new uint[] { 0x70, 0 }, _unum_3_4.Size), _unum_3_4.ExponentSizeMask, + Assert.AreEqual( + new BitMask(new uint[] { 0x70, 0 }, _unum_3_4.Size), + _unum_3_4.ExponentSizeMask, TestFailureMessageBuilder(_unum_3_4, nameof(_unum_3_4.ExponentSizeMask))); } @@ -104,11 +112,15 @@ public void UnumExponentSizeMaskIsCorrect() public void UnumFractionSizeMaskIsCorrect() { // 0 0000 0000 0000 0 000 11 - Assert.AreEqual(new BitMask(new uint[] { 3 }, _unum_3_2.Size), _unum_3_2.FractionSizeMask, + Assert.AreEqual( + new BitMask(new uint[] { 3 }, _unum_3_2.Size), + _unum_3_2.FractionSizeMask, TestFailureMessageBuilder(_unum_3_2, nameof(_unum_3_2.FractionSizeMask))); // 0 0000 0000 0000 0000 0000 0000 0 000 1111 - Assert.AreEqual(new BitMask(new uint[] { 0xF, 0 }, _unum_3_4.Size), _unum_3_4.FractionSizeMask, + Assert.AreEqual( + new BitMask(new uint[] { 0xF, 0 }, _unum_3_4.Size), + _unum_3_4.FractionSizeMask, TestFailureMessageBuilder(_unum_3_4, nameof(_unum_3_4.FractionSizeMask))); } @@ -116,11 +128,15 @@ public void UnumFractionSizeMaskIsCorrect() public void UnumExponentAndFractionSizeMaskIsCorrect() { // 0 0000 0000 0000 0 111 11 - Assert.AreEqual(new BitMask(new uint[] { 0x1F }, _unum_3_2.Size), _unum_3_2.ExponentAndFractionSizeMask, + Assert.AreEqual( + new BitMask(new uint[] { 0x1F }, _unum_3_2.Size), + _unum_3_2.ExponentAndFractionSizeMask, TestFailureMessageBuilder(_unum_3_2, nameof(_unum_3_2.ExponentAndFractionSizeMask))); // 0 0000 0000 0000 0000 0000 0000 0 111 1111 - Assert.AreEqual(new BitMask(new uint[] { 0x7F, 0 }, _unum_3_4.Size), _unum_3_4.ExponentAndFractionSizeMask, + Assert.AreEqual( + new BitMask(new uint[] { 0x7F, 0 }, _unum_3_4.Size), + _unum_3_4.ExponentAndFractionSizeMask, TestFailureMessageBuilder(_unum_3_4, nameof(_unum_3_4.ExponentAndFractionSizeMask))); } @@ -128,11 +144,15 @@ public void UnumExponentAndFractionSizeMaskIsCorrect() public void UnumTagMaskIsCorrect() { // 0 0000 0000 0000 1 111 11 - Assert.AreEqual(new BitMask(new uint[] { 0x3F }, _unum_3_2.Size), _unum_3_2.UnumTagMask, + Assert.AreEqual( + new BitMask(new uint[] { 0x3F }, _unum_3_2.Size), + _unum_3_2.UnumTagMask, TestFailureMessageBuilder(_unum_3_2, nameof(_unum_3_2.UnumTagMask))); // 0 0000 0000 0000 0000 0000 0000 1 111 1111 - Assert.AreEqual(new BitMask(new uint[] { 0xFF, 0 }, _unum_3_4.Size), _unum_3_4.UnumTagMask, + Assert.AreEqual( + new BitMask(new uint[] { 0xFF, 0 }, + _unum_3_4.Size), _unum_3_4.UnumTagMask, TestFailureMessageBuilder(_unum_3_4, nameof(_unum_3_4.UnumTagMask))); } @@ -140,11 +160,15 @@ public void UnumTagMaskIsCorrect() public void UnumSignBitMaskIsCorrect() { // 1 0000 0000 0000 0 000 00 - Assert.AreEqual(new BitMask(new uint[] { 0x40000 }, _unum_3_2.Size), _unum_3_2.SignBitMask, + Assert.AreEqual( + new BitMask(new uint[] { 0x40000 }, _unum_3_2.Size), + _unum_3_2.SignBitMask, TestFailureMessageBuilder(_unum_3_2, nameof(_unum_3_2.SignBitMask))); // 1 0000 0000 0000 0000 0000 0000 0 000 0000 - Assert.AreEqual(new BitMask(new uint[] { 0, 1 }, _unum_3_4.Size), _unum_3_4.SignBitMask, + Assert.AreEqual( + new BitMask(new uint[] { 0, 1 }, _unum_3_4.Size), + _unum_3_4.SignBitMask, TestFailureMessageBuilder(_unum_3_4, nameof(_unum_3_4.SignBitMask))); } @@ -152,11 +176,15 @@ public void UnumSignBitMaskIsCorrect() public void UnumPositiveInfinityIsCorrect() { // 0 1111 1111 1111 0 111 11 - Assert.AreEqual(new BitMask(new uint[] { 0x3FFDF }, _unum_3_2.Size), _unum_3_2.PositiveInfinity, + Assert.AreEqual( + new BitMask(new uint[] { 0x3FFDF }, _unum_3_2.Size), + _unum_3_2.PositiveInfinity, TestFailureMessageBuilder(_unum_3_2, nameof(_unum_3_2.PositiveInfinity))); // 0 1111 1111 1111 1111 1111 1111 0 111 1111 - Assert.AreEqual(new BitMask(new uint[] { 0xFFFFFF7F, 0 }, _unum_3_4.Size), _unum_3_4.PositiveInfinity, + Assert.AreEqual( + new BitMask(new uint[] { 0xFFFFFF7F, 0 }, _unum_3_4.Size), + _unum_3_4.PositiveInfinity, TestFailureMessageBuilder(_unum_3_4, nameof(_unum_3_4.PositiveInfinity))); } @@ -164,11 +192,15 @@ public void UnumPositiveInfinityIsCorrect() public void UnumNegativeInfinityIsCorrect() { // 1 1111 1111 1111 0 111 11 - Assert.AreEqual(new BitMask(new uint[] { 0x7FFDF }, _unum_3_2.Size), _unum_3_2.NegativeInfinity, + Assert.AreEqual( + new BitMask(new uint[] { 0x7FFDF }, _unum_3_2.Size), + _unum_3_2.NegativeInfinity, TestFailureMessageBuilder(_unum_3_2, nameof(_unum_3_2.NegativeInfinity))); // 1 1111 1111 1111 1111 1111 1111 0 111 1111 - Assert.AreEqual(new BitMask(new uint[] { 0xFFFFFF7F, 1 }, _unum_3_4.Size), _unum_3_4.NegativeInfinity, + Assert.AreEqual( + new BitMask(new uint[] { 0xFFFFFF7F, 1 }, _unum_3_4.Size), + _unum_3_4.NegativeInfinity, TestFailureMessageBuilder(_unum_3_4, nameof(_unum_3_4.NegativeInfinity))); } @@ -176,11 +208,15 @@ public void UnumNegativeInfinityIsCorrect() public void UnumQuietNotANumberIsCorrect() { // 0 1111 1111 1111 1 111 11 - Assert.AreEqual(new BitMask(new uint[] { 0x3FFFF }, _unum_3_2.Size), _unum_3_2.QuietNotANumber, + Assert.AreEqual( + new BitMask(new uint[] { 0x3FFFF }, _unum_3_2.Size), + _unum_3_2.QuietNotANumber, TestFailureMessageBuilder(_unum_3_2, nameof(_unum_3_2.QuietNotANumber))); // 0 1111 1111 1111 1111 1111 1111 1 111 1111 - Assert.AreEqual(new BitMask(new uint[] { 0xFFFFFFFF, 0 }, _unum_3_4.Size), _unum_3_4.QuietNotANumber, + Assert.AreEqual( + new BitMask(new uint[] { 0xFFFFFFFF, 0 }, _unum_3_4.Size), + _unum_3_4.QuietNotANumber, TestFailureMessageBuilder(_unum_3_4, nameof(_unum_3_4.QuietNotANumber))); } @@ -188,11 +224,15 @@ public void UnumQuietNotANumberIsCorrect() public void UnumSignalingNotANumberIsCorrect() { // 1 1111 1111 1111 1 111 11 - Assert.AreEqual(new BitMask(new uint[] { 0x7FFFF }, _unum_3_2.Size), _unum_3_2.SignalingNotANumber, + Assert.AreEqual( + new BitMask(new uint[] { 0x7FFFF }, _unum_3_2.Size), + _unum_3_2.SignalingNotANumber, TestFailureMessageBuilder(_unum_3_2, nameof(_unum_3_2.SignalingNotANumber))); // 1 1111 1111 1111 1111 1111 1111 1 111 1111 - Assert.AreEqual(new BitMask(new uint[] { 0xFFFFFFFF, 1 }, _unum_3_4.Size), _unum_3_4.SignalingNotANumber, + Assert.AreEqual( + new BitMask(new uint[] { 0xFFFFFFFF, 1 }, _unum_3_4.Size), + _unum_3_4.SignalingNotANumber, TestFailureMessageBuilder(_unum_3_4, nameof(_unum_3_4.SignalingNotANumber))); } @@ -200,11 +240,15 @@ public void UnumSignalingNotANumberIsCorrect() public void UnumLargestPositiveIsCorrect() { // 0 1111 1111 1110 0 111 11 - Assert.AreEqual(new BitMask(new uint[] { 0x3FF9F }, _unum_3_2.Size), _unum_3_2.LargestPositive, + Assert.AreEqual( + new BitMask(new uint[] { 0x3FF9F }, _unum_3_2.Size), + _unum_3_2.LargestPositive, TestFailureMessageBuilder(_unum_3_2, nameof(_unum_3_2.LargestPositive))); // 0 1111 1111 1111 1111 1111 1110 0 111 1111 - Assert.AreEqual(new BitMask(new uint[] { 0xFFFFFE7F, 0 }, _unum_3_4.Size), _unum_3_4.LargestPositive, + Assert.AreEqual( + new BitMask(new uint[] { 0xFFFFFE7F, 0 }, _unum_3_4.Size), + _unum_3_4.LargestPositive, TestFailureMessageBuilder(_unum_3_4, nameof(_unum_3_4.LargestPositive))); } @@ -212,11 +256,15 @@ public void UnumLargestPositiveIsCorrect() public void UnumSmallestPositiveIsCorrect() { // 0 0000 0000 0001 0 111 11 - Assert.AreEqual(new BitMask(new uint[] { 0x5F }, _unum_3_2.Size), _unum_3_2.SmallestPositive, + Assert.AreEqual( + new BitMask(new uint[] { 0x5F }, _unum_3_2.Size), + _unum_3_2.SmallestPositive, TestFailureMessageBuilder(_unum_3_2, nameof(_unum_3_2.SmallestPositive))); // 0 0000 0000 0000 0000 0000 0001 0 111 1111 - Assert.AreEqual(new BitMask(new uint[] { 0x17F, 0 }, _unum_3_4.Size), _unum_3_4.SmallestPositive, + Assert.AreEqual( + new BitMask(new uint[] { 0x17F, 0 }, _unum_3_4.Size), + _unum_3_4.SmallestPositive, TestFailureMessageBuilder(_unum_3_4, nameof(_unum_3_4.SmallestPositive))); } @@ -224,11 +272,15 @@ public void UnumSmallestPositiveIsCorrect() public void UnumLargestNegativeIsCorrect() { // 1 1111 1111 1110 0 111 11 - Assert.AreEqual(new BitMask(new uint[] { 0x7FF9F }, _unum_3_2.Size), _unum_3_2.LargestNegative, + Assert.AreEqual( + new BitMask(new uint[] { 0x7FF9F }, _unum_3_2.Size), + _unum_3_2.LargestNegative, TestFailureMessageBuilder(_unum_3_2, nameof(_unum_3_2.LargestNegative))); // 1 1111 1111 1111 1111 1111 1110 0 111 1111 - Assert.AreEqual(new BitMask(new uint[] { 0xFFFFFE7F, 1 }, _unum_3_4.Size), _unum_3_4.LargestNegative, + Assert.AreEqual( + new BitMask(new uint[] { 0xFFFFFE7F, 1 }, + _unum_3_4.Size), _unum_3_4.LargestNegative, TestFailureMessageBuilder(_unum_3_4, nameof(_unum_3_4.LargestNegative))); } diff --git a/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs b/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs index 4708396..0f0bf35 100644 --- a/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs +++ b/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs @@ -1,4 +1,4 @@ -using Xunit; +using Xunit; using Assert = Lombiq.Arithmetics.Tests.CompatibilityAssert; @@ -110,11 +110,11 @@ public void UnumIsCorrectlyConstructedFromUintArray() 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); + { + 0xFFFFE8FD , 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, + 0xFFFFFFFF , 0xFFFFFFFF, 0x200FEFFF + }, + _environment_4_8.Size); Assert.AreEqual(unumMin.UnumBits, bitMaskMinValue); var maxValue = new uint[8]; @@ -122,12 +122,12 @@ public void UnumIsCorrectlyConstructedFromUintArray() maxValue[7] >>= 1; var bitMaskMaxValue = new BitMask( - new uint[] - { - 0xFFFFE8FD , 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, - 0xFFFFFFFF , 0xFFFFFFFF, 0xFEFFF - - }, _environment_4_8.Size); + 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); @@ -727,4 +727,4 @@ public void UnumToFloatIsCorrect() //} } -} \ No newline at end of file +} From 1c0fcbbb1f8a4349e61034e4ae8eeb3b28b2a993 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Thu, 16 Dec 2021 22:01:25 +0100 Subject: [PATCH 10/49] Fix SA1413(Use trailing comma in multi-line initializers) --- Lombiq.Arithmetics.Tests/BitMaskTests.cs | 4 ++-- Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs | 4 ++-- Unum/UnumConfiguration.cs | 2 +- Unum/UnumEnvironment.cs | 2 +- 4 files changed, 6 insertions(+), 6 deletions(-) diff --git a/Lombiq.Arithmetics.Tests/BitMaskTests.cs b/Lombiq.Arithmetics.Tests/BitMaskTests.cs index 8ae30f9..48afc61 100644 --- a/Lombiq.Arithmetics.Tests/BitMaskTests.cs +++ b/Lombiq.Arithmetics.Tests/BitMaskTests.cs @@ -35,7 +35,7 @@ public void BitMaskSizeIsCorrectlySetWithSegments() Tuple.Create(new BitMask(new uint[] { 2, 2 }), 64U), Tuple.Create(new BitMask(new uint[] { 3, 3, 3 }), 96U), Tuple.Create(new BitMask(new uint[] { 4, 4, 4, 4 }), 128U), - Tuple.Create(new BitMask(new uint[] { 0 }, 222), 222U) + Tuple.Create(new BitMask(new uint[] { 0 }, 222), 222U), }; foreach (var item in sizesAndSegmentCounts) item.Item2.ShouldBe(item.Item1.Size, $"Mask: {item.Item1}"); @@ -66,7 +66,7 @@ public void BitMaskConstructorCorrectlyCopiesBitMask() { var masks = new BitMask[] { - new BitMask(new uint[] { 0x42, 0x42 }), new BitMask(new uint[] { 0x88, 0x88, 0x88 }) + new BitMask(new uint[] { 0x42, 0x42 }), new BitMask(new uint[] { 0x88, 0x88, 0x88 }), }; foreach (var mask in masks) mask.ShouldBe(new BitMask(mask)); diff --git a/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs b/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs index 0f0bf35..b2dc639 100644 --- a/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs +++ b/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs @@ -112,7 +112,7 @@ public void UnumIsCorrectlyConstructedFromUintArray() new uint[] { 0xFFFFE8FD , 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, - 0xFFFFFFFF , 0xFFFFFFFF, 0x200FEFFF + 0xFFFFFFFF , 0xFFFFFFFF, 0x200FEFFF, }, _environment_4_8.Size); Assert.AreEqual(unumMin.UnumBits, bitMaskMinValue); @@ -125,7 +125,7 @@ public void UnumIsCorrectlyConstructedFromUintArray() new uint[] { 0xFFFFE8FD , 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, - 0xFFFFFFFF , 0xFFFFFFFF, 0xFEFFF + 0xFFFFFFFF , 0xFFFFFFFF, 0xFEFFF, }, _environment_4_8.Size); var unumMax = new Unum(_environment_4_8, maxValue); diff --git a/Unum/UnumConfiguration.cs b/Unum/UnumConfiguration.cs index bb1d249..5e703b2 100644 --- a/Unum/UnumConfiguration.cs +++ b/Unum/UnumConfiguration.cs @@ -44,6 +44,6 @@ public enum IeeeConfiguration SinglePrecision, // 32-bit. DoublePrecision, // 64-bit. ExtendedPrecision, // 80-bit (Intel x87). - QuadPrecision // 128-bit. + QuadPrecision, // 128-bit. } } \ No newline at end of file diff --git a/Unum/UnumEnvironment.cs b/Unum/UnumEnvironment.cs index 0cb42e2..7cb50ff 100644 --- a/Unum/UnumEnvironment.cs +++ b/Unum/UnumEnvironment.cs @@ -204,6 +204,6 @@ public enum StandardEnvironment SinglePrecisionLike, // 50-bit. DoublePrecisionLike, // 92-bit. ExtendedPrecisionLike, // 92-bit. - QuadPrecisionLike // 157-bit. + QuadPrecisionLike, // 157-bit. } } From b3bc24779f86302851ac4f417df6e5ff4741f8b3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Thu, 16 Dec 2021 22:22:38 +0100 Subject: [PATCH 11/49] Fix QuireTests. --- .../PositTests/QuireTests.cs | 49 +++++++++---------- 1 file changed, 23 insertions(+), 26 deletions(-) diff --git a/Lombiq.Arithmetics.Tests/PositTests/QuireTests.cs b/Lombiq.Arithmetics.Tests/PositTests/QuireTests.cs index ceecbc3..34fef8b 100644 --- a/Lombiq.Arithmetics.Tests/PositTests/QuireTests.cs +++ b/Lombiq.Arithmetics.Tests/PositTests/QuireTests.cs @@ -6,28 +6,27 @@ namespace Lombiq.Arithmetics.Tests { public class QuireTests { - [Fact] public void QuireBitShiftLeftIsCorrect() { Assert.AreEqual( new Quire(new ulong[] { 0x80000000 }).Segments, - (new Quire(new ulong[] { 1 }) << 31).Segments); + (new Quire(new ulong[] { 1 }) << 31).Segments); Assert.AreEqual( new Quire(new ulong[] { 0 }).Segments, (new Quire(new ulong[] { 6 }) << -1).Segments); Assert.AreEqual( - new Quire(new ulong[] { 0, 0x8000000000000000 }).Segments, - (new Quire(new ulong[] { 1, 0 }) << 127).Segments); + new Quire(new ulong[] { 0, 0x_8000_0000_0000_0000 }).Segments, + (new Quire(new ulong[] { 1, 0 }) << 127).Segments); Assert.AreEqual( new Quire(new ulong[] { 1 }).Segments, - (new Quire(new ulong[] { 0x00000001 }) << 64).Segments); + (new Quire(new ulong[] { 0x00000001 }) << 64).Segments); Assert.AreEqual( new Quire(new ulong[] { 0x80000000, 0x00000000 }).Segments, - (new Quire(new ulong[] { 0x00800000, 0x00000000 }) << 8).Segments); + (new Quire(new ulong[] { 0x00800000, 0x00000000 }) << 8).Segments); Assert.AreEqual( new Quire(new ulong[] { 0x200000000 }).Segments, - (new Quire(new ulong[] { 0x00000001 }) << -31).Segments); + (new Quire(new ulong[] { 0x00000001 }) << -31).Segments); } [Fact] @@ -35,22 +34,22 @@ public void QuireBitShiftRightIsCorrect() { Assert.AreEqual( new Quire(new ulong[] { 0x00800000, 0x00000000 }).Segments, - (new Quire(new ulong[] { 0x80000000, 0x00000000 }) >> 8).Segments); + (new Quire(new ulong[] { 0x80000000, 0x00000000 }) >> 8).Segments); Assert.AreEqual( new Quire(new ulong[] { 1 }).Segments, - (new Quire(new ulong[] { 0x80000000 }) >> 31).Segments); + (new Quire(new ulong[] { 0x80000000 }) >> 31).Segments); Assert.AreEqual( new Quire(new ulong[] { 1, 0 }).Segments, - (new Quire(new ulong[] { 0, 0x8000000000000000 }) >> 127).Segments); + (new Quire(new ulong[] { 0, 0x_8000_0000_0000_0000 }) >> 127).Segments); Assert.AreEqual( - new Quire(new ulong[] { 0x1000000000000010, 0 }).Segments, - (new Quire(new ulong[] { 0x0000000000000100, 0x0000000000000001 }) >> 4).Segments); + new Quire(new ulong[] { 1_152_921_504_606_846_992, 0 }).Segments, + (new Quire(new ulong[] { 0x_0000_0000_0000_0100, 0x_0000_0000_0000_0001 }) >> 4).Segments); Assert.AreEqual( - new Quire(new ulong[] { 0x8000000000000000 }).Segments, - (new Quire(new ulong[] { 0x8000000000000000 }) >> 64).Segments); + new Quire(new[] { 0x_8000_0000_0000_0000 }).Segments, + (new Quire(new[] { 0x_8000_0000_0000_0000 }) >> 64).Segments); Assert.AreEqual( - new Quire(new ulong[] { 0x4000000000000000 }).Segments, - (new Quire(new ulong[] { 0x8000000000000000 }) >> -63).Segments); + new Quire(new ulong[] { 0x_4000_0000_0000_0000 }).Segments, + (new Quire(new[] { 0x_8000_0000_0000_0000 }) >> -63).Segments); } [Fact] @@ -58,35 +57,33 @@ public void QuireAdditionIsCorrect() { Assert.AreEqual( new Quire(new ulong[] { 5 }).Segments, - (new Quire(new ulong[] { 4 }) + new Quire(new ulong[] { 1 })).Segments); + (new Quire(new ulong[] { 4 }) + new Quire(new ulong[] { 1 })).Segments); Assert.AreEqual( new Quire(new ulong[] { 0, 2 }).Segments, - (new Quire(new ulong[] { ulong.MaxValue, 1 }) + new Quire(new ulong[] { 1, 0 })).Segments); + (new Quire(new ulong[] { ulong.MaxValue, 1 }) + new Quire(new ulong[] { 1, 0 })).Segments); Assert.AreEqual( new Quire(new ulong[] { 2, 0, 0, 1, 2 }).Segments, - (new Quire(new ulong[] { 1, 0, 0, 0, 1 }) + new Quire(new ulong[] { 1, 0, 0, 1, 1 })).Segments); + (new Quire(new ulong[] { 1, 0, 0, 0, 1 }) + new Quire(new ulong[] { 1, 0, 0, 1, 1 })).Segments); } [Fact] - public void QuireToIntegerAdditionIsCorrect() - { + public void QuireToIntegerAdditionIsCorrect() => Assert.AreEqual( new Quire(new ulong[] { 5 }).Segments, - (new Quire(new ulong[] { 4 }) + 1).Segments); - } + (new Quire(new ulong[] { 4 }) + 1).Segments); [Fact] public void QuireSubtractionIsCorrect() { Assert.AreEqual( new Quire(new ulong[] { 4 }).Segments, - (new Quire(new ulong[] { 5 }) - new Quire(new ulong[] { 1 })).Segments); + (new Quire(new ulong[] { 5 }) - new Quire(new ulong[] { 1 })).Segments); Assert.AreEqual( new Quire(new ulong[] { 1, 0, 0, 0, 1 }).Segments, - (new Quire(new ulong[] { 2, 0, 0, 1, 2 }) - new Quire(new ulong[] { 1, 0, 0, 1, 1 })).Segments); + (new Quire(new ulong[] { 2, 0, 0, 1, 2 }) - new Quire(new ulong[] { 1, 0, 0, 1, 1 })).Segments); Assert.AreEqual( new Quire(new ulong[] { ulong.MaxValue, 1 }).Segments, - (new Quire(new ulong[] { 0, 2 }) - new Quire(new ulong[] { 1, 0 })).Segments); + (new Quire(new ulong[] { 0, 2 }) - new Quire(new ulong[] { 1, 0 })).Segments); } } } From 274d2828dc535fdcbe9d332dfec91855cb50dd51 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Thu, 16 Dec 2021 22:23:22 +0100 Subject: [PATCH 12/49] Fix S2148 (Add underscores to this numeric value for readability). --- .../PositTests/Posit32Tests.cs | 150 +++++++++--------- .../PositTests/PositTests.cs | 2 +- .../UnumTests/UnumTests.cs | 6 +- Posit/Posit32.cs | 16 +- Posit/Quire.cs | 4 +- 5 files changed, 89 insertions(+), 89 deletions(-) diff --git a/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs b/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs index efc743a..64601a3 100644 --- a/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs +++ b/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs @@ -13,42 +13,42 @@ public class Posit32Tests [Fact] public void EncodeRegimeBitsIsCorrect() { - Assert.AreEqual(Posit32.EncodeRegimeBits(0), 0x40000000); - Assert.AreEqual(Posit32.EncodeRegimeBits(1), 0x60000000); - Assert.AreEqual(Posit32.EncodeRegimeBits(2), 0x70000000); - Assert.AreEqual(Posit32.EncodeRegimeBits(-3), 0x8000000); - Assert.AreEqual(Posit32.EncodeRegimeBits(-30), 0x00000001); - Assert.AreEqual(Posit32.EncodeRegimeBits(30), 0x7FFFFFFF); + Assert.AreEqual(Posit32.EncodeRegimeBits(0), 0x_4000_0000); + Assert.AreEqual(Posit32.EncodeRegimeBits(1), 0x_6000_0000); + Assert.AreEqual(Posit32.EncodeRegimeBits(2), 0x_7000_0000); + Assert.AreEqual(Posit32.EncodeRegimeBits(-3), 0x_800_0000); + Assert.AreEqual(Posit32.EncodeRegimeBits(-30), 0x_0000_0001); + Assert.AreEqual(Posit32.EncodeRegimeBits(30), 0x_7FFF_FFFF); } [Fact] public void Posit32IsCorrectlyConstructedFromInt() { - Assert.AreEqual(new Posit32(0).PositBits, 0x00000000); + Assert.AreEqual(new Posit32(0).PositBits, 0x_0000_0000); - Assert.AreEqual(new Posit32(1).PositBits, 0x40000000); + Assert.AreEqual(new Posit32(1).PositBits, 0x_4000_0000); - Assert.AreEqual(new Posit32(-1).PositBits, 0xC0000000); + Assert.AreEqual(new Posit32(-1).PositBits, 0x_C000_0000); - Assert.AreEqual(new Posit32(2).PositBits, 0x48000000); + Assert.AreEqual(new Posit32(2).PositBits, 0x_4800_0000); - Assert.AreEqual(new Posit32(13).PositBits, 0x5D000000); + Assert.AreEqual(new Posit32(13).PositBits, 0x_5D00_0000); - Assert.AreEqual(new Posit32(17).PositBits, 0x60400000); + Assert.AreEqual(new Posit32(17).PositBits, 0x_6040_0000); - Assert.AreEqual(new Posit32(500).PositBits, 0x71E80000); + Assert.AreEqual(new Posit32(500).PositBits, 0x_71E8_0000); - Assert.AreEqual(new Posit32(100).PositBits, 0b01101010010000000000000000000000); + Assert.AreEqual(new Posit32(100).PositBits, 0b_01101010_01000000_00000000_00000000); - Assert.AreEqual(new Posit32(-500).PositBits, 0x8E180000); + Assert.AreEqual(new Posit32(-500).PositBits, 0x_8E18_0000); - Assert.AreEqual(new Posit32(-499).PositBits, 0x8E1A0000); + Assert.AreEqual(new Posit32(-499).PositBits, 0x_8E1A_0000); - Assert.AreEqual(new Posit32(int.MaxValue).PositBits, 0b_0_111111110_11_00000000000000000000); + Assert.AreEqual(new Posit32(int.MaxValue).PositBits, 0b_01111111_10110000_00000000_00000000); - Assert.AreEqual(new Posit32(int.MinValue).PositBits, 0b_1_000000001_01_00000000000000000000); + Assert.AreEqual(new Posit32(int.MinValue).PositBits, 0b_10000000_01010000_00000000_00000000); - Assert.AreEqual(new Posit32(int.MaxValue - 1).PositBits, 0b_0_1111111101100000000000000000000); + Assert.AreEqual(new Posit32(int.MaxValue - 1).PositBits, 0b_01111111_10110000_00000000_00000000); } [Fact] @@ -62,7 +62,7 @@ public void Posit32AdditionIsCorrect() var posit0 = posit1 - 1; posit0.PositBits.ShouldBe(new Posit32(0).PositBits); var positNegative_1 = posit0 - 1; - positNegative_1.PositBits.ShouldBe(0xC0000000); + positNegative_1.PositBits.ShouldBe(0x_C000_0000); var positNegative_500 = new Posit32(-500); var positNegative_499 = positNegative_500 + 1; @@ -74,10 +74,10 @@ public void Posit32AdditionIsCorrect() var posit3 = new Posit32(100.0125F); var posit4 = posit3 - 100; - posit4.PositBits.ShouldBe(new Posit32(0b00010110011001100000000000000000, true).PositBits); + posit4.PositBits.ShouldBe(new Posit32(0b_00010110_01100110_00000000_00000000, true).PositBits); (new Posit32(500) + new Posit32(-500)).PositBits.ShouldBe(new Posit32(0).PositBits); - (new Posit32(99988) + new Posit32(-88999)).PositBits.ShouldBe(new Posit32(10989).PositBits); + (new Posit32(99_988) + new Posit32(-88_999)).PositBits.ShouldBe(new Posit32(10_989).PositBits); (new Posit32(0.75F) + new Posit32(0.75F)).PositBits.ShouldBe(new Posit32(1.5F).PositBits); (new Posit32(4F) + new Posit32(-3.75F)).PositBits.ShouldBe(new Posit32(0.25F).PositBits); } @@ -87,19 +87,19 @@ public void Posit32AdditionIsCorrectForPositives() { var posit1 = new Posit32(1); - for (var i = 1; i < 50000; i++) + for (var i = 1; i < 50_000; i++) { posit1 += 1; } - posit1.PositBits.ShouldBe(new Posit32(50000).PositBits); + posit1.PositBits.ShouldBe(new Posit32(50_000).PositBits); } [Fact] public void Posit32LengthOfRunOfBitsIsCorrect() { Assert.AreEqual(Posit32.LengthOfRunOfBits(1, 31), 30); - Assert.AreEqual(Posit32.LengthOfRunOfBits(0x60000000, 31), 2); - Assert.AreEqual(Posit32.LengthOfRunOfBits(0b00010000100011110101001111000101, 31), 2); + Assert.AreEqual(Posit32.LengthOfRunOfBits(0x_6000_0000, 31), 2); + Assert.AreEqual(Posit32.LengthOfRunOfBits(0b_00010000_10001111_01010011_11000101, 31), 2); } [Fact] @@ -133,7 +133,7 @@ public void Posit32MultiplicationIsCorrect() var posit3 = new Posit32(0.1F); posit3 *= new Posit32(0.01F); - posit3.PositBits.ShouldBe(new Posit32(0b00001100000011000100100110111010, true).PositBits); + posit3.PositBits.ShouldBe(new Posit32(0b_00001100_00001100_01001001_10111010, true).PositBits); var posit55 = new Posit32(int.MaxValue - 1); posit55 *= new Posit32(0.25F); @@ -142,11 +142,11 @@ public void Posit32MultiplicationIsCorrect() posit55 *= new Posit32(0); posit55.PositBits.ShouldBe(new Posit32(0).PositBits); - var positReal1 = new Posit32(0b01000000000000000011010001101110, true); - var positReal2 = new Posit32(0b01000000000000000011010001101110, true); + var positReal1 = new Posit32(0b_01000000_00000000_00110100_01101110, true); + var positReal2 = new Posit32(0b_01000000_00000000_00110100_01101110, true); var pr3 = positReal1 * positReal2; - Assert.AreEqual(pr3.PositBits, 0b01000000000000000110100011011101); + Assert.AreEqual(pr3.PositBits, 0b_01000000_00000000_01101000_11011101); } [Fact] @@ -167,26 +167,26 @@ public void Posit32DivisionIsCorrect() posit55 /= new Posit32(0); posit55.PositBits.ShouldBe(new Posit32(Posit32.NaNBitMask, true).PositBits); - var posit12345 = new Posit32(12345); + var posit12345 = new Posit32(12_345); posit12345 /= 100; - posit12345.PositBits.ShouldBe(new Posit32(0b01101011101101110011001100110011, true).PositBits); + posit12345.PositBits.ShouldBe(new Posit32(0b_01101011_10110111_00110011_00110011, true).PositBits); - var positBig = new Posit32(5000000); - positBig /= 1000000; + var positBig = new Posit32(5_000_000); + positBig /= 1_000_000; positBig.PositBits.ShouldBe(new Posit32(5).PositBits); - var positBig2 = new Posit32(50000000); - positBig2 /= 50000000; + var positBig2 = new Posit32(50_000_000); + positBig2 /= 50_000_000; positBig2.PositBits.ShouldBe(new Posit32(1).PositBits); var positSmall = new Posit32(0.02F); positSmall /= new Posit32(0.05F); - positSmall.PositBits.ShouldBe(new Posit32(0b00110100110011001100110011000101, true).PositBits); + positSmall.PositBits.ShouldBe(new Posit32(0b_00110100_11001100_11001100_11000101, true).PositBits); var positSmall2 = new Posit32(0.1F); positSmall2 /= 100; - positSmall2.PositBits.ShouldBe(new Posit32(0b00001100000011000100100110111011, true).PositBits); + positSmall2.PositBits.ShouldBe(new Posit32(0b_00001100_00001100_01001001_10111011, true).PositBits); } [Fact] @@ -201,58 +201,58 @@ public void Posit32ToIntIsCorrect() var posit8 = new Posit32(8); Assert.AreEqual((int)posit8, 8); - var posit16384 = new Posit32(16384); - Assert.AreEqual((int)posit16384, 16384); + var posit16384 = new Posit32(16_384); + Assert.AreEqual((int)posit16384, 16_384); var positNegative_13 = new Posit32(-13); Assert.AreEqual((int)positNegative_13, -13); var positIntMaxValue = new Posit32(int.MaxValue); Assert.AreEqual((int)positIntMaxValue, int.MaxValue); - var positCloseToIntMaxValue = new Posit32(2147481600); - Assert.AreEqual((int)positCloseToIntMaxValue, 2147481600); + var positCloseToIntMaxValue = new Posit32(2_147_481_600); + Assert.AreEqual((int)positCloseToIntMaxValue, 2_147_481_600); } [Fact] public void Posit32IsCorrectlyConstructedFromFloat() { - Assert.AreEqual(new Posit32(0F).PositBits, 0x00000000); - Assert.AreEqual(new Posit32(-0F).PositBits, 0x00000000); - Assert.AreEqual(new Posit32(0.75F).PositBits, 0b0_01111_00_000000000000000000000000); + Assert.AreEqual(new Posit32(0F).PositBits, 0x_0000_0000); + Assert.AreEqual(new Posit32(-0F).PositBits, 0x_0000_0000); + Assert.AreEqual(new Posit32(0.75F).PositBits, 0b_00111100_00000000_00000000_00000000); - Assert.AreEqual(new Posit32(0.0500000007450580596923828125F).PositBits, 0b0_001_11_10011001100110011001101000); - Assert.AreEqual(new Posit32(-0.00179999996908009052276611328125F).PositBits, 0b1_1110_01_0010100000100100000011000); + Assert.AreEqual(new Posit32(0.0500000007450580596923828125F).PositBits, 0b_00011110_01100110_01100110_01101000); + Assert.AreEqual(new Posit32(-0.00179999996908009052276611328125F).PositBits, 0b_11110010_01010000_01001000_00011000); - Assert.AreEqual(new Posit32(-134.75F).PositBits, 0x93CA0000); - Assert.AreEqual(new Posit32(100000.5F).PositBits, 0b0_111110_00_10000110101000001000000); - Assert.AreEqual(new Posit32(-2000000.5F).PositBits, 0b1_0000001_11_0001011110110111111110); + Assert.AreEqual(new Posit32(-134.75F).PositBits, 0x_93CA_0000); + Assert.AreEqual(new Posit32(100000.5F).PositBits, 0b_01111100_01000011_01010000_01000000); + Assert.AreEqual(new Posit32(-2000000.5F).PositBits, 0b_10000001_11000101_11101101_11111110); Assert.AreEqual( new Posit32( 1.065291755432698054096667486857660145523165660824704316367306233814815641380846500396728515625E-38F).PositBits, - 0b0_0000000000000000000000000000001); - Assert.AreEqual(new Posit32(2.7647944E+38F).PositBits, 0b0_1111111111111111111111111111111); + 0b_00000000_00000000_00000000_00000001); + Assert.AreEqual(new Posit32(2.7647944E+38F).PositBits, 0b_01111111_11111111_11111111_11111111); } [Fact] public void Posit32IsCorrectlyConstructedFromDouble() { - Assert.AreEqual(new Posit32(0D).PositBits, 0x00000000); - Assert.AreEqual(new Posit32(-0D).PositBits, 0x00000000); - Assert.AreEqual(new Posit32(0.75).PositBits, 0b0_01111_00_000000000000000000000000); + Assert.AreEqual(new Posit32(0D).PositBits, 0x_0000_0000); + Assert.AreEqual(new Posit32(-0D).PositBits, 0x_0000_0000); + Assert.AreEqual(new Posit32(0.75).PositBits, 0b_00111100_00000000_00000000_00000000); - Assert.AreEqual(new Posit32(0.0500000007450580596923828125).PositBits, 0b00011110011001100110011001101000); - Assert.AreEqual(new Posit32(-0.00179999996908009052276611328125).PositBits, 0b1_1110010010100000100100000011000); + Assert.AreEqual(new Posit32(0.0500000007450580596923828125).PositBits, 0b_00011110_01100110_01100110_01101000); + Assert.AreEqual(new Posit32(-0.00179999996908009052276611328125).PositBits, 0b_11110010_01010000_01001000_00011000); - Assert.AreEqual(new Posit32(-134.75).PositBits, 0b10010011110010100000000000000000); - Assert.AreEqual(new Posit32(100000.5).PositBits, 0b0_111110_00_10000110101000001000000); - Assert.AreEqual(new Posit32(-2000000.5).PositBits, 0b1_0000001_11_0001011110110111111110); + Assert.AreEqual(new Posit32(-134.75).PositBits, 0b_10010011_11001010_00000000_00000000); + Assert.AreEqual(new Posit32(100000.5).PositBits, 0b_01111100_01000011_01010000_01000000); + Assert.AreEqual(new Posit32(-2000000.5).PositBits, 0b_10000001_11000101_11101101_11111110); Assert.AreEqual( new Posit32( 1.065291755432698054096667486857660145523165660824704316367306233814815641380846500396728515625E-38).PositBits, - 0b0_0000000000000000000000000000001); - Assert.AreEqual(new Posit32(2.7647944E+38).PositBits, 0b0_1111111111111111111111111111111); + 0b_00000000_00000000_00000000_00000001); + Assert.AreEqual(new Posit32(2.7647944E+38).PositBits, 0b_01111111_11111111_11111111_11111111); } [Fact] @@ -261,8 +261,8 @@ public void Posit32ToFloatIsCorrect() var posit1 = new Posit32(1); Assert.AreEqual((float)posit1, 1); - var positNegative_1234 = new Posit32(-1234); - Assert.AreEqual((float)positNegative_1234, -1234); + var positNegative_1234 = new Posit32(-1_234); + Assert.AreEqual((float)positNegative_1234, -1_234); var posit3 = new Posit32(0.75F); Assert.AreEqual((float)posit3, 0.75); @@ -302,8 +302,8 @@ public void Posit32ToDoubleIsCorrect() var posit1 = new Posit32(1); Assert.AreEqual((double)posit1, 1); - var positNegative_1234 = new Posit32(-1234); - Assert.AreEqual((double)positNegative_1234, -1234); + var positNegative_1234 = new Posit32(-1_234); + Assert.AreEqual((double)positNegative_1234, -1_234); var posit3 = new Posit32((double)0.75); Assert.AreEqual((double)posit3, 0.75); @@ -347,17 +347,17 @@ public void Posit32ToQuireIsCorrect() Assert.AreEqual( ((Quire)positNegative1).Segments, (new Quire( - new ulong[] { 0, 0, 0, 0xFFFF000000000000, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue }, 512)) + new ulong[] { 0, 0, 0, 0x_FFFF_0000_0000_0000, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue }, 512)) .Segments); var positNegative3 = new Posit32(-3); Assert.AreEqual( ((Quire)positNegative3).Segments, (new Quire( - new ulong[] { 0, 0, 0, 0xFFFD000000000000, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue }, 512)) + new ulong[] { 0, 0, 0, 0x_FFFD_0000_0000_0000, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue }, 512)) .Segments); - var positMax = new Posit32(0x7FFFFFFF, true); + var positMax = new Posit32(0x_7FFF_FFFF, true); Assert.AreEqual(((Quire)positMax).Segments, (new Quire(new ulong[] { 1 }, 512) << 360).Segments); var positNaN = new Posit32(Posit32.NaNBitMask, true); @@ -372,9 +372,9 @@ public void Posit32FusedSumIsCorrect() { var positArray = new Posit32[3]; positArray[0] = new Posit32(1); - positArray[1] = new Posit32(16777216); + positArray[1] = new Posit32(16_777_216); positArray[2] = new Posit32(4); - Assert.AreEqual(Posit32.FusedSum(positArray).PositBits, new Posit32(16777224).PositBits); + Assert.AreEqual(Posit32.FusedSum(positArray).PositBits, new Posit32(16_777_224).PositBits); positArray[2] = new Posit32(Posit32.NaNBitMask, true); Assert.AreEqual(Posit32.FusedSum(positArray).PositBits, positArray[2].PositBits); @@ -477,17 +477,17 @@ public void Posit32SquareRootIsCorrect() var positSmallerThanOne1 = new Posit32(0.5F); Debug.WriteLine(((float)Posit32.Sqrt(positSmallerThanOne1)).ToString("0.0000000000")); - Posit32.Sqrt(positSmallerThanOne1).PositBits.ShouldBe(new Posit32(0b00111011010100000100111100110011, true).PositBits); + Posit32.Sqrt(positSmallerThanOne1).PositBits.ShouldBe(new Posit32(0b_00111011_01010000_01001111_00110011, true).PositBits); - var positBig = new Posit32(1004004); - Posit32.Sqrt(positBig).PositBits.ShouldBe(new Posit32(1002).PositBits); + var positBig = new Posit32(1_004_004); + Posit32.Sqrt(positBig).PositBits.ShouldBe(new Posit32(1_002).PositBits); } [Fact] public void Posit32ToStringIsCorrect() { var posit1 = new Posit32(0.75F); - var posit2 = new Posit32(-200000); + var posit2 = new Posit32(-200_000); var posit3 = new Posit32(125.12545F); var posit4 = new Posit32((double)0.999); diff --git a/Lombiq.Arithmetics.Tests/PositTests/PositTests.cs b/Lombiq.Arithmetics.Tests/PositTests/PositTests.cs index f110b17..f4805bb 100644 --- a/Lombiq.Arithmetics.Tests/PositTests/PositTests.cs +++ b/Lombiq.Arithmetics.Tests/PositTests/PositTests.cs @@ -59,7 +59,7 @@ public void PositIsCorrectlyConstructedFromUint() new Posit(_environment_6_3, 16384U).PositBits.ShouldBe(new BitMask(0x1B, _environment_6_3.Size)); - new Posit(_environment_6_3, 1048576U).PositBits.ShouldBe(new BitMask(0x1D, _environment_6_3.Size)); + new Posit(_environment_6_3, 1_048_576U).PositBits.ShouldBe(new BitMask(0x1D, _environment_6_3.Size)); new Posit(_environment_8_2, 13U).PositBits.ShouldBe(new BitMask(0x5D, _environment_8_2.Size)); diff --git a/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs b/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs index b2dc639..33fcd73 100644 --- a/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs +++ b/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs @@ -100,7 +100,7 @@ public void UnumIsCorrectlyConstructedFromUintArray() 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 unumBig = new Unum(_environment_4_8, new uint[] { 594_967_295 }); var bitMaskBig = new BitMask(new uint[] { 0xCF5FE51C, 0xF06E }, _environment_4_8.Size); Assert.AreEqual(unumBig.UnumBits, bitMaskBig); @@ -207,8 +207,8 @@ public void FractionToUintArrayIsCorrect() 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 unumBig = new Unum(_environment_4_8, new uint[] { 594_967_295 }); + Assert.AreEqual(unumBig.FractionToUintArray(), new uint[] { 594_967_295, 0, 0, 0, 0, 0, 0, 0, 0 }); var maxValue = new uint[8]; for (var i = 0; i < 8; i++) diff --git a/Posit/Posit32.cs b/Posit/Posit32.cs index 40e0c54..94ca871 100644 --- a/Posit/Posit32.cs +++ b/Posit/Posit32.cs @@ -45,11 +45,11 @@ namespace Lombiq.Arithmetics public const uint Float32HiddenBitMask = 0x_0080_0000; - public const ulong Double64FractionMask = 0x000F_FFFF_FFFF_FFFF; + public const ulong Double64FractionMask = 0x_000F_FFFF_FFFF_FFFF; - public const ulong Double64ExponentMask = 0x7FF0_0000_0000_0000; + public const ulong Double64ExponentMask = 0x_7FF0_0000_0000_0000; - public const ulong Double64HiddenBitMask = 0x0010_0000_0000_0000; + public const ulong Double64HiddenBitMask = 0x_0010_0000_0000_0000; #endregion @@ -64,7 +64,7 @@ public Posit32(Quire q) var sign = false; var positionOfMostSigniFicantOne = 511; var firstSegment = (ulong)(q >> (QuireSize - 64)); - if (firstSegment >= 0x8000000000000000) + if (firstSegment >= 0x_8000_0000_0000_0000) { q = ~q; q += 1; @@ -72,7 +72,7 @@ public Posit32(Quire q) } firstSegment = (ulong)(q >> (QuireSize - 64)); - while (firstSegment < 0x8000000000000000) + while (firstSegment < 0x_8000_0000_0000_0000) { q <<= 1; positionOfMostSigniFicantOne -= 1; @@ -195,11 +195,11 @@ public Posit32(double doubleBits) } var signBit = (ulongRepresentation & ((ulong)SignBitMask << 32)) != 0; - int scaleFactor = (int)((ulongRepresentation << 1) >> 53) - 1023; + int scaleFactor = (int)((ulongRepresentation << 1) >> 53) - 1_023; uint fractionBits = (uint)((ulongRepresentation & Double64FractionMask) >> 21); // Adding the hidden bit if it is one. - if (scaleFactor != -1023) fractionBits += (uint)(Double64HiddenBitMask >> 21); + if (scaleFactor != -1_023) fractionBits += (uint)(Double64HiddenBitMask >> 21); else scaleFactor += 1; var regimeKValue = scaleFactor / (1 << MaximumExponentSize); @@ -1019,7 +1019,7 @@ public static explicit operator double(Posit32 x) var fraction = (ulong)x.Fraction(); - doubleBits += (ulong)((scaleFactor + 1023) << 52); + doubleBits += (ulong)((scaleFactor + 1_023) << 52); fraction <<= (int)(52 - x.FractionSize()); doubleBits += (fraction << (64 - GetMostSignificantOnePosition(fraction) - 1)) >> (64 - GetMostSignificantOnePosition(fraction) - 1); diff --git a/Posit/Quire.cs b/Posit/Quire.cs index b563662..237358c 100644 --- a/Posit/Quire.cs +++ b/Posit/Quire.cs @@ -133,7 +133,7 @@ public Quire(uint firstSegment, ushort size) right = right & ((1 << (left.SegmentCount * 6)) - 1); bool carryOld, carryNew; - var segmentMaskWithLeadingOne = 0x8000000000000000; + var segmentMaskWithLeadingOne = 0x_8000_0000_0000_0000; var segments = new ulong[left.SegmentCount]; Array.Copy(left.Segments, segments, left.Segments.Length); ushort currentIndex; @@ -160,7 +160,7 @@ public Quire(uint firstSegment, ushort size) right = right & ((1 << (left.SegmentCount * 6)) - 1); bool carryOld, carryNew; - var segmentMaskWithLeadingOne = 0x8000000000000000; + var segmentMaskWithLeadingOne = 0x_8000_0000_0000_0000; var segments = new ulong[left.SegmentCount]; Array.Copy(left.Segments, segments, left.Segments.Length); uint segmentMaskWithClosingOne = 1; From fd9108d6356eb069859a7d24929e7a3ee385e3c7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Thu, 16 Dec 2021 22:31:49 +0100 Subject: [PATCH 13/49] Fix IDE0047 (Parentheses can be removed). --- BitMask/BitMask.cs | 2 +- .../PositTests/Posit32Tests.cs | 20 ++++---- .../UnumTests/UnumTests.cs | 2 +- Posit/Posit.cs | 14 +++--- Posit/Posit32.cs | 50 +++++++++---------- Posit/Quire.cs | 8 +-- Unum/Unum.cs | 10 ++-- Unum/UnumHelper.cs | 2 +- 8 files changed, 54 insertions(+), 54 deletions(-) diff --git a/BitMask/BitMask.cs b/BitMask/BitMask.cs index 16b8831..77b61b6 100644 --- a/BitMask/BitMask.cs +++ b/BitMask/BitMask.cs @@ -370,7 +370,7 @@ public BitMask SetSegment(int index, uint segment) for (ushort j = 0; j < segments.Length; j++) { - carryNew = ((segments[j] & segmentMaskWithLeadingOne) == segmentMaskWithLeadingOne); + carryNew = (segments[j] & segmentMaskWithLeadingOne) == segmentMaskWithLeadingOne; segments[j] <<= 1; if (carryOld) segments[j] |= segmentMaskWithClosingOne; carryOld = carryNew; diff --git a/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs b/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs index 64601a3..0df0440 100644 --- a/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs +++ b/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs @@ -346,15 +346,15 @@ public void Posit32ToQuireIsCorrect() var positNegative1 = new Posit32(-1); Assert.AreEqual( ((Quire)positNegative1).Segments, - (new Quire( - new ulong[] { 0, 0, 0, 0x_FFFF_0000_0000_0000, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue }, 512)) + new Quire( + new ulong[] { 0, 0, 0, 0x_FFFF_0000_0000_0000, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue }, 512) .Segments); var positNegative3 = new Posit32(-3); Assert.AreEqual( ((Quire)positNegative3).Segments, - (new Quire( - new ulong[] { 0, 0, 0, 0x_FFFD_0000_0000_0000, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue }, 512)) + new Quire( + new ulong[] { 0, 0, 0, 0x_FFFD_0000_0000_0000, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue }, 512) .Segments); var positMax = new Posit32(0x_7FFF_FFFF, true); @@ -387,9 +387,9 @@ public void Posit32MultiplyIntoQuireIsCorrect() var posit2 = new Posit32(4); var posit3 = new Posit32(-1); - Assert.AreEqual((new Posit32(Posit32.MultiplyIntoQuire(posit1, posit2))).PositBits, new Posit32(12).PositBits); + Assert.AreEqual(new Posit32(Posit32.MultiplyIntoQuire(posit1, posit2)).PositBits, new Posit32(12).PositBits); - Assert.AreEqual((new Posit32(Posit32.MultiplyIntoQuire(posit1, posit3))).PositBits, new Posit32(-3).PositBits); + Assert.AreEqual(new Posit32(Posit32.MultiplyIntoQuire(posit1, posit3)).PositBits, new Posit32(-3).PositBits); } [Fact] @@ -420,8 +420,8 @@ public void Posit32FusedMultiplyAddIsCorrect() var posit2 = new Posit32(0.5F); var posit3 = new Posit32(-1); - Assert.AreEqual((Posit32.FusedMultiplyAdd(posit1, posit2, posit3)).PositBits, new Posit32(149).PositBits); - Assert.AreEqual((Posit32.FusedMultiplyAdd(posit1, posit3, posit2)).PositBits, new Posit32(-299.5F).PositBits); + Assert.AreEqual(Posit32.FusedMultiplyAdd(posit1, posit2, posit3).PositBits, new Posit32(149).PositBits); + Assert.AreEqual(Posit32.FusedMultiplyAdd(posit1, posit3, posit2).PositBits, new Posit32(-299.5F).PositBits); } [Fact] @@ -431,8 +431,8 @@ public void Posit32FusedAddMultiplyIsCorrect() var posit2 = new Posit32(0.5F); var posit3 = new Posit32(-2); - Assert.AreEqual((Posit32.FusedAddMultiply(posit1, posit2, posit3)).PositBits, new Posit32(-2.5F).PositBits); - Assert.AreEqual((Posit32.FusedAddMultiply(posit2, posit3, posit1)).PositBits, new Posit32(-1.125F).PositBits); + Assert.AreEqual(Posit32.FusedAddMultiply(posit1, posit2, posit3).PositBits, new Posit32(-2.5F).PositBits); + Assert.AreEqual(Posit32.FusedAddMultiply(posit2, posit3, posit1).PositBits, new Posit32(-1.125F).PositBits); } [Fact] diff --git a/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs b/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs index 33fcd73..e2d0697 100644 --- a/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs +++ b/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs @@ -483,7 +483,7 @@ public void AddExactUnumsIsCorrect() 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(unum31.UnumBits, new Unum(_environment_3_4, 31).UnumBits); Assert.AreEqual(unum1.UnumBits, unum0Plus1.UnumBits); Assert.AreEqual(unum1.UnumBits, unum0PlusUnum1.UnumBits); diff --git a/Posit/Posit.cs b/Posit/Posit.cs index 0e4530a..61c913d 100644 --- a/Posit/Posit.cs +++ b/Posit/Posit.cs @@ -94,7 +94,7 @@ public BitMask EncodeRegimeBits(int regimeKValue) regimeBits = (new BitMask(1, _environment.Size) << (regimeKValue + 1)) - 1; regimeBits <<= _environment.Size - regimeBits.GetMostSignificantOnePosition() - 1; } - else regimeBits = (_environment.FirstRegimeBitBitMask << regimeKValue); + else regimeBits = _environment.FirstRegimeBitBitMask << regimeKValue; return regimeBits; } @@ -113,7 +113,7 @@ private BitMask AssemblePositBits(bool signBit, int regimeKValue, BitMask expone // Hiding the hidden bit. (It is always one.) fractionBits = fractionBits.SetZero((ushort)fractionMostSignificantOneIndex); - wholePosit += fractionBits << (_environment.Size - 2 - fractionMostSignificantOneIndex - (regimeLength) - + wholePosit += fractionBits << (_environment.Size - 2 - fractionMostSignificantOneIndex - regimeLength - _environment.MaximumExponentSize); return !signBit ? wholePosit : wholePosit.GetTwosComplement(_environment.Size); @@ -138,7 +138,7 @@ private BitMask AssemblePositBitsWithRounding(bool signBit, int regimeKValue, Bi { if (exponentBits == new BitMask(exponentBits.Size).SetOne((ushort)(exponentBits.Size - 1))) { - wholePosit += (wholePosit.GetLowest32Bits() & 1); + wholePosit += wholePosit.GetLowest32Bits() & 1; } else wholePosit += 1; } @@ -151,7 +151,7 @@ private BitMask AssemblePositBitsWithRounding(bool signBit, int regimeKValue, Bi // Hiding the hidden bit. (It is always one.) fractionBits = fractionBits.SetZero((ushort)fractionMostSignificantOneIndex); - var fractionShiftedLeftBy = _environment.Size - 2 - fractionMostSignificantOneIndex - (regimeLength) - + var fractionShiftedLeftBy = _environment.Size - 2 - fractionMostSignificantOneIndex - regimeLength - _environment.MaximumExponentSize; // Attaching the fraction. wholePosit += fractionBits << fractionShiftedLeftBy; @@ -163,7 +163,7 @@ private BitMask AssemblePositBitsWithRounding(bool signBit, int regimeKValue, Bi { if (fractionBits == new BitMask(fractionBits.Size).SetOne((ushort)(fractionBits.Size - 1))) { - wholePosit += (wholePosit.GetLowest32Bits() & 1); + wholePosit += wholePosit.GetLowest32Bits() & 1; } else wholePosit += 1; } @@ -349,7 +349,7 @@ public static int CalculateScaleFactor(int regimeKValue, uint exponentValue, byt if (resultFractionBits.GetMostSignificantOnePosition() == 0) return new Posit(left._environment, left.EmptyBitMask); var resultRegimeKValue = scaleFactor / (1 << left.MaximumExponentSize); - var resultExponentBits = new BitMask((uint)((scaleFactor % (1 << left.MaximumExponentSize))), left._environment.Size); + var resultExponentBits = new BitMask((uint)(scaleFactor % (1 << left.MaximumExponentSize)), left._environment.Size); return new Posit( left._environment, @@ -397,7 +397,7 @@ public static explicit operator int(Posit x) } else { - return (x.IsPositive()) ? int.MaxValue : int.MinValue; + return x.IsPositive() ? int.MaxValue : int.MinValue; } return x.IsPositive() ? (int)result : (int)-result; diff --git a/Posit/Posit32.cs b/Posit/Posit32.cs index 94ca871..bd528c9 100644 --- a/Posit/Posit32.cs +++ b/Posit/Posit32.cs @@ -1,4 +1,4 @@ -using System; +using System; using System.Runtime.CompilerServices; namespace Lombiq.Arithmetics @@ -166,7 +166,7 @@ public Posit32(float floatBits) if (regimeKValue > (Size - 2)) { - regimeKValue = (Size - 2); + regimeKValue = Size - 2; exponentValue = 0; } @@ -220,7 +220,7 @@ public Posit32(double doubleBits) if (regimeKValue > (Size - 2)) { - regimeKValue = (Size - 2); + regimeKValue = Size - 2; exponentValue = 0; } @@ -253,7 +253,7 @@ public static uint EncodeRegimeBits(int regimeKValue) regimeBits = (uint)(1 << (regimeKValue + 1)) - 1; regimeBits <<= Size - GetMostSignificantOnePosition(regimeBits) - 1; } - else regimeBits = (FirstRegimeBitBitMask >> -regimeKValue); + else regimeBits = FirstRegimeBitBitMask >> -regimeKValue; return regimeBits; } @@ -297,7 +297,7 @@ public static uint AssemblePositBitsWithRounding(bool signBit, int regimeKValue, if (exponentBits < SignBitMask) return signBit ? GetTwosComplement(wholePosit) : wholePosit; - if (exponentBits == SignBitMask) wholePosit += (wholePosit & 1); + if (exponentBits == SignBitMask) wholePosit += wholePosit & 1; else wholePosit += 1; return signBit ? GetTwosComplement(wholePosit) : wholePosit; @@ -308,7 +308,7 @@ public static uint AssemblePositBitsWithRounding(bool signBit, int regimeKValue, // Hiding the hidden bit. (It is always one.) fractionBits = SetZero(fractionBits, (ushort)fractionMostSignificantOneIndex); - var fractionShiftedLeftBy = SizeMinusFixedBits - (fractionMostSignificantOneIndex) - (regimeLength); + var fractionShiftedLeftBy = SizeMinusFixedBits - fractionMostSignificantOneIndex - regimeLength; // Attaching the fraction. wholePosit += fractionShiftedLeftBy >= 0 ? fractionBits << fractionShiftedLeftBy : fractionBits >> -fractionShiftedLeftBy; // Calculating rounding. @@ -321,7 +321,7 @@ public static uint AssemblePositBitsWithRounding(bool signBit, int regimeKValue, { if (fractionBits == SignBitMask) { - wholePosit += (wholePosit & 1); + wholePosit += wholePosit & 1; } else wholePosit += 1; } @@ -497,8 +497,8 @@ public static Quire MultiplyIntoQuire(Posit32 left, Posit32 right) var leftFractionSize = left.FractionSizeWithoutSignCheck(); var rightFractionSize = right.FractionSizeWithoutSignCheck(); - var longResultFractionBits = (left.FractionWithHiddenBitWithoutSignCheck() * - (ulong)right.FractionWithHiddenBitWithoutSignCheck()); + var longResultFractionBits = left.FractionWithHiddenBitWithoutSignCheck() * + (ulong)right.FractionWithHiddenBitWithoutSignCheck(); var fractionSizeChange = GetMostSignificantOnePosition(longResultFractionBits) - (leftFractionSize + rightFractionSize + 1); var scaleFactor = CalculateScaleFactor(left.GetRegimeKValue(), left.GetExponentValue(), MaximumExponentSize) + @@ -509,7 +509,7 @@ public static Quire MultiplyIntoQuire(Posit32 left, Posit32 right) var quireArray = new ulong[QuireSize / 64]; quireArray[0] = longResultFractionBits; var resultQuire = new Quire(quireArray); - resultQuire <<= (240 - GetMostSignificantOnePosition(longResultFractionBits) + 1 + scaleFactor); + resultQuire <<= 240 - GetMostSignificantOnePosition(longResultFractionBits) + 1 + scaleFactor; return !resultSignBit ? resultQuire : (~resultQuire) + 1; } @@ -618,7 +618,7 @@ public static Posit32 Sqrt(Posit32 number) } var resultRegimeKValue = inputScaleFactor / (1 << MaximumExponentSize); - var resultExponentBits = (inputScaleFactor % (1 << MaximumExponentSize)); + var resultExponentBits = inputScaleFactor % (1 << MaximumExponentSize); if (resultExponentBits < 0) { resultRegimeKValue -= 1; @@ -833,7 +833,7 @@ public static Posit32 FusedMultiplyMultiplySubtract(Posit32 a, Posit32 b, Posit3 if (resultFractionBits == 0) return new Posit32(0, true); var resultRegimeKValue = scaleFactor / (1 << MaximumExponentSize); - var resultExponentBits = (scaleFactor % (1 << MaximumExponentSize)); + var resultExponentBits = scaleFactor % (1 << MaximumExponentSize); if (resultExponentBits < 0) { resultRegimeKValue -= 1; @@ -881,8 +881,8 @@ public static Posit32 FusedMultiplyMultiplySubtract(Posit32 a, Posit32 b, Posit3 var leftFractionSize = left.FractionSizeWithoutSignCheck(); var rightFractionSize = right.FractionSizeWithoutSignCheck(); - var longResultFractionBits = (left.FractionWithHiddenBitWithoutSignCheck() * - (ulong)right.FractionWithHiddenBitWithoutSignCheck()); + var longResultFractionBits = left.FractionWithHiddenBitWithoutSignCheck() * + (ulong)right.FractionWithHiddenBitWithoutSignCheck(); var fractionSizeChange = GetMostSignificantOnePosition(longResultFractionBits) - (leftFractionSize + rightFractionSize + 1); var resultFractionBits = (uint)(longResultFractionBits >> (int)(leftFractionSize + 1 + rightFractionSize + 1 - 32)); var scaleFactor = @@ -892,7 +892,7 @@ public static Posit32 FusedMultiplyMultiplySubtract(Posit32 a, Posit32 b, Posit3 scaleFactor += (int)fractionSizeChange; var resultRegimeKValue = scaleFactor / (1 << MaximumExponentSize); - var resultExponentBits = (scaleFactor % (1 << MaximumExponentSize)); + var resultExponentBits = scaleFactor % (1 << MaximumExponentSize); if (resultExponentBits < 0) { resultRegimeKValue -= 1; @@ -917,9 +917,9 @@ public static Posit32 FusedMultiplyMultiplySubtract(Posit32 a, Posit32 b, Posit3 var leftFractionSize = left.FractionSizeWithoutSignCheck(); var rightFractionSize = right.FractionSizeWithoutSignCheck(); - var longResultFractionBits = (((ulong)(left.FractionWithHiddenBitWithoutSignCheck()) << (int)(63 - leftFractionSize)) / - (right.FractionWithHiddenBitWithoutSignCheck() << (int)(31 - rightFractionSize))); - var fractionSizeChange = GetMostSignificantOnePosition(longResultFractionBits) - (33); + var longResultFractionBits = ((ulong)left.FractionWithHiddenBitWithoutSignCheck() << (int)(63 - leftFractionSize)) / + (right.FractionWithHiddenBitWithoutSignCheck() << (int)(31 - rightFractionSize)); + var fractionSizeChange = GetMostSignificantOnePosition(longResultFractionBits) - 33; var scaleFactor = CalculateScaleFactor(left.GetRegimeKValue(), left.GetExponentValue(), MaximumExponentSize) - @@ -927,7 +927,7 @@ public static Posit32 FusedMultiplyMultiplySubtract(Posit32 a, Posit32 b, Posit3 scaleFactor += fractionSizeChange; var resultRegimeKValue = scaleFactor / (1 << MaximumExponentSize); - var resultExponentBits = (scaleFactor % (1 << MaximumExponentSize)); + var resultExponentBits = scaleFactor % (1 << MaximumExponentSize); if (resultExponentBits < 0) { resultRegimeKValue -= 1; @@ -957,11 +957,11 @@ public static explicit operator int(Posit32 x) } else { - result = (x.FractionWithHiddenBit() >> - -(int)(scaleFactor - mostSignificantOnePosition + 1)); + result = x.FractionWithHiddenBit() >> + -(int)(scaleFactor - mostSignificantOnePosition + 1); } } - else return (x.IsPositive()) ? int.MaxValue : int.MinValue; + else return x.IsPositive() ? int.MaxValue : int.MinValue; return x.IsPositive() ? (int)result : (int)-result; } @@ -983,7 +983,7 @@ public static explicit operator float(Posit32 x) if (scaleFactor == -127) { fraction >>= 1; - fraction += (Float32HiddenBitMask >> 1); + fraction += Float32HiddenBitMask >> 1; } floatBits += (uint)((scaleFactor + 127) << 23); @@ -1064,7 +1064,7 @@ public int CompareTo(Object value) if (this == positValue) return 0; // At least one of the values is NaN. - if (IsNaN()) return (positValue.IsNaN() ? 0 : -1); + if (IsNaN()) return positValue.IsNaN() ? 0 : -1; else return 1; } @@ -1078,7 +1078,7 @@ public int CompareTo(Posit32 value) if (this == value) return 0; // At least one of the values is NaN. - if (IsNaN()) return (value.IsNaN() ? 0 : -1); + if (IsNaN()) return value.IsNaN() ? 0 : -1; else return 1; } diff --git a/Posit/Quire.cs b/Posit/Quire.cs index 237358c..a90621d 100644 --- a/Posit/Quire.cs +++ b/Posit/Quire.cs @@ -1,4 +1,4 @@ -using System; +using System; namespace Lombiq.Arithmetics { @@ -60,7 +60,7 @@ public Quire(uint firstSegment, ushort size) buffer = (byte)((leftBit ? 1 : 0) + (rightBit ? 1 : 0) + (carry ? 1 : 0)); - if ((buffer & 1) == 1) result[segmentPosition] += (1UL << position); + if ((buffer & 1) == 1) result[segmentPosition] += 1UL << position; carry = buffer >> 1 == 1; position++; @@ -91,7 +91,7 @@ public Quire(uint firstSegment, ushort size) buffer = (byte)(2 + (leftBit ? 1 : 0) - (rightBit ? 1 : 0) - (carry ? 1 : 0)); - if ((buffer & 1) == 1) result[segmentPosition] += (1UL << position); + if ((buffer & 1) == 1) result[segmentPosition] += 1UL << position; carry = buffer >> 1 == 0; position++; @@ -171,7 +171,7 @@ public Quire(uint firstSegment, ushort size) for (ushort j = 0; j < segments.Length; j++) { - carryNew = ((segments[j] & segmentMaskWithLeadingOne) == segmentMaskWithLeadingOne); + carryNew = (segments[j] & segmentMaskWithLeadingOne) == segmentMaskWithLeadingOne; segments[j] <<= 1; if (carryOld) segments[j] |= segmentMaskWithClosingOne; carryOld = carryNew; diff --git a/Unum/Unum.cs b/Unum/Unum.cs index a3763f4..e814563 100644 --- a/Unum/Unum.cs +++ b/Unum/Unum.cs @@ -462,8 +462,8 @@ public Unum SetFractionSizeBits(byte fractionSize) /// <returns>The BitMask representing the Unum with its exponentSize set to the given value.</returns> public Unum SetExponentSizeBits(byte exponentSize) { - var newUnumBits = ((UnumBits & (new BitMask(Size, true) ^ ExponentSizeMask)) | - (new BitMask(exponentSize, Size) << FractionSizeSize)); + var newUnumBits = (UnumBits & (new BitMask(Size, true) ^ ExponentSizeMask)) | + (new BitMask(exponentSize, Size) << FractionSizeSize); return new Unum(_environment, newUnumBits); } @@ -816,7 +816,7 @@ public static explicit operator int(Unum x) if ((x.ExponentValueWithBias() + (int)x.FractionSizeWithHiddenBit()) < 31) //The Unum fits into the range. result = (x.FractionWithHiddenBit() << (x.ExponentValueWithBias() - (int)x.FractionSize())).GetLowest32Bits(); - else return (x.IsPositive()) ? int.MaxValue : int.MinValue; // The absolute value of the Unum is too large. + else return x.IsPositive() ? int.MaxValue : int.MinValue; // The absolute value of the Unum is too large. return x.IsPositive() ? (int)result : -(int)result; } @@ -832,8 +832,8 @@ public static explicit operator float(Unum x) if (x.IsNegativeInfinity()) return float.NegativeInfinity; if (x.IsPositiveInfinity()) return float.PositiveInfinity; if (x.ExponentValueWithBias() > 127) // Exponent is too big for float format. - return (x.IsPositive()) ? float.PositiveInfinity : float.NegativeInfinity; - if (x.ExponentValueWithBias() < -126) return (x.IsPositive()) ? 0 : -0; // Exponent is too small for float format. + return x.IsPositive() ? float.PositiveInfinity : float.NegativeInfinity; + if (x.ExponentValueWithBias() < -126) return x.IsPositive() ? 0 : -0; // Exponent is too small for float format. var result = (x.Fraction() << (23 - ((int)x.FractionSize()))).GetLowest32Bits(); result |= (uint)(x.ExponentValueWithBias() + 127) << 23; diff --git a/Unum/UnumHelper.cs b/Unum/UnumHelper.cs index 3d3f59d..1af8d5e 100644 --- a/Unum/UnumHelper.cs +++ b/Unum/UnumHelper.cs @@ -93,7 +93,7 @@ public static BitMask LargestExpressablePositiveInteger(UnumEnvironment environm if (BitsRequiredByLargestExpressablePositiveInteger(environment) > environment.EmptyBitMask.SegmentCount * 32) return environment.EmptyBitMask; - return (environment.EmptyBitMask.SetOne((ushort)(environment.FractionSizeMax)) - 1) << + return (environment.EmptyBitMask.SetOne((ushort)environment.FractionSizeMax) - 1) << ((1 << (environment.ExponentSizeMax - 1)) - environment.FractionSizeMax + 1); } } From 13d3a0a2fe102954b636abcb54cde7240d38d421 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Fri, 17 Dec 2021 00:31:42 +0100 Subject: [PATCH 14/49] Fix S1481 (Remove the unused local variables). --- Posit/Posit.cs | 2 -- 1 file changed, 2 deletions(-) diff --git a/Posit/Posit.cs b/Posit/Posit.cs index 61c913d..7fd532f 100644 --- a/Posit/Posit.cs +++ b/Posit/Posit.cs @@ -197,8 +197,6 @@ public uint ExponentSize() public uint GetExponentValue() { var exponentMask = IsPositive() ? PositBits : PositBits.GetTwosComplement(Size); - var fsize = (int)FractionSize(); - var esize = ExponentSize(); exponentMask = (exponentMask >> (int)FractionSize()) << (int)((PositBits.SegmentCount * 32) - ExponentSize()) >> (int)((PositBits.SegmentCount * 32) - MaximumExponentSize); From 85c0fd6a3e5ff50d197f33cc2f42fc9964e6e18e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Fri, 17 Dec 2021 01:26:42 +0100 Subject: [PATCH 15/49] Fix IDE0090 ('new' expression can be simplified). --- Posit/Posit32.cs | 2 +- Unum/UnumEnvironment.cs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Posit/Posit32.cs b/Posit/Posit32.cs index bd528c9..bc8ab6f 100644 --- a/Posit/Posit32.cs +++ b/Posit/Posit32.cs @@ -1088,7 +1088,7 @@ public int CompareTo(Posit32 value) public string ToString(IFormatProvider provider) => ((double)this).ToString(provider); - public Posit32 Parse(string number) => new Posit32(Double.Parse(number)); + public Posit32 Parse(string number) => new(Double.Parse(number)); public bool TryParse(string number, out Posit32 positResult) { diff --git a/Unum/UnumEnvironment.cs b/Unum/UnumEnvironment.cs index 7cb50ff..d7aff70 100644 --- a/Unum/UnumEnvironment.cs +++ b/Unum/UnumEnvironment.cs @@ -168,7 +168,7 @@ public UnumEnvironment(byte exponentSizeSize, byte fractionSizeSize) } public static UnumEnvironment FromConfigurationValues(byte eSize, ushort fSize) => - new UnumEnvironment(UnumHelper.SegmentSizeToSegmentSizeSize(eSize), UnumHelper.SegmentSizeToSegmentSizeSize(fSize)); + new(UnumHelper.SegmentSizeToSegmentSizeSize(eSize), UnumHelper.SegmentSizeToSegmentSizeSize(fSize)); public static UnumEnvironment FromConfiguration(UnumConfiguration configuration) => FromConfigurationValues(configuration.ExponentSize, configuration.FractionSize); From ad9a01e8dc3b89e63a449d05f2df645babe60fed Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Fri, 17 Dec 2021 16:04:47 +0100 Subject: [PATCH 16/49] Replace single line methods. --- .../CompatibilityAssert.cs | 29 +++-------- Posit/Posit.cs | 6 +-- Posit/Posit32.cs | 48 +++++-------------- 3 files changed, 20 insertions(+), 63 deletions(-) diff --git a/Lombiq.Arithmetics.Tests/CompatibilityAssert.cs b/Lombiq.Arithmetics.Tests/CompatibilityAssert.cs index dd8defd..caf818d 100644 --- a/Lombiq.Arithmetics.Tests/CompatibilityAssert.cs +++ b/Lombiq.Arithmetics.Tests/CompatibilityAssert.cs @@ -1,34 +1,19 @@ -using Xunit.Sdk; +using Shouldly; namespace Lombiq.Arithmetics.Tests { public static class CompatibilityAssert { - public static void AreEqual<T>(T actual, T expected) - { - Xunit.Assert.Equal(expected, actual); - } + public static void AreEqual<T>(T actual, T expected) => actual.ShouldBe(expected); - public static void AreEqual(uint actual, int expected) - { - Xunit.Assert.Equal((uint)expected, actual); - } + public static void AreEqual(uint actual, int expected) => actual.ShouldBe((uint)expected); public static void AreEqual(int actual, uint expected) { - Xunit.Assert.Equal(expected, (uint)actual); + var actualUInt = (uint)actual; + actualUInt.ShouldBe(expected); } - public static void AreEqual<T>(T actual, T expected, string userMessage) - { - try - { - Xunit.Assert.Equal(expected, actual); - } - catch (EqualException) - { - Xunit.Assert.True(false, userMessage); - } - } + public static void AreEqual<T>(T actual, T expected, string userMessage) => actual.ShouldBe(expected, userMessage); } -} \ No newline at end of file +} diff --git a/Posit/Posit.cs b/Posit/Posit.cs index 7fd532f..47018fc 100644 --- a/Posit/Posit.cs +++ b/Posit/Posit.cs @@ -222,10 +222,8 @@ public BitMask FractionWithHiddenBit() return result.SetOne((ushort)FractionSize()); } - public static int CalculateScaleFactor(int regimeKValue, uint exponentValue, byte maximumExponentSize) - { - return (int)((regimeKValue * (1 << maximumExponentSize)) + exponentValue); - } + public static int CalculateScaleFactor(int regimeKValue, uint exponentValue, byte maximumExponentSize) => + (int)((regimeKValue * (1 << maximumExponentSize)) + exponentValue); #endregion diff --git a/Posit/Posit32.cs b/Posit/Posit32.cs index bc8ab6f..e27e6be 100644 --- a/Posit/Posit32.cs +++ b/Posit/Posit32.cs @@ -342,12 +342,10 @@ public sbyte GetRegimeKValue() } [MethodImpl(MethodImplOptions.AggressiveInlining)] - public sbyte GetRegimeKValueWithoutSignCheck(byte lengthOfRunOfBits) - { - return (PositBits & FirstRegimeBitBitMask) == EmptyBitMask + public sbyte GetRegimeKValueWithoutSignCheck(byte lengthOfRunOfBits) => + (PositBits & FirstRegimeBitBitMask) == EmptyBitMask ? (sbyte)-lengthOfRunOfBits : (sbyte)(lengthOfRunOfBits - 1); - } [MethodImpl(MethodImplOptions.AggressiveInlining)] public short CalculateScaleFactor() @@ -392,20 +390,12 @@ public uint GetExponentValue() } [MethodImpl(MethodImplOptions.AggressiveInlining)] - public uint GetExponentValueWithoutSignCheck() - { - return (PositBits >> (int)FractionSizeWithoutSignCheck()) - << (Size - ExponentSize()) - >> (Size - MaximumExponentSize); - } + public uint GetExponentValueWithoutSignCheck() => + (PositBits >> (int)FractionSizeWithoutSignCheck()) << (Size - ExponentSize()) >> (Size - MaximumExponentSize); [MethodImpl(MethodImplOptions.AggressiveInlining)] - public uint GetExponentValueWithoutSignCheck(uint fractionSize) - { - return (PositBits >> (int)fractionSize) - << (Size - ExponentSize()) - >> (Size - MaximumExponentSize); - } + public uint GetExponentValueWithoutSignCheck(uint fractionSize) => + (PositBits >> (int)fractionSize) << (Size - ExponentSize()) >> (Size - MaximumExponentSize); [MethodImpl(MethodImplOptions.AggressiveInlining)] public uint FractionSize() @@ -1099,17 +1089,11 @@ public bool TryParse(string number, out Posit32 positResult) public bool Equals(Posit32 other) => (this == other) ? true : false; - public TypeCode GetTypeCode() - { - throw new NotImplementedException(); - } + public TypeCode GetTypeCode() => throw new NotSupportedException(); public bool ToBoolean(IFormatProvider provider) => !IsZero(); - public char ToChar(IFormatProvider provider) - { - throw new InvalidCastException(); - } + public char ToChar(IFormatProvider provider) => throw new InvalidCastException(); public sbyte ToSByte(IFormatProvider provider) => (sbyte)(int)this; @@ -1131,22 +1115,12 @@ public char ToChar(IFormatProvider provider) public double ToDouble(IFormatProvider provider) => (double)this; - public decimal ToDecimal(IFormatProvider provider) - { - throw new NotImplementedException(); - } + public decimal ToDecimal(IFormatProvider provider) => throw new NotSupportedException(); - public DateTime ToDateTime(IFormatProvider provider) - { - throw new InvalidCastException(); - } + public DateTime ToDateTime(IFormatProvider provider) => throw new InvalidCastException(); - public object ToType(Type conversionType, IFormatProvider provider) - { - throw new NotImplementedException(); - } + public object ToType(Type conversionType, IFormatProvider provider) => throw new NotSupportedException(); #endregion } } - From 493e35f826ee6baf13ca17026f40f9788a28947e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Fri, 17 Dec 2021 16:50:49 +0100 Subject: [PATCH 17/49] Fix CA1822 (Member does not access instance data and can be marked as static). --- .../UnumTests/UnumEnvironmentTests.cs | 2 +- Posit/Posit32.cs | 20 ------------------- 2 files changed, 1 insertion(+), 21 deletions(-) diff --git a/Lombiq.Arithmetics.Tests/UnumTests/UnumEnvironmentTests.cs b/Lombiq.Arithmetics.Tests/UnumTests/UnumEnvironmentTests.cs index a5a78b9..6686589 100644 --- a/Lombiq.Arithmetics.Tests/UnumTests/UnumEnvironmentTests.cs +++ b/Lombiq.Arithmetics.Tests/UnumTests/UnumEnvironmentTests.cs @@ -284,7 +284,7 @@ public void UnumLargestNegativeIsCorrect() TestFailureMessageBuilder(_unum_3_4, nameof(_unum_3_4.LargestNegative))); } - private string TestFailureMessageBuilder(Unum unum, string propertyName) => + private static string TestFailureMessageBuilder(Unum unum, string propertyName) => $"Testing the \"{propertyName}\" property of the Unum ({unum.ExponentSizeSize}, {unum.FractionSizeSize}) environment failed."; } } diff --git a/Posit/Posit32.cs b/Posit/Posit32.cs index e27e6be..ed7a233 100644 --- a/Posit/Posit32.cs +++ b/Posit/Posit32.cs @@ -258,26 +258,6 @@ public static uint EncodeRegimeBits(int regimeKValue) return regimeBits; } - private uint AssemblePositBits(bool signBit, int regimeKValue, uint exponentBits, uint fractionBits) - { - // Calculating the regime. - var wholePosit = EncodeRegimeBits(regimeKValue); - - // Attaching the exponent - var regimeLength = LengthOfRunOfBits(wholePosit, FirstRegimeBitPosition); - - wholePosit += exponentBits << (SizeMinusFixedBits - regimeLength); - - var fractionMostSignificantOneIndex = GetMostSignificantOnePosition(fractionBits) - 1; - - // Hiding the hidden bit. (It is always one.) - fractionBits = SetZero(fractionBits, (ushort)fractionMostSignificantOneIndex); - - wholePosit += fractionBits << (SizeMinusFixedBits - fractionMostSignificantOneIndex - regimeLength); - - return signBit ? GetTwosComplement(wholePosit) : wholePosit; - } - public static uint AssemblePositBitsWithRounding(bool signBit, int regimeKValue, uint exponentBits, uint fractionBits) { // Calculating the regime. From b1206762b548ae0eda6351dba07a316f216dc9f8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Fri, 17 Dec 2021 21:24:40 +0100 Subject: [PATCH 18/49] Add readonly. --- .../PositTests/PositTests.cs | 18 +++++++++--------- .../UnumTests/UnumEnvironmentTests.cs | 10 +++++----- .../UnumTests/UnumHelperTests.cs | 14 +++++++------- .../UnumTests/UnumTests.cs | 18 +++++++++--------- 4 files changed, 30 insertions(+), 30 deletions(-) diff --git a/Lombiq.Arithmetics.Tests/PositTests/PositTests.cs b/Lombiq.Arithmetics.Tests/PositTests/PositTests.cs index f4805bb..7c7cbe4 100644 --- a/Lombiq.Arithmetics.Tests/PositTests/PositTests.cs +++ b/Lombiq.Arithmetics.Tests/PositTests/PositTests.cs @@ -1,4 +1,4 @@ -using Shouldly; +using Shouldly; using System; using Xunit; @@ -8,14 +8,14 @@ namespace Lombiq.Arithmetics.Tests { public class PositTests { - private PositEnvironment _environment_6_1; - private PositEnvironment _environment_6_2; - private PositEnvironment _environment_6_3; - private PositEnvironment _environment_8_2; - private PositEnvironment _environment_12_2; - private PositEnvironment _environment_16_3; - private PositEnvironment _environment_32_3; - private PositEnvironment _environment_32_2; + private readonly PositEnvironment _environment_6_1; + private readonly PositEnvironment _environment_6_2; + private readonly PositEnvironment _environment_6_3; + private readonly PositEnvironment _environment_8_2; + private readonly PositEnvironment _environment_12_2; + private readonly PositEnvironment _environment_16_3; + private readonly PositEnvironment _environment_32_3; + private readonly PositEnvironment _environment_32_2; public PositTests() { diff --git a/Lombiq.Arithmetics.Tests/UnumTests/UnumEnvironmentTests.cs b/Lombiq.Arithmetics.Tests/UnumTests/UnumEnvironmentTests.cs index 6686589..3a6e348 100644 --- a/Lombiq.Arithmetics.Tests/UnumTests/UnumEnvironmentTests.cs +++ b/Lombiq.Arithmetics.Tests/UnumTests/UnumEnvironmentTests.cs @@ -6,11 +6,11 @@ namespace Lombiq.Arithmetics.Tests { public class UnumEnvironmentTests { - private UnumEnvironment _warlpiriEnvironment; - private UnumEnvironment _environment_3_2; - private UnumEnvironment _environment_3_4; - private Unum _unum_3_2; - private Unum _unum_3_4; + private readonly UnumEnvironment _warlpiriEnvironment; + private readonly UnumEnvironment _environment_3_2; + private readonly UnumEnvironment _environment_3_4; + private readonly Unum _unum_3_2; + private readonly Unum _unum_3_4; public UnumEnvironmentTests() { diff --git a/Lombiq.Arithmetics.Tests/UnumTests/UnumHelperTests.cs b/Lombiq.Arithmetics.Tests/UnumTests/UnumHelperTests.cs index 6591208..5536206 100644 --- a/Lombiq.Arithmetics.Tests/UnumTests/UnumHelperTests.cs +++ b/Lombiq.Arithmetics.Tests/UnumTests/UnumHelperTests.cs @@ -1,4 +1,4 @@ -using Xunit; +using Xunit; using Assert = Lombiq.Arithmetics.Tests.CompatibilityAssert; @@ -6,12 +6,12 @@ namespace Lombiq.Arithmetics.Tests { public class UnumHelperTests { - private UnumEnvironment _warlpiriEnvironment; - private UnumEnvironment _environment_2_2; - private UnumEnvironment _environment_2_3; - private UnumEnvironment _environment_2_4; - private UnumEnvironment _environment_3_2; - private UnumEnvironment _environment_4_8; + private readonly UnumEnvironment _warlpiriEnvironment; + private readonly UnumEnvironment _environment_2_2; + private readonly UnumEnvironment _environment_2_3; + private readonly UnumEnvironment _environment_2_4; + private readonly UnumEnvironment _environment_3_2; + private readonly UnumEnvironment _environment_4_8; public UnumHelperTests() { diff --git a/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs b/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs index e2d0697..14eade1 100644 --- a/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs +++ b/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs @@ -6,15 +6,15 @@ namespace Lombiq.Arithmetics.Tests { public class UnumTests { - private UnumEnvironment _warlpiriEnvironment; - private UnumEnvironment _environment_2_2; - private UnumEnvironment _environment_2_3; - private UnumEnvironment _environment_2_4; - private UnumEnvironment _environment_3_2; - private UnumEnvironment _environment_3_4; - private UnumEnvironment _environment_3_5; - private UnumEnvironment _environment_4_3; - private UnumEnvironment _environment_4_8; + private readonly UnumEnvironment _warlpiriEnvironment; + private readonly UnumEnvironment _environment_2_2; + private readonly UnumEnvironment _environment_2_3; + private readonly UnumEnvironment _environment_2_4; + private readonly UnumEnvironment _environment_3_2; + private readonly UnumEnvironment _environment_3_4; + private readonly UnumEnvironment _environment_3_5; + private readonly UnumEnvironment _environment_4_3; + private readonly UnumEnvironment _environment_4_8; public UnumTests() { From 205758866daf5b20352767333136d59d92c5936e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Fri, 17 Dec 2021 21:41:51 +0100 Subject: [PATCH 19/49] Fix IDE0004 (Cast is redundant). --- Posit/Posit.cs | 2 +- Unum/Unum.cs | 10 +++++----- Unum/UnumHelper.cs | 2 +- 3 files changed, 7 insertions(+), 7 deletions(-) diff --git a/Posit/Posit.cs b/Posit/Posit.cs index 47018fc..8464772 100644 --- a/Posit/Posit.cs +++ b/Posit/Posit.cs @@ -199,7 +199,7 @@ public uint GetExponentValue() var exponentMask = IsPositive() ? PositBits : PositBits.GetTwosComplement(Size); exponentMask = (exponentMask >> (int)FractionSize()) << (int)((PositBits.SegmentCount * 32) - ExponentSize()) - >> (int)((PositBits.SegmentCount * 32) - MaximumExponentSize); + >> (PositBits.SegmentCount * 32) - MaximumExponentSize; return exponentMask.GetLowest32Bits(); } diff --git a/Unum/Unum.cs b/Unum/Unum.cs index e814563..e53fbcd 100644 --- a/Unum/Unum.cs +++ b/Unum/Unum.cs @@ -481,7 +481,7 @@ public Unum SetExponentSizeBits(byte exponentSize) /// </returns> public uint[] FractionToUintArray() { - var resultMask = FractionWithHiddenBit() << (ExponentValueWithBias() - (int)FractionSize()); + var resultMask = FractionWithHiddenBit() << (ExponentValueWithBias() - FractionSize()); var result = new uint[resultMask.SegmentCount]; for (var i = 0; i < resultMask.SegmentCount; i++) result[i] = resultMask.Segments[i]; @@ -814,15 +814,15 @@ public static explicit operator int(Unum x) { uint result; - if ((x.ExponentValueWithBias() + (int)x.FractionSizeWithHiddenBit()) < 31) //The Unum fits into the range. - result = (x.FractionWithHiddenBit() << (x.ExponentValueWithBias() - (int)x.FractionSize())).GetLowest32Bits(); + if ((x.ExponentValueWithBias() + x.FractionSizeWithHiddenBit()) < 31) //The Unum fits into the range. + result = (x.FractionWithHiddenBit() << (x.ExponentValueWithBias() - x.FractionSize())).GetLowest32Bits(); else return x.IsPositive() ? int.MaxValue : int.MinValue; // The absolute value of the Unum is too large. return x.IsPositive() ? (int)result : -(int)result; } public static explicit operator uint(Unum x) => - (x.FractionWithHiddenBit() << (x.ExponentValueWithBias() - ((int)x.FractionSize()))).GetLowest32Bits(); + (x.FractionWithHiddenBit() << (x.ExponentValueWithBias() - x.FractionSize())).GetLowest32Bits(); // This is not well tested yet. public static explicit operator float(Unum x) @@ -835,7 +835,7 @@ public static explicit operator float(Unum x) return x.IsPositive() ? float.PositiveInfinity : float.NegativeInfinity; if (x.ExponentValueWithBias() < -126) return x.IsPositive() ? 0 : -0; // Exponent is too small for float format. - var result = (x.Fraction() << (23 - ((int)x.FractionSize()))).GetLowest32Bits(); + var result = (x.Fraction() << (23 - x.FractionSize())).GetLowest32Bits(); result |= (uint)(x.ExponentValueWithBias() + 127) << 23; return x.IsPositive() ? diff --git a/Unum/UnumHelper.cs b/Unum/UnumHelper.cs index 1af8d5e..01f1720 100644 --- a/Unum/UnumHelper.cs +++ b/Unum/UnumHelper.cs @@ -93,7 +93,7 @@ public static BitMask LargestExpressablePositiveInteger(UnumEnvironment environm if (BitsRequiredByLargestExpressablePositiveInteger(environment) > environment.EmptyBitMask.SegmentCount * 32) return environment.EmptyBitMask; - return (environment.EmptyBitMask.SetOne((ushort)environment.FractionSizeMax) - 1) << + return (environment.EmptyBitMask.SetOne(environment.FractionSizeMax) - 1) << ((1 << (environment.ExponentSizeMax - 1)) - environment.FractionSizeMax + 1); } } From 27505f424674a11794ef5fae4786528094520675 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Fri, 17 Dec 2021 21:59:43 +0100 Subject: [PATCH 20/49] Fix S3257 (Remove the array type; it is redundant). --- Lombiq.Arithmetics.Tests/BitMaskTests.cs | 42 +++++++++---------- .../UnumTests/UnumTests.cs | 4 +- 2 files changed, 23 insertions(+), 23 deletions(-) diff --git a/Lombiq.Arithmetics.Tests/BitMaskTests.cs b/Lombiq.Arithmetics.Tests/BitMaskTests.cs index 48afc61..8df70fb 100644 --- a/Lombiq.Arithmetics.Tests/BitMaskTests.cs +++ b/Lombiq.Arithmetics.Tests/BitMaskTests.cs @@ -11,7 +11,7 @@ public class BitMaskTests [Fact] public void BitMaskSegmentCountIsCorrectlyCalculatedFromSize() { - var sizesAndSegmentCounts = new Tuple<BitMask, uint>[] + var sizesAndSegmentCounts = new[] { Tuple.Create(new BitMask(0), 0U), Tuple.Create(new BitMask(31), 1U), @@ -28,7 +28,7 @@ public void BitMaskSegmentCountIsCorrectlyCalculatedFromSize() [Fact] public void BitMaskSizeIsCorrectlySetWithSegments() { - var sizesAndSegmentCounts = new Tuple<BitMask, uint>[] + var sizesAndSegmentCounts = new[] { Tuple.Create(new BitMask(new uint[0]), 0U), Tuple.Create(new BitMask(new uint[] { 1 }), 32U), @@ -49,7 +49,7 @@ public void BitMaskSetOneIsCorrect() Assert.AreEqual(0xFFFF, new BitMask(new uint[] { 0xFFFF }).SetOne(5).Segments[0]); Assert.AreEqual(0xFFFF + (1 << 30), new BitMask(new uint[] { 0xFFFF }).SetOne(30).Segments[0]); Assert.AreEqual((uint)(1 << 30) << 1, new BitMask(new uint[] { 0 }).SetOne(31).Segments[0]); - Assert.AreEqual(uint.MaxValue, new BitMask(new uint[] { 0xFFFFFFFE }).SetOne(0).Segments[0]); + Assert.AreEqual(uint.MaxValue, new BitMask(new[] { 0xFFFFFFFE }).SetOne(0).Segments[0]); Assert.AreEqual(uint.MaxValue, new BitMask(new uint[] { 0x7FFFFFFF }).SetOne(31).Segments[0]); Assert.AreEqual(new BitMask(new uint[] { 0, 0, 0xFFFF }), new BitMask(new uint[] { 0, 0, 0xFFFF }).SetOne(79)); Assert.AreEqual(new BitMask(new uint[] { 0, 0, 0x1FFFF }), new BitMask(new uint[] { 0, 0, 0xFFFF }).SetOne(80)); @@ -64,7 +64,7 @@ public void BitMaskSetZeroIsCorrect() [Fact] public void BitMaskConstructorCorrectlyCopiesBitMask() { - var masks = new BitMask[] + var masks = new[] { new BitMask(new uint[] { 0x42, 0x42 }), new BitMask(new uint[] { 0x88, 0x88, 0x88 }), }; @@ -77,10 +77,10 @@ public void BitMaskIntegerAdditionIsCorrect() { Assert.AreEqual(1, (new BitMask(new uint[] { 0 }) + 1).Segments[0]); Assert.AreEqual(0x1FFFE, (new BitMask(new uint[] { 0xFFFF }) + 0xFFFF).Segments[0]); - Assert.AreEqual(0xFFFFFFFF, (new BitMask(new uint[] { 0xFFFFFFFE }) + 1).Segments[0]); - Assert.AreEqual(0xFFFFFFFF, (new BitMask(new uint[] { 0xEFFFFFFF }) + 0x10000000).Segments[0]); - Assert.AreEqual(0, (new BitMask(new uint[] { 0xFFFFFFFF }) + 1).Segments[0]); - Assert.AreEqual(1, (new BitMask(new uint[] { 0xFFFFFFFF }) + 2).Segments[0]); + Assert.AreEqual(0xFFFFFFFF, (new BitMask(new[] { 0xFFFFFFFE }) + 1).Segments[0]); + Assert.AreEqual(0xFFFFFFFF, (new BitMask(new[] { 0xEFFFFFFF }) + 0x10000000).Segments[0]); + Assert.AreEqual(0, (new BitMask(new[] { 0xFFFFFFFF }) + 1).Segments[0]); + Assert.AreEqual(1, (new BitMask(new[] { 0xFFFFFFFF }) + 2).Segments[0]); Assert.AreEqual(new BitMask(new uint[] { 0, 0, 1 }), new BitMask(new uint[] { 0xFFFFFFFF, 0xFFFFFFFF, 0 }) + 1); } @@ -88,11 +88,11 @@ public void BitMaskIntegerAdditionIsCorrect() public void BitMaskIntegerSubtractionIsCorrect() { Assert.AreEqual(0, (new BitMask(new uint[] { 1 }) - 1).Segments[0]); - Assert.AreEqual(0, (new BitMask(new uint[] { 0xFFFFFFFF }) - 0xFFFFFFFF).Segments[0]); - Assert.AreEqual(1, (new BitMask(new uint[] { 0xFFFFFFFF }) - 0xFFFFFFFE).Segments[0]); + Assert.AreEqual(0, (new BitMask(new[] { 0xFFFFFFFF }) - 0xFFFFFFFF).Segments[0]); + Assert.AreEqual(1, (new BitMask(new[] { 0xFFFFFFFF }) - 0xFFFFFFFE).Segments[0]); Assert.AreEqual(0xFFFFFFFF, (new BitMask(new uint[] { 0 }) - 1).Segments[0]); Assert.AreEqual(0xFFFFFFFE, (new BitMask(new uint[] { 0 }) - 2).Segments[0]); - Assert.AreEqual(0xEFFFFFFF, (new BitMask(new uint[] { 0xFFFFFFFF }) - 0x10000000).Segments[0]); + Assert.AreEqual(0xEFFFFFFF, (new BitMask(new[] { 0xFFFFFFFF }) - 0x10000000).Segments[0]); Assert.AreEqual(0xFFFFFF, (new BitMask(new uint[] { 0x017FFFFF }) - 0x800000).Segments[0]); Assert.AreEqual(new BitMask(new uint[] { 0xFFFFFFFF, 0 }, 33), new BitMask(new uint[] { 0x7FFFFFFF, 1 }, 33) - 0x80000000); } @@ -100,8 +100,8 @@ public void BitMaskIntegerSubtractionIsCorrect() [Fact] public void BitMaskAdditionIsCorrect() { - new BitMask(new uint[] { 0xFFFFFFFF }).ShouldBe( - new BitMask(new uint[] { 0x55555555 }) + new BitMask(new uint[] { 0xAAAAAAAA })); + new BitMask(new[] { 0xFFFFFFFF }).ShouldBe( + new BitMask(new uint[] { 0x55555555 }) + new BitMask(new[] { 0xAAAAAAAA })); new BitMask(new uint[] { 0xFFFFFFFE, 1 }).ShouldBe( new BitMask(new uint[] { 0xFFFFFFFF, 0 }) + new BitMask(new uint[] { 0xFFFFFFFF, 0 })); new BitMask(new uint[] { 0xFFFFFFFE, 0xFFFFFFFF, 1 }).ShouldBe( @@ -111,8 +111,8 @@ public void BitMaskAdditionIsCorrect() [Fact] public void BitMaskSubtractionIsCorrect() { - new BitMask(new uint[] { 0xAAAAAAAA }).ShouldBe( - new BitMask(new uint[] { 0xFFFFFFFF }) - new BitMask(new uint[] { 0x55555555 })); + new BitMask(new[] { 0xAAAAAAAA }).ShouldBe( + new BitMask(new[] { 0xFFFFFFFF }) - new BitMask(new uint[] { 0x55555555 })); new BitMask(new uint[] { 0xFFFFFFFF, 0 }).ShouldBe( new BitMask(new uint[] { 0xFFFFFFFE, 1 }) - new BitMask(new uint[] { 0xFFFFFFFF, 0 })); new BitMask(new uint[] { 0xFFFFFFFF, 0xFFFFFFFF, 0 }).ShouldBe( @@ -122,7 +122,7 @@ public void BitMaskSubtractionIsCorrect() [Fact] public void BitMaskBitShiftLeftIsCorrect() { - new BitMask(new uint[] { 0x80000000 }).ShouldBe( + new BitMask(new[] { 0x80000000 }).ShouldBe( new BitMask(new uint[] { 1 }) << 31); new BitMask(new uint[] { 0x00000003 }).ShouldBe( new BitMask(new uint[] { 6 }) << -1); @@ -133,7 +133,7 @@ public void BitMaskBitShiftLeftIsCorrect() new BitMask(new uint[] { 0x80000000, 0x00000000 }).ShouldBe( new BitMask(new uint[] { 0x00800000, 0x00000000 }) << 8); new BitMask(new uint[] { 1 }).ShouldBe( - new BitMask(new uint[] { 0x80000000 }) << -31); + new BitMask(new[] { 0x80000000 }) << -31); (new BitMask(new uint[] { 1, 0 }) << 63).ShouldBe( new BitMask(new uint[] { 0x00000000, 0x80000000 })); } @@ -144,14 +144,14 @@ public void BitMaskBitShiftRightIsCorrect() new BitMask(new uint[] { 0x00800000, 0x00000000 }).ShouldBe( new BitMask(new uint[] { 0x80000000, 0x00000000 }) >> 8); new BitMask(new uint[] { 1 }).ShouldBe( - new BitMask(new uint[] { 0x80000000 }) >> 31); + new BitMask(new[] { 0x80000000 }) >> 31); new BitMask(new uint[] { 1, 0 }).ShouldBe( new BitMask(new uint[] { 0x00000000, 0x80000000 }) >> 63); new BitMask(new uint[] { 0x10000010, 0x00000000 }).ShouldBe( new BitMask(new uint[] { 0x00000100, 0x00000001 }) >> 4); new BitMask(new uint[] { 0 }).ShouldBe( - new BitMask(new uint[] { 0x80000000 }) >> 32); - new BitMask(new uint[] { 0x80000000 }).ShouldBe( + new BitMask(new[] { 0x80000000 }) >> 32); + new BitMask(new[] { 0x80000000 }).ShouldBe( new BitMask(new uint[] { 1 }) >> -31); } @@ -203,7 +203,7 @@ public void LengthOfRunOfBitsIsCorrect() { new BitMask(new uint[] { 0x00000001 }).LengthOfRunOfBits(32).ShouldBe((ushort)31); new BitMask(new uint[] { 0x30000000 }).LengthOfRunOfBits(32).ShouldBe((ushort)2); - new BitMask(new uint[] { 0x80000000 }).LengthOfRunOfBits(32).ShouldBe((ushort)1); + new BitMask(new[] { 0x80000000 }).LengthOfRunOfBits(32).ShouldBe((ushort)1); new BitMask(new uint[] { 0x00000000 }).LengthOfRunOfBits(32).ShouldBe((ushort)32); new BitMask(new uint[] { 0x00000013 }).LengthOfRunOfBits(5).ShouldBe((ushort)1); new BitMask(new uint[] { 17 }).LengthOfRunOfBits(5).ShouldBe((ushort)1); diff --git a/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs b/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs index 14eade1..96f007d 100644 --- a/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs +++ b/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs @@ -97,7 +97,7 @@ public void UnumIsCorrectlyConstructedFromUintArray() 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); + var bitMask500000 = new BitMask(new[] { 0xC7A1250C }, _environment_4_8.Size); Assert.AreEqual(unum500000.UnumBits, bitMask500000); var unumBig = new Unum(_environment_4_8, new uint[] { 594_967_295 }); @@ -431,7 +431,7 @@ public void ExponentMaskIsCorrect() // 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); + var bitMask_3_4_ExponentMask = new BitMask(new[] { 0xFF000000 }, 33); Assert.AreEqual(bitMask_3_4_ExponentMask, unum_3_4_allOne.ExponentMask()); } From 5b14bf9dcf9600e5ec8940c0e795d968ee94bc6c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Fri, 17 Dec 2021 22:33:08 +0100 Subject: [PATCH 21/49] Fix S125 (Remove this commented out code). --- BitMask/BitMask.cs | 4 +- .../PositTests/Posit32Tests.cs | 2 - .../PositTests/PositTests.cs | 6 +- .../UnumTests/UnumTests.cs | 131 +--------------- Posit/Posit.cs | 1 - Posit/Posit32.cs | 2 - Unum/Unum.cs | 143 ------------------ 7 files changed, 6 insertions(+), 283 deletions(-) diff --git a/BitMask/BitMask.cs b/BitMask/BitMask.cs index 77b61b6..45c6bab 100644 --- a/BitMask/BitMask.cs +++ b/BitMask/BitMask.cs @@ -322,7 +322,6 @@ public BitMask SetSegment(int index, uint segment) public static BitMask operator >>(BitMask left, int right) { if (right < 0) return left << -right; - //if (right > left.Size) return new BitMask(left.Size); bool carryOld, carryNew; var segmentMaskWithLeadingOne = 0x80000000; // 1000 0000 0000 0000 0000 0000 0000 0000 @@ -356,7 +355,6 @@ public BitMask SetSegment(int index, uint segment) public static BitMask operator <<(BitMask left, int right) { if (right < 0) return left >> -right; - //if (right > left.Size) return new BitMask(left.Size); bool carryOld, carryNew; var segmentMaskWithLeadingOne = 0x80000000; // 1000 0000 0000 0000 0000 0000 0000 0000 @@ -461,7 +459,7 @@ public ushort GetLeastSignificantOnePosition() } // Array indexer is not supported by Hastlayer yet. - //public uint this[int i] => Segments[i]; + //// public uint this[int i] => Segments[i]; public uint GetLowest32Bits() => Segments[0]; diff --git a/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs b/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs index 0df0440..9329193 100644 --- a/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs +++ b/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs @@ -293,7 +293,6 @@ public void Posit32ToFloatIsCorrect() var posit12 = new Posit32(0.707106781F); Assert.AreEqual((float)posit12, 0.707106781F); - //Debug.WriteLine((float)0.707106781); } [Fact] @@ -334,7 +333,6 @@ public void Posit32ToDoubleIsCorrect() var posit12 = new Posit32((double)0.707106781); Assert.AreEqual((double)posit12, (double)0.7071067802608013); - //Debug.WriteLine((float)0.707106781); } [Fact] diff --git a/Lombiq.Arithmetics.Tests/PositTests/PositTests.cs b/Lombiq.Arithmetics.Tests/PositTests/PositTests.cs index 7c7cbe4..0d6dc80 100644 --- a/Lombiq.Arithmetics.Tests/PositTests/PositTests.cs +++ b/Lombiq.Arithmetics.Tests/PositTests/PositTests.cs @@ -264,9 +264,9 @@ public void AdditionIsCorrect() posit4_16_3.PositBits.ShouldBe(new Posit(_environment_16_3, 4).PositBits); // This will be OK, once the quire will be used. - //var posit66K_32_3 = new Posit.Posit(_environment_32_3, 66000); - //var posit66K1_32_3 = posit66K_32_3 + 1; - //posit66K1_32_3.PositBits.ShouldBe(new Posit.Posit(_environment_32_3, 66001).PositBits); + //// var posit66K_32_3 = new Posit.Posit(_environment_32_3, 66000); + //// var posit66K1_32_3 = posit66K_32_3 + 1; + //// posit66K1_32_3.PositBits.ShouldBe(new Posit.Posit(_environment_32_3, 66001).PositBits); var posit48 = new Posit(_environment_16_3, 48); var posit13200 = new Posit(_environment_16_3, 13200); diff --git a/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs b/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs index 96f007d..d6eada3 100644 --- a/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs +++ b/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs @@ -204,7 +204,7 @@ public void FractionToUintArrayIsCorrect() 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 + var unum500000 = new Unum(_environment_4_8, new uint[] { 500000 }); Assert.AreEqual(unum500000.FractionToUintArray(), new uint[] { 500000, 0, 0, 0, 0, 0, 0, 0, 0 }); var unumBig = new Unum(_environment_4_8, new uint[] { 594_967_295 }); @@ -215,35 +215,13 @@ public void FractionToUintArrayIsCorrect() { 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 }); } - //[Fact] - //public void UnumIsCorrectlyConstructedFromFloat() - //{ - // var first = new Unum(_metaData_3_4, (float)30.0); - // var second = new Unum(_metaData_3_4, (float)9999999999999); - // var third = new Unum(_metaData_3_4, (float)1.5); - // var five = new Unum(_metaData_3_5, (float)5); - // var fourth = new Unum(_metaData_3_5, 0.75F); - - // var bitMask_1 = new BitMask(new uint[] { 0x3F22 }, _metaData_3_4.Size); - // var bitMask_2 = new BitMask(new uint[] { 0x6A2309EF }, _metaData_3_4.Size); - // var bitMask_5 = new BitMask(new uint[] { 0x1A21 }, _metaData_3_5.Size); - // var bitMask_3 = new BitMask(new uint[] { 0x660 }, _metaData_3_4.Size); - // var bitMask_4 = new BitMask(new uint[] { 0xA40 }, _metaData_3_5.Size); - - // Assert.AreEqual(first.UnumBits, bitMask_1); - // Assert.AreEqual(second.UnumBits, bitMask_2); - // Assert.AreEqual(five.UnumBits, bitMask_5); - // Assert.AreEqual(fourth.UnumBits, bitMask_4); - // Assert.AreEqual(third.UnumBits, bitMask_3); - - //} - [Fact] public void UnumIsCorrectlyConstructedFromInt() { @@ -328,32 +306,6 @@ public void UnumIsCorrectlyConstructedFromUInt() Assert.AreEqual(bitMask6000, unum6000.UnumBits); } - //[Fact] - //public void UnumIsCorrectlyConstructedFromDouble() - //{ - // var first = new Unum(_metaData_3_4, (double)30.0); - // var second = new Unum(_metaData_3_4, (double)9999999999999); - - // var bitMask_1 = new BitMask(new uint[] { 0x3F22 }, _metaData_3_4.Size); - // var bitMask_2 = new BitMask(new uint[] { 0x6A2309EF }, _metaData_3_4.Size); - - // Assert.AreEqual(first.UnumBits, bitMask_1); - // Assert.AreEqual(second.UnumBits, bitMask_2); - //} - - //[Fact] - //public void UnumIsCorrectlyConstructedFromLong() - //{ - // var first = new Unum(_metaData_3_4, (long)30); - // var second = new Unum(_metaData_3_4, (long)9999999999999); - - // var bitMask_1 = new BitMask(new uint[] { 0x3F22 }, _metaData_3_4.Size); - // var bitMask_2 = new BitMask(new uint[] { 0x6A2309EF }, _metaData_3_4.Size); - - // Assert.AreEqual(first.UnumBits, bitMask_1); - // Assert.AreEqual(second.UnumBits, bitMask_2); - //} - [Fact] public void IsExactIsCorrect() { @@ -496,11 +448,6 @@ public void AddExactUnumsIsCorrect() 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); @@ -519,40 +466,6 @@ public void AdditionIsCorrectForIntegers() Assert.AreEqual(result.UnumBits, new Unum(_environment_3_5, 0).UnumBits); } - //[Fact] - //public void AdditionIsCorrectForFloats() - //{ - // var res = new Unum(_metaData_3_5, 0); - // var res2 = new Unum(_metaData_3_5, 0); - // var end = 3; - // float facc = 0; - - // for (int i = 1; i <= end; i++) - // { - // facc += (float)(i * 0.5F); - // res += new Unum(_metaData_3_5, (float)(i * 0.5F)); - // } - // //res += new Unum(_metaData_3_5, 0); - // for (int i = 1; i <= end; i++) - // { - - // facc -= (float)(i * 0.5F); - // res -= new Unum(_metaData_3_5, (float)(i * 0.5F)); - // } - // var f = (float)res; - // //Assert.AreEqual(res.IsZero(), true); - // Assert.AreEqual(facc, f); - // Assert.AreEqual(res.UnumBits, new Unum(_metaData_3_5, 0).UnumBits); - - // var res3 = new Unum(_metaData_3_5, 0.5F); - // var res1 = new Unum(_metaData_3_5, (float)13.0); - // var res2 = new Unum(_metaData_3_5, (float)4.0); - // res3 = res1 + res2; - // res3 -= res2; - // res3 -= res1; - // Assert.AreEqual((float)res3, 0.5F); - //} - [Fact] public void SubtractExactUnumsIsCorrect() { @@ -667,19 +580,6 @@ public void UnumToIntIsCorrect() Assert.AreEqual(numberNegative1000, -1000); } - //[Fact] - //public void FloatToUnumIsCorrect() - //{ - // var first = new Unum(_environment_3_4, (float)30.0); - // var second = new Unum(_environment_3_4, (float)9999999999999); - - // var bitMask_1 = new BitMask(new uint[] { 0x3F22 }, 33); - // var bitMask_2 = new BitMask(new uint[] { 0x6A2309EF }, 33); - - // Assert.AreEqual(first.UnumBits, bitMask_1); - // Assert.AreEqual(second.UnumBits, bitMask_2); - //} - [Fact] public void UnumToFloatIsCorrect() { @@ -699,32 +599,5 @@ public void UnumToFloatIsCorrect() var numberNegative1000 = (float)unumNegative1000; Assert.AreEqual(numberNegative1000, -1000); } - - //[Fact] - //public void UnumToDoubleIsCorrect() - //{ - // var unum30 = new Unum(_metaData_3_4, 30); - // var unum1000 = new Unum(_metaData_3_4, 1000); - // var unumNegativeThirty = new Unum(_metaData_3_4, -30); - // var unumNegativeThousand = new Unum(_metaData_3_4, -1000); - - // var tooBigUnum = new Unum(_metaData_3_4, (double)9999999999999); - // var tooBigNegativeUnum = new Unum(_metaData_3_4, (double)-9999999999999); - - // var thirty = (double)unum30; - // var thousand = (double)unum1000; - // var negativeThirty = (double)unumNegativeThirty; - // var negativeThousand = (double)unumNegativeThousand; - // var tooBig = (double)tooBigUnum; - // var tooBigNegative = (double)tooBigNegativeUnum; - - // Assert.AreEqual(thirty, (double)30); - // Assert.AreEqual(thousand, (double)1000); - // Assert.AreEqual(negativeThirty, (double)-30); - // Assert.AreEqual(negativeThousand, (double)-1000); - // Assert.AreEqual(tooBig, (double)9999891824640); // Some information is lost due to limited size of Unum. - // Assert.AreEqual(tooBigNegative, (double)-9999891824640); // Some information is lost due to limited size of Unum. - //} - } } diff --git a/Posit/Posit.cs b/Posit/Posit.cs index 8464772..fc15126 100644 --- a/Posit/Posit.cs +++ b/Posit/Posit.cs @@ -183,7 +183,6 @@ public int GetRegimeKValue() public int CalculateScaleFactor() { if (GetRegimeKValue() == -(Size - 1)) return 0; - //return (int)((GetRegimeKValue() == 0) ? 1 + GetExponentValue() : (GetRegimeKValue() * (1 << MaximumExponentSize) + GetExponentValue())); return (int)((GetRegimeKValue() * (1 << MaximumExponentSize)) + GetExponentValue()); } diff --git a/Posit/Posit32.cs b/Posit/Posit32.cs index ed7a233..dfef9e1 100644 --- a/Posit/Posit32.cs +++ b/Posit/Posit32.cs @@ -296,7 +296,6 @@ public static uint AssemblePositBitsWithRounding(bool signBit, int regimeKValue, { if (Size + fractionShiftedLeftBy >= 0) fractionBits <<= Size + fractionShiftedLeftBy; else fractionBits >>= -(Size - fractionShiftedLeftBy); - //return !signBit ? wholePosit : GetTwosComplement(wholePosit); if (fractionBits >= SignBitMask) { if (fractionBits == SignBitMask) @@ -331,7 +330,6 @@ public sbyte GetRegimeKValueWithoutSignCheck(byte lengthOfRunOfBits) => public short CalculateScaleFactor() { var regimeKvalue = GetRegimeKValue(); - //return (int)((GetRegimeKValue() == 0) ? 1 + GetExponentValue() : (GetRegimeKValue() * (1 << MaximumExponentSize) + GetExponentValue())); return (regimeKvalue == -FirstRegimeBitPosition) ? (short)0 : (short)((regimeKvalue * (1 << MaximumExponentSize)) + GetExponentValue()); } diff --git a/Unum/Unum.cs b/Unum/Unum.cs index e53fbcd..36cac91 100644 --- a/Unum/Unum.cs +++ b/Unum/Unum.cs @@ -267,102 +267,6 @@ public Unum(UnumEnvironment environment, int value) } - // This doesn't work for all cases yet. - //public Unum(UnumEnvironment environment, double x) - //{ - // _environment = environment; - // UnumBits = _environment.EmptyBitMask; - - // // Handling special cases first. - // if (double.IsNaN(x)) - // { - // UnumBits = QuietNotANumber; - // return; - // } - // if (double.IsPositiveInfinity(x)) - // { - // UnumBits = PositiveInfinity; - // return; - // } - // if (double.IsNegativeInfinity(x)) - // { - // UnumBits = NegativeInfinity; - // return; - // } - - // var doubleBits = BitConverter.ToUInt64(BitConverter.GetBytes(x), 0); - // SetSignBit((doubleBits > ulong.MaxValue / 2)); - - // var doubleFractionBits = (BitConverter.ToUInt64(BitConverter.GetBytes(x), 0) << 12) >> 12; - // uint resultFractionSize = 52; - - // if (doubleFractionBits == 0) resultFractionSize = 0; - // else - // { - // while (doubleFractionBits % 2 == 0) - // { - // resultFractionSize -= 1; - // doubleFractionBits >>= 1; - // } - - // } - - // var uncertainty = false; - - // if (FractionSizeMax < resultFractionSize - 1) - // { - // SetFractionSizeBits((uint)(FractionSizeMax - 1)); - // uncertainty = true; - // } - // else SetFractionSizeBits(resultFractionSize - 1); - - // var doubleExponentBits = (BitConverter.ToUInt64(BitConverter.GetBytes(x), 0) << 1) >> 53; - - // // These are the only uncertain cases that we can safely handle without Ubounds. - // if (ExponentSizeMax < ExponentValueToExponentSize((int)doubleExponentBits - 1023)) - // { - // // The exponent is too big, so we express the number as the largest possible signed value, - // // but the Unum is uncertain, meaning that it's finite, but too big to express. - // if (doubleExponentBits - 1023 > 0) - // UnumBits = IsPositive() ? LargestPositive : LargestNegative; - // else // If the exponent is too small, we will handle it as a signed uncertain zero. - // { - // UnumBits = _environment.EmptyBitMask; - // if (!IsPositive()) Negate(); - // } - - // SetUncertainityBit(true); - - // return; - // } - - // var exponentSizeBits = ExponentValueToExponentSize((int)doubleExponentBits - 1023) - 1; - // SetExponentSizeBits(exponentSizeBits); - - // var doubleFraction = new uint[2]; - // doubleFraction[0] = (uint)((doubleFractionBits << 32) >> 32); - // doubleFraction[1] = (uint)((doubleFractionBits >> 32)); - - // if (uncertainty) - // { - // SetFractionBits(Size > 32 ? - // // This is necessary because Hastlayer enables only one size of BitMasks. - // new BitMask(doubleFraction, Size) >> ((int)resultFractionSize - (int)FractionSize()) : - // // The lower 32 bits wouldn't fit in anyway. - // new BitMask(new uint[] { doubleFraction[1] }, Size) >> ((int)resultFractionSize - FractionSizeMax)); - - // SetUncertainityBit(true); - // } - // else - // SetFractionBits(Size > 32 ? - // // This is necessary because Hastlayer enables only one size of BitMasks. - // new BitMask(doubleFraction, Size) : - // // The lower 32 bits wouldn't fit in anyway. - // new BitMask(new uint[] { doubleFraction[1] }, Size)); - - // SetExponentBits(ExponentValueToExponentBits((int)(doubleExponentBits - 1023), Size)); - //} - #endregion #region Methods to set the values of individual Unum structure elements @@ -758,57 +662,10 @@ public static BitMask AddAlignedFractions(BitMask left, BitMask right, bool sign public static Unum operator -(Unum left, Unum right) => SubtractExactUnums(left, right); - //public static Unum operator *(Unum left, Unum right) - //{ - // if (left.IsExact() && right.IsExact()) return MultiplyExactUnums(left, right); - - // return new Unum(); - //} - - //public static Unum operator /(Unum left, Unum right) - //{ - - //} - public static bool operator ==(Unum left, Unum right) => AreEqualExactUnums(left, right); public static bool operator !=(Unum left, Unum right) => !(left == right); - //public static bool operator <(Unum left, Unum right) - // { - // if (left.IsPositive() != right.IsPositive()) return left.IsPositive(); - // if (left.ExponentValueWithBias() > right.ExponentValueWithBias()) return left.IsPositive(); - // if (left.ExponentValueWithBias() < right.ExponentValueWithBias()) return right.IsPositive(); - // // if (left.FractionWithHiddenBit()) - - // return false; - // } - - //public static bool operator >(Unum left, Unum right) - //{ - - //} - - //public static bool operator <=(Unum left, Unum right) - //{ - - //} - - //public static bool operator >=(Unum left, Unum right) - //{ - - //} - - //public static implicit operator Unum(short x) - //{ - - //} - - //public static implicit operator Unum(ushort x) - //{ - - //} - //Converting from an Unum to int results in information loss, so only allowing it explicitly (with a cast). public static explicit operator int(Unum x) { From f569d4b6c4fe0ce71b68bbbcdc884d75b9696094 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Fri, 17 Dec 2021 22:40:45 +0100 Subject: [PATCH 22/49] Fix SA1520 (Use braces consistently). --- BitMask/BitMask.cs | 10 ++++++++-- Posit/Posit.cs | 25 ++++++++++++++++++++----- Posit/Posit32.cs | 42 +++++++++++++++++++++++++++++++++--------- Unum/Unum.cs | 21 ++++++++++++++++----- 4 files changed, 77 insertions(+), 21 deletions(-) diff --git a/BitMask/BitMask.cs b/BitMask/BitMask.cs index 45c6bab..5606a78 100644 --- a/BitMask/BitMask.cs +++ b/BitMask/BitMask.cs @@ -42,7 +42,10 @@ public BitMask(uint[] segments, ushort size = 0) Array.Copy(segments, extendedSegments, segments.Length); Segments = ImmutableArray.CreateRange(extendedSegments); } - else Segments = ImmutableArray.CreateRange(segments); + else + { + Segments = ImmutableArray.CreateRange(segments); + } } public BitMask(ushort size, bool allOne = false) @@ -442,7 +445,10 @@ public ushort GetLeastSignificantOnePosition() for (ushort i = 0; i < SegmentCount; i++) { currentSegment = Segments[i]; - if (currentSegment == 0) position += 32; + if (currentSegment == 0) + { + position += 32; + } else { while (currentSegment % 2 == 0) diff --git a/Posit/Posit.cs b/Posit/Posit.cs index fc15126..c976075 100644 --- a/Posit/Posit.cs +++ b/Posit/Posit.cs @@ -94,7 +94,10 @@ public BitMask EncodeRegimeBits(int regimeKValue) regimeBits = (new BitMask(1, _environment.Size) << (regimeKValue + 1)) - 1; regimeBits <<= _environment.Size - regimeBits.GetMostSignificantOnePosition() - 1; } - else regimeBits = _environment.FirstRegimeBitBitMask << regimeKValue; + else + { + regimeBits = _environment.FirstRegimeBitBitMask << regimeKValue; + } return regimeBits; } @@ -140,7 +143,10 @@ private BitMask AssemblePositBitsWithRounding(bool signBit, int regimeKValue, Bi { wholePosit += wholePosit.GetLowest32Bits() & 1; } - else wholePosit += 1; + else + { + wholePosit += 1; + } } return !signBit ? wholePosit : wholePosit.GetTwosComplement(_environment.Size); @@ -165,7 +171,10 @@ private BitMask AssemblePositBitsWithRounding(bool signBit, int regimeKValue, Bi { wholePosit += wholePosit.GetLowest32Bits() & 1; } - else wholePosit += 1; + else + { + wholePosit += 1; + } } } @@ -321,7 +330,10 @@ public static int CalculateScaleFactor(int regimeKValue, uint exponentValue, byt resultFractionBits += right.FractionWithHiddenBit() << (biggerPositMovedToLeft - scaleFactorDifference + fractionSizeDifference); } - else resultFractionBits -= right.FractionWithHiddenBit() << (biggerPositMovedToLeft - scaleFactorDifference + fractionSizeDifference); + else + { + resultFractionBits -= right.FractionWithHiddenBit() << (biggerPositMovedToLeft - scaleFactorDifference + fractionSizeDifference); + } scaleFactor += resultFractionBits.GetMostSignificantOnePosition() - (left.Size - 1); } @@ -336,7 +348,10 @@ public static int CalculateScaleFactor(int regimeKValue, uint exponentValue, byt { resultFractionBits += left.FractionWithHiddenBit() << (biggerPositMovedToLeft + scaleFactorDifference + fractionSizeDifference); } - else resultFractionBits -= left.FractionWithHiddenBit() << (biggerPositMovedToLeft + scaleFactorDifference + fractionSizeDifference); + else + { + resultFractionBits -= left.FractionWithHiddenBit() << (biggerPositMovedToLeft + scaleFactorDifference + fractionSizeDifference); + } scaleFactor += resultFractionBits.GetMostSignificantOnePosition() - (right.Size - 1); } diff --git a/Posit/Posit32.cs b/Posit/Posit32.cs index dfef9e1..d737ec2 100644 --- a/Posit/Posit32.cs +++ b/Posit/Posit32.cs @@ -253,7 +253,10 @@ public static uint EncodeRegimeBits(int regimeKValue) regimeBits = (uint)(1 << (regimeKValue + 1)) - 1; regimeBits <<= Size - GetMostSignificantOnePosition(regimeBits) - 1; } - else regimeBits = FirstRegimeBitBitMask >> -regimeKValue; + else + { + regimeBits = FirstRegimeBitBitMask >> -regimeKValue; + } return regimeBits; } @@ -302,7 +305,10 @@ public static uint AssemblePositBitsWithRounding(bool signBit, int regimeKValue, { wholePosit += wholePosit & 1; } - else wholePosit += 1; + else + { + wholePosit += 1; + } } } @@ -344,7 +350,11 @@ public byte ExponentSize() result = Size - (lengthOfRunOfBits + 2) > MaximumExponentSize ? MaximumExponentSize : (byte)(Size - (lengthOfRunOfBits + 2)); } - else result = (byte)(Size - lengthOfRunOfBits - 1); + else + { + result = (byte)(Size - lengthOfRunOfBits - 1); + } + return result; } @@ -765,11 +775,17 @@ public static Posit32 FusedMultiplyMultiplySubtract(Posit32 a, Posit32 b, Posit3 { resultFractionBits += rightFraction << smallerPositMovedToLeft; } - else resultFractionBits += rightFraction >> -smallerPositMovedToLeft; + else + { + resultFractionBits += rightFraction >> -smallerPositMovedToLeft; + } } - else resultFractionBits -= smallerPositMovedToLeft >= 0 + else + { + resultFractionBits -= smallerPositMovedToLeft >= 0 ? rightFraction << smallerPositMovedToLeft : rightFraction >> -smallerPositMovedToLeft; + } scaleFactor += (short)(GetMostSignificantOnePosition(resultFractionBits) - FirstRegimeBitPosition); } @@ -786,14 +802,19 @@ public static Posit32 FusedMultiplyMultiplySubtract(Posit32 a, Posit32 b, Posit3 { resultFractionBits += leftFraction << (biggerPositMovedToLeft + scaleFactorDifference + fractionSizeDifference); } - else resultFractionBits += leftFraction >> -(biggerPositMovedToLeft + scaleFactorDifference + fractionSizeDifference); - + else + { + resultFractionBits += leftFraction >> -(biggerPositMovedToLeft + scaleFactorDifference + fractionSizeDifference); + } } else if (biggerPositMovedToLeft + scaleFactorDifference + fractionSizeDifference >= 0) { resultFractionBits -= leftFraction << (biggerPositMovedToLeft + scaleFactorDifference + fractionSizeDifference); } - else resultFractionBits -= leftFraction >> -(biggerPositMovedToLeft + scaleFactorDifference + fractionSizeDifference); + else + { + resultFractionBits -= leftFraction >> -(biggerPositMovedToLeft + scaleFactorDifference + fractionSizeDifference); + } scaleFactor += (short)(GetMostSignificantOnePosition(resultFractionBits) - FirstRegimeBitPosition); } @@ -929,7 +950,10 @@ public static explicit operator int(Posit32 x) -(int)(scaleFactor - mostSignificantOnePosition + 1); } } - else return x.IsPositive() ? int.MaxValue : int.MinValue; + else + { + return x.IsPositive() ? int.MaxValue : int.MinValue; + } return x.IsPositive() ? (int)result : (int)-result; } diff --git a/Unum/Unum.cs b/Unum/Unum.cs index 36cac91..899e612 100644 --- a/Unum/Unum.cs +++ b/Unum/Unum.cs @@ -389,7 +389,10 @@ public uint[] FractionToUintArray() var result = new uint[resultMask.SegmentCount]; for (var i = 0; i < resultMask.SegmentCount; i++) result[i] = resultMask.Segments[i]; - if (!IsPositive()) result[resultMask.SegmentCount - 1] |= 0x80000000; + if (!IsPositive()) + { + result[resultMask.SegmentCount - 1] |= 0x80000000; + } else { result[resultMask.SegmentCount - 1] <<= 1; @@ -526,10 +529,15 @@ public static Unum AddExactUnums(Unum left, Unum right) } // Otherwise we get the Sign of the number that has a Hidden Bit set. - else resultSignBit = left.HiddenBitIsOne() ? !left.IsPositive() : !right.IsPositive(); + else + { + resultSignBit = left.HiddenBitIsOne() ? !left.IsPositive() : !right.IsPositive(); + } + } + else + { + resultSignBit = !left.IsPositive(); } - else resultSignBit = !left.IsPositive(); - } else if (exponentValueDifference > 0) // Left Exponent is bigger. { @@ -585,7 +593,10 @@ public static Unum AddExactUnums(Unum left, Unum right) resultExponent = scratchPad; // 0 resultExponentSize = 0; // If the Fraction is zero, so is the ExponentSize. } - else resultFractionSize = (ushort)(scratchPad.GetMostSignificantOnePosition() - 1); + else + { + resultFractionSize = (ushort)(scratchPad.GetMostSignificantOnePosition() - 1); + } if (resultExponent.GetMostSignificantOnePosition() != 0) // Erase the hidden bit if it is set. { From 64313adb8c142838f3ae646373dfeef7b1ccb861 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Fri, 17 Dec 2021 23:07:50 +0100 Subject: [PATCH 23/49] Fix SA1513 (Closing brace should be followed by blank line). --- Lombiq.Arithmetics.Tests/BitMaskTests.cs | 1 + Lombiq.Arithmetics.Tests/PositTests/PositTests.cs | 4 +++- Lombiq.Arithmetics.Tests/UnumTests/UnumHelperTests.cs | 1 + 3 files changed, 5 insertions(+), 1 deletion(-) diff --git a/Lombiq.Arithmetics.Tests/BitMaskTests.cs b/Lombiq.Arithmetics.Tests/BitMaskTests.cs index 8df70fb..eaa07e7 100644 --- a/Lombiq.Arithmetics.Tests/BitMaskTests.cs +++ b/Lombiq.Arithmetics.Tests/BitMaskTests.cs @@ -54,6 +54,7 @@ public void BitMaskSetOneIsCorrect() Assert.AreEqual(new BitMask(new uint[] { 0, 0, 0xFFFF }), new BitMask(new uint[] { 0, 0, 0xFFFF }).SetOne(79)); Assert.AreEqual(new BitMask(new uint[] { 0, 0, 0x1FFFF }), new BitMask(new uint[] { 0, 0, 0xFFFF }).SetOne(80)); } + [Fact] public void BitMaskSetZeroIsCorrect() { diff --git a/Lombiq.Arithmetics.Tests/PositTests/PositTests.cs b/Lombiq.Arithmetics.Tests/PositTests/PositTests.cs index 0d6dc80..04a4b7e 100644 --- a/Lombiq.Arithmetics.Tests/PositTests/PositTests.cs +++ b/Lombiq.Arithmetics.Tests/PositTests/PositTests.cs @@ -290,6 +290,7 @@ public void AdditionIsCorrectForPositives() { posit1 += 1; } + posit1.PositBits.ShouldBe(new Posit(_environment_32_3, 10000).PositBits); var posit1_32_2 = new Posit(_environment_32_2, 1); @@ -298,6 +299,7 @@ public void AdditionIsCorrectForPositives() { posit1_32_2 += 1; } + posit1_32_2.PositBits.ShouldBe(new Posit(_environment_32_2, 10000).PositBits); } @@ -327,10 +329,10 @@ public void AdditionIsCorrectForNegatives() { positA += positB; } + var result = (int)positA; Assert.AreEqual(result, 100000); } } } - diff --git a/Lombiq.Arithmetics.Tests/UnumTests/UnumHelperTests.cs b/Lombiq.Arithmetics.Tests/UnumTests/UnumHelperTests.cs index 5536206..79a26ed 100644 --- a/Lombiq.Arithmetics.Tests/UnumTests/UnumHelperTests.cs +++ b/Lombiq.Arithmetics.Tests/UnumTests/UnumHelperTests.cs @@ -33,6 +33,7 @@ public void BitsRequiredByLargestExpressablePositiveIntegerIsCorrect() Assert.AreEqual(UnumHelper.BitsRequiredByLargestExpressablePositiveInteger(_environment_3_2), 129); } + [Fact] public void LargestExpressablePositiveIntegerIsCorrect() { From 9a20fcc069dddf44fcaa00b97cd2621331e65956 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Fri, 17 Dec 2021 23:42:48 +0100 Subject: [PATCH 24/49] Fix SA1128 and CA1305. --- Lombiq.Arithmetics.Tests/BitMaskTests.cs | 1 - Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs | 4 ++-- Lombiq.Arithmetics.Tests/PositTests/PositTests.cs | 1 - Lombiq.Arithmetics.Tests/UnumTests/UnumHelperTests.cs | 2 -- Posit/Posit.cs | 2 -- Posit/Posit32.cs | 8 ++++---- Unum/Unum.cs | 4 ---- Unum/UnumEnvironment.cs | 1 - Unum/UnumException.cs | 6 ++++-- 9 files changed, 10 insertions(+), 19 deletions(-) diff --git a/Lombiq.Arithmetics.Tests/BitMaskTests.cs b/Lombiq.Arithmetics.Tests/BitMaskTests.cs index eaa07e7..71c1366 100644 --- a/Lombiq.Arithmetics.Tests/BitMaskTests.cs +++ b/Lombiq.Arithmetics.Tests/BitMaskTests.cs @@ -209,6 +209,5 @@ public void LengthOfRunOfBitsIsCorrect() new BitMask(new uint[] { 0x00000013 }).LengthOfRunOfBits(5).ShouldBe((ushort)1); new BitMask(new uint[] { 17 }).LengthOfRunOfBits(5).ShouldBe((ushort)1); } - } } diff --git a/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs b/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs index 9329193..6149608 100644 --- a/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs +++ b/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs @@ -91,6 +91,7 @@ public void Posit32AdditionIsCorrectForPositives() { posit1 += 1; } + posit1.PositBits.ShouldBe(new Posit32(50_000).PositBits); } @@ -474,7 +475,7 @@ public void Posit32SquareRootIsCorrect() Posit32.Sqrt(posit625).PositBits.ShouldBe(new Posit32(25).PositBits); var positSmallerThanOne1 = new Posit32(0.5F); - Debug.WriteLine(((float)Posit32.Sqrt(positSmallerThanOne1)).ToString("0.0000000000")); + Debug.WriteLine(((float)Posit32.Sqrt(positSmallerThanOne1)).ToString("0.0000000000", CultureInfo.InvariantCulture)); Posit32.Sqrt(positSmallerThanOne1).PositBits.ShouldBe(new Posit32(0b_00111011_01010000_01001111_00110011, true).PositBits); var positBig = new Posit32(1_004_004); @@ -493,7 +494,6 @@ public void Posit32ToStringIsCorrect() posit2.ToString(CultureInfo.InvariantCulture).ShouldBe("-200000"); posit3.ToString("0.############", CultureInfo.InvariantCulture).ShouldBe("125.125450134277"); posit4.ToString("0.###############", CultureInfo.InvariantCulture).ShouldBe("0.998999997973442"); - } } } diff --git a/Lombiq.Arithmetics.Tests/PositTests/PositTests.cs b/Lombiq.Arithmetics.Tests/PositTests/PositTests.cs index 04a4b7e..65a209f 100644 --- a/Lombiq.Arithmetics.Tests/PositTests/PositTests.cs +++ b/Lombiq.Arithmetics.Tests/PositTests/PositTests.cs @@ -334,5 +334,4 @@ public void AdditionIsCorrectForNegatives() Assert.AreEqual(result, 100000); } } - } diff --git a/Lombiq.Arithmetics.Tests/UnumTests/UnumHelperTests.cs b/Lombiq.Arithmetics.Tests/UnumTests/UnumHelperTests.cs index 79a26ed..ebe4c2c 100644 --- a/Lombiq.Arithmetics.Tests/UnumTests/UnumHelperTests.cs +++ b/Lombiq.Arithmetics.Tests/UnumTests/UnumHelperTests.cs @@ -31,7 +31,6 @@ public void BitsRequiredByLargestExpressablePositiveIntegerIsCorrect() Assert.AreEqual(UnumHelper.BitsRequiredByLargestExpressablePositiveInteger(_environment_2_3), 9); Assert.AreEqual(UnumHelper.BitsRequiredByLargestExpressablePositiveInteger(_environment_2_4), 9); Assert.AreEqual(UnumHelper.BitsRequiredByLargestExpressablePositiveInteger(_environment_3_2), 129); - } [Fact] @@ -43,7 +42,6 @@ public void LargestExpressablePositiveIntegerIsCorrect() Assert.AreEqual(UnumHelper.LargestExpressablePositiveInteger(_environment_2_2), new BitMask(480, _environment_2_2.Size)); Assert.AreEqual(UnumHelper.LargestExpressablePositiveInteger(_environment_2_3), new BitMask(510, _environment_2_3.Size)); Assert.AreEqual(UnumHelper.LargestExpressablePositiveInteger(_environment_2_4), new BitMask(511, _environment_2_4.Size)); - } } } diff --git a/Posit/Posit.cs b/Posit/Posit.cs index c976075..b4d0f7c 100644 --- a/Posit/Posit.cs +++ b/Posit/Posit.cs @@ -328,7 +328,6 @@ public static int CalculateScaleFactor(int regimeKValue, uint exponentValue, byt if (signBitsMatch) { resultFractionBits += right.FractionWithHiddenBit() << (biggerPositMovedToLeft - scaleFactorDifference + fractionSizeDifference); - } else { @@ -385,7 +384,6 @@ public static int CalculateScaleFactor(int regimeKValue, uint exponentValue, byt if (!left.IsPositive()) left = -left; if (!right.IsPositive()) right = -right; return (left.PositBits + right.PositBits).GetMostSignificantOnePosition() > left.PositBits.Size; - } public static bool operator <(Posit left, Posit right) => !(left.PositBits > right.PositBits); diff --git a/Posit/Posit32.cs b/Posit/Posit32.cs index d737ec2..b27851d 100644 --- a/Posit/Posit32.cs +++ b/Posit/Posit32.cs @@ -1,4 +1,5 @@ using System; +using System.Globalization; using System.Runtime.CompilerServices; namespace Lombiq.Arithmetics @@ -648,7 +649,6 @@ public static Posit32 FusedDotProduct(Posit32[] positArray1, Posit32[] positArra if (positArray1[i].IsNaN()) return positArray1[i]; if (positArray2[i].IsNaN()) return positArray2[i]; resultQuire += MultiplyIntoQuire(positArray1[i], positArray2[i]); - } return new Posit32(resultQuire); @@ -1074,17 +1074,17 @@ public int CompareTo(Posit32 value) else return 1; } - public override string ToString() => ((double)this).ToString(); + public override string ToString() => ((double)this).ToString(CultureInfo.InvariantCulture); public string ToString(string format, IFormatProvider formatProvider) => ((double)this).ToString(format, formatProvider); public string ToString(IFormatProvider provider) => ((double)this).ToString(provider); - public Posit32 Parse(string number) => new(Double.Parse(number)); + public Posit32 Parse(string number) => new(double.Parse(number, CultureInfo.InvariantCulture)); public bool TryParse(string number, out Posit32 positResult) { - var returnValue = Double.TryParse(number, out double result); + var returnValue = double.TryParse(number, out double result); positResult = new Posit32(result); return returnValue; } diff --git a/Unum/Unum.cs b/Unum/Unum.cs index 899e612..d222077 100644 --- a/Unum/Unum.cs +++ b/Unum/Unum.cs @@ -264,7 +264,6 @@ public Unum(UnumEnvironment environment, int value) valueArray[0] = (uint)-value; UnumBits = new Unum(environment, valueArray, true).UnumBits; } - } #endregion @@ -525,7 +524,6 @@ public static Unum AddExactUnums(Unum left, Unum right) resultSignBit = left.Fraction() >= right.Fraction() ? !left.IsPositive() // Left Fraction is bigger. : !right.IsPositive(); // Right Fraction is bigger. - } // Otherwise we get the Sign of the number that has a Hidden Bit set. @@ -636,11 +634,9 @@ public static BitMask ExponentValueToExponentBits(int value, ushort size) if (value < 0) // In case of a negative exponent the { exponent -= (uint)(-2 * value); - } return exponent; - } public static byte ExponentValueToExponentSize(int value) diff --git a/Unum/UnumEnvironment.cs b/Unum/UnumEnvironment.cs index d7aff70..bbb17dd 100644 --- a/Unum/UnumEnvironment.cs +++ b/Unum/UnumEnvironment.cs @@ -164,7 +164,6 @@ public UnumEnvironment(byte exponentSizeSize, byte fractionSizeSize) QuietNotANumber = PositiveInfinity + UncertaintyBitMask; SignalingNotANumber = NegativeInfinity + UncertaintyBitMask; - } public static UnumEnvironment FromConfigurationValues(byte eSize, ushort fSize) => diff --git a/Unum/UnumException.cs b/Unum/UnumException.cs index 440c3f4..63b3f87 100644 --- a/Unum/UnumException.cs +++ b/Unum/UnumException.cs @@ -4,8 +4,10 @@ namespace Lombiq.Arithmetics { public class UnumException : Exception { - public UnumException(string message) : base(message) { } + public UnumException(string message) + : base(message) { } - public UnumException(string message, Exception innerException) : base(message, innerException) { } + public UnumException(string message, Exception innerException) + : base(message, innerException) { } } } From 6a321e99fd093d590617dc554fdf6a87b15fe348 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Fri, 17 Dec 2021 23:52:16 +0100 Subject: [PATCH 25/49] Fix SA1505 (An opening brace should not be followed by a blank line). --- Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs | 1 - Lombiq.Arithmetics.Tests/PositTests/PositTests.cs | 1 - Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs | 1 - Posit/Posit32.cs | 1 - Posit/Quire.cs | 1 - Unum/Unum.cs | 2 -- 6 files changed, 7 deletions(-) diff --git a/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs b/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs index 6149608..e872777 100644 --- a/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs +++ b/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs @@ -9,7 +9,6 @@ namespace Lombiq.Arithmetics.Tests { public class Posit32Tests { - [Fact] public void EncodeRegimeBitsIsCorrect() { diff --git a/Lombiq.Arithmetics.Tests/PositTests/PositTests.cs b/Lombiq.Arithmetics.Tests/PositTests/PositTests.cs index 65a209f..00fe61a 100644 --- a/Lombiq.Arithmetics.Tests/PositTests/PositTests.cs +++ b/Lombiq.Arithmetics.Tests/PositTests/PositTests.cs @@ -50,7 +50,6 @@ public void EncodeRegimeBitsIsCorrect() [Fact] public void PositIsCorrectlyConstructedFromUint() { - new Posit(_environment_6_3, 0U).PositBits.ShouldBe(new BitMask(0x0, _environment_6_3.Size)); new Posit(_environment_6_3, 2).PositBits.ShouldBe(new BitMask(17, _environment_6_3.Size)); diff --git a/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs b/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs index d6eada3..5b50813 100644 --- a/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs +++ b/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs @@ -84,7 +84,6 @@ public void WarlpiriUnumValuesAndCalculationsAreCorrect() [Fact] public void UnumIsCorrectlyConstructedFromUintArray() { - var unum0 = new Unum(_environment_4_8, new uint[] { 0 }); Assert.AreEqual(unum0.IsZero(), true); diff --git a/Posit/Posit32.cs b/Posit/Posit32.cs index b27851d..2f8053d 100644 --- a/Posit/Posit32.cs +++ b/Posit/Posit32.cs @@ -464,7 +464,6 @@ public static short CalculateScaleFactor(sbyte regimeKValue, uint exponentValue, public static Quire MultiplyIntoQuire(Posit32 left, Posit32 right) { - if (left.IsZero() || right.IsZero()) return new Quire((ushort)QuireSize); if (left.IsNaN() || right.IsNaN()) return new Quire(1, (ushort)QuireSize) << (QuireSize - 1); var leftIsPositive = left.IsPositive(); diff --git a/Posit/Quire.cs b/Posit/Quire.cs index a90621d..7cc27e7 100644 --- a/Posit/Quire.cs +++ b/Posit/Quire.cs @@ -24,7 +24,6 @@ public Quire(ulong[] segments, ushort size = 0) Size = size; if (size > SegmentCount << 6) { - SegmentCount = (ushort)((size >> 6) + (size % 32 == 0 ? 0 : 1)); } diff --git a/Unum/Unum.cs b/Unum/Unum.cs index d222077..9eeb3e7 100644 --- a/Unum/Unum.cs +++ b/Unum/Unum.cs @@ -555,7 +555,6 @@ public static Unum AddExactUnums(Unum left, Unum right) } else // Right Exponent is bigger. { - // We align the fractions according to their exponent values so the Most Significant Bit of the bigger // number gets to the leftmost position that the FractionSize allows. // This way the digits that won't fit automatically get lost. @@ -626,7 +625,6 @@ public static bool AreEqualExactUnums(Unum left, Unum right) => public static BitMask ExponentValueToExponentBits(int value, ushort size) { - var exponent = new BitMask((uint)((value < 0) ? -value : value), size); var exponentSize = ExponentValueToExponentSize(value); exponent += (uint)(1 << (exponentSize - 1)) - 1; // Applying bias From 1da205cc6e29046e99bef257cfb5b7d8dea11faf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Sat, 18 Dec 2021 00:09:44 +0100 Subject: [PATCH 26/49] Fix SA1108 and SA1117. --- .../UnumTests/UnumEnvironmentTests.cs | 8 +-- Posit/Posit.cs | 6 +- Posit/Posit32.cs | 12 ++-- Unum/Unum.cs | 62 +++++++++++++------ 4 files changed, 58 insertions(+), 30 deletions(-) diff --git a/Lombiq.Arithmetics.Tests/UnumTests/UnumEnvironmentTests.cs b/Lombiq.Arithmetics.Tests/UnumTests/UnumEnvironmentTests.cs index 3a6e348..9835428 100644 --- a/Lombiq.Arithmetics.Tests/UnumTests/UnumEnvironmentTests.cs +++ b/Lombiq.Arithmetics.Tests/UnumTests/UnumEnvironmentTests.cs @@ -151,8 +151,8 @@ public void UnumTagMaskIsCorrect() // 0 0000 0000 0000 0000 0000 0000 1 111 1111 Assert.AreEqual( - new BitMask(new uint[] { 0xFF, 0 }, - _unum_3_4.Size), _unum_3_4.UnumTagMask, + new BitMask(new uint[] { 0xFF, 0 }, _unum_3_4.Size), + _unum_3_4.UnumTagMask, TestFailureMessageBuilder(_unum_3_4, nameof(_unum_3_4.UnumTagMask))); } @@ -279,8 +279,8 @@ public void UnumLargestNegativeIsCorrect() // 1 1111 1111 1111 1111 1111 1110 0 111 1111 Assert.AreEqual( - new BitMask(new uint[] { 0xFFFFFE7F, 1 }, - _unum_3_4.Size), _unum_3_4.LargestNegative, + new BitMask(new uint[] { 0xFFFFFE7F, 1 }, _unum_3_4.Size), + _unum_3_4.LargestNegative, TestFailureMessageBuilder(_unum_3_4, nameof(_unum_3_4.LargestNegative))); } diff --git a/Posit/Posit.cs b/Posit/Posit.cs index b4d0f7c..7a29e4d 100644 --- a/Posit/Posit.cs +++ b/Posit/Posit.cs @@ -318,8 +318,9 @@ public static int CalculateScaleFactor(int regimeKValue, uint exponentValue, byt scaleFactor += resultFractionBits.GetMostSignificantOnePosition() - left.FractionWithHiddenBit().GetMostSignificantOnePosition(); } - else if (scaleFactorDifference > 0) // The scale factor of the left Posit is bigger. + else if (scaleFactorDifference > 0) { + // The scale factor of the left Posit is bigger. var fractionSizeDifference = (int)(left.FractionSize() - right.FractionSize()); resultFractionBits += left.FractionWithHiddenBit(); var biggerPositMovedToLeft = left.Size - 1 - left.FractionWithHiddenBit().GetMostSignificantOnePosition(); @@ -336,8 +337,9 @@ public static int CalculateScaleFactor(int regimeKValue, uint exponentValue, byt scaleFactor += resultFractionBits.GetMostSignificantOnePosition() - (left.Size - 1); } - else // The scale factor of the right Posit is bigger. + else { + // The scale factor of the right Posit is bigger. var fractionSizeDifference = (int)(right.FractionSize() - left.FractionSize()); resultFractionBits += right.FractionWithHiddenBit(); var biggerPositMovedToLeft = right.Size - 1 - right.FractionWithHiddenBit().GetMostSignificantOnePosition(); diff --git a/Posit/Posit32.cs b/Posit/Posit32.cs index 2f8053d..68a8d60 100644 --- a/Posit/Posit32.cs +++ b/Posit/Posit32.cs @@ -568,8 +568,9 @@ public static Posit32 Sqrt(Posit32 number) var inputScaleFactor = number.CalculateScaleFactor(); //m var inputFractionWithHiddenBit = number.FractionWithHiddenBitWithoutSignCheck(); - if ((inputScaleFactor & 1) != 0) // if the scaleFactor is odd, shift the number to make it even + if ((inputScaleFactor & 1) != 0) { + // if the scaleFactor is odd, shift the number to make it even inputScaleFactor -= 1; inputFractionWithHiddenBit += inputFractionWithHiddenBit; } @@ -760,8 +761,9 @@ public static Posit32 FusedMultiplyMultiplySubtract(Posit32 a, Posit32 b, Posit3 scaleFactor += (short)(GetMostSignificantOnePosition(resultFractionBits) - leftFractionSize - 1); } - else if (scaleFactorDifference > 0) // The scale factor of the left Posit is bigger. + else if (scaleFactorDifference > 0) { + // The scale factor of the left Posit is bigger. var fractionSizeDifference = (int)(leftFractionSize - rightFractionSize); resultFractionBits += leftFraction; var biggerPositMovedToLeft = (int)(FirstRegimeBitPosition - leftFractionSize - 1); @@ -788,8 +790,9 @@ public static Posit32 FusedMultiplyMultiplySubtract(Posit32 a, Posit32 b, Posit3 scaleFactor += (short)(GetMostSignificantOnePosition(resultFractionBits) - FirstRegimeBitPosition); } - else // The scale factor of the right Posit is bigger. + else { + // The scale factor of the right Posit is bigger. var fractionSizeDifference = (int)(rightFractionSize - leftFractionSize); resultFractionBits += rightFraction; var biggerPositMovedToLeft = (int)(FirstRegimeBitPosition - rightFractionSize - 1); @@ -934,8 +937,9 @@ public static explicit operator int(Posit32 x) var scaleFactor = (x.GetRegimeKValue() * (1 << MaximumExponentSize)) + x.GetExponentValue(); - if (scaleFactor + 1 <= 31) // The posit fits into the range + if (scaleFactor + 1 <= 31) { + // The posit fits into the range var mostSignificantOnePosition = GetMostSignificantOnePosition(x.FractionWithHiddenBit()); if (scaleFactor - mostSignificantOnePosition + 1 >= 0) diff --git a/Unum/Unum.cs b/Unum/Unum.cs index 9eeb3e7..7ae8a92 100644 --- a/Unum/Unum.cs +++ b/Unum/Unum.cs @@ -242,8 +242,13 @@ public Unum(UnumEnvironment environment, uint[] value, bool negative = false) uncertainityBit = true; } - UnumBits = AssembleUnumBits(negative, exponent, fraction, - uncertainityBit, (byte)(exponentSize > 0 ? --exponentSize : 0), (ushort)(fractionSize > 0 ? --fractionSize : 0)); + UnumBits = AssembleUnumBits( + negative, + exponent, + fraction, + uncertainityBit, + (byte)(exponentSize > 0 ? --exponentSize : 0), + (ushort)(fractionSize > 0 ? --fractionSize : 0)); } public Unum(UnumEnvironment environment, int value) @@ -280,8 +285,13 @@ public Unum(UnumEnvironment environment, int value) /// <param name="exponentSize">The Unum's exponent size, in a notation that is one less than the actual value.</param> /// <param name="fractionSize">The Unum's fraction size, in a notation that is one less than the actual value.</param> /// <returns>The BitMask representing the whole Unum with all the parts set.</returns> - private BitMask AssembleUnumBits(bool signBit, BitMask exponent, BitMask fraction, - bool uncertainityBit, byte exponentSize, ushort fractionSize) + private BitMask AssembleUnumBits( + bool signBit, + BitMask exponent, + BitMask fraction, + bool uncertainityBit, + byte exponentSize, + ushort fractionSize) { var wholeUnum = new BitMask(exponentSize, Size) << FractionSizeSize; wholeUnum += fractionSize; @@ -501,8 +511,9 @@ public static Unum AddExactUnums(Unum left, Unum right) var smallerBitsMovedToLeft = 0; var resultExponentValue = 0; - if (exponentValueDifference == 0) // Exponents are equal. + if (exponentValueDifference == 0) { + // Exponents are equal. resultExponentValue = left.ExponentValueWithBias(); // We align the fractions so their Most Significant Bit gets to the leftmost position that the @@ -517,18 +528,17 @@ public static Unum AddExactUnums(Unum left, Unum right) if (!signBitsMatch) { - // If the value of the Hidden Bits match we just compare the fractions, - // and get the Sign of the bigger one. if (left.HiddenBitIsOne() == right.HiddenBitIsOne()) { + // If the value of the Hidden Bits match we just compare the fractions, + // and get the Sign of the bigger one. resultSignBit = left.Fraction() >= right.Fraction() ? !left.IsPositive() // Left Fraction is bigger. : !right.IsPositive(); // Right Fraction is bigger. } - - // Otherwise we get the Sign of the number that has a Hidden Bit set. else { + // Otherwise we get the Sign of the number that has a Hidden Bit set. resultSignBit = left.HiddenBitIsOne() ? !left.IsPositive() : !right.IsPositive(); } } @@ -537,8 +547,9 @@ public static Unum AddExactUnums(Unum left, Unum right) resultSignBit = !left.IsPositive(); } } - else if (exponentValueDifference > 0) // Left Exponent is bigger. + else if (exponentValueDifference > 0) { + // Left Exponent is bigger. // We align the fractions according to their exponent values so the Most Significant Bit of the bigger // number gets to the leftmost position that the FractionSize allows. // This way the digits that won't fit automatically get lost. @@ -551,10 +562,12 @@ public static Unum AddExactUnums(Unum left, Unum right) // Adding the aligned Fractions. scratchPad = AddAlignedFractions( scratchPad, - right.FractionWithHiddenBit() << smallerBitsMovedToLeft, signBitsMatch); + right.FractionWithHiddenBit() << smallerBitsMovedToLeft, + signBitsMatch); } - else // Right Exponent is bigger. + else { + // Right Exponent is bigger. // We align the fractions according to their exponent values so the Most Significant Bit of the bigger // number gets to the leftmost position that the FractionSize allows. // This way the digits that won't fit automatically get lost. @@ -567,7 +580,8 @@ public static Unum AddExactUnums(Unum left, Unum right) // Adding the aligned Fractions. scratchPad = AddAlignedFractions( scratchPad, - left.FractionWithHiddenBit() << smallerBitsMovedToLeft, signBitsMatch); + left.FractionWithHiddenBit() << smallerBitsMovedToLeft, + signBitsMatch); } // Calculating how the addition changed the exponent of the result. @@ -584,9 +598,10 @@ public static Unum AddExactUnums(Unum left, Unum right) ushort resultFractionSize = 0; - //Calculating the results FractionSize. - if (scratchPad.GetMostSignificantOnePosition() == 0) // If the Fraction is zero, so is the FractionSize. + // Calculating the results FractionSize. + if (scratchPad.GetMostSignificantOnePosition() == 0) { + // If the Fraction is zero, so is the FractionSize. resultExponent = scratchPad; // 0 resultExponentSize = 0; // If the Fraction is zero, so is the ExponentSize. } @@ -595,8 +610,9 @@ public static Unum AddExactUnums(Unum left, Unum right) resultFractionSize = (ushort)(scratchPad.GetMostSignificantOnePosition() - 1); } - if (resultExponent.GetMostSignificantOnePosition() != 0) // Erase the hidden bit if it is set. + if (resultExponent.GetMostSignificantOnePosition() != 0) { + // Erase the hidden bit if it is set. scratchPad = scratchPad.SetZero((ushort)(scratchPad.GetMostSignificantOnePosition() - 1)); resultFractionSize = (ushort)(resultFractionSize == 0 ? 0 : resultFractionSize - 1); } @@ -606,8 +622,13 @@ public static Unum AddExactUnums(Unum left, Unum right) if ((!left.IsExact()) || (!right.IsExact())) resultUbit = true; // Setting the parts of the result Unum to the calculated values. - var resultBitMask = left.AssembleUnumBits(resultSignBit, resultExponent, scratchPad, - resultUbit, resultExponentSize, resultFractionSize); + var resultBitMask = left.AssembleUnumBits( + resultSignBit, + resultExponent, + scratchPad, + resultUbit, + resultExponentSize, + resultFractionSize); return new Unum(left._environment, resultBitMask); } @@ -617,7 +638,7 @@ public static Unum AddExactUnums(Unum left, Unum right) public static Unum NegateExactUnum(Unum input) => input.Negate(); public static bool AreEqualExactUnums(Unum left, Unum right) => - left.IsZero() && right.IsZero() ? true : left.UnumBits == right.UnumBits; + (left.IsZero() && right.IsZero()) || left.UnumBits == right.UnumBits; #endregion @@ -629,8 +650,9 @@ public static BitMask ExponentValueToExponentBits(int value, ushort size) var exponentSize = ExponentValueToExponentSize(value); exponent += (uint)(1 << (exponentSize - 1)) - 1; // Applying bias - if (value < 0) // In case of a negative exponent the + if (value < 0) { + // In case of a negative exponent the. exponent -= (uint)(-2 * value); } From 2461b9596af6829cae22c769057a861682cb18d8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Sat, 18 Dec 2021 03:28:19 +0100 Subject: [PATCH 27/49] Fix IDE0021 (Use expression body for constructors). --- Posit/Posit32.cs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/Posit/Posit32.cs b/Posit/Posit32.cs index 68a8d60..bca30a4 100644 --- a/Posit/Posit32.cs +++ b/Posit/Posit32.cs @@ -115,10 +115,10 @@ public Posit32(uint value) PositBits = AssemblePositBitsWithRounding(false, kValue, exponentValue, PositBits); } - public Posit32(int value) - { - PositBits = value >= 0 ? new Posit32((uint)value).PositBits : GetTwosComplement(new Posit32((uint)-value).PositBits); - } + public Posit32(int value) => + PositBits = value >= 0 + ? new Posit32((uint)value).PositBits + : GetTwosComplement(new Posit32((uint)-value).PositBits); public Posit32(float floatBits) { From fff4b8fb0314af8dbc36a29b6988fb43de036d19 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Sat, 18 Dec 2021 03:35:11 +0100 Subject: [PATCH 28/49] Fix S113 (Add a new line at the end of the file). --- Unum/UnumConfiguration.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Unum/UnumConfiguration.cs b/Unum/UnumConfiguration.cs index 5e703b2..a619354 100644 --- a/Unum/UnumConfiguration.cs +++ b/Unum/UnumConfiguration.cs @@ -46,4 +46,4 @@ public enum IeeeConfiguration ExtendedPrecision, // 80-bit (Intel x87). QuadPrecision, // 128-bit. } -} \ No newline at end of file +} From f33965755d2e57c68d22aa63f8505df9b363c774 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Sat, 18 Dec 2021 03:38:37 +0100 Subject: [PATCH 29/49] Fix Posit32Tests. --- .../PositTests/Posit32Tests.cs | 75 +++++++++---------- 1 file changed, 37 insertions(+), 38 deletions(-) diff --git a/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs b/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs index e872777..832996b 100644 --- a/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs +++ b/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs @@ -15,7 +15,7 @@ public void EncodeRegimeBitsIsCorrect() Assert.AreEqual(Posit32.EncodeRegimeBits(0), 0x_4000_0000); Assert.AreEqual(Posit32.EncodeRegimeBits(1), 0x_6000_0000); Assert.AreEqual(Posit32.EncodeRegimeBits(2), 0x_7000_0000); - Assert.AreEqual(Posit32.EncodeRegimeBits(-3), 0x_800_0000); + Assert.AreEqual(Posit32.EncodeRegimeBits(-3), 0x_0800_0000); Assert.AreEqual(Posit32.EncodeRegimeBits(-30), 0x_0000_0001); Assert.AreEqual(Posit32.EncodeRegimeBits(30), 0x_7FFF_FFFF); } @@ -60,15 +60,15 @@ public void Posit32AdditionIsCorrect() var posit1 = new Posit32(1); var posit0 = posit1 - 1; posit0.PositBits.ShouldBe(new Posit32(0).PositBits); - var positNegative_1 = posit0 - 1; - positNegative_1.PositBits.ShouldBe(0x_C000_0000); + var positNegative1 = posit0 - 1; + positNegative1.PositBits.ShouldBe(0x_C000_0000); - var positNegative_500 = new Posit32(-500); - var positNegative_499 = positNegative_500 + 1; - positNegative_499.PositBits.ShouldBe(new Posit32(-499).PositBits); + var positNegative500 = new Posit32(-500); + var positNegative499 = positNegative500 + 1; + positNegative499.PositBits.ShouldBe(new Posit32(-499).PositBits); - var positNegative_2 = positNegative_1 - 1; - positNegative_2.PositBits.ShouldBe(new Posit32(-2).PositBits); + var positNegative2 = positNegative1 - 1; + positNegative2.PositBits.ShouldBe(new Posit32(-2).PositBits); var posit3 = new Posit32(100.0125F); var posit4 = posit3 - 100; @@ -204,8 +204,8 @@ public void Posit32ToIntIsCorrect() var posit16384 = new Posit32(16_384); Assert.AreEqual((int)posit16384, 16_384); - var positNegative_13 = new Posit32(-13); - Assert.AreEqual((int)positNegative_13, -13); + var positNegative13 = new Posit32(-13); + Assert.AreEqual((int)positNegative13, -13); var positIntMaxValue = new Posit32(int.MaxValue); Assert.AreEqual((int)positIntMaxValue, int.MaxValue); @@ -225,7 +225,7 @@ public void Posit32IsCorrectlyConstructedFromFloat() Assert.AreEqual(new Posit32(-134.75F).PositBits, 0x_93CA_0000); Assert.AreEqual(new Posit32(100000.5F).PositBits, 0b_01111100_01000011_01010000_01000000); - Assert.AreEqual(new Posit32(-2000000.5F).PositBits, 0b_10000001_11000101_11101101_11111110); + Assert.AreEqual(new Posit32(-2_000_000.5F).PositBits, 0b_10000001_11000101_11101101_11111110); Assert.AreEqual( new Posit32( @@ -246,7 +246,7 @@ public void Posit32IsCorrectlyConstructedFromDouble() Assert.AreEqual(new Posit32(-134.75).PositBits, 0b_10010011_11001010_00000000_00000000); Assert.AreEqual(new Posit32(100000.5).PositBits, 0b_01111100_01000011_01010000_01000000); - Assert.AreEqual(new Posit32(-2000000.5).PositBits, 0b_10000001_11000101_11101101_11111110); + Assert.AreEqual(new Posit32(-2_000_000.5).PositBits, 0b_10000001_11000101_11101101_11111110); Assert.AreEqual( new Posit32( @@ -261,8 +261,8 @@ public void Posit32ToFloatIsCorrect() var posit1 = new Posit32(1); Assert.AreEqual((float)posit1, 1); - var positNegative_1234 = new Posit32(-1_234); - Assert.AreEqual((float)positNegative_1234, -1_234); + var positNegative1234 = new Posit32(-1_234); + Assert.AreEqual((float)positNegative1234, -1_234); var posit3 = new Posit32(0.75F); Assert.AreEqual((float)posit3, 0.75); @@ -273,8 +273,8 @@ public void Posit32ToFloatIsCorrect() var posit5 = new Posit32(100000.5F); Assert.AreEqual((float)posit5, 100000.5); - var posit6 = new Posit32(-2000000.5F); - Assert.AreEqual((float)posit6, -2000000.5); + var posit6 = new Posit32(-2_000_000.5F); + Assert.AreEqual((float)posit6, -2_000_000.5); var posit7 = new Posit32(-0.00179999996908009052276611328125F); Assert.AreEqual((float)posit7, -0.00179999996908009052276611328125); @@ -301,38 +301,38 @@ public void Posit32ToDoubleIsCorrect() var posit1 = new Posit32(1); Assert.AreEqual((double)posit1, 1); - var positNegative_1234 = new Posit32(-1_234); - Assert.AreEqual((double)positNegative_1234, -1_234); + var positNegative1234 = new Posit32(-1_234); + Assert.AreEqual((double)positNegative1234, -1_234); - var posit3 = new Posit32((double)0.75); + var posit3 = new Posit32(0.75); Assert.AreEqual((double)posit3, 0.75); - var posit4 = new Posit32((double)-134.75); + var posit4 = new Posit32(-134.75); Assert.AreEqual((double)posit4, -134.75); - var posit5 = new Posit32((double)100000.5); + var posit5 = new Posit32(100000.5); Assert.AreEqual((double)posit5, 100000.5); - var posit6 = new Posit32((double)-2000000.5); - Assert.AreEqual((float)posit6, -2000000.5); + var posit6 = new Posit32(-2_000_000.5); + Assert.AreEqual((float)posit6, -2_000_000.5); - var posit7 = new Posit32((double)-0.00179999996908009052276611328125); + var posit7 = new Posit32(-0.00179999996908009052276611328125); Assert.AreEqual((double)posit7, -0.00179999996908009052276611328125); - var posit8 = new Posit32((double)0.0500000007450580596923828125); + var posit8 = new Posit32(0.0500000007450580596923828125); Assert.AreEqual((double)posit8, 0.0500000007450580596923828125); - var posit11 = new Posit32((double)0.002); - Assert.AreEqual((double)posit11, (double)0.001999999978579581); + var posit11 = new Posit32(0.002); + Assert.AreEqual((double)posit11, 0.001999999978579581); - var posit9 = new Posit32((double)0.005); - Assert.AreEqual((double)posit9, (double)0.005000000004656613); + var posit9 = new Posit32(0.005); + Assert.AreEqual((double)posit9, 0.005000000004656613); - var posit10 = new Posit32((double)0.1); - Assert.AreEqual((double)posit10, (double)0.10000000009313226); + var posit10 = new Posit32(0.1); + Assert.AreEqual((double)posit10, 0.10000000009313226); - var posit12 = new Posit32((double)0.707106781); - Assert.AreEqual((double)posit12, (double)0.7071067802608013); + var posit12 = new Posit32(0.707106781); + Assert.AreEqual((double)posit12, 0.7071067802608013); } [Fact] @@ -359,10 +359,10 @@ public void Posit32ToQuireIsCorrect() Assert.AreEqual(((Quire)positMax).Segments, (new Quire(new ulong[] { 1 }, 512) << 360).Segments); var positNaN = new Posit32(Posit32.NaNBitMask, true); - var QuireNaN = (Quire)positNaN; - var QuireNaNFromMask = new Quire(new ulong[] { 1 }, 512) << 511; + var quireNaN = (Quire)positNaN; + var quireNaNFromMask = new Quire(new ulong[] { 1 }, 512) << 511; - Assert.AreEqual(QuireNaN.Segments, QuireNaNFromMask.Segments); + Assert.AreEqual(quireNaN.Segments, quireNaNFromMask.Segments); } [Fact] @@ -487,7 +487,7 @@ public void Posit32ToStringIsCorrect() var posit1 = new Posit32(0.75F); var posit2 = new Posit32(-200_000); var posit3 = new Posit32(125.12545F); - var posit4 = new Posit32((double)0.999); + var posit4 = new Posit32(0.999); posit1.ToString(CultureInfo.InvariantCulture).ShouldBe("0.75"); posit2.ToString(CultureInfo.InvariantCulture).ShouldBe("-200000"); @@ -496,4 +496,3 @@ public void Posit32ToStringIsCorrect() } } } - From 22dd16cfe3f50726e38b630b543449279c9c0e69 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Sat, 18 Dec 2021 04:31:12 +0100 Subject: [PATCH 30/49] More ternary usage. --- Posit/Posit.cs | 11 +++-------- Posit/Posit32.cs | 47 +++++++++++++---------------------------------- 2 files changed, 16 insertions(+), 42 deletions(-) diff --git a/Posit/Posit.cs b/Posit/Posit.cs index 7a29e4d..1957864 100644 --- a/Posit/Posit.cs +++ b/Posit/Posit.cs @@ -305,14 +305,9 @@ public static int CalculateScaleFactor(int regimeKValue, uint exponentValue, byt } else { - if (left.FractionWithHiddenBit() >= right.FractionWithHiddenBit()) - { - resultFractionBits += left.FractionWithHiddenBit() - right.FractionWithHiddenBit(); - } - else - { - resultFractionBits += right.FractionWithHiddenBit() - left.FractionWithHiddenBit(); - } + resultFractionBits += left.FractionWithHiddenBit() >= right.FractionWithHiddenBit() + ? left.FractionWithHiddenBit() - right.FractionWithHiddenBit() + : right.FractionWithHiddenBit() - left.FractionWithHiddenBit(); } scaleFactor += resultFractionBits.GetMostSignificantOnePosition() - diff --git a/Posit/Posit32.cs b/Posit/Posit32.cs index bca30a4..c164fe4 100644 --- a/Posit/Posit32.cs +++ b/Posit/Posit32.cs @@ -346,6 +346,7 @@ public byte ExponentSize() var bits = IsPositive() ? PositBits : GetTwosComplement(PositBits); var lengthOfRunOfBits = LengthOfRunOfBits(bits, FirstRegimeBitPosition); byte result; + if (lengthOfRunOfBits + 2 <= Size) { result = Size - (lengthOfRunOfBits + 2) > MaximumExponentSize @@ -748,14 +749,9 @@ public static Posit32 FusedMultiplyMultiplySubtract(Posit32 a, Posit32 b, Posit3 } else { - if (leftFraction >= rightFraction) - { - resultFractionBits += leftFraction - rightFraction; - } - else - { - resultFractionBits += rightFraction - leftFraction; - } + resultFractionBits += leftFraction >= rightFraction + ? leftFraction - rightFraction + : rightFraction - leftFraction; } scaleFactor += (short)(GetMostSignificantOnePosition(resultFractionBits) - @@ -772,14 +768,9 @@ public static Posit32 FusedMultiplyMultiplySubtract(Posit32 a, Posit32 b, Posit3 if (signBitsMatch) { - if (smallerPositMovedToLeft >= 0) - { - resultFractionBits += rightFraction << smallerPositMovedToLeft; - } - else - { - resultFractionBits += rightFraction >> -smallerPositMovedToLeft; - } + resultFractionBits += smallerPositMovedToLeft >= 0 + ? rightFraction << smallerPositMovedToLeft + : rightFraction >> -smallerPositMovedToLeft; } else { @@ -800,14 +791,9 @@ public static Posit32 FusedMultiplyMultiplySubtract(Posit32 a, Posit32 b, Posit3 if (signBitsMatch) { - if (biggerPositMovedToLeft + scaleFactorDifference + fractionSizeDifference >= 0) - { - resultFractionBits += leftFraction << (biggerPositMovedToLeft + scaleFactorDifference + fractionSizeDifference); - } - else - { - resultFractionBits += leftFraction >> -(biggerPositMovedToLeft + scaleFactorDifference + fractionSizeDifference); - } + resultFractionBits += biggerPositMovedToLeft + scaleFactorDifference + fractionSizeDifference >= 0 + ? leftFraction << (biggerPositMovedToLeft + scaleFactorDifference + fractionSizeDifference) + : leftFraction >> -(biggerPositMovedToLeft + scaleFactorDifference + fractionSizeDifference); } else if (biggerPositMovedToLeft + scaleFactorDifference + fractionSizeDifference >= 0) { @@ -942,16 +928,9 @@ public static explicit operator int(Posit32 x) // The posit fits into the range var mostSignificantOnePosition = GetMostSignificantOnePosition(x.FractionWithHiddenBit()); - if (scaleFactor - mostSignificantOnePosition + 1 >= 0) - { - result = x.FractionWithHiddenBit() << - (int)(scaleFactor - mostSignificantOnePosition + 1); - } - else - { - result = x.FractionWithHiddenBit() >> - -(int)(scaleFactor - mostSignificantOnePosition + 1); - } + result = scaleFactor - mostSignificantOnePosition + 1 >= 0 + ? x.FractionWithHiddenBit() << (int)(scaleFactor - mostSignificantOnePosition + 1) + : x.FractionWithHiddenBit() >> -(int)(scaleFactor - mostSignificantOnePosition + 1); } else { From 34a7de237aa991c533431f6faa92ad5139311b70 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Sat, 18 Dec 2021 05:01:09 +0100 Subject: [PATCH 31/49] Fix Posit. --- Posit/Posit.cs | 114 +++++++++++++++++++++++-------------------------- 1 file changed, 53 insertions(+), 61 deletions(-) diff --git a/Posit/Posit.cs b/Posit/Posit.cs index 1957864..fc8c492 100644 --- a/Posit/Posit.cs +++ b/Posit/Posit.cs @@ -1,7 +1,9 @@ +using System.Diagnostics.CodeAnalysis; + namespace Lombiq.Arithmetics { - //signbit regime exponent(?) fraction(?) - public struct Posit + // signbit regime exponent(?) fraction(?) + public readonly struct Posit : System.IEquatable<Posit> { private readonly PositEnvironment _environment; public BitMask PositBits { get; } @@ -102,26 +104,6 @@ public BitMask EncodeRegimeBits(int regimeKValue) return regimeBits; } - private BitMask AssemblePositBits(bool signBit, int regimeKValue, BitMask exponentBits, BitMask fractionBits) - { - // Calculating the regime. - var wholePosit = EncodeRegimeBits(regimeKValue); - - // Attaching the exponent - var regimeLength = wholePosit.LengthOfRunOfBits((ushort)(_environment.FirstRegimeBitIndex + 1)); - wholePosit += exponentBits << (_environment.Size - (regimeLength + 2) - _environment.MaximumExponentSize); - - var fractionMostSignificantOneIndex = fractionBits.GetMostSignificantOnePosition() - 1; - - // Hiding the hidden bit. (It is always one.) - fractionBits = fractionBits.SetZero((ushort)fractionMostSignificantOneIndex); - - wholePosit += fractionBits << (_environment.Size - 2 - fractionMostSignificantOneIndex - regimeLength - - _environment.MaximumExponentSize); - - return !signBit ? wholePosit : wholePosit.GetTwosComplement(_environment.Size); - } - private BitMask AssemblePositBitsWithRounding(bool signBit, int regimeKValue, BitMask exponentBits, BitMask fractionBits) { // Calculating the regime. @@ -136,19 +118,7 @@ private BitMask AssemblePositBitsWithRounding(bool signBit, int regimeKValue, Bi // Calculating rounding. if (exponentShiftedLeftBy < 0) { - exponentBits <<= exponentBits.Size + exponentShiftedLeftBy; - if (exponentBits >= new BitMask(exponentBits.Size).SetOne((ushort)(exponentBits.Size - 1))) - { - if (exponentBits == new BitMask(exponentBits.Size).SetOne((ushort)(exponentBits.Size - 1))) - { - wholePosit += wholePosit.GetLowest32Bits() & 1; - } - else - { - wholePosit += 1; - } - } - + CaclulateRounding(exponentShiftedLeftBy, ref exponentBits, ref wholePosit); return !signBit ? wholePosit : wholePosit.GetTwosComplement(_environment.Size); } @@ -164,18 +134,7 @@ private BitMask AssemblePositBitsWithRounding(bool signBit, int regimeKValue, Bi // Calculating rounding. if (fractionShiftedLeftBy < 0) { - fractionBits <<= fractionBits.Size + fractionShiftedLeftBy; - if (fractionBits >= new BitMask(fractionBits.Size).SetOne((ushort)(fractionBits.Size - 1))) - { - if (fractionBits == new BitMask(fractionBits.Size).SetOne((ushort)(fractionBits.Size - 1))) - { - wholePosit += wholePosit.GetLowest32Bits() & 1; - } - else - { - wholePosit += 1; - } - } + CaclulateRounding(fractionShiftedLeftBy, ref fractionBits, ref wholePosit); } return !signBit ? wholePosit : wholePosit.GetTwosComplement(_environment.Size); @@ -207,7 +166,7 @@ public uint GetExponentValue() var exponentMask = IsPositive() ? PositBits : PositBits.GetTwosComplement(Size); exponentMask = (exponentMask >> (int)FractionSize()) << (int)((PositBits.SegmentCount * 32) - ExponentSize()) - >> (PositBits.SegmentCount * 32) - MaximumExponentSize; + >> ((PositBits.SegmentCount * 32) - MaximumExponentSize); return exponentMask.GetLowest32Bits(); } @@ -233,10 +192,30 @@ public BitMask FractionWithHiddenBit() public static int CalculateScaleFactor(int regimeKValue, uint exponentValue, byte maximumExponentSize) => (int)((regimeKValue * (1 << maximumExponentSize)) + exponentValue); + private static void CaclulateRounding(int shiftedLeftBy, ref BitMask bits, ref BitMask wholePosit) + { + bits <<= bits.Size + shiftedLeftBy; + if (bits >= new BitMask(bits.Size).SetOne((ushort)(bits.Size - 1))) + { + if (bits == new BitMask(bits.Size).SetOne((ushort)(bits.Size - 1))) + { + wholePosit += wholePosit.GetLowest32Bits() & 1; + } + else + { + wholePosit += 1; + } + } + } + #endregion #region operators + [SuppressMessage( + "Critical Code Smell", + "S3776:Cognitive Complexity of methods should not be too high", + Justification = "It's really not that bad.")] public static Posit operator +(Posit left, Posit right) { var leftIsPositive = left.IsPositive(); @@ -303,11 +282,13 @@ public static int CalculateScaleFactor(int regimeKValue, uint exponentValue, byt { resultFractionBits += left.FractionWithHiddenBit() + right.FractionWithHiddenBit(); } + else if (left.FractionWithHiddenBit() >= right.FractionWithHiddenBit()) + { + resultFractionBits += left.FractionWithHiddenBit() - right.FractionWithHiddenBit(); + } else { - resultFractionBits += left.FractionWithHiddenBit() >= right.FractionWithHiddenBit() - ? left.FractionWithHiddenBit() - right.FractionWithHiddenBit() - : right.FractionWithHiddenBit() - left.FractionWithHiddenBit(); + resultFractionBits += right.FractionWithHiddenBit() - left.FractionWithHiddenBit(); } scaleFactor += resultFractionBits.GetMostSignificantOnePosition() - @@ -321,14 +302,11 @@ public static int CalculateScaleFactor(int regimeKValue, uint exponentValue, byt var biggerPositMovedToLeft = left.Size - 1 - left.FractionWithHiddenBit().GetMostSignificantOnePosition(); resultFractionBits <<= biggerPositMovedToLeft; - if (signBitsMatch) - { - resultFractionBits += right.FractionWithHiddenBit() << (biggerPositMovedToLeft - scaleFactorDifference + fractionSizeDifference); - } - else - { - resultFractionBits -= right.FractionWithHiddenBit() << (biggerPositMovedToLeft - scaleFactorDifference + fractionSizeDifference); - } + var difference = right.FractionWithHiddenBit() << + (biggerPositMovedToLeft - scaleFactorDifference + fractionSizeDifference); + resultFractionBits = signBitsMatch + ? resultFractionBits + difference + : resultFractionBits - difference; scaleFactor += resultFractionBits.GetMostSignificantOnePosition() - (left.Size - 1); } @@ -342,11 +320,13 @@ public static int CalculateScaleFactor(int regimeKValue, uint exponentValue, byt if (signBitsMatch) { - resultFractionBits += left.FractionWithHiddenBit() << (biggerPositMovedToLeft + scaleFactorDifference + fractionSizeDifference); + resultFractionBits += left.FractionWithHiddenBit() << + (biggerPositMovedToLeft + scaleFactorDifference + fractionSizeDifference); } else { - resultFractionBits -= left.FractionWithHiddenBit() << (biggerPositMovedToLeft + scaleFactorDifference + fractionSizeDifference); + resultFractionBits -= left.FractionWithHiddenBit() << + (biggerPositMovedToLeft + scaleFactorDifference + fractionSizeDifference); } scaleFactor += resultFractionBits.GetMostSignificantOnePosition() - (right.Size - 1); @@ -408,6 +388,18 @@ public static explicit operator int(Posit x) return x.IsPositive() ? (int)result : (int)-result; } + public override bool Equals(object obj) => obj is Posit other && this == other; + + public bool Equals(Posit other) => this == other; + + public override int GetHashCode() + { + unchecked + { + return ((_environment != null ? _environment.GetHashCode() : 0) * 397) ^ PositBits.GetHashCode(); + } + } + #endregion } From 8e81a8280793bfff79ea7f3f8bd3840ca91c965a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Sat, 18 Dec 2021 05:58:46 +0100 Subject: [PATCH 32/49] Refactor BitMask. --- BitMask/BitMask.cs | 55 ++++++++++--------- Lombiq.Arithmetics.Tests/BitMaskTests.cs | 18 +++--- .../UnumTests/UnumEnvironmentTests.cs | 22 ++++---- Posit/Posit.cs | 32 +++++------ Posit/PositEnvironment.cs | 2 +- Unum/Unum.cs | 34 ++++++------ 6 files changed, 82 insertions(+), 81 deletions(-) diff --git a/BitMask/BitMask.cs b/BitMask/BitMask.cs index 5606a78..4209078 100644 --- a/BitMask/BitMask.cs +++ b/BitMask/BitMask.cs @@ -3,12 +3,16 @@ namespace Lombiq.Arithmetics { - public struct BitMask + public struct BitMask : IEquatable<BitMask> { + private const uint SegmentMaskWithLeadingOne = 0x80000000; // 1000 0000 0000 0000 0000 0000 0000 0000 + private const uint SegmentMaskWithClosingOne = 1; // 0000 0000 0000 0000 0000 0000 0000 0001 public ushort Size { get; } public ushort SegmentCount { get; } public ImmutableArray<uint> Segments { get; } + public uint Lowest32Bits => Segments[0]; + #region Constructors public BitMask(uint segment, ushort size) @@ -29,9 +33,8 @@ public BitMask(uint[] segments, ushort size = 0) var segmentBits = (ushort)(segments.Length << 5); Size = size < segmentBits ? segmentBits : size; - SegmentCount = size > segmentBits ? - (ushort)((size >> 5) + (size % 32 == 0 ? 0 : 1)) : - (ushort)segments.Length; + SegmentCount = (ushort)segments.Length; + if (size > segmentBits) SegmentCount = (ushort)((size >> 5) + (size % 32 == 0 ? 0 : 1)); if (SegmentCount > segments.Length) { @@ -135,7 +138,7 @@ public BitMask SetZero(ushort index) /// <returns>A BitMask where the trailing zeros are shifted out to the right.</returns> public BitMask ShiftOutLeastSignificantZeros() { - var leastSignificantOnePosition = GetLeastSignificantOnePosition(); + var leastSignificantOnePosition = FindLeastSignificantOnePosition(); var mask = new BitMask(this); if (leastSignificantOnePosition == 0) return mask; @@ -204,19 +207,20 @@ public BitMask SetSegment(int index, uint segment) public static BitMask operator +(BitMask left, BitMask right) { if (left.SegmentCount == 0 || right.SegmentCount == 0) return left; - bool carry = false, leftBit, rightBit; + bool carry = false; byte buffer; ushort segmentPosition = 0, position = 0; var segments = new uint[left.SegmentCount]; for (ushort i = 0; i < (left.Size > right.Size ? left.Size : right.Size); i++) { - leftBit = (left.Segments[segmentPosition] >> position) % 2 == 1; - rightBit = i >= right.Size ? false : (right.Segments[segmentPosition] >> position) % 2 == 1; + var leftBit = (left.Segments[segmentPosition] >> position) % 2; + var rightBit = i >= right.Size ? 0 : (right.Segments[segmentPosition] >> position) % 2; + var carryBit = carry ? 1 : 0; - buffer = (byte)((leftBit ? 1 : 0) + (rightBit ? 1 : 0) + (carry ? 1 : 0)); + buffer = (byte)(leftBit + rightBit + carryBit); - if (buffer % 2 == 1) segments[segmentPosition] += (uint)(1 << position); + if (buffer % 2 != 0) segments[segmentPosition] += (uint)(1 << position); carry = buffer >> 1 == 1; position++; @@ -240,19 +244,19 @@ public BitMask SetSegment(int index, uint segment) { if (left.SegmentCount == 0 || right.SegmentCount == 0) return left; - bool carry = false, leftBit, rightBit; + bool carry = false; byte buffer; ushort segmentPosition = 0, position = 0; var segments = new uint[left.SegmentCount]; for (ushort i = 0; i < (left.Size > right.Size ? left.Size : right.Size); i++) { - leftBit = (left.Segments[segmentPosition] >> position) % 2 == 1; - rightBit = i >= right.Size ? false : (right.Segments[segmentPosition] >> position) % 2 == 1; + var leftBit = (left.Segments[segmentPosition] >> position) % 2; + var rightBit = i >= right.Size ? 0 : (right.Segments[segmentPosition] >> position) % 2; - buffer = (byte)(2 + (leftBit ? 1 : 0) - (rightBit ? 1 : 0) - (carry ? 1 : 0)); + buffer = (byte)(2 + leftBit - rightBit - (carry ? 1 : 0)); - if (buffer % 2 == 1) segments[segmentPosition] += (uint)(1 << position); + if (buffer % 2 != 0) segments[segmentPosition] += (uint)(1 << position); carry = buffer >> 1 == 0; position++; @@ -327,7 +331,6 @@ public BitMask SetSegment(int index, uint segment) if (right < 0) return left << -right; bool carryOld, carryNew; - var segmentMaskWithLeadingOne = 0x80000000; // 1000 0000 0000 0000 0000 0000 0000 0000 var segments = new uint[left.SegmentCount]; left.Segments.CopyTo(segments); ushort currentIndex; @@ -341,7 +344,7 @@ public BitMask SetSegment(int index, uint segment) currentIndex = (ushort)(segments.Length - j); carryNew = segments[currentIndex] % 2 == 1; segments[currentIndex] >>= 1; - if (carryOld) segments[currentIndex] |= segmentMaskWithLeadingOne; + if (carryOld) segments[currentIndex] |= SegmentMaskWithLeadingOne; carryOld = carryNew; } } @@ -360,8 +363,6 @@ public BitMask SetSegment(int index, uint segment) if (right < 0) return left >> -right; bool carryOld, carryNew; - var segmentMaskWithLeadingOne = 0x80000000; // 1000 0000 0000 0000 0000 0000 0000 0000 - uint segmentMaskWithClosingOne = 1; // 0000 0000 0000 0000 0000 0000 0000 0001 var segments = new uint[left.SegmentCount]; left.Segments.CopyTo(segments); @@ -371,9 +372,9 @@ public BitMask SetSegment(int index, uint segment) for (ushort j = 0; j < segments.Length; j++) { - carryNew = (segments[j] & segmentMaskWithLeadingOne) == segmentMaskWithLeadingOne; + carryNew = (segments[j] & SegmentMaskWithLeadingOne) == SegmentMaskWithLeadingOne; segments[j] <<= 1; - if (carryOld) segments[j] |= segmentMaskWithClosingOne; + if (carryOld) segments[j] |= SegmentMaskWithClosingOne; carryOld = carryNew; } } @@ -390,7 +391,7 @@ public BitMask SetSegment(int index, uint segment) /// </summary> /// <returns>Returns the position (not index!) of the most significant 1-bit /// or zero if there is none.</returns> - public ushort GetMostSignificantOnePosition() + public ushort FindMostSignificantOnePosition() { ushort position = 0; uint currentSegment; @@ -424,7 +425,7 @@ public ushort LengthOfRunOfBits(ushort startingPosition) mask <<= 1; for (var i = 0; i < startingPosition; i++) { - if (mask.Segments[0] >> 31 > 0 != startingBit) return length; + if ((mask.Segments[0] >> 31 > 0) != startingBit) return length; mask <<= 1; length++; } @@ -437,7 +438,7 @@ public ushort LengthOfRunOfBits(ushort startingPosition) /// </summary> /// <returns>Returns the position (not index!) of the least significant 1-bit /// or zero if there is none.</returns> - public ushort GetLeastSignificantOnePosition() + public ushort FindLeastSignificantOnePosition() { ushort position = 1; uint currentSegment; @@ -467,13 +468,13 @@ public ushort GetLeastSignificantOnePosition() // Array indexer is not supported by Hastlayer yet. //// public uint this[int i] => Segments[i]; - public uint GetLowest32Bits() => Segments[0]; - #endregion #region Overrides - public override bool Equals(object obj) => this == (BitMask)obj; + public override bool Equals(object obj) => obj is BitMask other && this == other; + + public bool Equals(BitMask other) => this == other; public override int GetHashCode() { diff --git a/Lombiq.Arithmetics.Tests/BitMaskTests.cs b/Lombiq.Arithmetics.Tests/BitMaskTests.cs index 71c1366..a1ff8a8 100644 --- a/Lombiq.Arithmetics.Tests/BitMaskTests.cs +++ b/Lombiq.Arithmetics.Tests/BitMaskTests.cs @@ -159,20 +159,20 @@ public void BitMaskBitShiftRightIsCorrect() [Fact] public void FindMostSignificantOneIsCorrect() { - Assert.AreEqual(0, new BitMask(new uint[] { 0x00000000, 0x00000000 }).GetMostSignificantOnePosition()); - Assert.AreEqual(1, new BitMask(new uint[] { 0x00000001, 0x00000000 }).GetMostSignificantOnePosition()); - Assert.AreEqual(2, new BitMask(new uint[] { 0x00000002, 0x00000000 }).GetMostSignificantOnePosition()); - Assert.AreEqual(33, new BitMask(new uint[] { 0x00000002, 0x00000001 }).GetMostSignificantOnePosition()); + Assert.AreEqual(0, new BitMask(new uint[] { 0x00000000, 0x00000000 }).FindMostSignificantOnePosition()); + Assert.AreEqual(1, new BitMask(new uint[] { 0x00000001, 0x00000000 }).FindMostSignificantOnePosition()); + Assert.AreEqual(2, new BitMask(new uint[] { 0x00000002, 0x00000000 }).FindMostSignificantOnePosition()); + Assert.AreEqual(33, new BitMask(new uint[] { 0x00000002, 0x00000001 }).FindMostSignificantOnePosition()); } [Fact] public void FindLeastSignificantOneIsCorrect() { - Assert.AreEqual(0, new BitMask(new uint[] { 0x00000000, 0x00000000 }).GetLeastSignificantOnePosition()); - Assert.AreEqual(1, new BitMask(new uint[] { 0x00000001, 0x00000000 }).GetLeastSignificantOnePosition()); - Assert.AreEqual(2, new BitMask(new uint[] { 0x00000002, 0x00000000 }).GetLeastSignificantOnePosition()); - Assert.AreEqual(2, new BitMask(new uint[] { 0x00000002, 0x00000001 }).GetLeastSignificantOnePosition()); - Assert.AreEqual(33, new BitMask(new uint[] { 0x00000000, 0x00000001 }).GetLeastSignificantOnePosition()); + Assert.AreEqual(0, new BitMask(new uint[] { 0x00000000, 0x00000000 }).FindLeastSignificantOnePosition()); + Assert.AreEqual(1, new BitMask(new uint[] { 0x00000001, 0x00000000 }).FindLeastSignificantOnePosition()); + Assert.AreEqual(2, new BitMask(new uint[] { 0x00000002, 0x00000000 }).FindLeastSignificantOnePosition()); + Assert.AreEqual(2, new BitMask(new uint[] { 0x00000002, 0x00000001 }).FindLeastSignificantOnePosition()); + Assert.AreEqual(33, new BitMask(new uint[] { 0x00000000, 0x00000001 }).FindLeastSignificantOnePosition()); } [Fact] diff --git a/Lombiq.Arithmetics.Tests/UnumTests/UnumEnvironmentTests.cs b/Lombiq.Arithmetics.Tests/UnumTests/UnumEnvironmentTests.cs index 9835428..ad4108e 100644 --- a/Lombiq.Arithmetics.Tests/UnumTests/UnumEnvironmentTests.cs +++ b/Lombiq.Arithmetics.Tests/UnumTests/UnumEnvironmentTests.cs @@ -34,17 +34,17 @@ public void WarlpiriUnumEnvironmentIsCorrect() Assert.AreEqual(_warlpiriEnvironment.EmptyBitMask, _warlpiriEnvironment.ExponentAndFractionSizeMask); Assert.AreEqual(4, _warlpiriEnvironment.Size); - Assert.AreEqual(12, _warlpiriEnvironment.LargestNegative.GetLowest32Bits()); // 1100 - Assert.AreEqual(4, _warlpiriEnvironment.LargestPositive.GetLowest32Bits()); // 0100 - Assert.AreEqual(14, _warlpiriEnvironment.NegativeInfinity.GetLowest32Bits()); // 1110 - Assert.AreEqual(6, _warlpiriEnvironment.PositiveInfinity.GetLowest32Bits()); // 0110 - Assert.AreEqual(7, _warlpiriEnvironment.QuietNotANumber.GetLowest32Bits()); // 0111 - Assert.AreEqual(15, _warlpiriEnvironment.SignalingNotANumber.GetLowest32Bits()); // 1111 - Assert.AreEqual(8, _warlpiriEnvironment.SignBitMask.GetLowest32Bits()); // 1000 - Assert.AreEqual(2, _warlpiriEnvironment.SmallestPositive.GetLowest32Bits()); // 0010 - Assert.AreEqual(2, _warlpiriEnvironment.ULP.GetLowest32Bits()); // 0010 - Assert.AreEqual(1, _warlpiriEnvironment.UncertaintyBitMask.GetLowest32Bits()); // 0001 - Assert.AreEqual(1, _warlpiriEnvironment.UnumTagMask.GetLowest32Bits()); // 0001 + Assert.AreEqual(12, _warlpiriEnvironment.LargestNegative.Lowest32Bits); // 1100 + Assert.AreEqual(4, _warlpiriEnvironment.LargestPositive.Lowest32Bits); // 0100 + Assert.AreEqual(14, _warlpiriEnvironment.NegativeInfinity.Lowest32Bits); // 1110 + Assert.AreEqual(6, _warlpiriEnvironment.PositiveInfinity.Lowest32Bits); // 0110 + Assert.AreEqual(7, _warlpiriEnvironment.QuietNotANumber.Lowest32Bits); // 0111 + Assert.AreEqual(15, _warlpiriEnvironment.SignalingNotANumber.Lowest32Bits); // 1111 + Assert.AreEqual(8, _warlpiriEnvironment.SignBitMask.Lowest32Bits); // 1000 + Assert.AreEqual(2, _warlpiriEnvironment.SmallestPositive.Lowest32Bits); // 0010 + Assert.AreEqual(2, _warlpiriEnvironment.ULP.Lowest32Bits); // 0010 + Assert.AreEqual(1, _warlpiriEnvironment.UncertaintyBitMask.Lowest32Bits); // 0001 + Assert.AreEqual(1, _warlpiriEnvironment.UnumTagMask.Lowest32Bits); // 0001 Assert.AreEqual(1, _warlpiriEnvironment.UnumTagSize); } diff --git a/Posit/Posit.cs b/Posit/Posit.cs index fc8c492..8aa9dd4 100644 --- a/Posit/Posit.cs +++ b/Posit/Posit.cs @@ -55,7 +55,7 @@ public Posit(PositEnvironment environment, uint value) PositBits = new BitMask(value, _environment.Size); if (value == 0) return; - var exponentValue = (uint)PositBits.GetMostSignificantOnePosition() - 1; + var exponentValue = (uint)PositBits.FindMostSignificantOnePosition() - 1; ushort kValue = 0; while (exponentValue >= 1 << environment.MaximumExponentSize && kValue < _environment.Size - 1) @@ -94,7 +94,7 @@ public BitMask EncodeRegimeBits(int regimeKValue) if (regimeKValue > 0) { regimeBits = (new BitMask(1, _environment.Size) << (regimeKValue + 1)) - 1; - regimeBits <<= _environment.Size - regimeBits.GetMostSignificantOnePosition() - 1; + regimeBits <<= _environment.Size - regimeBits.FindMostSignificantOnePosition() - 1; } else { @@ -122,7 +122,7 @@ private BitMask AssemblePositBitsWithRounding(bool signBit, int regimeKValue, Bi return !signBit ? wholePosit : wholePosit.GetTwosComplement(_environment.Size); } - var fractionMostSignificantOneIndex = fractionBits.GetMostSignificantOnePosition() - 1; + var fractionMostSignificantOneIndex = fractionBits.FindMostSignificantOnePosition() - 1; // Hiding the hidden bit. (It is always one.) fractionBits = fractionBits.SetZero((ushort)fractionMostSignificantOneIndex); @@ -167,7 +167,7 @@ public uint GetExponentValue() exponentMask = (exponentMask >> (int)FractionSize()) << (int)((PositBits.SegmentCount * 32) - ExponentSize()) >> ((PositBits.SegmentCount * 32) - MaximumExponentSize); - return exponentMask.GetLowest32Bits(); + return exponentMask.Lowest32Bits; } public uint FractionSize() @@ -199,7 +199,7 @@ private static void CaclulateRounding(int shiftedLeftBy, ref BitMask bits, ref B { if (bits == new BitMask(bits.Size).SetOne((ushort)(bits.Size - 1))) { - wholePosit += wholePosit.GetLowest32Bits() & 1; + wholePosit += wholePosit.Lowest32Bits & 1; } else { @@ -220,7 +220,7 @@ private static void CaclulateRounding(int shiftedLeftBy, ref BitMask bits, ref B { var leftIsPositive = left.IsPositive(); var rightIsPositive = right.IsPositive(); - var resultSignBit = (left.PositBits + right.PositBits).GetMostSignificantOnePosition() < left.PositBits.Size + var resultSignBit = (left.PositBits + right.PositBits).FindMostSignificantOnePosition() < left.PositBits.Size ? !leftIsPositive : !rightIsPositive; @@ -291,15 +291,15 @@ private static void CaclulateRounding(int shiftedLeftBy, ref BitMask bits, ref B resultFractionBits += right.FractionWithHiddenBit() - left.FractionWithHiddenBit(); } - scaleFactor += resultFractionBits.GetMostSignificantOnePosition() - - left.FractionWithHiddenBit().GetMostSignificantOnePosition(); + scaleFactor += resultFractionBits.FindMostSignificantOnePosition() - + left.FractionWithHiddenBit().FindMostSignificantOnePosition(); } else if (scaleFactorDifference > 0) { // The scale factor of the left Posit is bigger. var fractionSizeDifference = (int)(left.FractionSize() - right.FractionSize()); resultFractionBits += left.FractionWithHiddenBit(); - var biggerPositMovedToLeft = left.Size - 1 - left.FractionWithHiddenBit().GetMostSignificantOnePosition(); + var biggerPositMovedToLeft = left.Size - 1 - left.FractionWithHiddenBit().FindMostSignificantOnePosition(); resultFractionBits <<= biggerPositMovedToLeft; var difference = right.FractionWithHiddenBit() << @@ -308,14 +308,14 @@ private static void CaclulateRounding(int shiftedLeftBy, ref BitMask bits, ref B ? resultFractionBits + difference : resultFractionBits - difference; - scaleFactor += resultFractionBits.GetMostSignificantOnePosition() - (left.Size - 1); + scaleFactor += resultFractionBits.FindMostSignificantOnePosition() - (left.Size - 1); } else { // The scale factor of the right Posit is bigger. var fractionSizeDifference = (int)(right.FractionSize() - left.FractionSize()); resultFractionBits += right.FractionWithHiddenBit(); - var biggerPositMovedToLeft = right.Size - 1 - right.FractionWithHiddenBit().GetMostSignificantOnePosition(); + var biggerPositMovedToLeft = right.Size - 1 - right.FractionWithHiddenBit().FindMostSignificantOnePosition(); resultFractionBits <<= biggerPositMovedToLeft; if (signBitsMatch) @@ -329,10 +329,10 @@ private static void CaclulateRounding(int shiftedLeftBy, ref BitMask bits, ref B (biggerPositMovedToLeft + scaleFactorDifference + fractionSizeDifference); } - scaleFactor += resultFractionBits.GetMostSignificantOnePosition() - (right.Size - 1); + scaleFactor += resultFractionBits.FindMostSignificantOnePosition() - (right.Size - 1); } - if (resultFractionBits.GetMostSignificantOnePosition() == 0) return new Posit(left._environment, left.EmptyBitMask); + if (resultFractionBits.FindMostSignificantOnePosition() == 0) return new Posit(left._environment, left.EmptyBitMask); var resultRegimeKValue = scaleFactor / (1 << left.MaximumExponentSize); var resultExponentBits = new BitMask((uint)(scaleFactor % (1 << left.MaximumExponentSize)), left._environment.Size); @@ -360,7 +360,7 @@ private static void CaclulateRounding(int shiftedLeftBy, ref BitMask bits, ref B { if (!left.IsPositive()) left = -left; if (!right.IsPositive()) right = -right; - return (left.PositBits + right.PositBits).GetMostSignificantOnePosition() > left.PositBits.Size; + return (left.PositBits + right.PositBits).FindMostSignificantOnePosition() > left.PositBits.Size; } public static bool operator <(Posit left, Posit right) => !(left.PositBits > right.PositBits); @@ -376,9 +376,9 @@ public static explicit operator int(Posit x) { result = (x.FractionWithHiddenBit() << ( (int)((x.GetRegimeKValue() * (1 << x.MaximumExponentSize)) + x.GetExponentValue()) - - x.FractionWithHiddenBit().GetMostSignificantOnePosition() + + x.FractionWithHiddenBit().FindMostSignificantOnePosition() + 1)) - .GetLowest32Bits(); + .Lowest32Bits; } else { diff --git a/Posit/PositEnvironment.cs b/Posit/PositEnvironment.cs index 18eac98..96ef21e 100644 --- a/Posit/PositEnvironment.cs +++ b/Posit/PositEnvironment.cs @@ -37,7 +37,7 @@ public PositEnvironment(byte size, byte maximumExponentSize) MaxValueBitMask = new BitMask(Size, true) >> 1; MinValueBitMask = SignBitMask + 1; NaNBitMask = SignBitMask; - QuireSize = new BitMask((uint)(((Size - 2) * (1 << MaximumExponentSize)) + 5),size).GetMostSignificantOnePosition(); + QuireSize = new BitMask((uint)(((Size - 2) * (1 << MaximumExponentSize)) + 5),size).FindMostSignificantOnePosition(); } } } diff --git a/Unum/Unum.cs b/Unum/Unum.cs index 7ae8a92..f30b310 100644 --- a/Unum/Unum.cs +++ b/Unum/Unum.cs @@ -194,14 +194,14 @@ public Unum(UnumEnvironment environment, uint[] value, bool negative = false) var exponent = new BitMask(value, Size); // The value of the exponent is one less than the number of binary digits in the integer. - var exponentValue = new BitMask((uint)(exponent.GetMostSignificantOnePosition() - 1), Size); + var exponentValue = new BitMask((uint)(exponent.FindMostSignificantOnePosition() - 1), Size); // Calculating the number of bits needed to represent the value of the exponent. - var exponentSize = exponentValue.GetMostSignificantOnePosition(); + var exponentSize = exponentValue.FindMostSignificantOnePosition(); // If the value of the exponent is not a power of 2, // then one more bit is needed to represent the biased value. - if ((exponentValue.GetLowest32Bits() & (exponentValue.GetLowest32Bits() - 1)) > 0) exponentSize++; + if ((exponentValue.Lowest32Bits & (exponentValue.Lowest32Bits - 1)) > 0) exponentSize++; // Handling input numbers that don't fit in the range of the given environment. if (exponentSize > ExponentSizeMax) @@ -224,12 +224,12 @@ public Unum(UnumEnvironment environment, uint[] value, bool negative = false) fraction = fraction.ShiftOutLeastSignificantZeros(); // Calculating the number of bits needed to represent the fraction. - var fractionSize = fraction.GetMostSignificantOnePosition(); + var fractionSize = fraction.FindMostSignificantOnePosition(); /* If there's a hidden bit and it's 1, * then the most significant 1-bit of the fraction is stored there, * so we're removing it from the fraction and decreasing fraction size accordingly. */ - if (exponent.GetLowest32Bits() > 0) + if (exponent.Lowest32Bits > 0) { fractionSize--; fraction = fraction.SetZero(fractionSize); @@ -439,9 +439,9 @@ public bool IsZero() => #region Methods for Utag independent Masks and values - public byte ExponentSize() => (byte)(((UnumBits & ExponentSizeMask) >> FractionSizeSize) + 1).GetLowest32Bits(); + public byte ExponentSize() => (byte)(((UnumBits & ExponentSizeMask) >> FractionSizeSize) + 1).Lowest32Bits; - public ushort FractionSize() => (ushort)((UnumBits & FractionSizeMask) + 1).GetLowest32Bits(); + public ushort FractionSize() => (ushort)((UnumBits & FractionSizeMask) + 1).Lowest32Bits; public BitMask FractionMask() { @@ -470,9 +470,9 @@ public BitMask FractionWithHiddenBit() => public int Bias() => (1 << (ExponentSize() - 1)) - 1; - public bool HiddenBitIsOne() => Exponent().GetLowest32Bits() > 0; + public bool HiddenBitIsOne() => Exponent().Lowest32Bits > 0; - public int ExponentValueWithBias() => (int)Exponent().GetLowest32Bits() - Bias() + (HiddenBitIsOne() ? 0 : 1); + public int ExponentValueWithBias() => (int)Exponent().Lowest32Bits - Bias() + (HiddenBitIsOne() ? 0 : 1); public bool IsNan() => UnumBits == SignalingNotANumber || UnumBits == QuietNotANumber; @@ -585,7 +585,7 @@ public static Unum AddExactUnums(Unum left, Unum right) } // Calculating how the addition changed the exponent of the result. - var exponentChange = scratchPad.GetMostSignificantOnePosition() - (left.FractionSizeMax + 1); + var exponentChange = scratchPad.FindMostSignificantOnePosition() - (left.FractionSizeMax + 1); var resultExponent = new BitMask(left._environment.Size) + ExponentValueToExponentBits(resultExponentValue + exponentChange, left.Size); // Calculating the ExponentSize needed to the excess-k notation of the results Exponent value. @@ -599,7 +599,7 @@ public static Unum AddExactUnums(Unum left, Unum right) ushort resultFractionSize = 0; // Calculating the results FractionSize. - if (scratchPad.GetMostSignificantOnePosition() == 0) + if (scratchPad.FindMostSignificantOnePosition() == 0) { // If the Fraction is zero, so is the FractionSize. resultExponent = scratchPad; // 0 @@ -607,13 +607,13 @@ public static Unum AddExactUnums(Unum left, Unum right) } else { - resultFractionSize = (ushort)(scratchPad.GetMostSignificantOnePosition() - 1); + resultFractionSize = (ushort)(scratchPad.FindMostSignificantOnePosition() - 1); } - if (resultExponent.GetMostSignificantOnePosition() != 0) + if (resultExponent.FindMostSignificantOnePosition() != 0) { // Erase the hidden bit if it is set. - scratchPad = scratchPad.SetZero((ushort)(scratchPad.GetMostSignificantOnePosition() - 1)); + scratchPad = scratchPad.SetZero((ushort)(scratchPad.FindMostSignificantOnePosition() - 1)); resultFractionSize = (ushort)(resultFractionSize == 0 ? 0 : resultFractionSize - 1); } @@ -699,14 +699,14 @@ public static explicit operator int(Unum x) uint result; if ((x.ExponentValueWithBias() + x.FractionSizeWithHiddenBit()) < 31) //The Unum fits into the range. - result = (x.FractionWithHiddenBit() << (x.ExponentValueWithBias() - x.FractionSize())).GetLowest32Bits(); + result = (x.FractionWithHiddenBit() << (x.ExponentValueWithBias() - x.FractionSize())).Lowest32Bits; else return x.IsPositive() ? int.MaxValue : int.MinValue; // The absolute value of the Unum is too large. return x.IsPositive() ? (int)result : -(int)result; } public static explicit operator uint(Unum x) => - (x.FractionWithHiddenBit() << (x.ExponentValueWithBias() - x.FractionSize())).GetLowest32Bits(); + (x.FractionWithHiddenBit() << (x.ExponentValueWithBias() - x.FractionSize())).Lowest32Bits; // This is not well tested yet. public static explicit operator float(Unum x) @@ -719,7 +719,7 @@ public static explicit operator float(Unum x) return x.IsPositive() ? float.PositiveInfinity : float.NegativeInfinity; if (x.ExponentValueWithBias() < -126) return x.IsPositive() ? 0 : -0; // Exponent is too small for float format. - var result = (x.Fraction() << (23 - x.FractionSize())).GetLowest32Bits(); + var result = (x.Fraction() << (23 - x.FractionSize())).Lowest32Bits; result |= (uint)(x.ExponentValueWithBias() + 127) << 23; return x.IsPositive() ? From 6beedb12674585ed74801c215d2d36ff219e04fc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Sat, 18 Dec 2021 07:00:02 +0100 Subject: [PATCH 33/49] Posit32 refactor. --- Posit/Posit32.cs | 96 ++++++++++++++++++++------------------- Posit/PositEnvironment.cs | 8 ++-- 2 files changed, 53 insertions(+), 51 deletions(-) diff --git a/Posit/Posit32.cs b/Posit/Posit32.cs index c164fe4..c774acf 100644 --- a/Posit/Posit32.cs +++ b/Posit/Posit32.cs @@ -1,9 +1,14 @@ using System; +using System.Diagnostics.CodeAnalysis; using System.Globalization; using System.Runtime.CompilerServices; namespace Lombiq.Arithmetics { + [SuppressMessage( + "Major Bug", + "S1244:Floating point numbers should not be tested for equality", + Justification = "Only test zero, should be exactly zero.")] public readonly struct Posit32 : IComparable, IConvertible, IFormattable, IEquatable<Posit32>, IComparable<Posit32> { public uint PositBits { get; } @@ -150,7 +155,7 @@ public Posit32(float floatBits) else scaleFactor += 1; var regimeKValue = scaleFactor / (1 << MaximumExponentSize); - if (scaleFactor < 0) regimeKValue = regimeKValue - 1; + if (scaleFactor < 0) regimeKValue--; var exponentValue = (uint)(scaleFactor - (regimeKValue * (1 << MaximumExponentSize))); if (exponentValue == 1 << MaximumExponentSize) @@ -204,7 +209,7 @@ public Posit32(double doubleBits) else scaleFactor += 1; var regimeKValue = scaleFactor / (1 << MaximumExponentSize); - if (scaleFactor < 0) regimeKValue = regimeKValue - 1; + if (scaleFactor < 0) regimeKValue--; var exponentValue = (uint)(scaleFactor - (regimeKValue * (1 << MaximumExponentSize))); if (exponentValue == 1 << MaximumExponentSize) @@ -262,6 +267,10 @@ public static uint EncodeRegimeBits(int regimeKValue) return regimeBits; } + [SuppressMessage( + "Critical Code Smell", + "S3776:Cognitive Complexity of methods should not be too high", + Justification = "It's not so complicated.")] public static uint AssemblePositBitsWithRounding(bool signBit, int regimeKValue, uint exponentBits, uint fractionBits) { // Calculating the regime. @@ -300,16 +309,10 @@ public static uint AssemblePositBitsWithRounding(bool signBit, int regimeKValue, { if (Size + fractionShiftedLeftBy >= 0) fractionBits <<= Size + fractionShiftedLeftBy; else fractionBits >>= -(Size - fractionShiftedLeftBy); + if (fractionBits >= SignBitMask) { - if (fractionBits == SignBitMask) - { - wholePosit += wholePosit & 1; - } - else - { - wholePosit += 1; - } + wholePosit += fractionBits == SignBitMask ? wholePosit & 1 : 1; } } @@ -345,16 +348,13 @@ public byte ExponentSize() { var bits = IsPositive() ? PositBits : GetTwosComplement(PositBits); var lengthOfRunOfBits = LengthOfRunOfBits(bits, FirstRegimeBitPosition); - byte result; + var result = (byte)(Size - lengthOfRunOfBits - 1); if (lengthOfRunOfBits + 2 <= Size) { result = Size - (lengthOfRunOfBits + 2) > MaximumExponentSize - ? MaximumExponentSize : (byte)(Size - (lengthOfRunOfBits + 2)); - } - else - { - result = (byte)(Size - lengthOfRunOfBits - 1); + ? MaximumExponentSize + : (byte)(Size - (lengthOfRunOfBits + 2)); } return result; @@ -544,9 +544,8 @@ public static byte LengthOfRunOfBits(uint bits, byte startingPosition) bits <<= Size - startingPosition; var startingBit = (bits >> 31) & 1; bits <<= 1; - for (var i = 0; i < startingPosition; i++) + for (var i = 0; i < startingPosition && bits >> 31 == startingBit; i++) { - if (bits >> 31 != startingBit) break; bits <<= 1; length++; } @@ -566,7 +565,7 @@ public static Posit32 Sqrt(Posit32 number) if (number.IsNaN() || number.IsZero()) return number; if (!number.IsPositive()) return new Posit32(NaNBitMask, true); - var inputScaleFactor = number.CalculateScaleFactor(); //m + var inputScaleFactor = number.CalculateScaleFactor(); var inputFractionWithHiddenBit = number.FractionWithHiddenBitWithoutSignCheck(); if ((inputScaleFactor & 1) != 0) @@ -578,10 +577,10 @@ public static Posit32 Sqrt(Posit32 number) inputScaleFactor >>= 1; - uint resultFractionBits = 0; //q - uint startingEstimate = 0; //s0 - uint temporaryEstimate; //t - uint estimateMaskingBit = 1U << (int)number.FractionSizeWithoutSignCheck(); //r + uint resultFractionBits = 0; + uint startingEstimate = 0; + uint temporaryEstimate; + uint estimateMaskingBit = 1U << (int)number.FractionSizeWithoutSignCheck(); while (estimateMaskingBit != 0) { @@ -697,6 +696,10 @@ public static Posit32 FusedMultiplyMultiplySubtract(Posit32 a, Posit32 b, Posit3 #region Operators + [SuppressMessage( + "Critical Code Smell", + "S3776:Cognitive Complexity of methods should not be too high", + Justification = "Breaking this method up wouldn't be too helpful.")] public static Posit32 operator +(Posit32 left, Posit32 right) { // Handling special cases first. @@ -743,6 +746,8 @@ public static Posit32 FusedMultiplyMultiplySubtract(Posit32 a, Posit32 b, Posit3 if (scaleFactorDifference == 0) { + // False positive, will cause nested ternary. +#pragma warning disable S3240 // The simplest possible condition syntax should be used if (signBitsMatch) { resultFractionBits += leftFraction + rightFraction; @@ -753,6 +758,7 @@ public static Posit32 FusedMultiplyMultiplySubtract(Posit32 a, Posit32 b, Posit3 ? leftFraction - rightFraction : rightFraction - leftFraction; } +#pragma warning restore S3240 // The simplest possible condition syntax should be used scaleFactor += (short)(GetMostSignificantOnePosition(resultFractionBits) - leftFractionSize - 1); @@ -844,6 +850,10 @@ public static Posit32 FusedMultiplyMultiplySubtract(Posit32 a, Posit32 b, Posit3 public static bool operator !=(Posit32 left, Posit32 right) => !(left == right); + public static bool operator <=(Posit32 left, Posit32 right) => left.CompareTo(right) <= 0; + + public static bool operator >=(Posit32 left, Posit32 right) => left.CompareTo(right) >= 0; + public static Posit32 operator *(Posit32 left, int right) => left * new Posit32(right); public static Posit32 operator *(Posit32 left, Posit32 right) @@ -1024,36 +1034,24 @@ public static explicit operator Quire(Posit32 x) #region Support methods - public int CompareTo(Object value) + public int CompareTo(object obj) { - if (value == null) - { - return 1; - } - - if (value is Posit32 positValue) - { - if (this < positValue) return -1; - if (this > positValue) return 1; - if (this == positValue) return 0; - - // At least one of the values is NaN. - if (IsNaN()) return positValue.IsNaN() ? 0 : -1; - else return 1; - } + if (obj == null) return 1; + if (obj is Posit32 positValue) return CompareTo(positValue); throw new ArgumentException("Argument must be an other posit"); } - public int CompareTo(Posit32 value) + public int CompareTo(Posit32 obj) { - if (this < value) return -1; - if (this > value) return 1; - if (this == value) return 0; + var otherIsNaN = obj.IsNaN(); + + if (IsNaN()) return otherIsNaN ? 0 : -1; + if (otherIsNaN) return 1; - // At least one of the values is NaN. - if (IsNaN()) return value.IsNaN() ? 0 : -1; - else return 1; + if (this < obj) return -1; + if (this > obj) return 1; + return 0; } public override string ToString() => ((double)this).ToString(CultureInfo.InvariantCulture); @@ -1071,7 +1069,9 @@ public bool TryParse(string number, out Posit32 positResult) return returnValue; } - public bool Equals(Posit32 other) => (this == other) ? true : false; + public override bool Equals(object obj) => obj is Posit32 other && this == other; + + public bool Equals(Posit32 other) => this == other; public TypeCode GetTypeCode() => throw new NotSupportedException(); @@ -1105,6 +1105,8 @@ public bool TryParse(string number, out Posit32 positResult) public object ToType(Type conversionType, IFormatProvider provider) => throw new NotSupportedException(); + public override int GetHashCode() => (int)PositBits; + #endregion } } diff --git a/Posit/PositEnvironment.cs b/Posit/PositEnvironment.cs index 96ef21e..1977019 100644 --- a/Posit/PositEnvironment.cs +++ b/Posit/PositEnvironment.cs @@ -1,10 +1,10 @@ -namespace Lombiq.Arithmetics +namespace Lombiq.Arithmetics { public class PositEnvironment { - public byte MaximumExponentSize { get; } //es + public byte MaximumExponentSize { get; } - public ushort Size { get; } //nbits + public ushort Size { get; } public uint Useed { get; } @@ -37,7 +37,7 @@ public PositEnvironment(byte size, byte maximumExponentSize) MaxValueBitMask = new BitMask(Size, true) >> 1; MinValueBitMask = SignBitMask + 1; NaNBitMask = SignBitMask; - QuireSize = new BitMask((uint)(((Size - 2) * (1 << MaximumExponentSize)) + 5),size).FindMostSignificantOnePosition(); + QuireSize = new BitMask((uint)(((Size - 2) * (1 << MaximumExponentSize)) + 5), size).FindMostSignificantOnePosition(); } } } From 4dc92fe37cc61f19bfe8ce9953e18fb761b826a2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Sat, 18 Dec 2021 07:09:39 +0100 Subject: [PATCH 34/49] Fix UnumHelper. --- Unum/UnumHelper.cs | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/Unum/UnumHelper.cs b/Unum/UnumHelper.cs index 01f1720..44c8f11 100644 --- a/Unum/UnumHelper.cs +++ b/Unum/UnumHelper.cs @@ -10,14 +10,15 @@ public static class UnumHelper /// <returns>The maximum size of the unum segment size.</returns> public static byte SegmentSizeToSegmentSizeSize(ushort segmentSize) { - if (segmentSize == 0 || segmentSize == 1) return 0; + if (segmentSize is 0 or 1) return 0; segmentSize--; byte position = 15; // Position of the most significant 1-bit. while ((segmentSize >> position) == 0) { position--; } + position++; - return ++position; + return position; } /// <summary> From 800f2289235ebabd585a6ceb1717ae034bc281eb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Sat, 18 Dec 2021 07:24:33 +0100 Subject: [PATCH 35/49] Fix UnumConfiguration. --- Unum/UnumConfiguration.cs | 34 +++++++++++++--------------------- 1 file changed, 13 insertions(+), 21 deletions(-) diff --git a/Unum/UnumConfiguration.cs b/Unum/UnumConfiguration.cs index a619354..22268de 100644 --- a/Unum/UnumConfiguration.cs +++ b/Unum/UnumConfiguration.cs @@ -3,14 +3,14 @@ namespace Lombiq.Arithmetics public class UnumConfiguration { /// <summary> - /// The number of bits in the exponent. + /// Gets the number of bits in the exponent. /// </summary> - public readonly byte ExponentSize; + public byte ExponentSize { get; } /// <summary> - /// The number of bits in the fraction. + /// Gets the number of bits in the fraction. /// </summary> - public readonly byte FractionSize; + public byte FractionSize { get; } public UnumConfiguration(byte exponentSize, byte fractionSize) { @@ -18,24 +18,16 @@ public UnumConfiguration(byte exponentSize, byte fractionSize) FractionSize = fractionSize; } - public static UnumConfiguration FromIeeeConfiguration(IeeeConfiguration configuration) - { - switch (configuration) + public static UnumConfiguration FromIeeeConfiguration(IeeeConfiguration configuration) => + configuration switch { - case IeeeConfiguration.HalfPrecision: - return new UnumConfiguration(5, 10); - case IeeeConfiguration.SinglePrecision: - return new UnumConfiguration(8, 23); - case IeeeConfiguration.DoublePrecision: - return new UnumConfiguration(11, 52); - case IeeeConfiguration.ExtendedPrecision: - return new UnumConfiguration(15, 64); - case IeeeConfiguration.QuadPrecision: - return new UnumConfiguration(15, 112); - default: - return new UnumConfiguration(0, 0); - } - } + IeeeConfiguration.HalfPrecision => new UnumConfiguration(5, 10), + IeeeConfiguration.SinglePrecision => new UnumConfiguration(8, 23), + IeeeConfiguration.DoublePrecision => new UnumConfiguration(11, 52), + IeeeConfiguration.ExtendedPrecision => new UnumConfiguration(15, 64), + IeeeConfiguration.QuadPrecision => new UnumConfiguration(15, 112), + _ => new UnumConfiguration(0, 0), + }; } public enum IeeeConfiguration From 1666ccd14b385ad35a2b0ac48ec7bf9e598b3f24 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Sat, 18 Dec 2021 07:30:26 +0100 Subject: [PATCH 36/49] Fix UnumEnvironment. --- Unum/UnumEnvironment.cs | 37 +++++++++++++++++-------------------- Unum/UnumException.cs | 6 +++++- 2 files changed, 22 insertions(+), 21 deletions(-) diff --git a/Unum/UnumEnvironment.cs b/Unum/UnumEnvironment.cs index bbb17dd..3a186d6 100644 --- a/Unum/UnumEnvironment.cs +++ b/Unum/UnumEnvironment.cs @@ -1,4 +1,4 @@ -namespace Lombiq.Arithmetics +namespace Lombiq.Arithmetics { public class UnumEnvironment { @@ -172,26 +172,23 @@ public static UnumEnvironment FromConfigurationValues(byte eSize, ushort fSize) public static UnumEnvironment FromConfiguration(UnumConfiguration configuration) => FromConfigurationValues(configuration.ExponentSize, configuration.FractionSize); - public static UnumEnvironment FromStandardEnvironment(StandardEnvironment environment) - { - switch (environment) + public static UnumEnvironment FromStandardEnvironment(StandardEnvironment environment) => + environment switch { - case StandardEnvironment.Warlpiri: - return new UnumEnvironment(0, 0); - case StandardEnvironment.HalfPrecisionLike: - return FromConfiguration(UnumConfiguration.FromIeeeConfiguration(IeeeConfiguration.HalfPrecision)); - case StandardEnvironment.SinglePrecisionLike: - return FromConfiguration(UnumConfiguration.FromIeeeConfiguration(IeeeConfiguration.SinglePrecision)); - case StandardEnvironment.DoublePrecisionLike: - return FromConfiguration(UnumConfiguration.FromIeeeConfiguration(IeeeConfiguration.DoublePrecision)); - case StandardEnvironment.ExtendedPrecisionLike: - return FromConfiguration(UnumConfiguration.FromIeeeConfiguration(IeeeConfiguration.ExtendedPrecision)); - case StandardEnvironment.QuadPrecisionLike: - return FromConfiguration(UnumConfiguration.FromIeeeConfiguration(IeeeConfiguration.QuadPrecision)); - default: - return FromConfiguration(UnumConfiguration.FromIeeeConfiguration(IeeeConfiguration.SinglePrecision)); - } - } + StandardEnvironment.Warlpiri => + new UnumEnvironment(0, 0), + StandardEnvironment.HalfPrecisionLike => + FromConfiguration(UnumConfiguration.FromIeeeConfiguration(IeeeConfiguration.HalfPrecision)), + StandardEnvironment.SinglePrecisionLike => + FromConfiguration(UnumConfiguration.FromIeeeConfiguration(IeeeConfiguration.SinglePrecision)), + StandardEnvironment.DoublePrecisionLike => + FromConfiguration(UnumConfiguration.FromIeeeConfiguration(IeeeConfiguration.DoublePrecision)), + StandardEnvironment.ExtendedPrecisionLike => + FromConfiguration(UnumConfiguration.FromIeeeConfiguration(IeeeConfiguration.ExtendedPrecision)), + StandardEnvironment.QuadPrecisionLike => + FromConfiguration(UnumConfiguration.FromIeeeConfiguration(IeeeConfiguration.QuadPrecision)), + _ => FromConfiguration(UnumConfiguration.FromIeeeConfiguration(IeeeConfiguration.SinglePrecision)), + }; public static UnumEnvironment GetDefaultEnvironment() => FromStandardEnvironment(StandardEnvironment.SinglePrecisionLike); } diff --git a/Unum/UnumException.cs b/Unum/UnumException.cs index 63b3f87..5dc2f01 100644 --- a/Unum/UnumException.cs +++ b/Unum/UnumException.cs @@ -1,4 +1,4 @@ -using System; +using System; namespace Lombiq.Arithmetics { @@ -9,5 +9,9 @@ public UnumException(string message) public UnumException(string message, Exception innerException) : base(message, innerException) { } + + public UnumException() + { + } } } From b17dd7d58c617b17766782ed1a1aba87f083883e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Sat, 18 Dec 2021 16:44:45 +0100 Subject: [PATCH 37/49] Refactor Quire and Unum. --- .../PositTests/Posit32Tests.cs | 14 +- .../PositTests/QuireTests.cs | 76 +++--- Posit/Quire.cs | 109 ++++---- Unum/Unum.cs | 256 ++++++++++-------- Unum/UnumEnvironment.cs | 9 + Unum/UnumException.cs | 7 +- 6 files changed, 263 insertions(+), 208 deletions(-) diff --git a/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs b/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs index 832996b..33ff9a6 100644 --- a/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs +++ b/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs @@ -339,30 +339,30 @@ public void Posit32ToDoubleIsCorrect() public void Posit32ToQuireIsCorrect() { var posit1 = new Posit32(1); - Assert.AreEqual(((Quire)posit1).Segments, (new Quire(new ulong[] { 1 }, 512) << 240).Segments); + Assert.AreEqual(((Quire)posit1).GetSegments(), (new Quire(new ulong[] { 1 }, 512) << 240).GetSegments()); var positNegative1 = new Posit32(-1); Assert.AreEqual( - ((Quire)positNegative1).Segments, + ((Quire)positNegative1).GetSegments(), new Quire( new ulong[] { 0, 0, 0, 0x_FFFF_0000_0000_0000, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue }, 512) - .Segments); + .GetSegments()); var positNegative3 = new Posit32(-3); Assert.AreEqual( - ((Quire)positNegative3).Segments, + ((Quire)positNegative3).GetSegments(), new Quire( new ulong[] { 0, 0, 0, 0x_FFFD_0000_0000_0000, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue }, 512) - .Segments); + .GetSegments()); var positMax = new Posit32(0x_7FFF_FFFF, true); - Assert.AreEqual(((Quire)positMax).Segments, (new Quire(new ulong[] { 1 }, 512) << 360).Segments); + Assert.AreEqual(((Quire)positMax).GetSegments(), (new Quire(new ulong[] { 1 }, 512) << 360).GetSegments()); var positNaN = new Posit32(Posit32.NaNBitMask, true); var quireNaN = (Quire)positNaN; var quireNaNFromMask = new Quire(new ulong[] { 1 }, 512) << 511; - Assert.AreEqual(quireNaN.Segments, quireNaNFromMask.Segments); + Assert.AreEqual(quireNaN.GetSegments(), quireNaNFromMask.GetSegments()); } [Fact] diff --git a/Lombiq.Arithmetics.Tests/PositTests/QuireTests.cs b/Lombiq.Arithmetics.Tests/PositTests/QuireTests.cs index 34fef8b..ef52c97 100644 --- a/Lombiq.Arithmetics.Tests/PositTests/QuireTests.cs +++ b/Lombiq.Arithmetics.Tests/PositTests/QuireTests.cs @@ -10,80 +10,80 @@ public class QuireTests public void QuireBitShiftLeftIsCorrect() { Assert.AreEqual( - new Quire(new ulong[] { 0x80000000 }).Segments, - (new Quire(new ulong[] { 1 }) << 31).Segments); + new Quire(new ulong[] { 0x80000000 }).GetSegments(), + (new Quire(new ulong[] { 1 }) << 31).GetSegments()); Assert.AreEqual( - new Quire(new ulong[] { 0 }).Segments, - (new Quire(new ulong[] { 6 }) << -1).Segments); + new Quire(new ulong[] { 0 }).GetSegments(), + (new Quire(new ulong[] { 6 }) << -1).GetSegments()); Assert.AreEqual( - new Quire(new ulong[] { 0, 0x_8000_0000_0000_0000 }).Segments, - (new Quire(new ulong[] { 1, 0 }) << 127).Segments); + new Quire(new ulong[] { 0, 0x_8000_0000_0000_0000 }).GetSegments(), + (new Quire(new ulong[] { 1, 0 }) << 127).GetSegments()); Assert.AreEqual( - new Quire(new ulong[] { 1 }).Segments, - (new Quire(new ulong[] { 0x00000001 }) << 64).Segments); + new Quire(new ulong[] { 1 }).GetSegments(), + (new Quire(new ulong[] { 0x00000001 }) << 64).GetSegments()); Assert.AreEqual( - new Quire(new ulong[] { 0x80000000, 0x00000000 }).Segments, - (new Quire(new ulong[] { 0x00800000, 0x00000000 }) << 8).Segments); + new Quire(new ulong[] { 0x80000000, 0x00000000 }).GetSegments(), + (new Quire(new ulong[] { 0x00800000, 0x00000000 }) << 8).GetSegments()); Assert.AreEqual( - new Quire(new ulong[] { 0x200000000 }).Segments, - (new Quire(new ulong[] { 0x00000001 }) << -31).Segments); + new Quire(new ulong[] { 0x200000000 }).GetSegments(), + (new Quire(new ulong[] { 0x00000001 }) << -31).GetSegments()); } [Fact] public void QuireBitShiftRightIsCorrect() { Assert.AreEqual( - new Quire(new ulong[] { 0x00800000, 0x00000000 }).Segments, - (new Quire(new ulong[] { 0x80000000, 0x00000000 }) >> 8).Segments); + new Quire(new ulong[] { 0x00800000, 0x00000000 }).GetSegments(), + (new Quire(new ulong[] { 0x80000000, 0x00000000 }) >> 8).GetSegments()); Assert.AreEqual( - new Quire(new ulong[] { 1 }).Segments, - (new Quire(new ulong[] { 0x80000000 }) >> 31).Segments); + new Quire(new ulong[] { 1 }).GetSegments(), + (new Quire(new ulong[] { 0x80000000 }) >> 31).GetSegments()); Assert.AreEqual( - new Quire(new ulong[] { 1, 0 }).Segments, - (new Quire(new ulong[] { 0, 0x_8000_0000_0000_0000 }) >> 127).Segments); + new Quire(new ulong[] { 1, 0 }).GetSegments(), + (new Quire(new ulong[] { 0, 0x_8000_0000_0000_0000 }) >> 127).GetSegments()); Assert.AreEqual( - new Quire(new ulong[] { 1_152_921_504_606_846_992, 0 }).Segments, - (new Quire(new ulong[] { 0x_0000_0000_0000_0100, 0x_0000_0000_0000_0001 }) >> 4).Segments); + new Quire(new ulong[] { 1_152_921_504_606_846_992, 0 }).GetSegments(), + (new Quire(new ulong[] { 0x_0000_0000_0000_0100, 0x_0000_0000_0000_0001 }) >> 4).GetSegments()); Assert.AreEqual( - new Quire(new[] { 0x_8000_0000_0000_0000 }).Segments, - (new Quire(new[] { 0x_8000_0000_0000_0000 }) >> 64).Segments); + new Quire(new[] { 0x_8000_0000_0000_0000 }).GetSegments(), + (new Quire(new[] { 0x_8000_0000_0000_0000 }) >> 64).GetSegments()); Assert.AreEqual( - new Quire(new ulong[] { 0x_4000_0000_0000_0000 }).Segments, - (new Quire(new[] { 0x_8000_0000_0000_0000 }) >> -63).Segments); + new Quire(new ulong[] { 0x_4000_0000_0000_0000 }).GetSegments(), + (new Quire(new[] { 0x_8000_0000_0000_0000 }) >> -63).GetSegments()); } [Fact] public void QuireAdditionIsCorrect() { Assert.AreEqual( - new Quire(new ulong[] { 5 }).Segments, - (new Quire(new ulong[] { 4 }) + new Quire(new ulong[] { 1 })).Segments); + new Quire(new ulong[] { 5 }).GetSegments(), + (new Quire(new ulong[] { 4 }) + new Quire(new ulong[] { 1 })).GetSegments()); Assert.AreEqual( - new Quire(new ulong[] { 0, 2 }).Segments, - (new Quire(new ulong[] { ulong.MaxValue, 1 }) + new Quire(new ulong[] { 1, 0 })).Segments); + new Quire(new ulong[] { 0, 2 }).GetSegments(), + (new Quire(new ulong[] { ulong.MaxValue, 1 }) + new Quire(new ulong[] { 1, 0 })).GetSegments()); Assert.AreEqual( - new Quire(new ulong[] { 2, 0, 0, 1, 2 }).Segments, - (new Quire(new ulong[] { 1, 0, 0, 0, 1 }) + new Quire(new ulong[] { 1, 0, 0, 1, 1 })).Segments); + new Quire(new ulong[] { 2, 0, 0, 1, 2 }).GetSegments(), + (new Quire(new ulong[] { 1, 0, 0, 0, 1 }) + new Quire(new ulong[] { 1, 0, 0, 1, 1 })).GetSegments()); } [Fact] public void QuireToIntegerAdditionIsCorrect() => Assert.AreEqual( - new Quire(new ulong[] { 5 }).Segments, - (new Quire(new ulong[] { 4 }) + 1).Segments); + new Quire(new ulong[] { 5 }).GetSegments(), + (new Quire(new ulong[] { 4 }) + 1).GetSegments()); [Fact] public void QuireSubtractionIsCorrect() { Assert.AreEqual( - new Quire(new ulong[] { 4 }).Segments, - (new Quire(new ulong[] { 5 }) - new Quire(new ulong[] { 1 })).Segments); + new Quire(new ulong[] { 4 }).GetSegments(), + (new Quire(new ulong[] { 5 }) - new Quire(new ulong[] { 1 })).GetSegments()); Assert.AreEqual( - new Quire(new ulong[] { 1, 0, 0, 0, 1 }).Segments, - (new Quire(new ulong[] { 2, 0, 0, 1, 2 }) - new Quire(new ulong[] { 1, 0, 0, 1, 1 })).Segments); + new Quire(new ulong[] { 1, 0, 0, 0, 1 }).GetSegments(), + (new Quire(new ulong[] { 2, 0, 0, 1, 2 }) - new Quire(new ulong[] { 1, 0, 0, 1, 1 })).GetSegments()); Assert.AreEqual( - new Quire(new ulong[] { ulong.MaxValue, 1 }).Segments, - (new Quire(new ulong[] { 0, 2 }) - new Quire(new ulong[] { 1, 0 })).Segments); + new Quire(new ulong[] { ulong.MaxValue, 1 }).GetSegments(), + (new Quire(new ulong[] { 0, 2 }) - new Quire(new ulong[] { 1, 0 })).GetSegments()); } } } diff --git a/Posit/Quire.cs b/Posit/Quire.cs index 7cc27e7..6b37915 100644 --- a/Posit/Quire.cs +++ b/Posit/Quire.cs @@ -1,21 +1,28 @@ using System; +using System.Collections.Generic; +using System.Diagnostics.CodeAnalysis; namespace Lombiq.Arithmetics { - public class Quire + [SuppressMessage("Major Code Smell", "S4035:Classes implementing \"IEquatable<T>\" should be sealed", Justification = "False Positive")] + public class Quire : IEqualityComparer<Quire> { + private const ulong SegmentMaskWithLeadingOne = 0x_8000_0000_0000_0000; + private const ulong SegmentMaskWithClosingOne = 1; + public ushort Size { get; } public ushort SegmentCount { get; } - public ulong[] Segments { get; } + + private readonly ulong[] _segments; public Quire(ushort size) { var partialSegment = size % 64; SegmentCount = (ushort)((size >> 6) + (partialSegment == 0 ? 0 : 1)); Size = size; - Segments = new ulong[SegmentCount]; + _segments = new ulong[SegmentCount]; for (int i = 0; i < SegmentCount; i++) - Segments[i] = 0; + GetSegments()[i] = 0; } public Quire(ulong[] segments, ushort size = 0) @@ -27,37 +34,37 @@ public Quire(ulong[] segments, ushort size = 0) SegmentCount = (ushort)((size >> 6) + (size % 32 == 0 ? 0 : 1)); } - Segments = new ulong[SegmentCount]; + _segments = new ulong[SegmentCount]; - Array.Copy(segments, Segments, segments.Length); + Array.Copy(segments, GetSegments(), segments.Length); for (int i = segments.Length; i < SegmentCount; i++) - Segments[i] = 0; + GetSegments()[i] = 0; } public Quire(uint firstSegment, ushort size) { Size = size; SegmentCount = (ushort)((size >> 6) + (size % 32 == 0 ? 0 : 1)); - Segments = new ulong[SegmentCount]; - Segments[0] = firstSegment; + _segments = new ulong[SegmentCount]; + GetSegments()[0] = firstSegment; for (int i = 1; i < SegmentCount; i++) - Segments[i] = 0; + GetSegments()[i] = 0; } + public ulong[] GetSegments() => _segments; + public static Quire operator +(Quire left, Quire right) { if (left.SegmentCount == 0 || right.SegmentCount == 0) return left; var result = new ulong[left.SegmentCount]; - bool carry = false, leftBit, rightBit; - byte buffer; + bool carry = false; ushort segmentPosition = 0, position = 0; for (ushort i = 0; i < left.SegmentCount << 6; i++) { - leftBit = ((left.Segments[segmentPosition] >> position) & 1) == 1; - rightBit = ((right.Segments[segmentPosition] >> position) & 1) == 1; - - buffer = (byte)((leftBit ? 1 : 0) + (rightBit ? 1 : 0) + (carry ? 1 : 0)); + bool leftBit = ((left.GetSegments()[segmentPosition] >> position) & 1) == 1; + bool rightBit = ((right.GetSegments()[segmentPosition] >> position) & 1) == 1; + byte buffer = (byte)((leftBit ? 1 : 0) + (rightBit ? 1 : 0) + (carry ? 1 : 0)); if ((buffer & 1) == 1) result[segmentPosition] += 1UL << position; carry = buffer >> 1 == 1; @@ -79,16 +86,15 @@ public Quire(uint firstSegment, ushort size) if (left.SegmentCount == 0 || right.SegmentCount == 0) return left; var result = new ulong[left.SegmentCount]; - bool carry = false, leftBit, rightBit; - byte buffer; + bool carry = false; ushort segmentPosition = 0, position = 0; for (ushort i = 0; i < left.SegmentCount << 6; i++) { - leftBit = ((left.Segments[segmentPosition] >> position) & 1) == 1; - rightBit = ((right.Segments[segmentPosition] >> position) & 1) == 1; + bool leftBit = ((left.GetSegments()[segmentPosition] >> position) & 1) == 1; + bool rightBit = ((right.GetSegments()[segmentPosition] >> position) & 1) == 1; - buffer = (byte)(2 + (leftBit ? 1 : 0) - (rightBit ? 1 : 0) - (carry ? 1 : 0)); + byte buffer = (byte)(2 + (leftBit ? 1 : 0) - (rightBit ? 1 : 0) - (carry ? 1 : 0)); if ((buffer & 1) == 1) result[segmentPosition] += 1UL << position; carry = buffer >> 1 == 0; @@ -108,7 +114,7 @@ public Quire(uint firstSegment, ushort size) { for (ushort i = 0; i < q.SegmentCount; i++) { - q.Segments[i] = ~q.Segments[i]; + q.GetSegments()[i] = ~q.GetSegments()[i]; } return q; @@ -116,10 +122,12 @@ public Quire(uint firstSegment, ushort size) public static bool operator ==(Quire left, Quire right) { - if (left.SegmentCount != right.SegmentCount) return false; + if (left == null && right == null) return true; + if (left == null || right == null || left.SegmentCount != right.SegmentCount) return false; + for (ushort i = 0; i < left.SegmentCount; i++) { - if (left.Segments[i] != right.Segments[i]) return false; + if (left.GetSegments()[i] != right.GetSegments()[i]) return false; } return true; @@ -129,24 +137,21 @@ public Quire(uint firstSegment, ushort size) public static Quire operator >>(Quire left, int right) { - right = right & ((1 << (left.SegmentCount * 6)) - 1); + right &= (1 << (left.SegmentCount * 6)) - 1; - bool carryOld, carryNew; - var segmentMaskWithLeadingOne = 0x_8000_0000_0000_0000; var segments = new ulong[left.SegmentCount]; - Array.Copy(left.Segments, segments, left.Segments.Length); - ushort currentIndex; + Array.Copy(left.GetSegments(), segments, left.GetSegments().Length); for (ushort i = 0; i < right; i++) { - carryOld = false; + bool carryOld = false; for (ushort j = 1; j <= segments.Length; j++) { - currentIndex = (ushort)(segments.Length - j); - carryNew = (segments[currentIndex] & 1) == 1; + ushort currentIndex = (ushort)(segments.Length - j); + bool carryNew = (segments[currentIndex] & 1) == 1; segments[currentIndex] >>= 1; - if (carryOld) segments[currentIndex] |= segmentMaskWithLeadingOne; + if (carryOld) segments[currentIndex] |= SegmentMaskWithLeadingOne; carryOld = carryNew; } } @@ -156,23 +161,20 @@ public Quire(uint firstSegment, ushort size) public static Quire operator <<(Quire left, int right) { - right = right & ((1 << (left.SegmentCount * 6)) - 1); + right &= (1 << (left.SegmentCount * 6)) - 1; - bool carryOld, carryNew; - var segmentMaskWithLeadingOne = 0x_8000_0000_0000_0000; var segments = new ulong[left.SegmentCount]; - Array.Copy(left.Segments, segments, left.Segments.Length); - uint segmentMaskWithClosingOne = 1; + Array.Copy(left.GetSegments(), segments, left.GetSegments().Length); for (ushort i = 0; i < right; i++) { - carryOld = false; + bool carryOld = false; for (ushort j = 0; j < segments.Length; j++) { - carryNew = (segments[j] & segmentMaskWithLeadingOne) == segmentMaskWithLeadingOne; + bool carryNew = (segments[j] & SegmentMaskWithLeadingOne) == SegmentMaskWithLeadingOne; segments[j] <<= 1; - if (carryOld) segments[j] |= segmentMaskWithClosingOne; + if (carryOld) segments[j] |= SegmentMaskWithClosingOne; carryOld = carryNew; } } @@ -180,16 +182,25 @@ public Quire(uint firstSegment, ushort size) return new Quire(segments); } - public static explicit operator ulong(Quire x) - { - return x.Segments[0]; - } + public static explicit operator ulong(Quire x) => x.GetSegments()[0]; - public static explicit operator uint(Quire x) + public static explicit operator uint(Quire x) => (uint)x.GetSegments()[0]; + + protected bool Equals(Quire other) => this == other; + public bool Equals(Quire x, Quire y) => x == y; + public override bool Equals(object obj) => obj is Quire other && this == other; + + public int GetHashCode(Quire obj) => obj.GetHashCode(); + + public override int GetHashCode() { - return (uint)x.Segments[0]; + unchecked + { + var hashCode = _segments != null ? _segments.GetHashCode() : 0; + hashCode = (hashCode * 397) ^ Size.GetHashCode(); + hashCode = (hashCode * 397) ^ SegmentCount.GetHashCode(); + return hashCode; + } } } } - - diff --git a/Unum/Unum.cs b/Unum/Unum.cs index f30b310..666e4da 100644 --- a/Unum/Unum.cs +++ b/Unum/Unum.cs @@ -1,8 +1,9 @@ using System; +using System.Diagnostics.CodeAnalysis; namespace Lombiq.Arithmetics { - public struct Unum + public readonly struct Unum : IEquatable<Unum> { private readonly UnumEnvironment _environment; @@ -82,6 +83,7 @@ public struct Unum /// <summary> /// Gets a BitMask for the Unit in the Last Place or Unit of Least Precision. /// </summary> + [SuppressMessage("Minor Code Smell", "S100:Methods and properties should be named in PascalCase", Justification = "It's an acronym.")] public BitMask ULP => _environment.ULP; /// <summary> @@ -178,14 +180,12 @@ public Unum(UnumEnvironment environment, uint[] value, bool negative = false) if (UnumBits == _environment.EmptyBitMask) return; // Handling the case when the number wouldn't fit in the range of the environment. - if (UnumHelper.LargestExpressablePositiveInteger(environment) != environment.EmptyBitMask) + if (UnumHelper.LargestExpressablePositiveInteger(environment) != environment.EmptyBitMask && + UnumBits > UnumHelper.LargestExpressablePositiveInteger(environment)) { - if (UnumBits > UnumHelper.LargestExpressablePositiveInteger(environment)) - { - UnumBits = negative ? environment.LargestNegative | environment.UncertaintyBitMask - : environment.LargestPositive | environment.UncertaintyBitMask; - return; - } + UnumBits = negative ? environment.LargestNegative | environment.UncertaintyBitMask + : environment.LargestPositive | environment.UncertaintyBitMask; + return; } var uncertainityBit = false; @@ -238,7 +238,7 @@ public Unum(UnumEnvironment environment, uint[] value, bool negative = false) // Handling input numbers that fit in the range, but are too big to represent exactly. if (fractionSize > FractionSizeMax) { - fraction = fraction >> (FractionSizeMax - fractionSize); + fraction >>= FractionSizeMax - fractionSize; uncertainityBit = true; } @@ -247,8 +247,8 @@ public Unum(UnumEnvironment environment, uint[] value, bool negative = false) exponent, fraction, uncertainityBit, - (byte)(exponentSize > 0 ? --exponentSize : 0), - (ushort)(fractionSize > 0 ? --fractionSize : 0)); + (byte)(exponentSize > 0 ? exponentSize - 1 : 0), + (ushort)(fractionSize > 0 ? fractionSize - 1 : 0)); } public Unum(UnumEnvironment environment, int value) @@ -313,7 +313,7 @@ private BitMask AssembleUnumBits( /// <returns>The BitMask representing the Unum with its SignBit set to the given value.</returns> public Unum SetSignBit(bool signBit) { - var newUnumBits = signBit ? UnumBits | SignBitMask : UnumBits & (new BitMask(Size, true) ^ (SignBitMask)); + var newUnumBits = signBit ? UnumBits | SignBitMask : UnumBits & (new BitMask(Size, true) ^ SignBitMask); return new Unum(_environment, newUnumBits); } @@ -369,9 +369,6 @@ public Unum SetFractionSizeBits(byte fractionSize) /// <summary> /// Sets the exponentSize to the given value and leaves everything else as is. /// </summary> - /// <param name="fraction"> - /// The desired exponentSize in a notation that is one less than the actual value. - /// </param> /// <returns>The BitMask representing the Unum with its exponentSize set to the given value.</returns> public Unum SetExponentSizeBits(byte exponentSize) { @@ -486,68 +483,102 @@ public BitMask FractionWithHiddenBit() => public static Unum AddExactUnums(Unum left, Unum right) { - // It could be only FractionSizeMax + 2 long if that would be Hastlayer-compatible (it isn't due to static - // array sizes). - var scratchPad = new BitMask(left._environment.Size); - // Handling special cases first. - if (left.IsNan() || right.IsNan()) - return new Unum(left._environment, left.QuietNotANumber); + if (AddExactUnumsSpecial(left, right) is { } special) return special; + + AddExactUnumsInner( + left, + right, + out var scratchPad, + out var resultExponentValue, + out var smallerBitsMovedToLeft, + out var resultSignBit); + + // Calculating how the addition changed the exponent of the result. + var exponentChange = scratchPad.FindMostSignificantOnePosition() - (left.FractionSizeMax + 1); + var resultExponent = new BitMask(left._environment.Size) + + ExponentValueToExponentBits(resultExponentValue + exponentChange, left.Size); + // Calculating the ExponentSize needed to the excess-k notation of the results Exponent value. + var resultExponentSize = (byte)(ExponentValueToExponentSize(resultExponentValue + exponentChange) - 1); + + var resultUbit = false; + if (smallerBitsMovedToLeft < 0) resultUbit = true; // There are lost digits, so we set the ubit to 1. + // If there are no lost digits, we can shift out the least significant zeros to save space. + else scratchPad = scratchPad.ShiftOutLeastSignificantZeros(); + + ushort resultFractionSize = 0; + + // Calculating the results FractionSize. + if (scratchPad.FindMostSignificantOnePosition() == 0) + { + // If the Fraction is zero, so is the FractionSize. + resultExponent = scratchPad; // 0 + resultExponentSize = 0; // If the Fraction is zero, so is the ExponentSize. + } + else + { + resultFractionSize = (ushort)(scratchPad.FindMostSignificantOnePosition() - 1); + } + + if (resultExponent.FindMostSignificantOnePosition() != 0) + { + // Erase the hidden bit if it is set. + scratchPad = scratchPad.SetZero((ushort)(scratchPad.FindMostSignificantOnePosition() - 1)); + resultFractionSize = (ushort)(resultFractionSize == 0 ? 0 : resultFractionSize - 1); + } + + // This is temporary, for the imitation of float behaviour. Now the Ubit works as a flag for rounded values. + // When Ubounds will be implemented this should be handled in the addition operator. + if (!left.IsExact() || !right.IsExact()) resultUbit = true; + + // Setting the parts of the result Unum to the calculated values. + var resultBitMask = left.AssembleUnumBits( + resultSignBit, + resultExponent, + scratchPad, + resultUbit, + resultExponentSize, + resultFractionSize); - if ((left.IsPositiveInfinity() && right.IsNegativeInfinity()) || + return new Unum(left._environment, resultBitMask); + } + + private static Unum? AddExactUnumsSpecial(Unum left, Unum right) + { + if (left.IsNan() || + right.IsNan() || + (left.IsPositiveInfinity() && right.IsNegativeInfinity()) || (left.IsNegativeInfinity() && right.IsPositiveInfinity())) + { return new Unum(left._environment, left.QuietNotANumber); + } if (left.IsPositiveInfinity() || right.IsPositiveInfinity()) + { return new Unum(left._environment, left.PositiveInfinity); + } if (left.IsNegativeInfinity() || right.IsNegativeInfinity()) + { return new Unum(left._environment, left.NegativeInfinity); + } + + return null; + } + private static void AddExactUnumsInner( + Unum left, + Unum right, + out BitMask scratchPad, + out int resultExponentValue, + out int smallerBitsMovedToLeft, + out bool resultSignBit) + { var exponentValueDifference = left.ExponentValueWithBias() - right.ExponentValueWithBias(); var signBitsMatch = left.IsPositive() == right.IsPositive(); - var resultSignBit = false; - var biggerBitsMovedToLeft = 0; - var smallerBitsMovedToLeft = 0; - var resultExponentValue = 0; - - if (exponentValueDifference == 0) - { - // Exponents are equal. - resultExponentValue = left.ExponentValueWithBias(); + int biggerBitsMovedToLeft; - // We align the fractions so their Most Significant Bit gets to the leftmost position that the - // FractionSize allows. This way the digits that won't fit automatically get lost. - biggerBitsMovedToLeft = left.FractionSizeMax + 1 - (left.FractionSize() + 1); - smallerBitsMovedToLeft = left.FractionSizeMax + 1 - (right.FractionSize() + 1); - // Adding the aligned Fractions. - scratchPad = AddAlignedFractions( - left.FractionWithHiddenBit() << biggerBitsMovedToLeft, - right.FractionWithHiddenBit() << smallerBitsMovedToLeft, - signBitsMatch); - - if (!signBitsMatch) - { - if (left.HiddenBitIsOne() == right.HiddenBitIsOne()) - { - // If the value of the Hidden Bits match we just compare the fractions, - // and get the Sign of the bigger one. - resultSignBit = left.Fraction() >= right.Fraction() - ? !left.IsPositive() // Left Fraction is bigger. - : !right.IsPositive(); // Right Fraction is bigger. - } - else - { - // Otherwise we get the Sign of the number that has a Hidden Bit set. - resultSignBit = left.HiddenBitIsOne() ? !left.IsPositive() : !right.IsPositive(); - } - } - else - { - resultSignBit = !left.IsPositive(); - } - } - else if (exponentValueDifference > 0) + if (exponentValueDifference > 0) { // Left Exponent is bigger. // We align the fractions according to their exponent values so the Most Significant Bit of the bigger @@ -564,8 +595,10 @@ public static Unum AddExactUnums(Unum left, Unum right) scratchPad, right.FractionWithHiddenBit() << smallerBitsMovedToLeft, signBitsMatch); + + return; } - else + else if (exponentValueDifference < 0) { // Right Exponent is bigger. // We align the fractions according to their exponent values so the Most Significant Bit of the bigger @@ -582,55 +615,46 @@ public static Unum AddExactUnums(Unum left, Unum right) scratchPad, left.FractionWithHiddenBit() << smallerBitsMovedToLeft, signBitsMatch); - } - // Calculating how the addition changed the exponent of the result. - var exponentChange = scratchPad.FindMostSignificantOnePosition() - (left.FractionSizeMax + 1); - var resultExponent = new BitMask(left._environment.Size) + - ExponentValueToExponentBits(resultExponentValue + exponentChange, left.Size); - // Calculating the ExponentSize needed to the excess-k notation of the results Exponent value. - var resultExponentSize = (byte)(ExponentValueToExponentSize(resultExponentValue + exponentChange) - 1); + return; + } - var resultUbit = false; - if (smallerBitsMovedToLeft < 0) resultUbit = true; // There are lost digits, so we set the ubit to 1. - // If there are no lost digits, we can shift out the least significant zeros to save space. - else scratchPad = scratchPad.ShiftOutLeastSignificantZeros(); + // Exponents are equal. + resultExponentValue = left.ExponentValueWithBias(); - ushort resultFractionSize = 0; + // We align the fractions so their Most Significant Bit gets to the leftmost position that the + // FractionSize allows. This way the digits that won't fit automatically get lost. + biggerBitsMovedToLeft = left.FractionSizeMax + 1 - (left.FractionSize() + 1); + smallerBitsMovedToLeft = left.FractionSizeMax + 1 - (right.FractionSize() + 1); + // Adding the aligned Fractions. + scratchPad = AddAlignedFractions( + left.FractionWithHiddenBit() << biggerBitsMovedToLeft, + right.FractionWithHiddenBit() << smallerBitsMovedToLeft, + signBitsMatch); - // Calculating the results FractionSize. - if (scratchPad.FindMostSignificantOnePosition() == 0) + if (!signBitsMatch) { - // If the Fraction is zero, so is the FractionSize. - resultExponent = scratchPad; // 0 - resultExponentSize = 0; // If the Fraction is zero, so is the ExponentSize. + // False Positive. +#pragma warning disable S3240 // The simplest possible condition syntax should be used + if (left.HiddenBitIsOne() == right.HiddenBitIsOne()) + { + // If the value of the Hidden Bits match we just compare the fractions, + // and get the Sign of the bigger one. + resultSignBit = left.Fraction() >= right.Fraction() + ? !left.IsPositive() // Left Fraction is bigger. + : !right.IsPositive(); // Right Fraction is bigger. + } + else + { + // Otherwise we get the Sign of the number that has a Hidden Bit set. + resultSignBit = left.HiddenBitIsOne() ? !left.IsPositive() : !right.IsPositive(); + } +#pragma warning restore S3240 // The simplest possible condition syntax should be used } else { - resultFractionSize = (ushort)(scratchPad.FindMostSignificantOnePosition() - 1); - } - - if (resultExponent.FindMostSignificantOnePosition() != 0) - { - // Erase the hidden bit if it is set. - scratchPad = scratchPad.SetZero((ushort)(scratchPad.FindMostSignificantOnePosition() - 1)); - resultFractionSize = (ushort)(resultFractionSize == 0 ? 0 : resultFractionSize - 1); + resultSignBit = !left.IsPositive(); } - - // This is temporary, for the imitation of float behaviour. Now the Ubit works as a flag for rounded values. - // When Ubounds will be implemented this should be handled in the addition operator. - if ((!left.IsExact()) || (!right.IsExact())) resultUbit = true; - - // Setting the parts of the result Unum to the calculated values. - var resultBitMask = left.AssembleUnumBits( - resultSignBit, - resultExponent, - scratchPad, - resultUbit, - resultExponentSize, - resultFractionSize); - - return new Unum(left._environment, resultBitMask); } public static Unum SubtractExactUnums(Unum left, Unum right) => AddExactUnums(left, NegateExactUnum(right)); @@ -671,11 +695,9 @@ public static byte ExponentValueToExponentSize(int value) public static BitMask AddAlignedFractions(BitMask left, BitMask right, bool signBitsMatch) { - var mask = new BitMask(left.Size); - - if (signBitsMatch) mask = left + right; - else mask = left > right ? left - right : right - left; + if (signBitsMatch) return left + right; + var mask = left > right ? left - right : right - left; return mask; } @@ -693,12 +715,12 @@ public static BitMask AddAlignedFractions(BitMask left, BitMask right, bool sign public static bool operator !=(Unum left, Unum right) => !(left == right); - //Converting from an Unum to int results in information loss, so only allowing it explicitly (with a cast). + // Converting from an Unum to int results in information loss, so only allowing it explicitly (with a cast). public static explicit operator int(Unum x) { uint result; - if ((x.ExponentValueWithBias() + x.FractionSizeWithHiddenBit()) < 31) //The Unum fits into the range. + if ((x.ExponentValueWithBias() + x.FractionSizeWithHiddenBit()) < 31) // The Unum fits into the range. result = (x.FractionWithHiddenBit() << (x.ExponentValueWithBias() - x.FractionSize())).Lowest32Bits; else return x.IsPositive() ? int.MaxValue : int.MinValue; // The absolute value of the Unum is too large. @@ -730,11 +752,19 @@ public static explicit operator float(Unum x) #endregion #region Overrides - public override bool Equals(object obj) => base.Equals(obj); + public override bool Equals(object obj) => obj is Unum other && this == other; + + public bool Equals(Unum other) => this == other; - public override int GetHashCode() => base.GetHashCode(); + public override int GetHashCode() + { + unchecked + { + return ((_environment != null ? _environment.GetHashCode() : 0) * 397) ^ UnumBits.GetHashCode(); + } + } - public override string ToString() => base.ToString(); + public override string ToString() => $"{nameof(Unum)}(Bits:{UnumBits};Environment:{_environment})"; #endregion } diff --git a/Unum/UnumEnvironment.cs b/Unum/UnumEnvironment.cs index 3a186d6..11ae948 100644 --- a/Unum/UnumEnvironment.cs +++ b/Unum/UnumEnvironment.cs @@ -1,3 +1,5 @@ +using System.Diagnostics.CodeAnalysis; + namespace Lombiq.Arithmetics { public class UnumEnvironment @@ -78,6 +80,10 @@ public class UnumEnvironment /// <summary> /// Gets a BitMask for the Unit in the Last Place or Unit of Least Precision. /// </summary> + [SuppressMessage( + "Minor Code Smell", + "S100:Methods and properties should be named in PascalCase", + Justification = "This is an acronym.")] public BitMask ULP { get; } /// <summary> @@ -166,6 +172,9 @@ public UnumEnvironment(byte exponentSizeSize, byte fractionSizeSize) SignalingNotANumber = NegativeInfinity + UncertaintyBitMask; } + public override string ToString() => + $"{nameof(UnumEnvironment)}(Exponent:{ExponentSizeSize};Fraction:{FractionSizeSize})"; + public static UnumEnvironment FromConfigurationValues(byte eSize, ushort fSize) => new(UnumHelper.SegmentSizeToSegmentSizeSize(eSize), UnumHelper.SegmentSizeToSegmentSizeSize(fSize)); diff --git a/Unum/UnumException.cs b/Unum/UnumException.cs index 5dc2f01..fdd2ae3 100644 --- a/Unum/UnumException.cs +++ b/Unum/UnumException.cs @@ -1,7 +1,9 @@ using System; +using System.Runtime.Serialization; namespace Lombiq.Arithmetics { + [Serializable] public class UnumException : Exception { public UnumException(string message) @@ -10,7 +12,10 @@ public UnumException(string message) public UnumException(string message, Exception innerException) : base(message, innerException) { } - public UnumException() + public UnumException() { } + + protected UnumException(SerializationInfo info, StreamingContext context) + : base(info, context) { } } From e0675743d285640cc39cafd0ec1029bf5f83fdbf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Sat, 18 Dec 2021 19:36:49 +0100 Subject: [PATCH 38/49] Go back to Quire.Segments property because Hastlayer can't deal with the array returning method. --- .../PositTests/Posit32Tests.cs | 14 ++-- .../PositTests/QuireTests.cs | 76 +++++++++---------- Posit/Quire.cs | 47 ++++++------ Unum/Unum.cs | 46 ++++++----- 4 files changed, 92 insertions(+), 91 deletions(-) diff --git a/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs b/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs index 33ff9a6..832996b 100644 --- a/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs +++ b/Lombiq.Arithmetics.Tests/PositTests/Posit32Tests.cs @@ -339,30 +339,30 @@ public void Posit32ToDoubleIsCorrect() public void Posit32ToQuireIsCorrect() { var posit1 = new Posit32(1); - Assert.AreEqual(((Quire)posit1).GetSegments(), (new Quire(new ulong[] { 1 }, 512) << 240).GetSegments()); + Assert.AreEqual(((Quire)posit1).Segments, (new Quire(new ulong[] { 1 }, 512) << 240).Segments); var positNegative1 = new Posit32(-1); Assert.AreEqual( - ((Quire)positNegative1).GetSegments(), + ((Quire)positNegative1).Segments, new Quire( new ulong[] { 0, 0, 0, 0x_FFFF_0000_0000_0000, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue }, 512) - .GetSegments()); + .Segments); var positNegative3 = new Posit32(-3); Assert.AreEqual( - ((Quire)positNegative3).GetSegments(), + ((Quire)positNegative3).Segments, new Quire( new ulong[] { 0, 0, 0, 0x_FFFD_0000_0000_0000, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue, ulong.MaxValue }, 512) - .GetSegments()); + .Segments); var positMax = new Posit32(0x_7FFF_FFFF, true); - Assert.AreEqual(((Quire)positMax).GetSegments(), (new Quire(new ulong[] { 1 }, 512) << 360).GetSegments()); + Assert.AreEqual(((Quire)positMax).Segments, (new Quire(new ulong[] { 1 }, 512) << 360).Segments); var positNaN = new Posit32(Posit32.NaNBitMask, true); var quireNaN = (Quire)positNaN; var quireNaNFromMask = new Quire(new ulong[] { 1 }, 512) << 511; - Assert.AreEqual(quireNaN.GetSegments(), quireNaNFromMask.GetSegments()); + Assert.AreEqual(quireNaN.Segments, quireNaNFromMask.Segments); } [Fact] diff --git a/Lombiq.Arithmetics.Tests/PositTests/QuireTests.cs b/Lombiq.Arithmetics.Tests/PositTests/QuireTests.cs index ef52c97..34fef8b 100644 --- a/Lombiq.Arithmetics.Tests/PositTests/QuireTests.cs +++ b/Lombiq.Arithmetics.Tests/PositTests/QuireTests.cs @@ -10,80 +10,80 @@ public class QuireTests public void QuireBitShiftLeftIsCorrect() { Assert.AreEqual( - new Quire(new ulong[] { 0x80000000 }).GetSegments(), - (new Quire(new ulong[] { 1 }) << 31).GetSegments()); + new Quire(new ulong[] { 0x80000000 }).Segments, + (new Quire(new ulong[] { 1 }) << 31).Segments); Assert.AreEqual( - new Quire(new ulong[] { 0 }).GetSegments(), - (new Quire(new ulong[] { 6 }) << -1).GetSegments()); + new Quire(new ulong[] { 0 }).Segments, + (new Quire(new ulong[] { 6 }) << -1).Segments); Assert.AreEqual( - new Quire(new ulong[] { 0, 0x_8000_0000_0000_0000 }).GetSegments(), - (new Quire(new ulong[] { 1, 0 }) << 127).GetSegments()); + new Quire(new ulong[] { 0, 0x_8000_0000_0000_0000 }).Segments, + (new Quire(new ulong[] { 1, 0 }) << 127).Segments); Assert.AreEqual( - new Quire(new ulong[] { 1 }).GetSegments(), - (new Quire(new ulong[] { 0x00000001 }) << 64).GetSegments()); + new Quire(new ulong[] { 1 }).Segments, + (new Quire(new ulong[] { 0x00000001 }) << 64).Segments); Assert.AreEqual( - new Quire(new ulong[] { 0x80000000, 0x00000000 }).GetSegments(), - (new Quire(new ulong[] { 0x00800000, 0x00000000 }) << 8).GetSegments()); + new Quire(new ulong[] { 0x80000000, 0x00000000 }).Segments, + (new Quire(new ulong[] { 0x00800000, 0x00000000 }) << 8).Segments); Assert.AreEqual( - new Quire(new ulong[] { 0x200000000 }).GetSegments(), - (new Quire(new ulong[] { 0x00000001 }) << -31).GetSegments()); + new Quire(new ulong[] { 0x200000000 }).Segments, + (new Quire(new ulong[] { 0x00000001 }) << -31).Segments); } [Fact] public void QuireBitShiftRightIsCorrect() { Assert.AreEqual( - new Quire(new ulong[] { 0x00800000, 0x00000000 }).GetSegments(), - (new Quire(new ulong[] { 0x80000000, 0x00000000 }) >> 8).GetSegments()); + new Quire(new ulong[] { 0x00800000, 0x00000000 }).Segments, + (new Quire(new ulong[] { 0x80000000, 0x00000000 }) >> 8).Segments); Assert.AreEqual( - new Quire(new ulong[] { 1 }).GetSegments(), - (new Quire(new ulong[] { 0x80000000 }) >> 31).GetSegments()); + new Quire(new ulong[] { 1 }).Segments, + (new Quire(new ulong[] { 0x80000000 }) >> 31).Segments); Assert.AreEqual( - new Quire(new ulong[] { 1, 0 }).GetSegments(), - (new Quire(new ulong[] { 0, 0x_8000_0000_0000_0000 }) >> 127).GetSegments()); + new Quire(new ulong[] { 1, 0 }).Segments, + (new Quire(new ulong[] { 0, 0x_8000_0000_0000_0000 }) >> 127).Segments); Assert.AreEqual( - new Quire(new ulong[] { 1_152_921_504_606_846_992, 0 }).GetSegments(), - (new Quire(new ulong[] { 0x_0000_0000_0000_0100, 0x_0000_0000_0000_0001 }) >> 4).GetSegments()); + new Quire(new ulong[] { 1_152_921_504_606_846_992, 0 }).Segments, + (new Quire(new ulong[] { 0x_0000_0000_0000_0100, 0x_0000_0000_0000_0001 }) >> 4).Segments); Assert.AreEqual( - new Quire(new[] { 0x_8000_0000_0000_0000 }).GetSegments(), - (new Quire(new[] { 0x_8000_0000_0000_0000 }) >> 64).GetSegments()); + new Quire(new[] { 0x_8000_0000_0000_0000 }).Segments, + (new Quire(new[] { 0x_8000_0000_0000_0000 }) >> 64).Segments); Assert.AreEqual( - new Quire(new ulong[] { 0x_4000_0000_0000_0000 }).GetSegments(), - (new Quire(new[] { 0x_8000_0000_0000_0000 }) >> -63).GetSegments()); + new Quire(new ulong[] { 0x_4000_0000_0000_0000 }).Segments, + (new Quire(new[] { 0x_8000_0000_0000_0000 }) >> -63).Segments); } [Fact] public void QuireAdditionIsCorrect() { Assert.AreEqual( - new Quire(new ulong[] { 5 }).GetSegments(), - (new Quire(new ulong[] { 4 }) + new Quire(new ulong[] { 1 })).GetSegments()); + new Quire(new ulong[] { 5 }).Segments, + (new Quire(new ulong[] { 4 }) + new Quire(new ulong[] { 1 })).Segments); Assert.AreEqual( - new Quire(new ulong[] { 0, 2 }).GetSegments(), - (new Quire(new ulong[] { ulong.MaxValue, 1 }) + new Quire(new ulong[] { 1, 0 })).GetSegments()); + new Quire(new ulong[] { 0, 2 }).Segments, + (new Quire(new ulong[] { ulong.MaxValue, 1 }) + new Quire(new ulong[] { 1, 0 })).Segments); Assert.AreEqual( - new Quire(new ulong[] { 2, 0, 0, 1, 2 }).GetSegments(), - (new Quire(new ulong[] { 1, 0, 0, 0, 1 }) + new Quire(new ulong[] { 1, 0, 0, 1, 1 })).GetSegments()); + new Quire(new ulong[] { 2, 0, 0, 1, 2 }).Segments, + (new Quire(new ulong[] { 1, 0, 0, 0, 1 }) + new Quire(new ulong[] { 1, 0, 0, 1, 1 })).Segments); } [Fact] public void QuireToIntegerAdditionIsCorrect() => Assert.AreEqual( - new Quire(new ulong[] { 5 }).GetSegments(), - (new Quire(new ulong[] { 4 }) + 1).GetSegments()); + new Quire(new ulong[] { 5 }).Segments, + (new Quire(new ulong[] { 4 }) + 1).Segments); [Fact] public void QuireSubtractionIsCorrect() { Assert.AreEqual( - new Quire(new ulong[] { 4 }).GetSegments(), - (new Quire(new ulong[] { 5 }) - new Quire(new ulong[] { 1 })).GetSegments()); + new Quire(new ulong[] { 4 }).Segments, + (new Quire(new ulong[] { 5 }) - new Quire(new ulong[] { 1 })).Segments); Assert.AreEqual( - new Quire(new ulong[] { 1, 0, 0, 0, 1 }).GetSegments(), - (new Quire(new ulong[] { 2, 0, 0, 1, 2 }) - new Quire(new ulong[] { 1, 0, 0, 1, 1 })).GetSegments()); + new Quire(new ulong[] { 1, 0, 0, 0, 1 }).Segments, + (new Quire(new ulong[] { 2, 0, 0, 1, 2 }) - new Quire(new ulong[] { 1, 0, 0, 1, 1 })).Segments); Assert.AreEqual( - new Quire(new ulong[] { ulong.MaxValue, 1 }).GetSegments(), - (new Quire(new ulong[] { 0, 2 }) - new Quire(new ulong[] { 1, 0 })).GetSegments()); + new Quire(new ulong[] { ulong.MaxValue, 1 }).Segments, + (new Quire(new ulong[] { 0, 2 }) - new Quire(new ulong[] { 1, 0 })).Segments); } } } diff --git a/Posit/Quire.cs b/Posit/Quire.cs index 6b37915..be0bdeb 100644 --- a/Posit/Quire.cs +++ b/Posit/Quire.cs @@ -13,16 +13,21 @@ public class Quire : IEqualityComparer<Quire> public ushort Size { get; } public ushort SegmentCount { get; } - private readonly ulong[] _segments; + [SuppressMessage( + "Performance", + "CA1819:Properties should not return arrays", + Justification = "Not currently posisble due to IArraySizeHolder limitations.")] + // See: https://github.com/Lombiq/Hastlayer-SDK/issues/62#issuecomment-997227931 + public ulong[] Segments { get; } public Quire(ushort size) { var partialSegment = size % 64; SegmentCount = (ushort)((size >> 6) + (partialSegment == 0 ? 0 : 1)); Size = size; - _segments = new ulong[SegmentCount]; + Segments = new ulong[SegmentCount]; for (int i = 0; i < SegmentCount; i++) - GetSegments()[i] = 0; + Segments[i] = 0; } public Quire(ulong[] segments, ushort size = 0) @@ -34,25 +39,23 @@ public Quire(ulong[] segments, ushort size = 0) SegmentCount = (ushort)((size >> 6) + (size % 32 == 0 ? 0 : 1)); } - _segments = new ulong[SegmentCount]; + Segments = new ulong[SegmentCount]; - Array.Copy(segments, GetSegments(), segments.Length); + Array.Copy(segments, Segments, segments.Length); for (int i = segments.Length; i < SegmentCount; i++) - GetSegments()[i] = 0; + Segments[i] = 0; } public Quire(uint firstSegment, ushort size) { Size = size; SegmentCount = (ushort)((size >> 6) + (size % 32 == 0 ? 0 : 1)); - _segments = new ulong[SegmentCount]; - GetSegments()[0] = firstSegment; + Segments = new ulong[SegmentCount]; + Segments[0] = firstSegment; for (int i = 1; i < SegmentCount; i++) - GetSegments()[i] = 0; + Segments[i] = 0; } - public ulong[] GetSegments() => _segments; - public static Quire operator +(Quire left, Quire right) { if (left.SegmentCount == 0 || right.SegmentCount == 0) return left; @@ -62,8 +65,8 @@ public Quire(uint firstSegment, ushort size) for (ushort i = 0; i < left.SegmentCount << 6; i++) { - bool leftBit = ((left.GetSegments()[segmentPosition] >> position) & 1) == 1; - bool rightBit = ((right.GetSegments()[segmentPosition] >> position) & 1) == 1; + bool leftBit = ((left.Segments[segmentPosition] >> position) & 1) == 1; + bool rightBit = ((right.Segments[segmentPosition] >> position) & 1) == 1; byte buffer = (byte)((leftBit ? 1 : 0) + (rightBit ? 1 : 0) + (carry ? 1 : 0)); if ((buffer & 1) == 1) result[segmentPosition] += 1UL << position; @@ -91,8 +94,8 @@ public Quire(uint firstSegment, ushort size) for (ushort i = 0; i < left.SegmentCount << 6; i++) { - bool leftBit = ((left.GetSegments()[segmentPosition] >> position) & 1) == 1; - bool rightBit = ((right.GetSegments()[segmentPosition] >> position) & 1) == 1; + bool leftBit = ((left.Segments[segmentPosition] >> position) & 1) == 1; + bool rightBit = ((right.Segments[segmentPosition] >> position) & 1) == 1; byte buffer = (byte)(2 + (leftBit ? 1 : 0) - (rightBit ? 1 : 0) - (carry ? 1 : 0)); @@ -114,7 +117,7 @@ public Quire(uint firstSegment, ushort size) { for (ushort i = 0; i < q.SegmentCount; i++) { - q.GetSegments()[i] = ~q.GetSegments()[i]; + q.Segments[i] = ~q.Segments[i]; } return q; @@ -127,7 +130,7 @@ public Quire(uint firstSegment, ushort size) for (ushort i = 0; i < left.SegmentCount; i++) { - if (left.GetSegments()[i] != right.GetSegments()[i]) return false; + if (left.Segments[i] != right.Segments[i]) return false; } return true; @@ -140,7 +143,7 @@ public Quire(uint firstSegment, ushort size) right &= (1 << (left.SegmentCount * 6)) - 1; var segments = new ulong[left.SegmentCount]; - Array.Copy(left.GetSegments(), segments, left.GetSegments().Length); + Array.Copy(left.Segments, segments, left.Segments.Length); for (ushort i = 0; i < right; i++) { @@ -164,7 +167,7 @@ public Quire(uint firstSegment, ushort size) right &= (1 << (left.SegmentCount * 6)) - 1; var segments = new ulong[left.SegmentCount]; - Array.Copy(left.GetSegments(), segments, left.GetSegments().Length); + Array.Copy(left.Segments, segments, left.Segments.Length); for (ushort i = 0; i < right; i++) { @@ -182,9 +185,9 @@ public Quire(uint firstSegment, ushort size) return new Quire(segments); } - public static explicit operator ulong(Quire x) => x.GetSegments()[0]; + public static explicit operator ulong(Quire x) => x.Segments[0]; - public static explicit operator uint(Quire x) => (uint)x.GetSegments()[0]; + public static explicit operator uint(Quire x) => (uint)x.Segments[0]; protected bool Equals(Quire other) => this == other; public bool Equals(Quire x, Quire y) => x == y; @@ -196,7 +199,7 @@ public override int GetHashCode() { unchecked { - var hashCode = _segments != null ? _segments.GetHashCode() : 0; + var hashCode = Segments != null ? Segments.GetHashCode() : 0; hashCode = (hashCode * 397) ^ Size.GetHashCode(); hashCode = (hashCode * 397) ^ SegmentCount.GetHashCode(); return hashCode; diff --git a/Unum/Unum.cs b/Unum/Unum.cs index 666e4da..8e6cb3d 100644 --- a/Unum/Unum.cs +++ b/Unum/Unum.cs @@ -481,10 +481,31 @@ public BitMask FractionWithHiddenBit() => #region Operations for exact Unums + [SuppressMessage( + "Critical Code Smell", + "S3776:Cognitive Complexity of methods should not be too high", + Justification = "Not currently posisble due to TypeConverter limitations.")] + // See: https://github.com/Lombiq/Hastlayer-SDK/issues/62 public static Unum AddExactUnums(Unum left, Unum right) { // Handling special cases first. - if (AddExactUnumsSpecial(left, right) is { } special) return special; + if (left.IsNan() || + right.IsNan() || + (left.IsPositiveInfinity() && right.IsNegativeInfinity()) || + (left.IsNegativeInfinity() && right.IsPositiveInfinity())) + { + return new Unum(left._environment, left.QuietNotANumber); + } + + if (left.IsPositiveInfinity() || right.IsPositiveInfinity()) + { + return new Unum(left._environment, left.PositiveInfinity); + } + + if (left.IsNegativeInfinity() || right.IsNegativeInfinity()) + { + return new Unum(left._environment, left.NegativeInfinity); + } AddExactUnumsInner( left, @@ -543,29 +564,6 @@ public static Unum AddExactUnums(Unum left, Unum right) return new Unum(left._environment, resultBitMask); } - private static Unum? AddExactUnumsSpecial(Unum left, Unum right) - { - if (left.IsNan() || - right.IsNan() || - (left.IsPositiveInfinity() && right.IsNegativeInfinity()) || - (left.IsNegativeInfinity() && right.IsPositiveInfinity())) - { - return new Unum(left._environment, left.QuietNotANumber); - } - - if (left.IsPositiveInfinity() || right.IsPositiveInfinity()) - { - return new Unum(left._environment, left.PositiveInfinity); - } - - if (left.IsNegativeInfinity() || right.IsNegativeInfinity()) - { - return new Unum(left._environment, left.NegativeInfinity); - } - - return null; - } - private static void AddExactUnumsInner( Unum left, Unum right, From 5a23edfc3ef013ae869600fffa518840d67ab16d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Sat, 18 Dec 2021 20:12:10 +0100 Subject: [PATCH 39/49] Fix transformation issue in Quire equation op. --- Posit/Quire.cs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/Posit/Quire.cs b/Posit/Quire.cs index be0bdeb..256ddd3 100644 --- a/Posit/Quire.cs +++ b/Posit/Quire.cs @@ -125,8 +125,7 @@ public Quire(uint firstSegment, ushort size) public static bool operator ==(Quire left, Quire right) { - if (left == null && right == null) return true; - if (left == null || right == null || left.SegmentCount != right.SegmentCount) return false; + if (left.SegmentCount != right.SegmentCount) return false; for (ushort i = 0; i < left.SegmentCount; i++) { From 28a93ae7d83763a77098c19c007112f6123a2249 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Sat, 18 Dec 2021 20:16:22 +0100 Subject: [PATCH 40/49] Fix CA1825 (Use Array.Empty<uint>() instead). --- Lombiq.Arithmetics.Tests/BitMaskTests.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Lombiq.Arithmetics.Tests/BitMaskTests.cs b/Lombiq.Arithmetics.Tests/BitMaskTests.cs index a1ff8a8..c4957db 100644 --- a/Lombiq.Arithmetics.Tests/BitMaskTests.cs +++ b/Lombiq.Arithmetics.Tests/BitMaskTests.cs @@ -30,7 +30,7 @@ public void BitMaskSizeIsCorrectlySetWithSegments() { var sizesAndSegmentCounts = new[] { - Tuple.Create(new BitMask(new uint[0]), 0U), + Tuple.Create(new BitMask(Array.Empty<uint>()), 0U), Tuple.Create(new BitMask(new uint[] { 1 }), 32U), Tuple.Create(new BitMask(new uint[] { 2, 2 }), 64U), Tuple.Create(new BitMask(new uint[] { 3, 3, 3 }), 96U), From b9d00dc03ea43372fc42a1e5da15e6eabbb1b93a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Sat, 18 Dec 2021 20:23:51 +0100 Subject: [PATCH 41/49] Fix Lombiq.Arithmetics.Tests. --- .../UnumTests/UnumTests.cs | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs b/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs index 5b50813..c8488cc 100644 --- a/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs +++ b/Lombiq.Arithmetics.Tests/UnumTests/UnumTests.cs @@ -110,8 +110,8 @@ public void UnumIsCorrectlyConstructedFromUintArray() var bitMaskMinValue = new BitMask( new uint[] { - 0xFFFFE8FD , 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, - 0xFFFFFFFF , 0xFFFFFFFF, 0x200FEFFF, + 0xFFFFE8FD, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, + 0xFFFFFFFF, 0xFFFFFFFF, 0x200FEFFF, }, _environment_4_8.Size); Assert.AreEqual(unumMin.UnumBits, bitMaskMinValue); @@ -121,10 +121,10 @@ public void UnumIsCorrectlyConstructedFromUintArray() maxValue[7] >>= 1; var bitMaskMaxValue = new BitMask( - new uint[] + new uint[] { - 0xFFFFE8FD , 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, - 0xFFFFFFFF , 0xFFFFFFFF, 0xFEFFF, + 0xFFFFE8FD, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, + 0xFFFFFFFF, 0xFFFFFFFF, 0xFEFFF, }, _environment_4_8.Size); var unumMax = new Unum(_environment_4_8, maxValue); @@ -217,8 +217,9 @@ public void FractionToUintArrayIsCorrect() 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 }); + Assert.AreEqual( + unumMax.FractionToUintArray(), + new uint[] { 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x7FFFFFFF, 0 }); } [Fact] @@ -484,8 +485,8 @@ public void SubtractExactUnumsIsCorrect() 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); + var unum30 = new Unum(_environment_3_4, 30); + var unumZero = new Unum(_environment_3_4, 0); Assert.AreEqual(Unum.SubtractExactUnums(unum30, unum30).UnumBits, unumZero.UnumBits); } From 487ae08245672e278ee7cd23f1bcb3ac3bf518c3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Mon, 20 Dec 2021 02:16:27 +0100 Subject: [PATCH 42/49] Update note on CA1819. --- Posit/Quire.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Posit/Quire.cs b/Posit/Quire.cs index 256ddd3..737b7be 100644 --- a/Posit/Quire.cs +++ b/Posit/Quire.cs @@ -17,7 +17,7 @@ public class Quire : IEqualityComparer<Quire> "Performance", "CA1819:Properties should not return arrays", Justification = "Not currently posisble due to IArraySizeHolder limitations.")] - // See: https://github.com/Lombiq/Hastlayer-SDK/issues/62#issuecomment-997227931 + // See: https://github.com/Lombiq/Hastlayer-SDK/issues/63 public ulong[] Segments { get; } public Quire(ushort size) From 00b207f56029be240283e51d83d75be7e7235b09 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Mon, 20 Dec 2021 19:40:03 +0100 Subject: [PATCH 43/49] Revert CompatibilityAssert. --- .../CompatibilityAssert.cs | 22 ++++++++++++------- 1 file changed, 14 insertions(+), 8 deletions(-) diff --git a/Lombiq.Arithmetics.Tests/CompatibilityAssert.cs b/Lombiq.Arithmetics.Tests/CompatibilityAssert.cs index caf818d..61e1c98 100644 --- a/Lombiq.Arithmetics.Tests/CompatibilityAssert.cs +++ b/Lombiq.Arithmetics.Tests/CompatibilityAssert.cs @@ -1,19 +1,25 @@ -using Shouldly; +using Xunit.Sdk; namespace Lombiq.Arithmetics.Tests { public static class CompatibilityAssert { - public static void AreEqual<T>(T actual, T expected) => actual.ShouldBe(expected); + public static void AreEqual<T>(T actual, T expected) => Xunit.Assert.Equal(expected, actual); - public static void AreEqual(uint actual, int expected) => actual.ShouldBe((uint)expected); + public static void AreEqual(uint actual, int expected) => Xunit.Assert.Equal((uint)expected, actual); - public static void AreEqual(int actual, uint expected) + public static void AreEqual(int actual, uint expected) => Xunit.Assert.Equal(expected, (uint)actual); + + public static void AreEqual<T>(T actual, T expected, string userMessage) { - var actualUInt = (uint)actual; - actualUInt.ShouldBe(expected); + try + { + Xunit.Assert.Equal(expected, actual); + } + catch (EqualException) + { + Xunit.Assert.True(false, userMessage); + } } - - public static void AreEqual<T>(T actual, T expected, string userMessage) => actual.ShouldBe(expected, userMessage); } } From 88a44437e823d9eb1683c52047620a3406a75fb5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Tue, 21 Dec 2021 13:31:32 +0100 Subject: [PATCH 44/49] Make test project files more uniform. --- Lombiq.Arithmetics.Tests/Lombiq.Arithmetics.Tests.csproj | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/Lombiq.Arithmetics.Tests/Lombiq.Arithmetics.Tests.csproj b/Lombiq.Arithmetics.Tests/Lombiq.Arithmetics.Tests.csproj index 394b774..3b12826 100644 --- a/Lombiq.Arithmetics.Tests/Lombiq.Arithmetics.Tests.csproj +++ b/Lombiq.Arithmetics.Tests/Lombiq.Arithmetics.Tests.csproj @@ -25,4 +25,7 @@ <ItemGroup> <ProjectReference Include="..\Lombiq.Arithmetics.csproj" /> </ItemGroup> -</Project> \ No newline at end of file + <ItemGroup> + <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> + </ItemGroup> +</Project> From 6c788de0c29f78c87f9c06cf1e0592a39d4f0dec Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Tue, 21 Dec 2021 14:10:40 +0100 Subject: [PATCH 45/49] Remove unnecessary "Service" entries from csproj. --- Lombiq.Arithmetics.Tests/Lombiq.Arithmetics.Tests.csproj | 3 --- 1 file changed, 3 deletions(-) diff --git a/Lombiq.Arithmetics.Tests/Lombiq.Arithmetics.Tests.csproj b/Lombiq.Arithmetics.Tests/Lombiq.Arithmetics.Tests.csproj index 3b12826..f670fe4 100644 --- a/Lombiq.Arithmetics.Tests/Lombiq.Arithmetics.Tests.csproj +++ b/Lombiq.Arithmetics.Tests/Lombiq.Arithmetics.Tests.csproj @@ -25,7 +25,4 @@ <ItemGroup> <ProjectReference Include="..\Lombiq.Arithmetics.csproj" /> </ItemGroup> - <ItemGroup> - <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> - </ItemGroup> </Project> From ff50594e829806ca6c4d4e755204375248dc7f22 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Tue, 21 Dec 2021 22:11:39 +0100 Subject: [PATCH 46/49] Update Shouldly to the same version --- Lombiq.Arithmetics.Tests/Lombiq.Arithmetics.Tests.csproj | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Lombiq.Arithmetics.Tests/Lombiq.Arithmetics.Tests.csproj b/Lombiq.Arithmetics.Tests/Lombiq.Arithmetics.Tests.csproj index f670fe4..9344d09 100644 --- a/Lombiq.Arithmetics.Tests/Lombiq.Arithmetics.Tests.csproj +++ b/Lombiq.Arithmetics.Tests/Lombiq.Arithmetics.Tests.csproj @@ -15,7 +15,7 @@ </ItemGroup> <ItemGroup> <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.5.0" /> - <PackageReference Include="Shouldly" Version="3.0.2" /> + <PackageReference Include="Shouldly" Version="4.0.3" /> <PackageReference Include="xunit" Version="2.4.1" /> <PackageReference Include="xunit.runner.visualstudio" Version="2.4.1"> <PrivateAssets>all</PrivateAssets> From 4bbd391c2f7c2dac1a68663be8d4030af38d5094 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Wed, 22 Dec 2021 02:56:02 +0100 Subject: [PATCH 47/49] Update Posit/Posit.cs MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Zoltán Lehóczky <zoltan.lehoczky@lombiq.com> --- Posit/Posit.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Posit/Posit.cs b/Posit/Posit.cs index 8aa9dd4..6b17712 100644 --- a/Posit/Posit.cs +++ b/Posit/Posit.cs @@ -292,7 +292,7 @@ private static void CaclulateRounding(int shiftedLeftBy, ref BitMask bits, ref B } scaleFactor += resultFractionBits.FindMostSignificantOnePosition() - - left.FractionWithHiddenBit().FindMostSignificantOnePosition(); + left.FractionWithHiddenBit().FindMostSignificantOnePosition(); } else if (scaleFactorDifference > 0) { From 0ea1c5475fd40979cc24dc0a50612a366058b211 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Wed, 22 Dec 2021 02:56:13 +0100 Subject: [PATCH 48/49] Update Posit/Quire.cs MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Zoltán Lehóczky <zoltan.lehoczky@lombiq.com> --- Posit/Quire.cs | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/Posit/Quire.cs b/Posit/Quire.cs index 737b7be..4b01879 100644 --- a/Posit/Quire.cs +++ b/Posit/Quire.cs @@ -4,7 +4,11 @@ namespace Lombiq.Arithmetics { - [SuppressMessage("Major Code Smell", "S4035:Classes implementing \"IEquatable<T>\" should be sealed", Justification = "False Positive")] + [SuppressMessage( + "Major Code Smell", + "S4035:Classes implementing \"IEquatable<T>\" should be sealed", + Justification = "False positive, it actually implements IEqualityComparer<T>.")] + public class Quire : IEqualityComparer<Quire> { private const ulong SegmentMaskWithLeadingOne = 0x_8000_0000_0000_0000; From b316660c798233e0230137cf355525addcc7e7ce Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?D=C3=A1vid=20El-Saig?= <david.el-saig@lombiq.com> Date: Wed, 22 Dec 2021 03:46:57 +0100 Subject: [PATCH 49/49] Remove unintelligible comment --- Unum/Unum.cs | 1 - 1 file changed, 1 deletion(-) diff --git a/Unum/Unum.cs b/Unum/Unum.cs index 8e6cb3d..0114b63 100644 --- a/Unum/Unum.cs +++ b/Unum/Unum.cs @@ -674,7 +674,6 @@ public static BitMask ExponentValueToExponentBits(int value, ushort size) if (value < 0) { - // In case of a negative exponent the. exponent -= (uint)(-2 * value); }