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);
             }