From 87a85b82d937f4b6243be284062bd5470648dfee Mon Sep 17 00:00:00 2001 From: Oliver Booth Date: Wed, 5 Apr 2023 15:06:02 +0100 Subject: [PATCH 01/15] feat: add Unpack for IBinaryInteger This introduces an experiment, to add support for generic math in X10D. So far, build and tests remain passing - this is a good sign. There is potential here. This API is subject to change and may be removed without warning. --- .../Collections/BinaryIntegerExtensions.cs | 89 +++++++++++++++++++ X10D/src/Collections/ByteExtensions.cs | 6 +- X10D/src/Collections/Int16Extensions.cs | 6 +- X10D/src/Collections/Int32Extensions.cs | 6 +- X10D/src/Collections/Int64Extensions.cs | 4 +- 5 files changed, 107 insertions(+), 4 deletions(-) create mode 100644 X10D/src/Collections/BinaryIntegerExtensions.cs diff --git a/X10D/src/Collections/BinaryIntegerExtensions.cs b/X10D/src/Collections/BinaryIntegerExtensions.cs new file mode 100644 index 000000000..2f3a44c75 --- /dev/null +++ b/X10D/src/Collections/BinaryIntegerExtensions.cs @@ -0,0 +1,89 @@ +#if NET7_0_OR_GREATER +using System.Diagnostics.Contracts; +using System.Numerics; +using System.Runtime.CompilerServices; +using System.Runtime.Intrinsics.X86; +using X10D.CompilerServices; + +namespace X10D.Collections; + +/// +/// Collection-related extension methods for . +/// +public static class BinaryIntegerExtensions +{ + /// + /// Unpacks this integer into a boolean list, treating it as a bit field. + /// + /// The value to unpack. + /// An array of with a length equal to the size of . + [Pure] + [MethodImpl(CompilerResources.MethodImplOptions)] + public static bool[] Unpack(this TInteger value) + where TInteger : unmanaged, IBinaryInteger + { + unsafe + { + var buffer = new bool[sizeof(TInteger) * 8]; + value.Unpack(buffer); + return buffer; + } + } + + /// + /// Unpacks this integer into a boolean list, treating it as a bit field. + /// + /// The value to unpack. + /// When this method returns, contains the unpacked booleans from . + /// is not large enough to contain the result. + [MethodImpl(CompilerResources.MethodImplOptions)] + public static void Unpack(this TInteger value, Span destination) + where TInteger : unmanaged, IBinaryInteger + { + unsafe + { + if (destination.Length < sizeof(TInteger) * 8) + { + throw new ArgumentException(ExceptionMessages.DestinationSpanLengthTooShort, nameof(destination)); + } + } + + switch (value) + { + case byte valueByte when Sse3.IsSupported: + valueByte.UnpackInternal_Ssse3(destination); + break; + + case int valueInt32 when Avx2.IsSupported: + valueInt32.UnpackInternal_Ssse3(destination); + break; + + case int valueInt32 when Sse3.IsSupported: + valueInt32.UnpackInternal_Ssse3(destination); + break; + + case short valueInt16 when Sse3.IsSupported: + valueInt16.UnpackInternal_Ssse3(destination); + break; + + default: + UnpackInternal_Fallback(value, destination); + break; + } + } + + [MethodImpl(CompilerResources.MethodImplOptions)] + internal static void UnpackInternal_Fallback(this TInteger value, Span destination) + where TInteger : unmanaged, IBinaryInteger + { + unsafe + { + int bitCount = sizeof(TInteger) * 8; + for (var index = 0; index < bitCount; index++) + { + destination[index] = (value & (TInteger.One << index)) != TInteger.Zero; + } + } + } +} +#endif diff --git a/X10D/src/Collections/ByteExtensions.cs b/X10D/src/Collections/ByteExtensions.cs index 427afed5a..559036886 100644 --- a/X10D/src/Collections/ByteExtensions.cs +++ b/X10D/src/Collections/ByteExtensions.cs @@ -1,5 +1,7 @@ -using System.Diagnostics.CodeAnalysis; +#if !NET7_0_OR_GREATER +using System.Diagnostics.CodeAnalysis; using System.Diagnostics.Contracts; +#endif using System.Runtime.CompilerServices; using X10D.CompilerServices; @@ -17,6 +19,7 @@ public static class ByteExtensions { private const int Size = sizeof(byte) * 8; +#if !NET7_0_OR_GREATER /// /// Unpacks this 8-bit unsigned integer into a boolean list, treating it as a bit field. /// @@ -56,6 +59,7 @@ public static void Unpack(this byte value, Span destination) UnpackInternal_Fallback(value, destination); } +#endif [MethodImpl(CompilerResources.MethodImplOptions)] internal static void UnpackInternal_Fallback(this byte value, Span destination) diff --git a/X10D/src/Collections/Int16Extensions.cs b/X10D/src/Collections/Int16Extensions.cs index c53c0fb30..c5f837306 100644 --- a/X10D/src/Collections/Int16Extensions.cs +++ b/X10D/src/Collections/Int16Extensions.cs @@ -1,5 +1,7 @@ -using System.Diagnostics.CodeAnalysis; +#if !NET7_0_OR_GREATER +using System.Diagnostics.CodeAnalysis; using System.Diagnostics.Contracts; +#endif using System.Runtime.CompilerServices; using X10D.CompilerServices; @@ -17,6 +19,7 @@ public static class Int16Extensions { private const int Size = sizeof(short) * 8; +#if !NET7_0_OR_GREATER /// /// Unpacks this 16-bit signed integer into a boolean list, treating it as a bit field. /// @@ -56,6 +59,7 @@ public static void Unpack(this short value, Span destination) UnpackInternal_Fallback(value, destination); } +#endif [MethodImpl(CompilerResources.MethodImplOptions)] internal static void UnpackInternal_Fallback(this short value, Span destination) diff --git a/X10D/src/Collections/Int32Extensions.cs b/X10D/src/Collections/Int32Extensions.cs index 7e2ebafef..60455cd28 100644 --- a/X10D/src/Collections/Int32Extensions.cs +++ b/X10D/src/Collections/Int32Extensions.cs @@ -1,5 +1,7 @@ -using System.Diagnostics.CodeAnalysis; +#if !NET7_0_OR_GREATER +using System.Diagnostics.CodeAnalysis; using System.Diagnostics.Contracts; +#endif using System.Runtime.CompilerServices; using X10D.CompilerServices; @@ -17,6 +19,7 @@ public static class Int32Extensions { private const int Size = sizeof(int) * 8; +#if !NET7_0_OR_GREATER /// /// Unpacks this 32-bit signed integer into a boolean list, treating it as a bit field. /// @@ -62,6 +65,7 @@ public static void Unpack(this int value, Span destination) UnpackInternal_Fallback(value, destination); } +#endif [MethodImpl(CompilerResources.MethodImplOptions)] internal static void UnpackInternal_Fallback(this int value, Span destination) diff --git a/X10D/src/Collections/Int64Extensions.cs b/X10D/src/Collections/Int64Extensions.cs index 5b31a1de8..b6fd7ad7f 100644 --- a/X10D/src/Collections/Int64Extensions.cs +++ b/X10D/src/Collections/Int64Extensions.cs @@ -1,4 +1,5 @@ -using System.Diagnostics.Contracts; +#if !NET7_0_OR_GREATER +using System.Diagnostics.Contracts; namespace X10D.Collections; @@ -41,3 +42,4 @@ public static void Unpack(this long value, Span destination) } } } +#endif From b91aad630593744218c75131b506c534a391b5ad Mon Sep 17 00:00:00 2001 From: Oliver Booth Date: Wed, 5 Apr 2023 15:35:25 +0100 Subject: [PATCH 02/15] feat: convert DigitalRoot and Mod to generic math --- X10D.Tests/src/Math/UInt32Tests.cs | 6 +++ X10D.Tests/src/Math/UInt64Tests.cs | 8 +++- X10D/src/Math/BigIntegerExtensions.cs | 4 ++ X10D/src/Math/BinaryIntegerExtensions.cs | 58 ++++++++++++++++++++++++ X10D/src/Math/ByteExtensions.cs | 2 + X10D/src/Math/Int16Extensions.cs | 4 ++ X10D/src/Math/Int32Extensions.cs | 4 ++ X10D/src/Math/Int64Extensions.cs | 4 ++ X10D/src/Math/SByteExtensions.cs | 4 ++ X10D/src/Math/UInt16Extensions.cs | 2 + X10D/src/Math/UInt32Extensions.cs | 2 + X10D/src/Math/UInt64Extensions.cs | 2 + X10D/src/Time/Int16Extensions.cs | 2 +- X10D/src/Time/SByteExtensions.cs | 2 +- 14 files changed, 101 insertions(+), 3 deletions(-) create mode 100644 X10D/src/Math/BinaryIntegerExtensions.cs diff --git a/X10D.Tests/src/Math/UInt32Tests.cs b/X10D.Tests/src/Math/UInt32Tests.cs index 445464208..0ea052b7e 100644 --- a/X10D.Tests/src/Math/UInt32Tests.cs +++ b/X10D.Tests/src/Math/UInt32Tests.cs @@ -11,8 +11,14 @@ public partial class UInt32Tests public void DigitalRootShouldBeCorrect() { const uint value = 238; + +#if NET7_0_OR_GREATER + Assert.AreEqual(4, value.DigitalRoot()); + Assert.AreEqual(4, (-value).DigitalRoot()); +#else Assert.AreEqual(4U, value.DigitalRoot()); Assert.AreEqual(4U, (-value).DigitalRoot()); +#endif } [TestMethod] diff --git a/X10D.Tests/src/Math/UInt64Tests.cs b/X10D.Tests/src/Math/UInt64Tests.cs index c5e81baa9..17f60f4a7 100644 --- a/X10D.Tests/src/Math/UInt64Tests.cs +++ b/X10D.Tests/src/Math/UInt64Tests.cs @@ -11,12 +11,18 @@ public partial class UInt64Tests public void DigitalRootShouldBeCorrect() { const ulong value = 238; - Assert.AreEqual(4U, value.DigitalRoot()); // -ulong operator not defined because it might exceed long.MinValue, // so instead, cast to long and then negate. // HAX. + +#if NET7_0_OR_GREATER + Assert.AreEqual(4, (-(long)value).DigitalRoot()); + Assert.AreEqual(4, value.DigitalRoot()); +#else Assert.AreEqual(4U, (-(long)value).DigitalRoot()); + Assert.AreEqual(4U, value.DigitalRoot()); +#endif } [TestMethod] diff --git a/X10D/src/Math/BigIntegerExtensions.cs b/X10D/src/Math/BigIntegerExtensions.cs index 4ce5a0d36..ead10ca4c 100644 --- a/X10D/src/Math/BigIntegerExtensions.cs +++ b/X10D/src/Math/BigIntegerExtensions.cs @@ -10,6 +10,7 @@ namespace X10D.Math; /// public static class BigIntegerExtensions { +#if !NET7_0_OR_GREATER /// /// Computes the digital root of this 8-bit integer. /// @@ -27,6 +28,7 @@ public static int DigitalRoot(this BigInteger value) BigInteger root = BigInteger.Abs(value).Mod(9); return (int)(root == 0 ? 9 : root); } +#endif /// /// Returns the factorial of the current 64-bit signed integer. @@ -155,6 +157,7 @@ public static BigInteger LowestCommonMultiple(this BigInteger value, BigInteger return value * other / value.GreatestCommonFactor(other); } +#if !NET7_0_OR_GREATER /// /// Performs a modulo operation which supports a negative dividend. /// @@ -176,6 +179,7 @@ public static BigInteger Mod(this BigInteger dividend, BigInteger divisor) BigInteger r = dividend % divisor; return r < 0 ? r + divisor : r; } +#endif /// /// Returns the multiplicative persistence of a specified value. diff --git a/X10D/src/Math/BinaryIntegerExtensions.cs b/X10D/src/Math/BinaryIntegerExtensions.cs new file mode 100644 index 000000000..94b3728bd --- /dev/null +++ b/X10D/src/Math/BinaryIntegerExtensions.cs @@ -0,0 +1,58 @@ +#if NET7_0_OR_GREATER +using System.Diagnostics.Contracts; +using System.Globalization; +using System.Numerics; +using System.Runtime.CompilerServices; +using X10D.CompilerServices; + +namespace X10D.Math; + +/// +/// Math-related extension methods for . +/// +public static class BinaryIntegerExtensions +{ + /// + /// Computes the digital root of this integer. + /// + /// The value whose digital root to compute. + /// The digital root of . + /// The digital root is defined as the recursive sum of digits until that result is a single digit. + /// + /// The digital root is defined as the recursive sum of digits until that result is a single digit. + /// For example, the digital root of 239 is 5: 2 + 3 + 9 = 14, then 1 + 4 = 5. + /// + [Pure] + [MethodImpl(CompilerResources.MethodImplOptions)] + public static int DigitalRoot(this TInteger value) + where TInteger : IBinaryInteger + { + var nine = TInteger.CreateChecked(9); + TInteger root = TInteger.Abs(value).Mod(nine); + return int.CreateChecked(root == TInteger.Zero ? nine : root); + } + + /// + /// Performs a modulo operation which supports a negative dividend. + /// + /// The dividend. + /// The divisor. + /// The result of dividend mod divisor. + /// + /// The % operator (commonly called the modulo operator) in C# is not defined to be modulo, but is instead + /// remainder. This quirk inherently makes it difficult to use modulo in a negative context, as x % y where x is + /// negative will return a negative value, akin to -(x % y), even if precedence is forced. This method provides a + /// modulo operation which supports negative dividends. + /// + /// ShreevatsaR, https://stackoverflow.com/a/1082938/1467293 + /// CC-BY-SA 2.5 + [Pure] + [MethodImpl(CompilerResources.MethodImplOptions)] + public static TInteger Mod(this TInteger dividend, TInteger divisor) + where TInteger : IBinaryInteger + { + TInteger r = dividend % divisor; + return r < TInteger.Zero ? r + divisor : r; + } +} +#endif diff --git a/X10D/src/Math/ByteExtensions.cs b/X10D/src/Math/ByteExtensions.cs index 6a7db3381..0d4ea5670 100644 --- a/X10D/src/Math/ByteExtensions.cs +++ b/X10D/src/Math/ByteExtensions.cs @@ -9,6 +9,7 @@ namespace X10D.Math; /// public static class ByteExtensions { +#if !NET7_0_OR_GREATER /// /// Computes the digital root of this 8-bit integer. /// @@ -26,6 +27,7 @@ public static byte DigitalRoot(this byte value) int root = value % 9; return (byte)(root == 0 ? 9 : root); } +#endif /// /// Returns the factorial of the current 8-bit unsigned integer. diff --git a/X10D/src/Math/Int16Extensions.cs b/X10D/src/Math/Int16Extensions.cs index 7896cf3c7..e4e57ca9e 100644 --- a/X10D/src/Math/Int16Extensions.cs +++ b/X10D/src/Math/Int16Extensions.cs @@ -9,6 +9,7 @@ namespace X10D.Math; /// public static class Int16Extensions { +#if !NET7_0_OR_GREATER /// /// Computes the digital root of this 16-bit integer. /// @@ -25,6 +26,7 @@ public static short DigitalRoot(this short value) short root = System.Math.Abs(value).Mod(9); return root < 1 ? (short)(9 - root) : root; } +#endif /// /// Returns the factorial of the current 16-bit signed integer. @@ -125,6 +127,7 @@ public static short LowestCommonMultiple(this short value, short other) return (short)((long)value).LowestCommonMultiple(other); } +#if !NET7_0_OR_GREATER /// /// Performs a modulo operation which supports a negative dividend. /// @@ -146,6 +149,7 @@ public static short Mod(this short dividend, short divisor) int r = dividend % divisor; return (short)(r < 0 ? r + divisor : r); } +#endif /// /// Returns the multiplicative persistence of a specified value. diff --git a/X10D/src/Math/Int32Extensions.cs b/X10D/src/Math/Int32Extensions.cs index edaf0dd4e..71df5a317 100644 --- a/X10D/src/Math/Int32Extensions.cs +++ b/X10D/src/Math/Int32Extensions.cs @@ -9,6 +9,7 @@ namespace X10D.Math; /// public static class Int32Extensions { +#if !NET7_0_OR_GREATER /// /// Computes the digital root of this 32-bit integer. /// @@ -25,6 +26,7 @@ public static int DigitalRoot(this int value) int root = System.Math.Abs(value).Mod(9); return root < 1 ? 9 - root : root; } +#endif /// /// Returns the factorial of the current 32-bit signed integer. @@ -125,6 +127,7 @@ public static int LowestCommonMultiple(this int value, int other) return (int)((long)value).LowestCommonMultiple(other); } +#if !NET7_0_OR_GREATER /// /// Performs a modulo operation which supports a negative dividend. /// @@ -146,6 +149,7 @@ public static int Mod(this int dividend, int divisor) int r = dividend % divisor; return r < 0 ? r + divisor : r; } +#endif /// /// Returns the multiplicative persistence of a specified value. diff --git a/X10D/src/Math/Int64Extensions.cs b/X10D/src/Math/Int64Extensions.cs index 5f888cc77..85405fc41 100644 --- a/X10D/src/Math/Int64Extensions.cs +++ b/X10D/src/Math/Int64Extensions.cs @@ -9,6 +9,7 @@ namespace X10D.Math; /// public static class Int64Extensions { +#if !NET7_0_OR_GREATER /// /// Computes the digital root of this 64-bit integer. /// @@ -25,6 +26,7 @@ public static long DigitalRoot(this long value) long root = System.Math.Abs(value).Mod(9L); return root < 1L ? 9L - root : root; } +#endif /// /// Returns the factorial of the current 64-bit signed integer. @@ -164,6 +166,7 @@ public static long LowestCommonMultiple(this long value, long other) return value * other / value.GreatestCommonFactor(other); } +#if !NET7_0_OR_GREATER /// /// Performs a modulo operation which supports a negative dividend. /// @@ -185,6 +188,7 @@ public static long Mod(this long dividend, long divisor) long r = dividend % divisor; return r < 0 ? r + divisor : r; } +#endif /// /// Returns the multiplicative persistence of a specified value. diff --git a/X10D/src/Math/SByteExtensions.cs b/X10D/src/Math/SByteExtensions.cs index cc61037ca..81b827a4e 100644 --- a/X10D/src/Math/SByteExtensions.cs +++ b/X10D/src/Math/SByteExtensions.cs @@ -10,6 +10,7 @@ namespace X10D.Math; [CLSCompliant(false)] public static class SByteExtensions { +#if !NET7_0_OR_GREATER /// /// Computes the digital root of this 32-bit integer. /// @@ -26,6 +27,7 @@ public static sbyte DigitalRoot(this sbyte value) int root = System.Math.Abs(value).Mod(9); return (sbyte)(root < 1 ? 9 - root : root); } +#endif /// /// Returns the factorial of the current 8-bit signed integer. @@ -126,6 +128,7 @@ public static sbyte LowestCommonMultiple(this sbyte value, sbyte other) return (sbyte)((long)value).LowestCommonMultiple(other); } +#if !NET7_0_OR_GREATER /// /// Performs a modulo operation which supports a negative dividend. /// @@ -147,6 +150,7 @@ public static sbyte Mod(this sbyte dividend, sbyte divisor) int r = dividend % divisor; return (sbyte)(r < 0 ? r + divisor : r); } +#endif /// /// Returns the multiplicative persistence of a specified value. diff --git a/X10D/src/Math/UInt16Extensions.cs b/X10D/src/Math/UInt16Extensions.cs index e118e58f6..95f60e6aa 100644 --- a/X10D/src/Math/UInt16Extensions.cs +++ b/X10D/src/Math/UInt16Extensions.cs @@ -10,6 +10,7 @@ namespace X10D.Math; [CLSCompliant(false)] public static class UInt16Extensions { +#if !NET7_0_OR_GREATER /// /// Computes the digital root of the current 16-bit unsigned integer. /// @@ -26,6 +27,7 @@ public static ushort DigitalRoot(this ushort value) var root = (ushort)(value % 9); return (ushort)(root == 0 ? 9 : root); } +#endif /// /// Returns the factorial of the current 16-bit unsigned integer. diff --git a/X10D/src/Math/UInt32Extensions.cs b/X10D/src/Math/UInt32Extensions.cs index 79fed45a3..5661274de 100644 --- a/X10D/src/Math/UInt32Extensions.cs +++ b/X10D/src/Math/UInt32Extensions.cs @@ -10,6 +10,7 @@ namespace X10D.Math; [CLSCompliant(false)] public static class UInt32Extensions { +#if !NET7_0_OR_GREATER /// /// Computes the digital root of the current 32-bit unsigned integer. /// @@ -26,6 +27,7 @@ public static uint DigitalRoot(this uint value) uint root = value % 9; return root == 0 ? 9 : root; } +#endif /// /// Returns the factorial of the current 32-bit unsigned integer. diff --git a/X10D/src/Math/UInt64Extensions.cs b/X10D/src/Math/UInt64Extensions.cs index 4bf9365a8..64cb2ce43 100644 --- a/X10D/src/Math/UInt64Extensions.cs +++ b/X10D/src/Math/UInt64Extensions.cs @@ -10,6 +10,7 @@ namespace X10D.Math; [CLSCompliant(false)] public static class UInt64Extensions { +#if !NET7_0_OR_GREATER /// /// Computes the digital root of the current 64-bit unsigned integer. /// @@ -26,6 +27,7 @@ public static ulong DigitalRoot(this ulong value) ulong root = value % 9; return root == 0 ? 9 : root; } +#endif /// /// Returns the factorial of the current 64-bit unsigned integer. diff --git a/X10D/src/Time/Int16Extensions.cs b/X10D/src/Time/Int16Extensions.cs index d1644df91..9673aa941 100644 --- a/X10D/src/Time/Int16Extensions.cs +++ b/X10D/src/Time/Int16Extensions.cs @@ -32,7 +32,7 @@ public static bool IsLeapYear(this short value) value++; } - return value.Mod(4) == 0 && (value.Mod(100) != 0 || value.Mod(400) == 0); + return value.Mod((short)4) == 0 && (value.Mod((short)100) != 0 || value.Mod((short)400) == 0); } /// diff --git a/X10D/src/Time/SByteExtensions.cs b/X10D/src/Time/SByteExtensions.cs index 7013e93c7..dccf0a09b 100644 --- a/X10D/src/Time/SByteExtensions.cs +++ b/X10D/src/Time/SByteExtensions.cs @@ -33,7 +33,7 @@ public static bool IsLeapYear(this sbyte value) value++; } - return value.Mod(4) == 0 && value.Mod(100) != 0; // mod 400 not required, sbyte.MaxValue is 127 anyway + return value.Mod((sbyte)4) == 0 && value.Mod((sbyte)100) != 0; // mod 400 not required, sbyte.MaxValue is 127 anyway } /// From 21271314af2c07748dd4c3600388d64b25127e3d Mon Sep 17 00:00:00 2001 From: Oliver Booth Date: Wed, 5 Apr 2023 17:36:49 +0100 Subject: [PATCH 03/15] feat: add generic math where possible in MathUtility --- X10D/src/Math/BinaryIntegerExtensions.cs | 24 -- X10D/src/Math/MathUtility.cs | 393 +++++++++++++++-------- X10D/src/Math/NumberExtensions.cs | 104 ++++++ 3 files changed, 356 insertions(+), 165 deletions(-) create mode 100644 X10D/src/Math/NumberExtensions.cs diff --git a/X10D/src/Math/BinaryIntegerExtensions.cs b/X10D/src/Math/BinaryIntegerExtensions.cs index 94b3728bd..20eae9589 100644 --- a/X10D/src/Math/BinaryIntegerExtensions.cs +++ b/X10D/src/Math/BinaryIntegerExtensions.cs @@ -1,6 +1,5 @@ #if NET7_0_OR_GREATER using System.Diagnostics.Contracts; -using System.Globalization; using System.Numerics; using System.Runtime.CompilerServices; using X10D.CompilerServices; @@ -31,28 +30,5 @@ public static int DigitalRoot(this TInteger value) TInteger root = TInteger.Abs(value).Mod(nine); return int.CreateChecked(root == TInteger.Zero ? nine : root); } - - /// - /// Performs a modulo operation which supports a negative dividend. - /// - /// The dividend. - /// The divisor. - /// The result of dividend mod divisor. - /// - /// The % operator (commonly called the modulo operator) in C# is not defined to be modulo, but is instead - /// remainder. This quirk inherently makes it difficult to use modulo in a negative context, as x % y where x is - /// negative will return a negative value, akin to -(x % y), even if precedence is forced. This method provides a - /// modulo operation which supports negative dividends. - /// - /// ShreevatsaR, https://stackoverflow.com/a/1082938/1467293 - /// CC-BY-SA 2.5 - [Pure] - [MethodImpl(CompilerResources.MethodImplOptions)] - public static TInteger Mod(this TInteger dividend, TInteger divisor) - where TInteger : IBinaryInteger - { - TInteger r = dividend % divisor; - return r < TInteger.Zero ? r + divisor : r; - } } #endif diff --git a/X10D/src/Math/MathUtility.cs b/X10D/src/Math/MathUtility.cs index c5bc859b1..2ba9f21ae 100644 --- a/X10D/src/Math/MathUtility.cs +++ b/X10D/src/Math/MathUtility.cs @@ -1,4 +1,5 @@ using System.Diagnostics.Contracts; +using System.Numerics; using System.Runtime.CompilerServices; using X10D.CompilerServices; @@ -12,6 +13,7 @@ public static class MathUtility private const double DefaultGamma = 2.2; private const float DefaultGammaF = 2.2f; +#if !NET7_0_OR_GREATER /// /// Applies a simple bias function to value. /// @@ -40,80 +42,6 @@ public static double Bias(double value, double bias) return value / ((1.0 / bias - 2.0) * (1.0 - value) + 1.0); } - /// - /// Calculates exponential decay for a value. - /// - /// The value to decay. - /// A factor by which to scale the decay. - /// The decay amount. - /// The exponentially decayed value. - public static float ExponentialDecay(float value, float alpha, float decay) - { - return value * MathF.Exp(-decay * alpha); - } - - /// - /// Calculates exponential decay for a value. - /// - /// The value to decay. - /// A factor by which to scale the decay. - /// The decay amount. - /// The exponentially decayed value. - public static double ExponentialDecay(double value, double alpha, double decay) - { - return value * System.Math.Exp(-decay * alpha); - } - - /// - /// Converts a gamma-encoded value to a linear value using a gamma value of 2.2. - /// - /// The gamma-encoded value to convert. Expected range is [0, 1]. - /// The linear value. - [Pure] - [MethodImpl(CompilerResources.MethodImplOptions)] - public static float GammaToLinear(float value) - { - return GammaToLinear(value, DefaultGammaF); - } - - /// - /// Converts a gamma-encoded value to a linear value using the specified gamma value. - /// - /// The gamma-encoded value to convert. Expected range is [0, 1]. - /// The gamma value to use for decoding. - /// The linear value. - [Pure] - [MethodImpl(CompilerResources.MethodImplOptions)] - public static float GammaToLinear(float value, float gamma) - { - return MathF.Pow(value, 1.0f / gamma); - } - - /// - /// Converts a gamma-encoded value to a linear value using a gamma value of 2.2. - /// - /// The gamma-encoded value to convert. Expected range is [0, 1]. - /// The linear value. - [Pure] - [MethodImpl(CompilerResources.MethodImplOptions)] - public static double GammaToLinear(double value) - { - return GammaToLinear(value, DefaultGamma); - } - - /// - /// Converts a gamma-encoded value to a linear value using the specified gamma value. - /// - /// The gamma-encoded value to convert. Expected range is [0, 1]. - /// The gamma value to use for decoding. - /// The linear value. - [Pure] - [MethodImpl(CompilerResources.MethodImplOptions)] - public static double GammaToLinear(double value, double gamma) - { - return System.Math.Pow(value, 1.0 / gamma); - } - /// /// Returns the linear interpolation inverse of a value, such that it determines where a value lies between two other /// values. @@ -190,6 +118,167 @@ public static double Lerp(double value, double target, double alpha) return ((1.0 - alpha) * value) + (alpha * target); } + /// + /// Performs smooth Hermite interpolation from one value to a target using a specified alpha. + /// + /// The interpolation source. + /// The interpolation target. + /// The interpolation alpha. + /// The interpolation result. + public static float SmoothStep(float value, float target, float alpha) + { + alpha = System.Math.Clamp(alpha, 0.0f, 1.0f); + alpha = -2.0f * alpha * alpha * alpha + 3.0f * alpha * alpha; + return target * alpha + value * (1.0f - alpha); + } + + /// + /// Performs smooth Hermite interpolation from one value to a target using a specified alpha. + /// + /// The interpolation source. + /// The interpolation target. + /// The interpolation alpha. + /// The interpolation result. + public static double SmoothStep(double value, double target, double alpha) + { + alpha = System.Math.Clamp(alpha, 0.0, 1.0); + alpha = -2.0 * alpha * alpha * alpha + 3.0 * alpha * alpha; + return target * alpha + value * (1.0 - alpha); + } + + /// + /// Converts a value from being a percentage of one range, to being the same percentage in a new range. + /// + /// The value to convert. + /// The old minimum value. + /// The old maximum value. + /// The new minimum value. + /// The new maximum value. + /// The scaled value. + [Pure] + [MethodImpl(CompilerResources.MethodImplOptions)] + public static float ScaleRange(float value, float oldMin, float oldMax, float newMin, float newMax) + { + float oldRange = oldMax - oldMin; + float newRange = newMax - newMin; + float alpha = (value - oldMin) / oldRange; + return (alpha * newRange) + newMin; + } + + /// + /// Converts a value from being a percentage of one range, to being the same percentage in a new range. + /// + /// The value to convert. + /// The old minimum value. + /// The old maximum value. + /// The new minimum value. + /// The new maximum value. + /// The scaled value. + [Pure] + [MethodImpl(CompilerResources.MethodImplOptions)] + public static double ScaleRange(double value, double oldMin, double oldMax, double newMin, double newMax) + { + double oldRange = oldMax - oldMin; + double newRange = newMax - newMin; + double alpha = (value - oldMin) / oldRange; + return (alpha * newRange) + newMin; + } + + /// + /// Returns the incremental sawtooth wave of a given value. + /// + /// The value to calculate. + /// The sawtooth wave of the given value. + public static float Sawtooth(float value) + { + return (value - MathF.Floor(value)); + } + + /// + /// Returns the incremental sawtooth wave of a given value. + /// + /// The value to calculate. + /// The sawtooth wave of the given value. + public static double Sawtooth(double value) + { + return (value - System.Math.Floor(value)); + } +#endif + + /// + /// Calculates exponential decay for a value. + /// + /// The value to decay. + /// A factor by which to scale the decay. + /// The decay amount. + /// The exponentially decayed value. + public static float ExponentialDecay(float value, float alpha, float decay) + { + return value * MathF.Exp(-decay * alpha); + } + + /// + /// Calculates exponential decay for a value. + /// + /// The value to decay. + /// A factor by which to scale the decay. + /// The decay amount. + /// The exponentially decayed value. + public static double ExponentialDecay(double value, double alpha, double decay) + { + return value * System.Math.Exp(-decay * alpha); + } + + /// + /// Converts a gamma-encoded value to a linear value using a gamma value of 2.2. + /// + /// The gamma-encoded value to convert. Expected range is [0, 1]. + /// The linear value. + [Pure] + [MethodImpl(CompilerResources.MethodImplOptions)] + public static float GammaToLinear(float value) + { + return GammaToLinear(value, DefaultGammaF); + } + + /// + /// Converts a gamma-encoded value to a linear value using the specified gamma value. + /// + /// The gamma-encoded value to convert. Expected range is [0, 1]. + /// The gamma value to use for decoding. + /// The linear value. + [Pure] + [MethodImpl(CompilerResources.MethodImplOptions)] + public static float GammaToLinear(float value, float gamma) + { + return MathF.Pow(value, 1.0f / gamma); + } + + /// + /// Converts a gamma-encoded value to a linear value using a gamma value of 2.2. + /// + /// The gamma-encoded value to convert. Expected range is [0, 1]. + /// The linear value. + [Pure] + [MethodImpl(CompilerResources.MethodImplOptions)] + public static double GammaToLinear(double value) + { + return GammaToLinear(value, DefaultGamma); + } + + /// + /// Converts a gamma-encoded value to a linear value using the specified gamma value. + /// + /// The gamma-encoded value to convert. Expected range is [0, 1]. + /// The gamma value to use for decoding. + /// The linear value. + [Pure] + [MethodImpl(CompilerResources.MethodImplOptions)] + public static double GammaToLinear(double value, double gamma) + { + return System.Math.Pow(value, 1.0 / gamma); + } + /// /// Converts a linear value to a gamma-encoded value using a gamma value of 2.2. /// @@ -289,103 +378,119 @@ public static double Pulse(double value, double lowerBound, double upperBound) } /// - /// Returns the incremental sawtooth wave of a given value. + /// Calculates the sigmoid function for the given input value. /// - /// The value to calculate. - /// The sawtooth wave of the given value. - public static float Sawtooth(float value) + /// The input value for which to calculate the sigmoid function. + /// The result of applying the sigmoid function to the input value. + /// + /// The sigmoid function is a commonly used activation function in artificial neural networks and logistic regression. It + /// maps any real-valued number to a value between 0 and 1. + /// + public static float Sigmoid(float value) { - return (value - MathF.Floor(value)); + return 1.0f / (1.0f + MathF.Exp(-value)); } /// - /// Returns the incremental sawtooth wave of a given value. + /// Calculates the sigmoid function for the given input value. /// - /// The value to calculate. - /// The sawtooth wave of the given value. - public static double Sawtooth(double value) + /// The input value for which to calculate the sigmoid function. + /// The result of applying the sigmoid function to the input value. + /// + /// The sigmoid function is a commonly used activation function in artificial neural networks and logistic regression. It + /// maps any real-valued number to a value between 0 and 1. + /// + public static double Sigmoid(double value) { - return (value - System.Math.Floor(value)); + return 1.0f / (1.0f + System.Math.Exp(-value)); } +#if NET7_0_OR_GREATER /// - /// Converts a value from being a percentage of one range, to being the same percentage in a new range. + /// Applies a simple bias function to value. /// - /// The value to convert. - /// The old minimum value. - /// The old maximum value. - /// The new minimum value. - /// The new maximum value. - /// The scaled value. - [Pure] - [MethodImpl(CompilerResources.MethodImplOptions)] - public static float ScaleRange(float value, float oldMin, float oldMax, float newMin, float newMax) + /// The value to which the bias function will be applied. + /// The bias value. Valid values range from 0-1. + /// The biased result. + /// + /// If is less than 0.5, will be shifted downward; otherwise, upward. + /// + public static TNumber Bias(TNumber value, TNumber bias) + where TNumber : INumber { - float oldRange = oldMax - oldMin; - float newRange = newMax - newMin; - float alpha = (value - oldMin) / oldRange; - return (alpha * newRange) + newMin; + TNumber identity = TNumber.MultiplicativeIdentity; + return value / ((identity / bias - TNumber.CreateChecked(2)) * (identity - value) + identity); } /// - /// Converts a value from being a percentage of one range, to being the same percentage in a new range. + /// Returns the linear interpolation inverse of a value, such that it determines where a value lies between two other + /// values. /// - /// The value to convert. - /// The old minimum value. - /// The old maximum value. - /// The new minimum value. - /// The new maximum value. - /// The scaled value. + /// The value whose lerp inverse is to be found. + /// The start of the range. + /// The end of the range. + /// A value determined by (alpha - start) / (end - start). [Pure] [MethodImpl(CompilerResources.MethodImplOptions)] - public static double ScaleRange(double value, double oldMin, double oldMax, double newMin, double newMax) + public static TNumber InverseLerp(TNumber alpha, TNumber start, TNumber end) + where TNumber : INumber { - double oldRange = oldMax - oldMin; - double newRange = newMax - newMin; - double alpha = (value - oldMin) / oldRange; - return (alpha * newRange) + newMin; + if (start == end) + { + return TNumber.Zero; + } + + return (alpha - start) / (end - start); } /// - /// Calculates the sigmoid function for the given input value. + /// Linearly interpolates from one value to a target using a specified alpha. /// - /// The input value for which to calculate the sigmoid function. - /// The result of applying the sigmoid function to the input value. - /// - /// The sigmoid function is a commonly used activation function in artificial neural networks and logistic regression. It - /// maps any real-valued number to a value between 0 and 1. - /// - public static float Sigmoid(float value) + /// The interpolation source. + /// The interpolation target. + /// The interpolation alpha. + /// + /// The interpolation result as determined by (1 - alpha) * value + alpha * target. + /// + [Pure] + [MethodImpl(CompilerResources.MethodImplOptions)] + public static TNumber Lerp(TNumber value, TNumber target, TNumber alpha) + where TNumber : INumber { - return 1.0f / (1.0f + MathF.Exp(-value)); + // rookie mistake: a + t * (b - a) + // "precise" method: (1 - t) * a + t * b + return ((TNumber.MultiplicativeIdentity - alpha) * value) + (alpha * target); } /// - /// Calculates the sigmoid function for the given input value. + /// Returns the incremental sawtooth wave of a given value. /// - /// The input value for which to calculate the sigmoid function. - /// The result of applying the sigmoid function to the input value. - /// - /// The sigmoid function is a commonly used activation function in artificial neural networks and logistic regression. It - /// maps any real-valued number to a value between 0 and 1. - /// - public static double Sigmoid(double value) + /// The value to calculate. + /// The sawtooth wave of the given value. + public static TNumber Sawtooth(TNumber value) + where TNumber : IFloatingPoint { - return 1.0f / (1.0f + System.Math.Exp(-value)); + return (value - TNumber.Floor(value)); } /// - /// Performs smooth Hermite interpolation from one value to a target using a specified alpha. + /// Converts a value from being a percentage of one range, to being the same percentage in a new range. /// - /// The interpolation source. - /// The interpolation target. - /// The interpolation alpha. - /// The interpolation result. - public static float SmoothStep(float value, float target, float alpha) + /// The value to convert. + /// The old minimum value. + /// The old maximum value. + /// The new minimum value. + /// The new maximum value. + /// The scaled value. + [Pure] + [MethodImpl(CompilerResources.MethodImplOptions)] + public static TNumber ScaleRange(TNumber value, TNumber oldMin, TNumber oldMax, TNumber newMin, TNumber newMax) + where TNumber : INumber { - alpha = System.Math.Clamp(alpha, 0.0f, 1.0f); - alpha = -2.0f * alpha * alpha * alpha + 3.0f * alpha * alpha; - return target * alpha + value * (1.0f - alpha); + TNumber oldRange = oldMax - oldMin; + TNumber newRange = newMax - newMin; + TNumber alpha = (value - oldMin) / oldRange; + return (alpha * newRange) + newMin; } /// @@ -395,10 +500,16 @@ public static float SmoothStep(float value, float target, float alpha) /// The interpolation target. /// The interpolation alpha. /// The interpolation result. - public static double SmoothStep(double value, double target, double alpha) + public static TNumber SmoothStep(TNumber value, TNumber target, TNumber alpha) + where TNumber : INumber { - alpha = System.Math.Clamp(alpha, 0.0, 1.0); - alpha = -2.0 * alpha * alpha * alpha + 3.0 * alpha * alpha; - return target * alpha + value * (1.0 - alpha); + TNumber one = TNumber.One; + TNumber two = one + one; + TNumber three = two + one; + + alpha = TNumber.Clamp(alpha, TNumber.Zero, TNumber.One); + alpha = -two * alpha * alpha * alpha + three * alpha * alpha; + return target * alpha + value * (one - alpha); } +#endif } diff --git a/X10D/src/Math/NumberExtensions.cs b/X10D/src/Math/NumberExtensions.cs new file mode 100644 index 000000000..12f00f8de --- /dev/null +++ b/X10D/src/Math/NumberExtensions.cs @@ -0,0 +1,104 @@ +#if NET7_0_OR_GREATER +using System.Diagnostics.Contracts; +using System.Numerics; +using System.Runtime.CompilerServices; +using X10D.CompilerServices; + +namespace X10D.Math; + +/// +/// Math-related extension methods for . +/// +public static class NumberExtensions +{ + /// + /// Returns a value indicating whether the current value is evenly divisible by 2. + /// + /// The value whose parity to check. + /// + /// if is evenly divisible by 2, or + /// otherwise. + /// + [Pure] + [MethodImpl(CompilerResources.MethodImplOptions)] + public static bool IsEven(this TNumber value) + where TNumber : INumber + { + return value % TNumber.CreateChecked(2) == TNumber.Zero; + } + + /// + /// Returns a value indicating whether the current value is not evenly divisible by 2. + /// + /// The value whose parity to check. + /// + /// if is not evenly divisible by 2, or + /// otherwise. + /// + [Pure] + [MethodImpl(CompilerResources.MethodImplOptions)] + public static bool IsOdd(this TNumber value) + where TNumber : INumber + { + return !value.IsEven(); + } + + /// + /// Performs a modulo operation which supports a negative dividend. + /// + /// The dividend. + /// The divisor. + /// The result of dividend mod divisor. + /// + /// The % operator (commonly called the modulo operator) in C# is not defined to be modulo, but is instead + /// remainder. This quirk inherently makes it difficult to use modulo in a negative context, as x % y where x is + /// negative will return a negative value, akin to -(x % y), even if precedence is forced. This method provides a + /// modulo operation which supports negative dividends. + /// + /// ShreevatsaR, https://stackoverflow.com/a/1082938/1467293 + /// CC-BY-SA 2.5 + [Pure] + [MethodImpl(CompilerResources.MethodImplOptions)] + public static TNumber Mod(this TNumber dividend, TNumber divisor) + where TNumber : INumber + { + TNumber r = dividend % divisor; + return r < TNumber.Zero ? r + divisor : r; + } + + /// + /// Returns an integer that indicates the sign of this number. + /// + /// A signed number. + /// + /// A number that indicates the sign of , as shown in the following table. + /// + /// + /// + /// Return value + /// Meaning + /// + /// + /// + /// -1 + /// is less than zero. + /// + /// + /// 0 + /// is equal to zero. + /// + /// + /// 1 + /// is greater than zero. + /// + /// + /// + [Pure] + [MethodImpl(CompilerResources.MethodImplOptions)] + public static int Sign(this TNumber value) + where TNumber : INumber + { + return TNumber.Sign(value); + } +} +#endif From 423fb90cc4cc64e1dade357c900147c3f33d9546 Mon Sep 17 00:00:00 2001 From: Oliver Booth Date: Fri, 25 Aug 2023 02:34:55 +0100 Subject: [PATCH 04/15] feat: add IBinaryInteger.CountDigits --- X10D/src/Math/NumberExtensions.cs | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/X10D/src/Math/NumberExtensions.cs b/X10D/src/Math/NumberExtensions.cs index 12f00f8de..b2c68a12e 100644 --- a/X10D/src/Math/NumberExtensions.cs +++ b/X10D/src/Math/NumberExtensions.cs @@ -11,6 +11,22 @@ namespace X10D.Math; /// public static class NumberExtensions { + /// + /// Returns the number of digits in the current binary integer. + /// + /// The value whose digit count to compute. + /// The number of digits in . + public static int CountDigits(this TNumber value) + where TNumber : IBinaryInteger + { + if (TNumber.IsZero(value)) + { + return 1; + } + + return 1 + (int)System.Math.Floor(System.Math.Log10(System.Math.Abs(double.CreateChecked(value)))); + } + /// /// Returns a value indicating whether the current value is evenly divisible by 2. /// From 39dfea762296a0ba1a6b7753cd3a21256a3f20b8 Mon Sep 17 00:00:00 2001 From: Oliver Booth Date: Fri, 25 Aug 2023 02:42:51 +0100 Subject: [PATCH 05/15] [ci skip] fix: define CountDigits in the correct file I'm an idiot. --- X10D/src/Math/BinaryIntegerExtensions.cs | 16 ++++++++++++++++ X10D/src/Math/NumberExtensions.cs | 16 ---------------- 2 files changed, 16 insertions(+), 16 deletions(-) diff --git a/X10D/src/Math/BinaryIntegerExtensions.cs b/X10D/src/Math/BinaryIntegerExtensions.cs index 20eae9589..9029e6f52 100644 --- a/X10D/src/Math/BinaryIntegerExtensions.cs +++ b/X10D/src/Math/BinaryIntegerExtensions.cs @@ -11,6 +11,22 @@ namespace X10D.Math; /// public static class BinaryIntegerExtensions { + /// + /// Returns the number of digits in the current binary integer. + /// + /// The value whose digit count to compute. + /// The number of digits in . + public static int CountDigits(this TNumber value) + where TNumber : IBinaryInteger + { + if (TNumber.IsZero(value)) + { + return 1; + } + + return 1 + (int)System.Math.Floor(System.Math.Log10(System.Math.Abs(double.CreateChecked(value)))); + } + /// /// Computes the digital root of this integer. /// diff --git a/X10D/src/Math/NumberExtensions.cs b/X10D/src/Math/NumberExtensions.cs index b2c68a12e..12f00f8de 100644 --- a/X10D/src/Math/NumberExtensions.cs +++ b/X10D/src/Math/NumberExtensions.cs @@ -11,22 +11,6 @@ namespace X10D.Math; /// public static class NumberExtensions { - /// - /// Returns the number of digits in the current binary integer. - /// - /// The value whose digit count to compute. - /// The number of digits in . - public static int CountDigits(this TNumber value) - where TNumber : IBinaryInteger - { - if (TNumber.IsZero(value)) - { - return 1; - } - - return 1 + (int)System.Math.Floor(System.Math.Log10(System.Math.Abs(double.CreateChecked(value)))); - } - /// /// Returns a value indicating whether the current value is evenly divisible by 2. /// From b8f85e4270de24155a6e468937d321bf66871ae3 Mon Sep 17 00:00:00 2001 From: Oliver Booth Date: Fri, 25 Aug 2023 02:50:15 +0100 Subject: [PATCH 06/15] refactor: CountDigits is Pure. also honour methodimpl --- X10D/src/Math/BinaryIntegerExtensions.cs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/X10D/src/Math/BinaryIntegerExtensions.cs b/X10D/src/Math/BinaryIntegerExtensions.cs index 9029e6f52..582c62464 100644 --- a/X10D/src/Math/BinaryIntegerExtensions.cs +++ b/X10D/src/Math/BinaryIntegerExtensions.cs @@ -16,6 +16,8 @@ public static class BinaryIntegerExtensions /// /// The value whose digit count to compute. /// The number of digits in . + [Pure] + [MethodImpl(CompilerResources.MethodImplOptions)] public static int CountDigits(this TNumber value) where TNumber : IBinaryInteger { From 2da8c7db7ab19e86b7991f1a2ba63cc550401cb4 Mon Sep 17 00:00:00 2001 From: Oliver Booth Date: Fri, 25 Aug 2023 02:53:06 +0100 Subject: [PATCH 07/15] refactor: rename TNumber as TInteger --- X10D/src/Math/BinaryIntegerExtensions.cs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/X10D/src/Math/BinaryIntegerExtensions.cs b/X10D/src/Math/BinaryIntegerExtensions.cs index 582c62464..3e5fd21a7 100644 --- a/X10D/src/Math/BinaryIntegerExtensions.cs +++ b/X10D/src/Math/BinaryIntegerExtensions.cs @@ -1,4 +1,4 @@ -#if NET7_0_OR_GREATER +#if NET7_0_OR_GREATER using System.Diagnostics.Contracts; using System.Numerics; using System.Runtime.CompilerServices; @@ -18,10 +18,10 @@ public static class BinaryIntegerExtensions /// The number of digits in . [Pure] [MethodImpl(CompilerResources.MethodImplOptions)] - public static int CountDigits(this TNumber value) - where TNumber : IBinaryInteger + public static int CountDigits(this TInteger value) + where TInteger : IBinaryInteger { - if (TNumber.IsZero(value)) + if (TInteger.IsZero(value)) { return 1; } From bb2f67e9b6ca7acb868c32ab86accadd62ab1531 Mon Sep 17 00:00:00 2001 From: Oliver Booth Date: Sat, 26 Aug 2023 18:08:14 +0100 Subject: [PATCH 08/15] style: remove UTF8 BOM --- X10D.Hosting/src/Assembly.cs | 2 +- .../src/DependencyInjection/ServiceCollectionExtensions.cs | 2 +- X10D.Tests/1000primes.txt | 2 +- X10D.Tests/src/Collections/ArrayTests.AsReadOnly.cs | 2 +- X10D.Tests/src/Collections/ArrayTests.Clear.cs | 2 +- X10D.Tests/src/Collections/ArrayTests.cs | 2 +- X10D.Tests/src/Collections/BoolListTests.cs | 2 +- X10D.Tests/src/Collections/ByteTests.cs | 2 +- .../src/Collections/CollectionTests.ClearAndDisposeAll.cs | 2 +- .../src/Collections/CollectionTests.ClearAndDisposeAllAsync.cs | 2 +- X10D.Tests/src/Collections/CollectionTests.cs | 2 +- X10D.Tests/src/Collections/DictionaryTests.cs | 2 +- X10D.Tests/src/Collections/EnumerableTests.DisposeAll.cs | 2 +- X10D.Tests/src/Collections/EnumerableTests.DisposeAllAsync.cs | 2 +- X10D.Tests/src/Collections/EnumerableTests.cs | 2 +- X10D.Tests/src/Collections/Int16Tests.cs | 2 +- X10D.Tests/src/Collections/Int32Tests.cs | 2 +- X10D.Tests/src/Collections/Int64Tests.cs | 2 +- X10D.Tests/src/Collections/ListTests.cs | 2 +- X10D.Tests/src/Collections/SpanTest.cs | 2 +- X10D.Tests/src/Core/CoreTests.cs | 2 +- X10D.Tests/src/Core/EnumTests.cs | 2 +- X10D.Tests/src/Core/IntrinsicTests.cs | 2 +- X10D.Tests/src/Core/NullableTests.cs | 2 +- X10D.Tests/src/Core/RandomTests.cs | 2 +- X10D.Tests/src/Core/SpanTest.cs | 2 +- X10D.Tests/src/Drawing/CircleFTests.cs | 2 +- X10D.Tests/src/Drawing/CircleTests.cs | 2 +- X10D.Tests/src/Drawing/ColorTests.cs | 2 +- X10D.Tests/src/Drawing/CuboidTests.cs | 2 +- X10D.Tests/src/Drawing/EllipseFTests.cs | 2 +- X10D.Tests/src/Drawing/EllipseTests.cs | 2 +- X10D.Tests/src/Drawing/Line3DTests.cs | 2 +- X10D.Tests/src/Drawing/LineFTests.cs | 2 +- X10D.Tests/src/Drawing/LineTests.cs | 2 +- X10D.Tests/src/Drawing/PointFTests.cs | 2 +- X10D.Tests/src/Drawing/PointTests.cs | 2 +- X10D.Tests/src/Drawing/PolygonFTests.cs | 2 +- X10D.Tests/src/Drawing/PolygonTests.cs | 2 +- X10D.Tests/src/Drawing/PolyhedronTests.cs | 2 +- X10D.Tests/src/Drawing/RandomTests.cs | 2 +- X10D.Tests/src/Drawing/SizeTests.cs | 2 +- X10D.Tests/src/Drawing/SphereTests.cs | 2 +- X10D.Tests/src/Hosting/ServiceCollectionTests.cs | 2 +- X10D.Tests/src/IO/BooleanTests.cs | 2 +- X10D.Tests/src/IO/StreamTests.WriteUInt64.cs | 2 +- X10D.Tests/src/IO/TextReaderTests.cs | 2 +- X10D.Tests/src/IO/TextWriterTests.Double.cs | 2 +- X10D.Tests/src/IO/TextWriterTests.Int32.cs | 2 +- X10D.Tests/src/IO/TextWriterTests.Int64.cs | 2 +- X10D.Tests/src/IO/TextWriterTests.Single.cs | 2 +- X10D.Tests/src/IO/TextWriterTests.UInt32.cs | 2 +- X10D.Tests/src/IO/TextWriterTests.UInt64.cs | 2 +- X10D.Tests/src/IO/TextWriterTests.cs | 2 +- X10D.Tests/src/IO/UInt16Tests.cs | 2 +- X10D.Tests/src/IO/UInt32Tests.cs | 2 +- X10D.Tests/src/IO/UInt64Tests.cs | 2 +- X10D.Tests/src/Linq/ByteTests.cs | 2 +- X10D.Tests/src/Linq/DecimalTests.cs | 2 +- X10D.Tests/src/Linq/DoubleTests.cs | 2 +- X10D.Tests/src/Linq/EnumerableTests.cs | 2 +- X10D.Tests/src/Linq/Int16Tests.cs | 2 +- X10D.Tests/src/Linq/Int32Tests.cs | 2 +- X10D.Tests/src/Linq/Int64Tests.cs | 2 +- X10D.Tests/src/Linq/SByteTests.cs | 2 +- X10D.Tests/src/Linq/SingleTests.cs | 2 +- X10D.Tests/src/Linq/UInt16Tests.cs | 2 +- X10D.Tests/src/Linq/UInt32Tests.cs | 2 +- X10D.Tests/src/Linq/UInt64Tests.cs | 2 +- X10D.Tests/src/Math/BigIntegerTests.Wrap.cs | 2 +- X10D.Tests/src/Math/BigIntegerTests.cs | 2 +- X10D.Tests/src/Math/ByteTests.Wrap.cs | 2 +- X10D.Tests/src/Math/ByteTests.cs | 2 +- X10D.Tests/src/Math/ComparableTests.cs | 2 +- X10D.Tests/src/Math/DecimalTests.Wrap.cs | 2 +- X10D.Tests/src/Math/DecimalTests.cs | 2 +- X10D.Tests/src/Math/DoubleTests.Wrap.cs | 2 +- X10D.Tests/src/Math/DoubleTests.cs | 2 +- X10D.Tests/src/Math/Int16Tests.Wrap.cs | 2 +- X10D.Tests/src/Math/Int16Tests.cs | 2 +- X10D.Tests/src/Math/Int32Tests.Wrap.cs | 2 +- X10D.Tests/src/Math/Int32Tests.cs | 2 +- X10D.Tests/src/Math/Int64Tests.Wrap.cs | 2 +- X10D.Tests/src/Math/Int64Tests.cs | 2 +- X10D.Tests/src/Math/IsPrimeTests.cs | 2 +- X10D.Tests/src/Math/MathUtilityTests.cs | 2 +- X10D.Tests/src/Math/SByteTests.Wrap.cs | 2 +- X10D.Tests/src/Math/SByteTests.cs | 2 +- X10D.Tests/src/Math/SingleTests.Wrap.cs | 2 +- X10D.Tests/src/Math/SingleTests.cs | 2 +- X10D.Tests/src/Math/UInt16Tests.Wrap.cs | 2 +- X10D.Tests/src/Math/UInt16Tests.cs | 2 +- X10D.Tests/src/Math/UInt32Tests.Wrap.cs | 2 +- X10D.Tests/src/Math/UInt64Tests.Wrap.cs | 2 +- X10D.Tests/src/Net/EndPointTests.cs | 2 +- X10D.Tests/src/Net/IPAddressTests.cs | 2 +- X10D.Tests/src/Net/Int16Tests.cs | 2 +- X10D.Tests/src/Net/Int32Tests.cs | 2 +- X10D.Tests/src/Net/Int64Tests.cs | 2 +- X10D.Tests/src/Numerics/ByteTests.cs | 2 +- X10D.Tests/src/Numerics/Int16Tests.cs | 2 +- X10D.Tests/src/Numerics/Int32Tests.cs | 2 +- X10D.Tests/src/Numerics/Int64Tests.cs | 2 +- X10D.Tests/src/Numerics/QuaternionTests.cs | 2 +- X10D.Tests/src/Numerics/RandomTests.cs | 2 +- X10D.Tests/src/Numerics/SByteTests.cs | 2 +- X10D.Tests/src/Numerics/UInt16Tests.cs | 2 +- X10D.Tests/src/Numerics/UInt32Tests.cs | 2 +- X10D.Tests/src/Numerics/UInt64Tests.cs | 2 +- X10D.Tests/src/Numerics/Vector2Tests.cs | 2 +- X10D.Tests/src/Numerics/Vector3Tests.cs | 2 +- X10D.Tests/src/Numerics/Vector4Tests.cs | 2 +- X10D.Tests/src/Reactive/ProgressTests.cs | 2 +- X10D.Tests/src/Reflection/MemberInfoTests.cs | 2 +- X10D.Tests/src/Reflection/TypeTests.cs | 2 +- X10D.Tests/src/Text/CharSpanTests.cs | 2 +- X10D.Tests/src/Text/CharTests.cs | 2 +- X10D.Tests/src/Text/CoreTests.cs | 2 +- X10D.Tests/src/Text/EnumerableTests.cs | 2 +- X10D.Tests/src/Text/RuneTests.cs | 2 +- X10D.Tests/src/Text/StringBuilderReaderTests.cs | 2 +- X10D.Tests/src/Text/StringTests.cs | 2 +- X10D.Tests/src/Time/ByteTests.cs | 2 +- X10D.Tests/src/Time/CharSpanTests.cs | 2 +- X10D.Tests/src/Time/DecimalTests.cs | 2 +- X10D.Tests/src/Time/DoubleTests.cs | 2 +- X10D.Tests/src/Time/HalfTests.cs | 2 +- X10D.Tests/src/Time/Int16Tests.cs | 2 +- X10D.Tests/src/Time/Int32Tests.cs | 2 +- X10D.Tests/src/Time/Int64Tests.cs | 2 +- X10D.Tests/src/Time/SByteTests.cs | 2 +- X10D.Tests/src/Time/SingleTests.cs | 2 +- X10D.Tests/src/Time/StringTests.cs | 2 +- X10D.Tests/src/Time/TimeSpanParserTests.cs | 2 +- X10D.Tests/src/Time/TimeSpanTests.cs | 2 +- X10D.Tests/src/Time/UInt16Tests.cs | 2 +- X10D.Tests/src/Time/UInt32Tests.cs | 2 +- X10D.Tests/src/Time/UInt64Tests.cs | 2 +- X10D/src/Assembly.cs | 2 +- X10D/src/Collections/ArrayExtensions.cs | 2 +- X10D/src/Collections/BinaryIntegerExtensions.cs | 2 +- X10D/src/Collections/ByteExtensions.cs | 2 +- X10D/src/Collections/CollectionExtensions.cs | 2 +- X10D/src/Collections/DictionaryExtensions.cs | 2 +- X10D/src/Collections/EnumerableExtensions.cs | 2 +- X10D/src/Collections/Int16Extensions.cs | 2 +- X10D/src/Collections/Int32Extensions.cs | 2 +- X10D/src/Collections/Int64Extensions.cs | 2 +- X10D/src/Collections/SpanExtensions.cs | 2 +- X10D/src/Collections/SpanSplitEnumerator.cs | 2 +- X10D/src/CompilerServices/CompilerResources.cs | 2 +- X10D/src/Core/EnumExtensions.cs | 2 +- X10D/src/Core/Extensions.cs | 2 +- X10D/src/Core/IntrinsicExtensions.cs | 2 +- X10D/src/Core/IntrinsicUtility.cs | 2 +- X10D/src/Core/NullableExtensions.cs | 2 +- X10D/src/Core/RandomExtensions.cs | 2 +- X10D/src/Core/SpanExtensions.cs | 2 +- X10D/src/Drawing/Circle.cs | 2 +- X10D/src/Drawing/CircleF.cs | 2 +- X10D/src/Drawing/ColorExtensions.cs | 2 +- X10D/src/Drawing/Cuboid.cs | 2 +- X10D/src/Drawing/Ellipse.cs | 2 +- X10D/src/Drawing/EllipseF.cs | 2 +- X10D/src/Drawing/Line.cs | 2 +- X10D/src/Drawing/Line3D.cs | 2 +- X10D/src/Drawing/LineF.cs | 2 +- X10D/src/Drawing/PointExtensions.cs | 2 +- X10D/src/Drawing/PointFExtensions.cs | 2 +- X10D/src/Drawing/Polygon.cs | 2 +- X10D/src/Drawing/PolygonF.cs | 2 +- X10D/src/Drawing/Polyhedron.cs | 2 +- X10D/src/Drawing/RandomExtensions.cs | 2 +- X10D/src/Drawing/SizeExtensions.cs | 2 +- X10D/src/Drawing/Sphere.cs | 2 +- X10D/src/ExceptionMessages.Designer.cs | 2 +- X10D/src/ExceptionMessages.resx | 2 +- X10D/src/IO/BooleanExtensions.cs | 2 +- X10D/src/IO/ByteExtensions.cs | 2 +- X10D/src/IO/DirectoryInfoExtensions.cs | 2 +- X10D/src/IO/DoubleExtensions.cs | 2 +- X10D/src/IO/FileInfoExtensions.cs | 2 +- X10D/src/IO/Int16Extensions.cs | 2 +- X10D/src/IO/Int32Extensions.cs | 2 +- X10D/src/IO/Int64Extensions.cs | 2 +- X10D/src/IO/ListOfByteExtensions.cs | 2 +- X10D/src/IO/SByteExtensions.cs | 2 +- X10D/src/IO/SingleExtensions.cs | 2 +- X10D/src/IO/StreamExtensions.Reading.cs | 2 +- X10D/src/IO/StreamExtensions.Writing.cs | 2 +- X10D/src/IO/StreamExtensions.cs | 2 +- X10D/src/IO/TextReaderExtensions.cs | 2 +- X10D/src/IO/TextWriterExtensions.WriteLineNoAlloc.Double.cs | 2 +- X10D/src/IO/TextWriterExtensions.WriteLineNoAlloc.Int32.cs | 2 +- X10D/src/IO/TextWriterExtensions.WriteLineNoAlloc.Int64.cs | 2 +- X10D/src/IO/TextWriterExtensions.WriteLineNoAlloc.Single.cs | 2 +- X10D/src/IO/TextWriterExtensions.WriteLineNoAlloc.UInt32.cs | 2 +- X10D/src/IO/TextWriterExtensions.WriteLineNoAlloc.UInt64.cs | 2 +- X10D/src/IO/TextWriterExtensions.WriteNoAlloc.Double.cs | 2 +- X10D/src/IO/TextWriterExtensions.WriteNoAlloc.Int32.cs | 2 +- X10D/src/IO/TextWriterExtensions.WriteNoAlloc.Int64.cs | 2 +- X10D/src/IO/TextWriterExtensions.WriteNoAlloc.Single.cs | 2 +- X10D/src/IO/TextWriterExtensions.WriteNoAlloc.UInt32.cs | 2 +- X10D/src/IO/TextWriterExtensions.WriteNoAlloc.UInt64.cs | 2 +- X10D/src/IO/TextWriterExtensions.cs | 2 +- X10D/src/IO/UInt16Extensions.cs | 2 +- X10D/src/IO/UInt32Extensions.cs | 2 +- X10D/src/IO/UInt64Extensions.cs | 2 +- X10D/src/Linq/ByteExtensions.cs | 2 +- X10D/src/Linq/DecimalExtensions.cs | 2 +- X10D/src/Linq/DoubleExtensions.cs | 2 +- X10D/src/Linq/EnumerableExtensions.cs | 2 +- X10D/src/Linq/Int16Extensions.cs | 2 +- X10D/src/Linq/Int32Extensions.cs | 2 +- X10D/src/Linq/Int64Extensions.cs | 2 +- X10D/src/Linq/ReadOnlySpanExtensions.cs | 2 +- X10D/src/Linq/SingleExtensions.cs | 2 +- X10D/src/Linq/SpanExtensions.cs | 2 +- X10D/src/Math/BigIntegerExtensions.cs | 2 +- X10D/src/Math/DecimalExtensions.cs | 2 +- X10D/src/Math/DoubleExtensions.cs | 2 +- X10D/src/Math/InclusiveOptions.cs | 2 +- X10D/src/Math/MathUtility.cs | 2 +- X10D/src/Math/NumberExtensions.cs | 2 +- X10D/src/Math/SByteExtensions.cs | 2 +- X10D/src/Math/SingleExtensions.cs | 2 +- X10D/src/Math/UInt16Extensions.cs | 2 +- X10D/src/Math/UInt32Extensions.cs | 2 +- X10D/src/Math/UInt64Extensions.cs | 2 +- X10D/src/Net/EndPointExtensions.cs | 2 +- X10D/src/Net/IPAddressExtensions.cs | 2 +- X10D/src/Net/Int16Extensions.cs | 2 +- X10D/src/Net/Int32Extensions.cs | 2 +- X10D/src/Net/Int64Extensions.cs | 2 +- X10D/src/Numerics/ByteExtensions.cs | 2 +- X10D/src/Numerics/Int16Extensions.cs | 2 +- X10D/src/Numerics/Int32Extensions.cs | 2 +- X10D/src/Numerics/Int64Extensions.cs | 2 +- X10D/src/Numerics/QuaternionExtensions.cs | 2 +- X10D/src/Numerics/RandomExtensions.cs | 2 +- X10D/src/Numerics/SByteExtensions.cs | 2 +- X10D/src/Numerics/UInt16Extensions.cs | 2 +- X10D/src/Numerics/UInt32Extensions.cs | 2 +- X10D/src/Numerics/UInt64Extensions.cs | 2 +- X10D/src/Numerics/Vector2Extensions.cs | 2 +- X10D/src/Numerics/Vector3Extensions.cs | 2 +- X10D/src/Numerics/Vector4Extensions.cs | 2 +- X10D/src/Reactive/ProgressExtensions.cs | 2 +- X10D/src/Reflection/MemberInfoExtensions.cs | 2 +- X10D/src/Reflection/TypeExtensions.cs | 2 +- X10D/src/Text/CharExtensions.cs | 2 +- X10D/src/Text/CharSpanExtensions.cs | 2 +- X10D/src/Text/EnumerableExtensions.cs | 2 +- X10D/src/Text/Extensions.cs | 2 +- X10D/src/Text/RuneExtensions.cs | 2 +- X10D/src/Text/StringBuilderReader.cs | 2 +- X10D/src/Text/StringExtensions.cs | 2 +- X10D/src/Time/ByteExtensions.cs | 2 +- X10D/src/Time/CharSpanExtensions.cs | 2 +- X10D/src/Time/DateOnlyExtensions.cs | 2 +- X10D/src/Time/DecimalExtensions.cs | 2 +- X10D/src/Time/DoubleExtensions.cs | 2 +- X10D/src/Time/HalfExtensions.cs | 2 +- X10D/src/Time/Int16Extensions.cs | 2 +- X10D/src/Time/Int32Extensions.cs | 2 +- X10D/src/Time/Int64Extensions.cs | 2 +- X10D/src/Time/SByteExtensions.cs | 2 +- X10D/src/Time/SingleExtensions.cs | 2 +- X10D/src/Time/TimeSpanExtensions.cs | 2 +- X10D/src/Time/TimeSpanParser.cs | 2 +- X10D/src/Time/UInt16Extensions.cs | 2 +- X10D/src/Time/UInt32Extensions.cs | 2 +- X10D/src/Time/UInt64Extensions.cs | 2 +- tools/Benchmarks/Program.cs | 2 +- tools/Directory.Build.props | 2 +- tools/SourceGenerator/EmojiRegexGenerator.cs | 2 +- tools/SourceGenerator/MethodOverloadGenerator.cs | 2 +- tools/SourceGenerator/OverloadSyntaxReceiver.cs | 2 +- tools/SourceValidator/Program.cs | 2 +- tools/UpmPackageGenerator/Program.cs | 2 +- tools/X10D.MetaServices/Assembly.cs | 2 +- tools/X10D.MetaServices/AutoOverloadAttribute.cs | 2 +- tools/X10D.MetaServices/OverloadTypeAttribute.cs | 2 +- 283 files changed, 283 insertions(+), 283 deletions(-) diff --git a/X10D.Hosting/src/Assembly.cs b/X10D.Hosting/src/Assembly.cs index f5476101b..c0d560ec4 100644 --- a/X10D.Hosting/src/Assembly.cs +++ b/X10D.Hosting/src/Assembly.cs @@ -1 +1 @@ -[assembly: CLSCompliant(true)] +[assembly: CLSCompliant(true)] diff --git a/X10D.Hosting/src/DependencyInjection/ServiceCollectionExtensions.cs b/X10D.Hosting/src/DependencyInjection/ServiceCollectionExtensions.cs index ea0d3a42d..70a05b7fd 100644 --- a/X10D.Hosting/src/DependencyInjection/ServiceCollectionExtensions.cs +++ b/X10D.Hosting/src/DependencyInjection/ServiceCollectionExtensions.cs @@ -1,4 +1,4 @@ -using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.Hosting; namespace X10D.Hosting.DependencyInjection; diff --git a/X10D.Tests/1000primes.txt b/X10D.Tests/1000primes.txt index 1d931b04d..4dbadc386 100644 --- a/X10D.Tests/1000primes.txt +++ b/X10D.Tests/1000primes.txt @@ -1,4 +1,4 @@ -2 +2 3 5 7 diff --git a/X10D.Tests/src/Collections/ArrayTests.AsReadOnly.cs b/X10D.Tests/src/Collections/ArrayTests.AsReadOnly.cs index e1d010dbd..f7339d0f4 100644 --- a/X10D.Tests/src/Collections/ArrayTests.AsReadOnly.cs +++ b/X10D.Tests/src/Collections/ArrayTests.AsReadOnly.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Collections; namespace X10D.Tests.Collections; diff --git a/X10D.Tests/src/Collections/ArrayTests.Clear.cs b/X10D.Tests/src/Collections/ArrayTests.Clear.cs index 560895274..509785ee0 100644 --- a/X10D.Tests/src/Collections/ArrayTests.Clear.cs +++ b/X10D.Tests/src/Collections/ArrayTests.Clear.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Collections; namespace X10D.Tests.Collections; diff --git a/X10D.Tests/src/Collections/ArrayTests.cs b/X10D.Tests/src/Collections/ArrayTests.cs index 53c46f5cb..5469f7500 100644 --- a/X10D.Tests/src/Collections/ArrayTests.cs +++ b/X10D.Tests/src/Collections/ArrayTests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; namespace X10D.Tests.Collections; diff --git a/X10D.Tests/src/Collections/BoolListTests.cs b/X10D.Tests/src/Collections/BoolListTests.cs index c90bc1647..de3a428f6 100644 --- a/X10D.Tests/src/Collections/BoolListTests.cs +++ b/X10D.Tests/src/Collections/BoolListTests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Collections; namespace X10D.Tests.Collections; diff --git a/X10D.Tests/src/Collections/ByteTests.cs b/X10D.Tests/src/Collections/ByteTests.cs index 4f35f86b4..4891123a1 100644 --- a/X10D.Tests/src/Collections/ByteTests.cs +++ b/X10D.Tests/src/Collections/ByteTests.cs @@ -1,4 +1,4 @@ -using System.Runtime.Intrinsics.X86; +using System.Runtime.Intrinsics.X86; using NUnit.Framework; using X10D.Collections; diff --git a/X10D.Tests/src/Collections/CollectionTests.ClearAndDisposeAll.cs b/X10D.Tests/src/Collections/CollectionTests.ClearAndDisposeAll.cs index 24c542fc5..226439f75 100644 --- a/X10D.Tests/src/Collections/CollectionTests.ClearAndDisposeAll.cs +++ b/X10D.Tests/src/Collections/CollectionTests.ClearAndDisposeAll.cs @@ -1,4 +1,4 @@ -using System.Collections.ObjectModel; +using System.Collections.ObjectModel; using NSubstitute; using NUnit.Framework; using X10D.Collections; diff --git a/X10D.Tests/src/Collections/CollectionTests.ClearAndDisposeAllAsync.cs b/X10D.Tests/src/Collections/CollectionTests.ClearAndDisposeAllAsync.cs index e176fa06a..f08d63904 100644 --- a/X10D.Tests/src/Collections/CollectionTests.ClearAndDisposeAllAsync.cs +++ b/X10D.Tests/src/Collections/CollectionTests.ClearAndDisposeAllAsync.cs @@ -1,4 +1,4 @@ -using System.Collections.ObjectModel; +using System.Collections.ObjectModel; using NSubstitute; using NUnit.Framework; using X10D.Collections; diff --git a/X10D.Tests/src/Collections/CollectionTests.cs b/X10D.Tests/src/Collections/CollectionTests.cs index 8452830af..9a7b0402d 100644 --- a/X10D.Tests/src/Collections/CollectionTests.cs +++ b/X10D.Tests/src/Collections/CollectionTests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; namespace X10D.Tests.Collections; diff --git a/X10D.Tests/src/Collections/DictionaryTests.cs b/X10D.Tests/src/Collections/DictionaryTests.cs index c420375aa..d21e8263e 100644 --- a/X10D.Tests/src/Collections/DictionaryTests.cs +++ b/X10D.Tests/src/Collections/DictionaryTests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Collections; namespace X10D.Tests.Collections; diff --git a/X10D.Tests/src/Collections/EnumerableTests.DisposeAll.cs b/X10D.Tests/src/Collections/EnumerableTests.DisposeAll.cs index 6f8519bc6..fc5a4fb44 100644 --- a/X10D.Tests/src/Collections/EnumerableTests.DisposeAll.cs +++ b/X10D.Tests/src/Collections/EnumerableTests.DisposeAll.cs @@ -1,4 +1,4 @@ -using NSubstitute; +using NSubstitute; using NUnit.Framework; using X10D.Collections; diff --git a/X10D.Tests/src/Collections/EnumerableTests.DisposeAllAsync.cs b/X10D.Tests/src/Collections/EnumerableTests.DisposeAllAsync.cs index 9cd238f1e..b785115f0 100644 --- a/X10D.Tests/src/Collections/EnumerableTests.DisposeAllAsync.cs +++ b/X10D.Tests/src/Collections/EnumerableTests.DisposeAllAsync.cs @@ -1,4 +1,4 @@ -using NSubstitute; +using NSubstitute; using NUnit.Framework; using X10D.Collections; diff --git a/X10D.Tests/src/Collections/EnumerableTests.cs b/X10D.Tests/src/Collections/EnumerableTests.cs index df6442c11..a08c05fda 100644 --- a/X10D.Tests/src/Collections/EnumerableTests.cs +++ b/X10D.Tests/src/Collections/EnumerableTests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Collections; using X10D.Core; diff --git a/X10D.Tests/src/Collections/Int16Tests.cs b/X10D.Tests/src/Collections/Int16Tests.cs index 8672a0a6e..f7bfab3d6 100644 --- a/X10D.Tests/src/Collections/Int16Tests.cs +++ b/X10D.Tests/src/Collections/Int16Tests.cs @@ -1,4 +1,4 @@ -#if NET5_0_OR_GREATER +#if NET5_0_OR_GREATER using System.Runtime.Intrinsics.X86; #endif using NUnit.Framework; diff --git a/X10D.Tests/src/Collections/Int32Tests.cs b/X10D.Tests/src/Collections/Int32Tests.cs index 97485e139..39b1036f0 100644 --- a/X10D.Tests/src/Collections/Int32Tests.cs +++ b/X10D.Tests/src/Collections/Int32Tests.cs @@ -1,4 +1,4 @@ -#if NET5_0_OR_GREATER +#if NET5_0_OR_GREATER using System.Runtime.Intrinsics.X86; #endif using NUnit.Framework; diff --git a/X10D.Tests/src/Collections/Int64Tests.cs b/X10D.Tests/src/Collections/Int64Tests.cs index 1cfee7920..9862ec857 100644 --- a/X10D.Tests/src/Collections/Int64Tests.cs +++ b/X10D.Tests/src/Collections/Int64Tests.cs @@ -1,4 +1,4 @@ -using System.Diagnostics; +using System.Diagnostics; using System.Globalization; using NUnit.Framework; using X10D.Collections; diff --git a/X10D.Tests/src/Collections/ListTests.cs b/X10D.Tests/src/Collections/ListTests.cs index bd62f8c8b..599a58f08 100644 --- a/X10D.Tests/src/Collections/ListTests.cs +++ b/X10D.Tests/src/Collections/ListTests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Collections; namespace X10D.Tests.Collections; diff --git a/X10D.Tests/src/Collections/SpanTest.cs b/X10D.Tests/src/Collections/SpanTest.cs index 04f263a18..fa7ac4580 100644 --- a/X10D.Tests/src/Collections/SpanTest.cs +++ b/X10D.Tests/src/Collections/SpanTest.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Collections; namespace X10D.Tests.Collections; diff --git a/X10D.Tests/src/Core/CoreTests.cs b/X10D.Tests/src/Core/CoreTests.cs index fea360dd5..a5df6ac43 100644 --- a/X10D.Tests/src/Core/CoreTests.cs +++ b/X10D.Tests/src/Core/CoreTests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Core; namespace X10D.Tests.Core; diff --git a/X10D.Tests/src/Core/EnumTests.cs b/X10D.Tests/src/Core/EnumTests.cs index c335b9a30..d4e991295 100644 --- a/X10D.Tests/src/Core/EnumTests.cs +++ b/X10D.Tests/src/Core/EnumTests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Core; namespace X10D.Tests.Core; diff --git a/X10D.Tests/src/Core/IntrinsicTests.cs b/X10D.Tests/src/Core/IntrinsicTests.cs index da5fd8ea0..e45f236ec 100644 --- a/X10D.Tests/src/Core/IntrinsicTests.cs +++ b/X10D.Tests/src/Core/IntrinsicTests.cs @@ -1,4 +1,4 @@ -#if NET6_0_OR_GREATER +#if NET6_0_OR_GREATER using System.Runtime.Intrinsics; using System.Runtime.Intrinsics.X86; using NUnit.Framework; diff --git a/X10D.Tests/src/Core/NullableTests.cs b/X10D.Tests/src/Core/NullableTests.cs index db4c8ef17..1dd08c1d1 100644 --- a/X10D.Tests/src/Core/NullableTests.cs +++ b/X10D.Tests/src/Core/NullableTests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Core; namespace X10D.Tests.Core; diff --git a/X10D.Tests/src/Core/RandomTests.cs b/X10D.Tests/src/Core/RandomTests.cs index 5e1022d1d..72fe1e760 100644 --- a/X10D.Tests/src/Core/RandomTests.cs +++ b/X10D.Tests/src/Core/RandomTests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Collections; using X10D.Core; diff --git a/X10D.Tests/src/Core/SpanTest.cs b/X10D.Tests/src/Core/SpanTest.cs index 85fb46090..4755ff050 100644 --- a/X10D.Tests/src/Core/SpanTest.cs +++ b/X10D.Tests/src/Core/SpanTest.cs @@ -1,4 +1,4 @@ -#if NET5_0_OR_GREATER +#if NET5_0_OR_GREATER using System.Runtime.Intrinsics.Arm; using System.Runtime.Intrinsics.X86; #endif diff --git a/X10D.Tests/src/Drawing/CircleFTests.cs b/X10D.Tests/src/Drawing/CircleFTests.cs index 06a4de8ff..9b05dec6e 100644 --- a/X10D.Tests/src/Drawing/CircleFTests.cs +++ b/X10D.Tests/src/Drawing/CircleFTests.cs @@ -1,4 +1,4 @@ -using System.Drawing; +using System.Drawing; using NUnit.Framework; using X10D.Drawing; diff --git a/X10D.Tests/src/Drawing/CircleTests.cs b/X10D.Tests/src/Drawing/CircleTests.cs index e03fb0c4d..c98d367af 100644 --- a/X10D.Tests/src/Drawing/CircleTests.cs +++ b/X10D.Tests/src/Drawing/CircleTests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Drawing; namespace X10D.Tests.Drawing; diff --git a/X10D.Tests/src/Drawing/ColorTests.cs b/X10D.Tests/src/Drawing/ColorTests.cs index 7868484af..cb5cc9731 100644 --- a/X10D.Tests/src/Drawing/ColorTests.cs +++ b/X10D.Tests/src/Drawing/ColorTests.cs @@ -1,4 +1,4 @@ -using System.Drawing; +using System.Drawing; using NUnit.Framework; using X10D.Drawing; diff --git a/X10D.Tests/src/Drawing/CuboidTests.cs b/X10D.Tests/src/Drawing/CuboidTests.cs index 37d006f8f..08203ea8d 100644 --- a/X10D.Tests/src/Drawing/CuboidTests.cs +++ b/X10D.Tests/src/Drawing/CuboidTests.cs @@ -1,4 +1,4 @@ -using System.Numerics; +using System.Numerics; using NUnit.Framework; using X10D.Drawing; diff --git a/X10D.Tests/src/Drawing/EllipseFTests.cs b/X10D.Tests/src/Drawing/EllipseFTests.cs index aecdcdc4c..5c5d82891 100644 --- a/X10D.Tests/src/Drawing/EllipseFTests.cs +++ b/X10D.Tests/src/Drawing/EllipseFTests.cs @@ -1,4 +1,4 @@ -using System.Drawing; +using System.Drawing; using System.Numerics; using NUnit.Framework; using X10D.Drawing; diff --git a/X10D.Tests/src/Drawing/EllipseTests.cs b/X10D.Tests/src/Drawing/EllipseTests.cs index 6f938cdaf..0ddf5b100 100644 --- a/X10D.Tests/src/Drawing/EllipseTests.cs +++ b/X10D.Tests/src/Drawing/EllipseTests.cs @@ -1,4 +1,4 @@ -using System.Drawing; +using System.Drawing; using NUnit.Framework; using X10D.Drawing; diff --git a/X10D.Tests/src/Drawing/Line3DTests.cs b/X10D.Tests/src/Drawing/Line3DTests.cs index 1182a5b89..36f88e452 100644 --- a/X10D.Tests/src/Drawing/Line3DTests.cs +++ b/X10D.Tests/src/Drawing/Line3DTests.cs @@ -1,4 +1,4 @@ -using System.Drawing; +using System.Drawing; using System.Numerics; using NUnit.Framework; using X10D.Drawing; diff --git a/X10D.Tests/src/Drawing/LineFTests.cs b/X10D.Tests/src/Drawing/LineFTests.cs index 412fff267..fa11b7111 100644 --- a/X10D.Tests/src/Drawing/LineFTests.cs +++ b/X10D.Tests/src/Drawing/LineFTests.cs @@ -1,4 +1,4 @@ -using System.Drawing; +using System.Drawing; using NUnit.Framework; using X10D.Drawing; diff --git a/X10D.Tests/src/Drawing/LineTests.cs b/X10D.Tests/src/Drawing/LineTests.cs index 24a985d37..5ae1c306b 100644 --- a/X10D.Tests/src/Drawing/LineTests.cs +++ b/X10D.Tests/src/Drawing/LineTests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Drawing; namespace X10D.Tests.Drawing; diff --git a/X10D.Tests/src/Drawing/PointFTests.cs b/X10D.Tests/src/Drawing/PointFTests.cs index aace160eb..1bdd8c894 100644 --- a/X10D.Tests/src/Drawing/PointFTests.cs +++ b/X10D.Tests/src/Drawing/PointFTests.cs @@ -1,4 +1,4 @@ -using System.Drawing; +using System.Drawing; using NUnit.Framework; #if !NET6_0_OR_GREATER using X10D.Core; diff --git a/X10D.Tests/src/Drawing/PointTests.cs b/X10D.Tests/src/Drawing/PointTests.cs index ae0765762..347d7a2da 100644 --- a/X10D.Tests/src/Drawing/PointTests.cs +++ b/X10D.Tests/src/Drawing/PointTests.cs @@ -1,4 +1,4 @@ -using System.Drawing; +using System.Drawing; using NUnit.Framework; using X10D.Drawing; diff --git a/X10D.Tests/src/Drawing/PolygonFTests.cs b/X10D.Tests/src/Drawing/PolygonFTests.cs index f6a09de2c..9052c9867 100644 --- a/X10D.Tests/src/Drawing/PolygonFTests.cs +++ b/X10D.Tests/src/Drawing/PolygonFTests.cs @@ -1,4 +1,4 @@ -using System.Drawing; +using System.Drawing; using System.Numerics; using NUnit.Framework; using X10D.Drawing; diff --git a/X10D.Tests/src/Drawing/PolygonTests.cs b/X10D.Tests/src/Drawing/PolygonTests.cs index 4d73cd852..50fe6d845 100644 --- a/X10D.Tests/src/Drawing/PolygonTests.cs +++ b/X10D.Tests/src/Drawing/PolygonTests.cs @@ -1,4 +1,4 @@ -using System.Drawing; +using System.Drawing; using NUnit.Framework; using X10D.Drawing; diff --git a/X10D.Tests/src/Drawing/PolyhedronTests.cs b/X10D.Tests/src/Drawing/PolyhedronTests.cs index 8e8542351..30545e7c5 100644 --- a/X10D.Tests/src/Drawing/PolyhedronTests.cs +++ b/X10D.Tests/src/Drawing/PolyhedronTests.cs @@ -1,4 +1,4 @@ -using System.Numerics; +using System.Numerics; using NUnit.Framework; using X10D.Drawing; diff --git a/X10D.Tests/src/Drawing/RandomTests.cs b/X10D.Tests/src/Drawing/RandomTests.cs index 349ca338e..7559aca35 100644 --- a/X10D.Tests/src/Drawing/RandomTests.cs +++ b/X10D.Tests/src/Drawing/RandomTests.cs @@ -1,4 +1,4 @@ -using System.Drawing; +using System.Drawing; using NUnit.Framework; using X10D.Drawing; diff --git a/X10D.Tests/src/Drawing/SizeTests.cs b/X10D.Tests/src/Drawing/SizeTests.cs index 47a2a42bc..d89fa89b3 100644 --- a/X10D.Tests/src/Drawing/SizeTests.cs +++ b/X10D.Tests/src/Drawing/SizeTests.cs @@ -1,4 +1,4 @@ -using System.Drawing; +using System.Drawing; using NUnit.Framework; using X10D.Drawing; diff --git a/X10D.Tests/src/Drawing/SphereTests.cs b/X10D.Tests/src/Drawing/SphereTests.cs index dcbf8ceaa..75c29b490 100644 --- a/X10D.Tests/src/Drawing/SphereTests.cs +++ b/X10D.Tests/src/Drawing/SphereTests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Drawing; namespace X10D.Tests.Drawing; diff --git a/X10D.Tests/src/Hosting/ServiceCollectionTests.cs b/X10D.Tests/src/Hosting/ServiceCollectionTests.cs index 06919142d..d9a8351c9 100644 --- a/X10D.Tests/src/Hosting/ServiceCollectionTests.cs +++ b/X10D.Tests/src/Hosting/ServiceCollectionTests.cs @@ -1,4 +1,4 @@ -using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.Hosting; using NUnit.Framework; using X10D.Hosting.DependencyInjection; diff --git a/X10D.Tests/src/IO/BooleanTests.cs b/X10D.Tests/src/IO/BooleanTests.cs index 2994e039a..87e2075fd 100644 --- a/X10D.Tests/src/IO/BooleanTests.cs +++ b/X10D.Tests/src/IO/BooleanTests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.IO; namespace X10D.Tests.IO; diff --git a/X10D.Tests/src/IO/StreamTests.WriteUInt64.cs b/X10D.Tests/src/IO/StreamTests.WriteUInt64.cs index 1bf846455..5d8edcf6a 100644 --- a/X10D.Tests/src/IO/StreamTests.WriteUInt64.cs +++ b/X10D.Tests/src/IO/StreamTests.WriteUInt64.cs @@ -1,4 +1,4 @@ -using System.Diagnostics.CodeAnalysis; +using System.Diagnostics.CodeAnalysis; using NUnit.Framework; using X10D.IO; diff --git a/X10D.Tests/src/IO/TextReaderTests.cs b/X10D.Tests/src/IO/TextReaderTests.cs index a6ff77efe..d6e7491a7 100644 --- a/X10D.Tests/src/IO/TextReaderTests.cs +++ b/X10D.Tests/src/IO/TextReaderTests.cs @@ -1,4 +1,4 @@ -using System.Text; +using System.Text; using NUnit.Framework; using X10D.IO; diff --git a/X10D.Tests/src/IO/TextWriterTests.Double.cs b/X10D.Tests/src/IO/TextWriterTests.Double.cs index 0eb936189..be9fa2864 100644 --- a/X10D.Tests/src/IO/TextWriterTests.Double.cs +++ b/X10D.Tests/src/IO/TextWriterTests.Double.cs @@ -1,4 +1,4 @@ -using System.Globalization; +using System.Globalization; using System.Text; using NUnit.Framework; using X10D.IO; diff --git a/X10D.Tests/src/IO/TextWriterTests.Int32.cs b/X10D.Tests/src/IO/TextWriterTests.Int32.cs index 46d13b69b..9d5b7a0de 100644 --- a/X10D.Tests/src/IO/TextWriterTests.Int32.cs +++ b/X10D.Tests/src/IO/TextWriterTests.Int32.cs @@ -1,4 +1,4 @@ -using System.Globalization; +using System.Globalization; using System.Text; using NUnit.Framework; using X10D.IO; diff --git a/X10D.Tests/src/IO/TextWriterTests.Int64.cs b/X10D.Tests/src/IO/TextWriterTests.Int64.cs index f9b10b4ef..662e54aa2 100644 --- a/X10D.Tests/src/IO/TextWriterTests.Int64.cs +++ b/X10D.Tests/src/IO/TextWriterTests.Int64.cs @@ -1,4 +1,4 @@ -using System.Globalization; +using System.Globalization; using System.Text; using NUnit.Framework; using X10D.IO; diff --git a/X10D.Tests/src/IO/TextWriterTests.Single.cs b/X10D.Tests/src/IO/TextWriterTests.Single.cs index 35629b3ce..4ad055cb1 100644 --- a/X10D.Tests/src/IO/TextWriterTests.Single.cs +++ b/X10D.Tests/src/IO/TextWriterTests.Single.cs @@ -1,4 +1,4 @@ -using System.Globalization; +using System.Globalization; using System.Text; using NUnit.Framework; using X10D.IO; diff --git a/X10D.Tests/src/IO/TextWriterTests.UInt32.cs b/X10D.Tests/src/IO/TextWriterTests.UInt32.cs index 5b35c9989..3ba143be4 100644 --- a/X10D.Tests/src/IO/TextWriterTests.UInt32.cs +++ b/X10D.Tests/src/IO/TextWriterTests.UInt32.cs @@ -1,4 +1,4 @@ -using System.Globalization; +using System.Globalization; using System.Text; using NUnit.Framework; using X10D.IO; diff --git a/X10D.Tests/src/IO/TextWriterTests.UInt64.cs b/X10D.Tests/src/IO/TextWriterTests.UInt64.cs index a7b45519a..5b41d38c3 100644 --- a/X10D.Tests/src/IO/TextWriterTests.UInt64.cs +++ b/X10D.Tests/src/IO/TextWriterTests.UInt64.cs @@ -1,4 +1,4 @@ -using System.Globalization; +using System.Globalization; using System.Text; using NUnit.Framework; using X10D.IO; diff --git a/X10D.Tests/src/IO/TextWriterTests.cs b/X10D.Tests/src/IO/TextWriterTests.cs index 6c0945ba2..0ae62b11e 100644 --- a/X10D.Tests/src/IO/TextWriterTests.cs +++ b/X10D.Tests/src/IO/TextWriterTests.cs @@ -1,4 +1,4 @@ -using System.Diagnostics; +using System.Diagnostics; using System.Diagnostics.CodeAnalysis; using System.Text; using NUnit.Framework; diff --git a/X10D.Tests/src/IO/UInt16Tests.cs b/X10D.Tests/src/IO/UInt16Tests.cs index 4ce858d2c..58307e494 100644 --- a/X10D.Tests/src/IO/UInt16Tests.cs +++ b/X10D.Tests/src/IO/UInt16Tests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.IO; namespace X10D.Tests.IO; diff --git a/X10D.Tests/src/IO/UInt32Tests.cs b/X10D.Tests/src/IO/UInt32Tests.cs index eada9aaea..cce312a57 100644 --- a/X10D.Tests/src/IO/UInt32Tests.cs +++ b/X10D.Tests/src/IO/UInt32Tests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.IO; namespace X10D.Tests.IO; diff --git a/X10D.Tests/src/IO/UInt64Tests.cs b/X10D.Tests/src/IO/UInt64Tests.cs index 6ed1be8cc..aeb589bb5 100644 --- a/X10D.Tests/src/IO/UInt64Tests.cs +++ b/X10D.Tests/src/IO/UInt64Tests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.IO; namespace X10D.Tests.IO; diff --git a/X10D.Tests/src/Linq/ByteTests.cs b/X10D.Tests/src/Linq/ByteTests.cs index 0ece8b641..a3b79e29d 100644 --- a/X10D.Tests/src/Linq/ByteTests.cs +++ b/X10D.Tests/src/Linq/ByteTests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Linq; namespace X10D.Tests.Linq; diff --git a/X10D.Tests/src/Linq/DecimalTests.cs b/X10D.Tests/src/Linq/DecimalTests.cs index db0e66b76..909c4783d 100644 --- a/X10D.Tests/src/Linq/DecimalTests.cs +++ b/X10D.Tests/src/Linq/DecimalTests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Linq; namespace X10D.Tests.Linq; diff --git a/X10D.Tests/src/Linq/DoubleTests.cs b/X10D.Tests/src/Linq/DoubleTests.cs index 01399ea9f..3975e46e0 100644 --- a/X10D.Tests/src/Linq/DoubleTests.cs +++ b/X10D.Tests/src/Linq/DoubleTests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Linq; namespace X10D.Tests.Linq; diff --git a/X10D.Tests/src/Linq/EnumerableTests.cs b/X10D.Tests/src/Linq/EnumerableTests.cs index 253690a6b..84e037881 100644 --- a/X10D.Tests/src/Linq/EnumerableTests.cs +++ b/X10D.Tests/src/Linq/EnumerableTests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Linq; namespace X10D.Tests.Linq; diff --git a/X10D.Tests/src/Linq/Int16Tests.cs b/X10D.Tests/src/Linq/Int16Tests.cs index 76a6a480b..1401d9e30 100644 --- a/X10D.Tests/src/Linq/Int16Tests.cs +++ b/X10D.Tests/src/Linq/Int16Tests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Linq; namespace X10D.Tests.Linq; diff --git a/X10D.Tests/src/Linq/Int32Tests.cs b/X10D.Tests/src/Linq/Int32Tests.cs index 5f8422ab2..783cbbac0 100644 --- a/X10D.Tests/src/Linq/Int32Tests.cs +++ b/X10D.Tests/src/Linq/Int32Tests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Linq; namespace X10D.Tests.Linq; diff --git a/X10D.Tests/src/Linq/Int64Tests.cs b/X10D.Tests/src/Linq/Int64Tests.cs index aad07384f..c55f74df2 100644 --- a/X10D.Tests/src/Linq/Int64Tests.cs +++ b/X10D.Tests/src/Linq/Int64Tests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Linq; namespace X10D.Tests.Linq; diff --git a/X10D.Tests/src/Linq/SByteTests.cs b/X10D.Tests/src/Linq/SByteTests.cs index a8592793f..9eaeb833b 100644 --- a/X10D.Tests/src/Linq/SByteTests.cs +++ b/X10D.Tests/src/Linq/SByteTests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Linq; namespace X10D.Tests.Linq; diff --git a/X10D.Tests/src/Linq/SingleTests.cs b/X10D.Tests/src/Linq/SingleTests.cs index 0bac26527..8486b8bb8 100644 --- a/X10D.Tests/src/Linq/SingleTests.cs +++ b/X10D.Tests/src/Linq/SingleTests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Linq; namespace X10D.Tests.Linq; diff --git a/X10D.Tests/src/Linq/UInt16Tests.cs b/X10D.Tests/src/Linq/UInt16Tests.cs index 8abfc9769..60be62e98 100644 --- a/X10D.Tests/src/Linq/UInt16Tests.cs +++ b/X10D.Tests/src/Linq/UInt16Tests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Linq; namespace X10D.Tests.Linq; diff --git a/X10D.Tests/src/Linq/UInt32Tests.cs b/X10D.Tests/src/Linq/UInt32Tests.cs index 20d121727..8fde601f6 100644 --- a/X10D.Tests/src/Linq/UInt32Tests.cs +++ b/X10D.Tests/src/Linq/UInt32Tests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Linq; namespace X10D.Tests.Linq; diff --git a/X10D.Tests/src/Linq/UInt64Tests.cs b/X10D.Tests/src/Linq/UInt64Tests.cs index 64710d36c..1c8c889f0 100644 --- a/X10D.Tests/src/Linq/UInt64Tests.cs +++ b/X10D.Tests/src/Linq/UInt64Tests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Linq; namespace X10D.Tests.Linq; diff --git a/X10D.Tests/src/Math/BigIntegerTests.Wrap.cs b/X10D.Tests/src/Math/BigIntegerTests.Wrap.cs index ecff3df82..601a6e27e 100644 --- a/X10D.Tests/src/Math/BigIntegerTests.Wrap.cs +++ b/X10D.Tests/src/Math/BigIntegerTests.Wrap.cs @@ -1,4 +1,4 @@ -using System.Numerics; +using System.Numerics; using NUnit.Framework; using X10D.Math; diff --git a/X10D.Tests/src/Math/BigIntegerTests.cs b/X10D.Tests/src/Math/BigIntegerTests.cs index 80c0cec13..2812a2bda 100644 --- a/X10D.Tests/src/Math/BigIntegerTests.cs +++ b/X10D.Tests/src/Math/BigIntegerTests.cs @@ -1,4 +1,4 @@ -using System.Numerics; +using System.Numerics; using NUnit.Framework; using X10D.Math; diff --git a/X10D.Tests/src/Math/ByteTests.Wrap.cs b/X10D.Tests/src/Math/ByteTests.Wrap.cs index 91c214fe9..9785f58ed 100644 --- a/X10D.Tests/src/Math/ByteTests.Wrap.cs +++ b/X10D.Tests/src/Math/ByteTests.Wrap.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Math; namespace X10D.Tests.Math; diff --git a/X10D.Tests/src/Math/ByteTests.cs b/X10D.Tests/src/Math/ByteTests.cs index 0d80790a3..660822200 100644 --- a/X10D.Tests/src/Math/ByteTests.cs +++ b/X10D.Tests/src/Math/ByteTests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Math; namespace X10D.Tests.Math; diff --git a/X10D.Tests/src/Math/ComparableTests.cs b/X10D.Tests/src/Math/ComparableTests.cs index cb90266df..970d649d5 100644 --- a/X10D.Tests/src/Math/ComparableTests.cs +++ b/X10D.Tests/src/Math/ComparableTests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Math; namespace X10D.Tests.Math; diff --git a/X10D.Tests/src/Math/DecimalTests.Wrap.cs b/X10D.Tests/src/Math/DecimalTests.Wrap.cs index 140804313..5bed0f359 100644 --- a/X10D.Tests/src/Math/DecimalTests.Wrap.cs +++ b/X10D.Tests/src/Math/DecimalTests.Wrap.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Math; namespace X10D.Tests.Math; diff --git a/X10D.Tests/src/Math/DecimalTests.cs b/X10D.Tests/src/Math/DecimalTests.cs index 8c4b31ea1..d84699b99 100644 --- a/X10D.Tests/src/Math/DecimalTests.cs +++ b/X10D.Tests/src/Math/DecimalTests.cs @@ -1,4 +1,4 @@ -using System.Numerics; +using System.Numerics; using NUnit.Framework; using X10D.Math; diff --git a/X10D.Tests/src/Math/DoubleTests.Wrap.cs b/X10D.Tests/src/Math/DoubleTests.Wrap.cs index fdc5ada24..138264de7 100644 --- a/X10D.Tests/src/Math/DoubleTests.Wrap.cs +++ b/X10D.Tests/src/Math/DoubleTests.Wrap.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Math; namespace X10D.Tests.Math; diff --git a/X10D.Tests/src/Math/DoubleTests.cs b/X10D.Tests/src/Math/DoubleTests.cs index 3929b2481..7a23f98c7 100644 --- a/X10D.Tests/src/Math/DoubleTests.cs +++ b/X10D.Tests/src/Math/DoubleTests.cs @@ -1,4 +1,4 @@ -using System.Numerics; +using System.Numerics; using NUnit.Framework; using X10D.Math; diff --git a/X10D.Tests/src/Math/Int16Tests.Wrap.cs b/X10D.Tests/src/Math/Int16Tests.Wrap.cs index b5f20d779..0f9a5e5e1 100644 --- a/X10D.Tests/src/Math/Int16Tests.Wrap.cs +++ b/X10D.Tests/src/Math/Int16Tests.Wrap.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Math; namespace X10D.Tests.Math; diff --git a/X10D.Tests/src/Math/Int16Tests.cs b/X10D.Tests/src/Math/Int16Tests.cs index 5612e4b1a..7ba50a23b 100644 --- a/X10D.Tests/src/Math/Int16Tests.cs +++ b/X10D.Tests/src/Math/Int16Tests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Math; namespace X10D.Tests.Math; diff --git a/X10D.Tests/src/Math/Int32Tests.Wrap.cs b/X10D.Tests/src/Math/Int32Tests.Wrap.cs index 754ae4869..bf4e63655 100644 --- a/X10D.Tests/src/Math/Int32Tests.Wrap.cs +++ b/X10D.Tests/src/Math/Int32Tests.Wrap.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Math; namespace X10D.Tests.Math; diff --git a/X10D.Tests/src/Math/Int32Tests.cs b/X10D.Tests/src/Math/Int32Tests.cs index 0bfbf259d..664e16f3c 100644 --- a/X10D.Tests/src/Math/Int32Tests.cs +++ b/X10D.Tests/src/Math/Int32Tests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Math; namespace X10D.Tests.Math; diff --git a/X10D.Tests/src/Math/Int64Tests.Wrap.cs b/X10D.Tests/src/Math/Int64Tests.Wrap.cs index 643429525..fb7f7bac5 100644 --- a/X10D.Tests/src/Math/Int64Tests.Wrap.cs +++ b/X10D.Tests/src/Math/Int64Tests.Wrap.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Math; namespace X10D.Tests.Math; diff --git a/X10D.Tests/src/Math/Int64Tests.cs b/X10D.Tests/src/Math/Int64Tests.cs index bd5f52449..8dd40a907 100644 --- a/X10D.Tests/src/Math/Int64Tests.cs +++ b/X10D.Tests/src/Math/Int64Tests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Math; namespace X10D.Tests.Math; diff --git a/X10D.Tests/src/Math/IsPrimeTests.cs b/X10D.Tests/src/Math/IsPrimeTests.cs index 4d50e68ea..452a28634 100644 --- a/X10D.Tests/src/Math/IsPrimeTests.cs +++ b/X10D.Tests/src/Math/IsPrimeTests.cs @@ -1,4 +1,4 @@ -using System.Numerics; +using System.Numerics; using System.Reflection; using System.Text; using NUnit.Framework; diff --git a/X10D.Tests/src/Math/MathUtilityTests.cs b/X10D.Tests/src/Math/MathUtilityTests.cs index 01028a296..eff50c1cd 100644 --- a/X10D.Tests/src/Math/MathUtilityTests.cs +++ b/X10D.Tests/src/Math/MathUtilityTests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; #if !NET6_0_OR_GREATER using X10D.Core; #endif diff --git a/X10D.Tests/src/Math/SByteTests.Wrap.cs b/X10D.Tests/src/Math/SByteTests.Wrap.cs index dd7b9b970..5727874a4 100644 --- a/X10D.Tests/src/Math/SByteTests.Wrap.cs +++ b/X10D.Tests/src/Math/SByteTests.Wrap.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Math; namespace X10D.Tests.Math; diff --git a/X10D.Tests/src/Math/SByteTests.cs b/X10D.Tests/src/Math/SByteTests.cs index 9550cfb56..3727af4dd 100644 --- a/X10D.Tests/src/Math/SByteTests.cs +++ b/X10D.Tests/src/Math/SByteTests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Math; namespace X10D.Tests.Math; diff --git a/X10D.Tests/src/Math/SingleTests.Wrap.cs b/X10D.Tests/src/Math/SingleTests.Wrap.cs index 596a40a58..b95e29ad6 100644 --- a/X10D.Tests/src/Math/SingleTests.Wrap.cs +++ b/X10D.Tests/src/Math/SingleTests.Wrap.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Math; namespace X10D.Tests.Math; diff --git a/X10D.Tests/src/Math/SingleTests.cs b/X10D.Tests/src/Math/SingleTests.cs index 5e50fe7af..abf31caa9 100644 --- a/X10D.Tests/src/Math/SingleTests.cs +++ b/X10D.Tests/src/Math/SingleTests.cs @@ -1,4 +1,4 @@ -using System.Numerics; +using System.Numerics; using NUnit.Framework; using X10D.Math; diff --git a/X10D.Tests/src/Math/UInt16Tests.Wrap.cs b/X10D.Tests/src/Math/UInt16Tests.Wrap.cs index e5be52580..364515c09 100644 --- a/X10D.Tests/src/Math/UInt16Tests.Wrap.cs +++ b/X10D.Tests/src/Math/UInt16Tests.Wrap.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Math; namespace X10D.Tests.Math; diff --git a/X10D.Tests/src/Math/UInt16Tests.cs b/X10D.Tests/src/Math/UInt16Tests.cs index c6f38ad0c..d51f983eb 100644 --- a/X10D.Tests/src/Math/UInt16Tests.cs +++ b/X10D.Tests/src/Math/UInt16Tests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Math; namespace X10D.Tests.Math; diff --git a/X10D.Tests/src/Math/UInt32Tests.Wrap.cs b/X10D.Tests/src/Math/UInt32Tests.Wrap.cs index 572f71c1e..9a967f05e 100644 --- a/X10D.Tests/src/Math/UInt32Tests.Wrap.cs +++ b/X10D.Tests/src/Math/UInt32Tests.Wrap.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Math; namespace X10D.Tests.Math; diff --git a/X10D.Tests/src/Math/UInt64Tests.Wrap.cs b/X10D.Tests/src/Math/UInt64Tests.Wrap.cs index 7307589a0..54b902e17 100644 --- a/X10D.Tests/src/Math/UInt64Tests.Wrap.cs +++ b/X10D.Tests/src/Math/UInt64Tests.Wrap.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Math; namespace X10D.Tests.Math; diff --git a/X10D.Tests/src/Net/EndPointTests.cs b/X10D.Tests/src/Net/EndPointTests.cs index 7dca5cfc1..98dbe602f 100644 --- a/X10D.Tests/src/Net/EndPointTests.cs +++ b/X10D.Tests/src/Net/EndPointTests.cs @@ -1,4 +1,4 @@ -using System.Net; +using System.Net; using NUnit.Framework; using X10D.Net; diff --git a/X10D.Tests/src/Net/IPAddressTests.cs b/X10D.Tests/src/Net/IPAddressTests.cs index ab48f2473..8f916fb3c 100644 --- a/X10D.Tests/src/Net/IPAddressTests.cs +++ b/X10D.Tests/src/Net/IPAddressTests.cs @@ -1,4 +1,4 @@ -using System.Net; +using System.Net; using NUnit.Framework; using X10D.Net; diff --git a/X10D.Tests/src/Net/Int16Tests.cs b/X10D.Tests/src/Net/Int16Tests.cs index 310a18399..8bfb3f8f1 100644 --- a/X10D.Tests/src/Net/Int16Tests.cs +++ b/X10D.Tests/src/Net/Int16Tests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Net; namespace X10D.Tests.Net; diff --git a/X10D.Tests/src/Net/Int32Tests.cs b/X10D.Tests/src/Net/Int32Tests.cs index 50b8899b9..3322b9a25 100644 --- a/X10D.Tests/src/Net/Int32Tests.cs +++ b/X10D.Tests/src/Net/Int32Tests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Net; namespace X10D.Tests.Net; diff --git a/X10D.Tests/src/Net/Int64Tests.cs b/X10D.Tests/src/Net/Int64Tests.cs index a2150e127..845b0f9e9 100644 --- a/X10D.Tests/src/Net/Int64Tests.cs +++ b/X10D.Tests/src/Net/Int64Tests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Net; namespace X10D.Tests.Net; diff --git a/X10D.Tests/src/Numerics/ByteTests.cs b/X10D.Tests/src/Numerics/ByteTests.cs index 4a191b79f..300a34878 100644 --- a/X10D.Tests/src/Numerics/ByteTests.cs +++ b/X10D.Tests/src/Numerics/ByteTests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Numerics; namespace X10D.Tests.Numerics; diff --git a/X10D.Tests/src/Numerics/Int16Tests.cs b/X10D.Tests/src/Numerics/Int16Tests.cs index 73a00259d..ce7b2735c 100644 --- a/X10D.Tests/src/Numerics/Int16Tests.cs +++ b/X10D.Tests/src/Numerics/Int16Tests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Numerics; namespace X10D.Tests.Numerics; diff --git a/X10D.Tests/src/Numerics/Int32Tests.cs b/X10D.Tests/src/Numerics/Int32Tests.cs index 36b3c1dc3..33871d968 100644 --- a/X10D.Tests/src/Numerics/Int32Tests.cs +++ b/X10D.Tests/src/Numerics/Int32Tests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Numerics; namespace X10D.Tests.Numerics; diff --git a/X10D.Tests/src/Numerics/Int64Tests.cs b/X10D.Tests/src/Numerics/Int64Tests.cs index c4c7c7b8f..756c35d5f 100644 --- a/X10D.Tests/src/Numerics/Int64Tests.cs +++ b/X10D.Tests/src/Numerics/Int64Tests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Numerics; namespace X10D.Tests.Numerics; diff --git a/X10D.Tests/src/Numerics/QuaternionTests.cs b/X10D.Tests/src/Numerics/QuaternionTests.cs index ce33ad24a..40a25cd7d 100644 --- a/X10D.Tests/src/Numerics/QuaternionTests.cs +++ b/X10D.Tests/src/Numerics/QuaternionTests.cs @@ -1,4 +1,4 @@ -using System.Numerics; +using System.Numerics; using NUnit.Framework; using X10D.Numerics; diff --git a/X10D.Tests/src/Numerics/RandomTests.cs b/X10D.Tests/src/Numerics/RandomTests.cs index 38b1716da..434b217fa 100644 --- a/X10D.Tests/src/Numerics/RandomTests.cs +++ b/X10D.Tests/src/Numerics/RandomTests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Numerics; namespace X10D.Tests.Numerics; diff --git a/X10D.Tests/src/Numerics/SByteTests.cs b/X10D.Tests/src/Numerics/SByteTests.cs index 72132bc80..d36a352a2 100644 --- a/X10D.Tests/src/Numerics/SByteTests.cs +++ b/X10D.Tests/src/Numerics/SByteTests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Numerics; namespace X10D.Tests.Numerics; diff --git a/X10D.Tests/src/Numerics/UInt16Tests.cs b/X10D.Tests/src/Numerics/UInt16Tests.cs index 585f4792b..ae5f090a5 100644 --- a/X10D.Tests/src/Numerics/UInt16Tests.cs +++ b/X10D.Tests/src/Numerics/UInt16Tests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Numerics; namespace X10D.Tests.Numerics; diff --git a/X10D.Tests/src/Numerics/UInt32Tests.cs b/X10D.Tests/src/Numerics/UInt32Tests.cs index da77d5b75..5f71af4b2 100644 --- a/X10D.Tests/src/Numerics/UInt32Tests.cs +++ b/X10D.Tests/src/Numerics/UInt32Tests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Numerics; namespace X10D.Tests.Numerics; diff --git a/X10D.Tests/src/Numerics/UInt64Tests.cs b/X10D.Tests/src/Numerics/UInt64Tests.cs index d01bd3980..ec9ff74f7 100644 --- a/X10D.Tests/src/Numerics/UInt64Tests.cs +++ b/X10D.Tests/src/Numerics/UInt64Tests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Numerics; namespace X10D.Tests.Numerics; diff --git a/X10D.Tests/src/Numerics/Vector2Tests.cs b/X10D.Tests/src/Numerics/Vector2Tests.cs index e18688e34..7b119d0fa 100644 --- a/X10D.Tests/src/Numerics/Vector2Tests.cs +++ b/X10D.Tests/src/Numerics/Vector2Tests.cs @@ -1,4 +1,4 @@ -using System.Numerics; +using System.Numerics; using NUnit.Framework; #if !NET6_0_OR_GREATER using X10D.Core; diff --git a/X10D.Tests/src/Numerics/Vector3Tests.cs b/X10D.Tests/src/Numerics/Vector3Tests.cs index 23c1795d6..3eecf105e 100644 --- a/X10D.Tests/src/Numerics/Vector3Tests.cs +++ b/X10D.Tests/src/Numerics/Vector3Tests.cs @@ -1,4 +1,4 @@ -using System.Numerics; +using System.Numerics; using NUnit.Framework; using X10D.Numerics; diff --git a/X10D.Tests/src/Numerics/Vector4Tests.cs b/X10D.Tests/src/Numerics/Vector4Tests.cs index 108fb473a..7dd3e8ac0 100644 --- a/X10D.Tests/src/Numerics/Vector4Tests.cs +++ b/X10D.Tests/src/Numerics/Vector4Tests.cs @@ -1,4 +1,4 @@ -using System.Numerics; +using System.Numerics; using NUnit.Framework; using X10D.Numerics; diff --git a/X10D.Tests/src/Reactive/ProgressTests.cs b/X10D.Tests/src/Reactive/ProgressTests.cs index e18ed3969..5b8f18057 100644 --- a/X10D.Tests/src/Reactive/ProgressTests.cs +++ b/X10D.Tests/src/Reactive/ProgressTests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Reactive; namespace X10D.Tests.Reactive; diff --git a/X10D.Tests/src/Reflection/MemberInfoTests.cs b/X10D.Tests/src/Reflection/MemberInfoTests.cs index bbb0952e7..8ce577470 100644 --- a/X10D.Tests/src/Reflection/MemberInfoTests.cs +++ b/X10D.Tests/src/Reflection/MemberInfoTests.cs @@ -1,4 +1,4 @@ -using System.Reflection; +using System.Reflection; using NUnit.Framework; using X10D.Reflection; diff --git a/X10D.Tests/src/Reflection/TypeTests.cs b/X10D.Tests/src/Reflection/TypeTests.cs index f474b9764..a7f927dd0 100644 --- a/X10D.Tests/src/Reflection/TypeTests.cs +++ b/X10D.Tests/src/Reflection/TypeTests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Reflection; namespace X10D.Tests.Reflection; diff --git a/X10D.Tests/src/Text/CharSpanTests.cs b/X10D.Tests/src/Text/CharSpanTests.cs index 683f7c06d..fa02e2f79 100644 --- a/X10D.Tests/src/Text/CharSpanTests.cs +++ b/X10D.Tests/src/Text/CharSpanTests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Text; namespace X10D.Tests.Text; diff --git a/X10D.Tests/src/Text/CharTests.cs b/X10D.Tests/src/Text/CharTests.cs index cf17cdfc5..5ac8840ff 100644 --- a/X10D.Tests/src/Text/CharTests.cs +++ b/X10D.Tests/src/Text/CharTests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Text; namespace X10D.Tests.Text; diff --git a/X10D.Tests/src/Text/CoreTests.cs b/X10D.Tests/src/Text/CoreTests.cs index bbd114c47..ca2f1ddd5 100644 --- a/X10D.Tests/src/Text/CoreTests.cs +++ b/X10D.Tests/src/Text/CoreTests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Text; namespace X10D.Tests.Text; diff --git a/X10D.Tests/src/Text/EnumerableTests.cs b/X10D.Tests/src/Text/EnumerableTests.cs index 8e6ecd1da..ab6bfd057 100644 --- a/X10D.Tests/src/Text/EnumerableTests.cs +++ b/X10D.Tests/src/Text/EnumerableTests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Text; namespace X10D.Tests.Text; diff --git a/X10D.Tests/src/Text/RuneTests.cs b/X10D.Tests/src/Text/RuneTests.cs index 49c13e490..fc196c948 100644 --- a/X10D.Tests/src/Text/RuneTests.cs +++ b/X10D.Tests/src/Text/RuneTests.cs @@ -1,4 +1,4 @@ -#if NET5_0_OR_GREATER +#if NET5_0_OR_GREATER using System.Text; using NUnit.Framework; using X10D.Text; diff --git a/X10D.Tests/src/Text/StringBuilderReaderTests.cs b/X10D.Tests/src/Text/StringBuilderReaderTests.cs index 07e8849e4..8575511b0 100644 --- a/X10D.Tests/src/Text/StringBuilderReaderTests.cs +++ b/X10D.Tests/src/Text/StringBuilderReaderTests.cs @@ -1,4 +1,4 @@ -using System.Text; +using System.Text; using NUnit.Framework; using X10D.Text; diff --git a/X10D.Tests/src/Text/StringTests.cs b/X10D.Tests/src/Text/StringTests.cs index 336cafba7..44422d11b 100644 --- a/X10D.Tests/src/Text/StringTests.cs +++ b/X10D.Tests/src/Text/StringTests.cs @@ -1,4 +1,4 @@ -using System.Text; +using System.Text; #if NET5_0_OR_GREATER using System.Text.Json.Serialization; #endif diff --git a/X10D.Tests/src/Time/ByteTests.cs b/X10D.Tests/src/Time/ByteTests.cs index 7c3a3ede1..9d4b59a0d 100644 --- a/X10D.Tests/src/Time/ByteTests.cs +++ b/X10D.Tests/src/Time/ByteTests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Time; namespace X10D.Tests.Time; diff --git a/X10D.Tests/src/Time/CharSpanTests.cs b/X10D.Tests/src/Time/CharSpanTests.cs index f420cf065..f06ab6cdc 100644 --- a/X10D.Tests/src/Time/CharSpanTests.cs +++ b/X10D.Tests/src/Time/CharSpanTests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Time; namespace X10D.Tests.Time; diff --git a/X10D.Tests/src/Time/DecimalTests.cs b/X10D.Tests/src/Time/DecimalTests.cs index f1a2b0242..cba4370b7 100644 --- a/X10D.Tests/src/Time/DecimalTests.cs +++ b/X10D.Tests/src/Time/DecimalTests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Time; namespace X10D.Tests.Time; diff --git a/X10D.Tests/src/Time/DoubleTests.cs b/X10D.Tests/src/Time/DoubleTests.cs index 093e4660b..52478376a 100644 --- a/X10D.Tests/src/Time/DoubleTests.cs +++ b/X10D.Tests/src/Time/DoubleTests.cs @@ -1,4 +1,4 @@ -#if NET5_0_OR_GREATER +#if NET5_0_OR_GREATER using NUnit.Framework; using X10D.Time; diff --git a/X10D.Tests/src/Time/HalfTests.cs b/X10D.Tests/src/Time/HalfTests.cs index b2f7faf39..7f6ceab14 100644 --- a/X10D.Tests/src/Time/HalfTests.cs +++ b/X10D.Tests/src/Time/HalfTests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Time; namespace X10D.Tests.Time; diff --git a/X10D.Tests/src/Time/Int16Tests.cs b/X10D.Tests/src/Time/Int16Tests.cs index f6c40ed99..325aa8480 100644 --- a/X10D.Tests/src/Time/Int16Tests.cs +++ b/X10D.Tests/src/Time/Int16Tests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Time; namespace X10D.Tests.Time; diff --git a/X10D.Tests/src/Time/Int32Tests.cs b/X10D.Tests/src/Time/Int32Tests.cs index f0c258bf2..72edd0299 100644 --- a/X10D.Tests/src/Time/Int32Tests.cs +++ b/X10D.Tests/src/Time/Int32Tests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Time; namespace X10D.Tests.Time; diff --git a/X10D.Tests/src/Time/Int64Tests.cs b/X10D.Tests/src/Time/Int64Tests.cs index bf317e87c..1e7a38190 100644 --- a/X10D.Tests/src/Time/Int64Tests.cs +++ b/X10D.Tests/src/Time/Int64Tests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Time; namespace X10D.Tests.Time; diff --git a/X10D.Tests/src/Time/SByteTests.cs b/X10D.Tests/src/Time/SByteTests.cs index 7a7de1868..75185599e 100644 --- a/X10D.Tests/src/Time/SByteTests.cs +++ b/X10D.Tests/src/Time/SByteTests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Time; namespace X10D.Tests.Time; diff --git a/X10D.Tests/src/Time/SingleTests.cs b/X10D.Tests/src/Time/SingleTests.cs index 52fbe24c1..37b94b20b 100644 --- a/X10D.Tests/src/Time/SingleTests.cs +++ b/X10D.Tests/src/Time/SingleTests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Time; namespace X10D.Tests.Time; diff --git a/X10D.Tests/src/Time/StringTests.cs b/X10D.Tests/src/Time/StringTests.cs index c74658eb4..b176b41d6 100644 --- a/X10D.Tests/src/Time/StringTests.cs +++ b/X10D.Tests/src/Time/StringTests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Time; namespace X10D.Tests.Time; diff --git a/X10D.Tests/src/Time/TimeSpanParserTests.cs b/X10D.Tests/src/Time/TimeSpanParserTests.cs index a5a3aefe4..8a0e1caf7 100644 --- a/X10D.Tests/src/Time/TimeSpanParserTests.cs +++ b/X10D.Tests/src/Time/TimeSpanParserTests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Time; namespace X10D.Tests.Time; diff --git a/X10D.Tests/src/Time/TimeSpanTests.cs b/X10D.Tests/src/Time/TimeSpanTests.cs index ca68da365..eb7cad406 100644 --- a/X10D.Tests/src/Time/TimeSpanTests.cs +++ b/X10D.Tests/src/Time/TimeSpanTests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Time; namespace X10D.Tests.Time; diff --git a/X10D.Tests/src/Time/UInt16Tests.cs b/X10D.Tests/src/Time/UInt16Tests.cs index d93f58ac4..fe54926e1 100644 --- a/X10D.Tests/src/Time/UInt16Tests.cs +++ b/X10D.Tests/src/Time/UInt16Tests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Time; namespace X10D.Tests.Time; diff --git a/X10D.Tests/src/Time/UInt32Tests.cs b/X10D.Tests/src/Time/UInt32Tests.cs index 605110fe6..f6bc0f749 100644 --- a/X10D.Tests/src/Time/UInt32Tests.cs +++ b/X10D.Tests/src/Time/UInt32Tests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Time; namespace X10D.Tests.Time; diff --git a/X10D.Tests/src/Time/UInt64Tests.cs b/X10D.Tests/src/Time/UInt64Tests.cs index dcd08cdfb..78e868184 100644 --- a/X10D.Tests/src/Time/UInt64Tests.cs +++ b/X10D.Tests/src/Time/UInt64Tests.cs @@ -1,4 +1,4 @@ -using NUnit.Framework; +using NUnit.Framework; using X10D.Time; namespace X10D.Tests.Time; diff --git a/X10D/src/Assembly.cs b/X10D/src/Assembly.cs index a2c26c136..524d51351 100644 --- a/X10D/src/Assembly.cs +++ b/X10D/src/Assembly.cs @@ -1,4 +1,4 @@ -using System.Runtime.CompilerServices; +using System.Runtime.CompilerServices; [assembly: CLSCompliant(true)] [assembly: InternalsVisibleTo("X10D.Tests")] diff --git a/X10D/src/Collections/ArrayExtensions.cs b/X10D/src/Collections/ArrayExtensions.cs index 7dd5863e4..5c767052d 100644 --- a/X10D/src/Collections/ArrayExtensions.cs +++ b/X10D/src/Collections/ArrayExtensions.cs @@ -1,4 +1,4 @@ -using System.Diagnostics.Contracts; +using System.Diagnostics.Contracts; namespace X10D.Collections; diff --git a/X10D/src/Collections/BinaryIntegerExtensions.cs b/X10D/src/Collections/BinaryIntegerExtensions.cs index 2f3a44c75..7f29b21af 100644 --- a/X10D/src/Collections/BinaryIntegerExtensions.cs +++ b/X10D/src/Collections/BinaryIntegerExtensions.cs @@ -1,4 +1,4 @@ -#if NET7_0_OR_GREATER +#if NET7_0_OR_GREATER using System.Diagnostics.Contracts; using System.Numerics; using System.Runtime.CompilerServices; diff --git a/X10D/src/Collections/ByteExtensions.cs b/X10D/src/Collections/ByteExtensions.cs index 559036886..34d08bef0 100644 --- a/X10D/src/Collections/ByteExtensions.cs +++ b/X10D/src/Collections/ByteExtensions.cs @@ -1,4 +1,4 @@ -#if !NET7_0_OR_GREATER +#if !NET7_0_OR_GREATER using System.Diagnostics.CodeAnalysis; using System.Diagnostics.Contracts; #endif diff --git a/X10D/src/Collections/CollectionExtensions.cs b/X10D/src/Collections/CollectionExtensions.cs index e9b2c6ed1..f1f94864c 100644 --- a/X10D/src/Collections/CollectionExtensions.cs +++ b/X10D/src/Collections/CollectionExtensions.cs @@ -1,4 +1,4 @@ -namespace X10D.Collections; +namespace X10D.Collections; /// /// Collection-related extension methods for . diff --git a/X10D/src/Collections/DictionaryExtensions.cs b/X10D/src/Collections/DictionaryExtensions.cs index 241efe920..387016ef2 100644 --- a/X10D/src/Collections/DictionaryExtensions.cs +++ b/X10D/src/Collections/DictionaryExtensions.cs @@ -1,4 +1,4 @@ -using System.Diagnostics.Contracts; +using System.Diagnostics.Contracts; #if NET6_0_OR_GREATER using System.Runtime.InteropServices; #endif diff --git a/X10D/src/Collections/EnumerableExtensions.cs b/X10D/src/Collections/EnumerableExtensions.cs index a183c2b89..d6e1fccca 100644 --- a/X10D/src/Collections/EnumerableExtensions.cs +++ b/X10D/src/Collections/EnumerableExtensions.cs @@ -1,4 +1,4 @@ -using System.Diagnostics.Contracts; +using System.Diagnostics.Contracts; namespace X10D.Collections; diff --git a/X10D/src/Collections/Int16Extensions.cs b/X10D/src/Collections/Int16Extensions.cs index c5f837306..ed4b3cd34 100644 --- a/X10D/src/Collections/Int16Extensions.cs +++ b/X10D/src/Collections/Int16Extensions.cs @@ -1,4 +1,4 @@ -#if !NET7_0_OR_GREATER +#if !NET7_0_OR_GREATER using System.Diagnostics.CodeAnalysis; using System.Diagnostics.Contracts; #endif diff --git a/X10D/src/Collections/Int32Extensions.cs b/X10D/src/Collections/Int32Extensions.cs index 60455cd28..25092143c 100644 --- a/X10D/src/Collections/Int32Extensions.cs +++ b/X10D/src/Collections/Int32Extensions.cs @@ -1,4 +1,4 @@ -#if !NET7_0_OR_GREATER +#if !NET7_0_OR_GREATER using System.Diagnostics.CodeAnalysis; using System.Diagnostics.Contracts; #endif diff --git a/X10D/src/Collections/Int64Extensions.cs b/X10D/src/Collections/Int64Extensions.cs index b6fd7ad7f..c72dfbd8e 100644 --- a/X10D/src/Collections/Int64Extensions.cs +++ b/X10D/src/Collections/Int64Extensions.cs @@ -1,4 +1,4 @@ -#if !NET7_0_OR_GREATER +#if !NET7_0_OR_GREATER using System.Diagnostics.Contracts; namespace X10D.Collections; diff --git a/X10D/src/Collections/SpanExtensions.cs b/X10D/src/Collections/SpanExtensions.cs index ac2fd2b30..da54843ac 100644 --- a/X10D/src/Collections/SpanExtensions.cs +++ b/X10D/src/Collections/SpanExtensions.cs @@ -1,4 +1,4 @@ -namespace X10D.Collections; +namespace X10D.Collections; /// /// Extension methods for and diff --git a/X10D/src/Collections/SpanSplitEnumerator.cs b/X10D/src/Collections/SpanSplitEnumerator.cs index c99d9e7ed..1bd1c9515 100644 --- a/X10D/src/Collections/SpanSplitEnumerator.cs +++ b/X10D/src/Collections/SpanSplitEnumerator.cs @@ -1,4 +1,4 @@ -namespace X10D.Collections; +namespace X10D.Collections; /// /// Enumerates the elements of a . diff --git a/X10D/src/CompilerServices/CompilerResources.cs b/X10D/src/CompilerServices/CompilerResources.cs index c06c585fd..a02ca9919 100644 --- a/X10D/src/CompilerServices/CompilerResources.cs +++ b/X10D/src/CompilerServices/CompilerResources.cs @@ -1,4 +1,4 @@ -using System.Runtime.CompilerServices; +using System.Runtime.CompilerServices; namespace X10D.CompilerServices; diff --git a/X10D/src/Core/EnumExtensions.cs b/X10D/src/Core/EnumExtensions.cs index 29b764910..2545f1ed8 100644 --- a/X10D/src/Core/EnumExtensions.cs +++ b/X10D/src/Core/EnumExtensions.cs @@ -1,4 +1,4 @@ -using System.Diagnostics.Contracts; +using System.Diagnostics.Contracts; namespace X10D.Core; diff --git a/X10D/src/Core/Extensions.cs b/X10D/src/Core/Extensions.cs index 8817ca06b..df3969fea 100644 --- a/X10D/src/Core/Extensions.cs +++ b/X10D/src/Core/Extensions.cs @@ -1,4 +1,4 @@ -using System.Diagnostics.Contracts; +using System.Diagnostics.Contracts; namespace X10D.Core; diff --git a/X10D/src/Core/IntrinsicExtensions.cs b/X10D/src/Core/IntrinsicExtensions.cs index c9f5380a4..7085c6347 100644 --- a/X10D/src/Core/IntrinsicExtensions.cs +++ b/X10D/src/Core/IntrinsicExtensions.cs @@ -1,4 +1,4 @@ -#if NETCOREAPP3_0_OR_GREATER +#if NETCOREAPP3_0_OR_GREATER using System.Diagnostics.CodeAnalysis; using System.Diagnostics.Contracts; using System.Runtime.CompilerServices; diff --git a/X10D/src/Core/IntrinsicUtility.cs b/X10D/src/Core/IntrinsicUtility.cs index ff573b8c6..44997cc98 100644 --- a/X10D/src/Core/IntrinsicUtility.cs +++ b/X10D/src/Core/IntrinsicUtility.cs @@ -1,4 +1,4 @@ -#if NETCOREAPP3_0_OR_GREATER +#if NETCOREAPP3_0_OR_GREATER using System.Diagnostics.CodeAnalysis; using System.Diagnostics.Contracts; diff --git a/X10D/src/Core/NullableExtensions.cs b/X10D/src/Core/NullableExtensions.cs index 541fbd2b3..b90b4c544 100644 --- a/X10D/src/Core/NullableExtensions.cs +++ b/X10D/src/Core/NullableExtensions.cs @@ -1,4 +1,4 @@ -namespace X10D.Core; +namespace X10D.Core; /// /// Extension methods for diff --git a/X10D/src/Core/RandomExtensions.cs b/X10D/src/Core/RandomExtensions.cs index 49e8634af..fa8d412b6 100644 --- a/X10D/src/Core/RandomExtensions.cs +++ b/X10D/src/Core/RandomExtensions.cs @@ -1,4 +1,4 @@ -using System.Globalization; +using System.Globalization; using System.Text; using X10D.Math; diff --git a/X10D/src/Core/SpanExtensions.cs b/X10D/src/Core/SpanExtensions.cs index 6c0b6c069..c75880cf9 100644 --- a/X10D/src/Core/SpanExtensions.cs +++ b/X10D/src/Core/SpanExtensions.cs @@ -1,4 +1,4 @@ -using System.Diagnostics.CodeAnalysis; +using System.Diagnostics.CodeAnalysis; using System.Diagnostics.Contracts; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; diff --git a/X10D/src/Drawing/Circle.cs b/X10D/src/Drawing/Circle.cs index 75e3f23f5..5a64d7dff 100644 --- a/X10D/src/Drawing/Circle.cs +++ b/X10D/src/Drawing/Circle.cs @@ -1,4 +1,4 @@ -using System.Drawing; +using System.Drawing; namespace X10D.Drawing; diff --git a/X10D/src/Drawing/CircleF.cs b/X10D/src/Drawing/CircleF.cs index 7832eb35d..309fc508b 100644 --- a/X10D/src/Drawing/CircleF.cs +++ b/X10D/src/Drawing/CircleF.cs @@ -1,4 +1,4 @@ -using System.Drawing; +using System.Drawing; using System.Numerics; using X10D.Numerics; diff --git a/X10D/src/Drawing/ColorExtensions.cs b/X10D/src/Drawing/ColorExtensions.cs index 47ee9dfe2..86f7615e7 100644 --- a/X10D/src/Drawing/ColorExtensions.cs +++ b/X10D/src/Drawing/ColorExtensions.cs @@ -1,4 +1,4 @@ -using System.Diagnostics.Contracts; +using System.Diagnostics.Contracts; using System.Drawing; using System.Runtime.CompilerServices; using X10D.CompilerServices; diff --git a/X10D/src/Drawing/Cuboid.cs b/X10D/src/Drawing/Cuboid.cs index cc2ebae50..1e64a741d 100644 --- a/X10D/src/Drawing/Cuboid.cs +++ b/X10D/src/Drawing/Cuboid.cs @@ -1,4 +1,4 @@ -using System.Numerics; +using System.Numerics; using X10D.Numerics; namespace X10D.Drawing; diff --git a/X10D/src/Drawing/Ellipse.cs b/X10D/src/Drawing/Ellipse.cs index 736b3aac8..ba8646a0c 100644 --- a/X10D/src/Drawing/Ellipse.cs +++ b/X10D/src/Drawing/Ellipse.cs @@ -1,4 +1,4 @@ -using System.Drawing; +using System.Drawing; namespace X10D.Drawing; diff --git a/X10D/src/Drawing/EllipseF.cs b/X10D/src/Drawing/EllipseF.cs index 310f17f23..f4365fd16 100644 --- a/X10D/src/Drawing/EllipseF.cs +++ b/X10D/src/Drawing/EllipseF.cs @@ -1,4 +1,4 @@ -using System.Drawing; +using System.Drawing; using System.Numerics; using X10D.Numerics; diff --git a/X10D/src/Drawing/Line.cs b/X10D/src/Drawing/Line.cs index 4c240600b..b6c700120 100644 --- a/X10D/src/Drawing/Line.cs +++ b/X10D/src/Drawing/Line.cs @@ -1,4 +1,4 @@ -using System.Drawing; +using System.Drawing; using System.Numerics; namespace X10D.Drawing; diff --git a/X10D/src/Drawing/Line3D.cs b/X10D/src/Drawing/Line3D.cs index 9775c72ff..34d8bab15 100644 --- a/X10D/src/Drawing/Line3D.cs +++ b/X10D/src/Drawing/Line3D.cs @@ -1,4 +1,4 @@ -using System.Drawing; +using System.Drawing; using System.Numerics; namespace X10D.Drawing; diff --git a/X10D/src/Drawing/LineF.cs b/X10D/src/Drawing/LineF.cs index c4b31b21c..1382b41a8 100644 --- a/X10D/src/Drawing/LineF.cs +++ b/X10D/src/Drawing/LineF.cs @@ -1,4 +1,4 @@ -using System.Drawing; +using System.Drawing; using System.Numerics; using X10D.Numerics; diff --git a/X10D/src/Drawing/PointExtensions.cs b/X10D/src/Drawing/PointExtensions.cs index 4b36c6458..6d0b7b725 100644 --- a/X10D/src/Drawing/PointExtensions.cs +++ b/X10D/src/Drawing/PointExtensions.cs @@ -1,4 +1,4 @@ -using System.Diagnostics.Contracts; +using System.Diagnostics.Contracts; using System.Drawing; using System.Numerics; using System.Runtime.CompilerServices; diff --git a/X10D/src/Drawing/PointFExtensions.cs b/X10D/src/Drawing/PointFExtensions.cs index 0b82643b6..4207440fb 100644 --- a/X10D/src/Drawing/PointFExtensions.cs +++ b/X10D/src/Drawing/PointFExtensions.cs @@ -1,4 +1,4 @@ -using System.Diagnostics.Contracts; +using System.Diagnostics.Contracts; using System.Drawing; using System.Numerics; using System.Runtime.CompilerServices; diff --git a/X10D/src/Drawing/Polygon.cs b/X10D/src/Drawing/Polygon.cs index 9f03b588b..e3b651978 100644 --- a/X10D/src/Drawing/Polygon.cs +++ b/X10D/src/Drawing/Polygon.cs @@ -1,4 +1,4 @@ -using System.Diagnostics.CodeAnalysis; +using System.Diagnostics.CodeAnalysis; using System.Drawing; namespace X10D.Drawing; diff --git a/X10D/src/Drawing/PolygonF.cs b/X10D/src/Drawing/PolygonF.cs index 074edc31e..7499db9d5 100644 --- a/X10D/src/Drawing/PolygonF.cs +++ b/X10D/src/Drawing/PolygonF.cs @@ -1,4 +1,4 @@ -using System.Diagnostics.CodeAnalysis; +using System.Diagnostics.CodeAnalysis; using System.Drawing; using System.Numerics; using X10D.Numerics; diff --git a/X10D/src/Drawing/Polyhedron.cs b/X10D/src/Drawing/Polyhedron.cs index 6be327ee6..f968cd97c 100644 --- a/X10D/src/Drawing/Polyhedron.cs +++ b/X10D/src/Drawing/Polyhedron.cs @@ -1,4 +1,4 @@ -using System.Diagnostics.CodeAnalysis; +using System.Diagnostics.CodeAnalysis; using System.Drawing; using System.Numerics; diff --git a/X10D/src/Drawing/RandomExtensions.cs b/X10D/src/Drawing/RandomExtensions.cs index 880cd84d8..1836e52bb 100644 --- a/X10D/src/Drawing/RandomExtensions.cs +++ b/X10D/src/Drawing/RandomExtensions.cs @@ -1,4 +1,4 @@ -using System.Drawing; +using System.Drawing; #pragma warning disable CA5394 diff --git a/X10D/src/Drawing/SizeExtensions.cs b/X10D/src/Drawing/SizeExtensions.cs index d44fcce49..5276c4bf2 100644 --- a/X10D/src/Drawing/SizeExtensions.cs +++ b/X10D/src/Drawing/SizeExtensions.cs @@ -1,4 +1,4 @@ -using System.Diagnostics.Contracts; +using System.Diagnostics.Contracts; using System.Drawing; using System.Numerics; using System.Runtime.CompilerServices; diff --git a/X10D/src/Drawing/Sphere.cs b/X10D/src/Drawing/Sphere.cs index 26d91d66a..0d5a693b4 100644 --- a/X10D/src/Drawing/Sphere.cs +++ b/X10D/src/Drawing/Sphere.cs @@ -1,4 +1,4 @@ -using System.Numerics; +using System.Numerics; namespace X10D.Drawing; diff --git a/X10D/src/ExceptionMessages.Designer.cs b/X10D/src/ExceptionMessages.Designer.cs index ebabf39ba..8d6c6b6c9 100644 --- a/X10D/src/ExceptionMessages.Designer.cs +++ b/X10D/src/ExceptionMessages.Designer.cs @@ -1,4 +1,4 @@ -//------------------------------------------------------------------------------ +//------------------------------------------------------------------------------ // // This code was generated by a tool. // diff --git a/X10D/src/ExceptionMessages.resx b/X10D/src/ExceptionMessages.resx index 9bc8b28b8..f9dcc1ef7 100644 --- a/X10D/src/ExceptionMessages.resx +++ b/X10D/src/ExceptionMessages.resx @@ -1,4 +1,4 @@ - +