Use MTP, fix maths tests

Author: Perksey

Directory.Packages.props

@@ -10,7 +10,7 @@
     <PackageVersion Include="NUnit.Analyzers" Version="4.11.2" />
     <PackageVersion Include="coverlet.collector" Version="6.0.4" />
     <PackageVersion Include="NUnit" Version="4.4.0" />
-    <PackageVersion Include="xunit" Version="2.9.3" />
+    <PackageVersion Include="xunit.v3" Version="3.2.1" />
     <PackageVersion Include="xunit.runner.visualstudio" Version="3.1.5" />
     <!-- eng/benchmarks -->
     <PackageVersion Include="BenchmarkDotNet" Version="0.15.6" />
@@ -44,4 +44,4 @@
     <PackageVersion Include="Verify.DiffPlex" Version="3.1.2" />
     <PackageVersion Include="Verify.NUnit" Version="31.6.0" />
   </ItemGroup>
-</Project>
+</Project>

global.json

@@ -2,5 +2,8 @@
     "sdk": {
         "version": "10.0.100",
         "rollForward": "major"
+    },
+    "test": {
+        "runner": "Microsoft.Testing.Platform"
     }
 }

sources/Maths/Maths/Plane.cs

@@ -14,8 +14,8 @@ namespace Silk.NET.Maths
     /// <typeparam name="T">The type used to store values.</typeparam>
     [Serializable]
     [DataContract]
-    public struct Plane<T>
-        : IEquatable<Plane<T>> where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+    public struct Plane<T> : IEquatable<Plane<T>>
+        where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
     {
         /// <summary>The normal vector of the Plane.</summary>
         [DataMember]
@@ -58,22 +58,21 @@ public Plane(Vector4D<T> value)
         /// <param name="value1">The first Plane to compare.</param>
         /// <param name="value2">The second Plane to compare.</param>
         /// <returns>True if the Planes are equal; False otherwise.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static bool operator ==(Plane<T> value1, Plane<T> value2)
-            => value1.Normal == value2.Normal && Scalar.Equal(value1.Distance, value2.Distance);
+        [MethodImpl((MethodImplOptions)768)]
+        public static bool operator ==(Plane<T> value1, Plane<T> value2) =>
+            value1.Normal == value2.Normal && Scalar.Equal(value1.Distance, value2.Distance);
 
         /// <summary>Returns a boolean indicating whether the two given Planes are not equal.</summary>
         /// <param name="value1">The first Plane to compare.</param>
         /// <param name="value2">The second Plane to compare.</param>
         /// <returns>True if the Planes are not equal; False if they are equal.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static bool operator !=(Plane<T> value1, Plane<T> value2)
-            => !(value1 == value2);
+        [MethodImpl((MethodImplOptions)768)]
+        public static bool operator !=(Plane<T> value1, Plane<T> value2) => !(value1 == value2);
 
         /// <summary>Returns a boolean indicating whether the given Object is equal to this Plane instance.</summary>
         /// <param name="obj">The Object to compare against.</param>
         /// <returns>True if the Object is equal to this Plane; False otherwise.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
+        [MethodImpl((MethodImplOptions)768)]
         public override readonly bool Equals(object? obj)
         {
             return (obj is Plane<T> other) && Equals(other);
@@ -82,7 +81,7 @@ public override readonly bool Equals(object? obj)
         /// <summary>Returns a boolean indicating whether the given Plane is equal to this Plane instance.</summary>
         /// <param name="other">The Plane to compare this instance to.</param>
         /// <returns>True if the other Plane is equal to this instance; False otherwise.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
+        [MethodImpl((MethodImplOptions)768)]
         public readonly bool Equals(Plane<T> other)
         {
             return Normal.Equals(other.Normal) && Scalar.Equal(Distance, other.Distance);
@@ -92,129 +91,135 @@ public readonly bool Equals(Plane<T> other)
         /// <returns>The hash code.</returns>
         public override readonly int GetHashCode()
         {
-            return Normal.GetHashCode() + Distance.GetHashCode();
+            return HashCode.Combine(Normal.GetHashCode(), Distance.GetHashCode());
         }
 
         /// <summary>Returns a String representing this Plane instance.</summary>
         /// <returns>The string representation.</returns>
         public override readonly string ToString()
         {
             CultureInfo ci = CultureInfo.CurrentCulture;
-            return string.Format(ci, "{{Normal:{0} D:{1}}}", Normal.ToString(), Distance.ToString("G", ci));
+            return string.Format(
+                ci,
+                "{{Normal:{0} D:{1}}}",
+                Normal.ToString(),
+                Distance.ToString("G", ci)
+            );
         }
 
         /// <summary>
         /// Converts a <see cref="Plane{T}"/> into one with a <typeparamref name="T"/> of <see cref="Half"/>
         /// </summary>
         /// <param name="from">The source matrix</param>
         /// <returns>The <see cref="Half"/> matrix</returns>
-        public static explicit operator Plane<Half>(Plane<T> from)
-            => new((Vector3D<Half>) from.Normal, Scalar.As<T, Half>(from.Distance));
+        public static explicit operator Plane<Half>(Plane<T> from) =>
+            new((Vector3D<Half>)from.Normal, Scalar.As<T, Half>(from.Distance));
 
         /// <summary>
         /// Converts a <see cref="Plane{T}"/> into one with a <typeparamref name="T"/> of <see cref="float"/>
         /// </summary>
         /// <param name="from">The source matrix</param>
         /// <returns>The <see cref="float"/> matrix</returns>
-        public static explicit operator Plane<float>(Plane<T> from)
-            => new((Vector3D<float>) from.Normal, Scalar.As<T, float>(from.Distance));
+        public static explicit operator Plane<float>(Plane<T> from) =>
+            new((Vector3D<float>)from.Normal, Scalar.As<T, float>(from.Distance));
 
         /// <summary>
         /// Converts a <see cref="Plane{T}"/> into <see cref="System.Numerics.Plane"/>
         /// </summary>
         /// <param name="from">The source matrix</param>
         /// <returns>The <see cref="System.Numerics"/> matrix</returns>
-        public static explicit operator System.Numerics.Plane(Plane<T> from)
-            => new((System.Numerics.Vector3) from.Normal, Scalar.As<T, float>(from.Distance));
-        
+        public static explicit operator System.Numerics.Plane(Plane<T> from) =>
+            new((System.Numerics.Vector3)from.Normal, Scalar.As<T, float>(from.Distance));
+
         /// <summary>
         /// Converts a <see cref="Plane{T}"/> into one with a <typeparamref name="T"/> of <see cref="double"/>
         /// </summary>
         /// <param name="from">The source matrix</param>
         /// <returns>The <see cref="double"/> matrix</returns>
-        public static explicit operator Plane<double>(Plane<T> from)
-            => new((Vector3D<double>) from.Normal, Scalar.As<T, double>(from.Distance));
+        public static explicit operator Plane<double>(Plane<T> from) =>
+            new((Vector3D<double>)from.Normal, Scalar.As<T, double>(from.Distance));
 
         /// <summary>
         /// Converts a <see cref="Plane{T}"/> into one with a <typeparamref name="T"/> of <see cref="decimal"/>
         /// </summary>
         /// <param name="from">The source matrix</param>
         /// <returns>The <see cref="decimal"/> matrix</returns>
-        public static explicit operator Plane<decimal>(Plane<T> from)
-            => new((Vector3D<decimal>) from.Normal, Scalar.As<T, decimal>(from.Distance));
+        public static explicit operator Plane<decimal>(Plane<T> from) =>
+            new((Vector3D<decimal>)from.Normal, Scalar.As<T, decimal>(from.Distance));
 
         /// <summary>
         /// Converts a <see cref="Plane{T}"/> into one with a <typeparamref name="T"/> of <see cref="sbyte"/>
         /// </summary>
         /// <param name="from">The source matrix</param>
         /// <returns>The <see cref="sbyte"/> matrix</returns>
-        public static explicit operator Plane<sbyte>(Plane<T> from)
-            => new((Vector3D<sbyte>) from.Normal, Scalar.As<T, sbyte>(from.Distance));
+        public static explicit operator Plane<sbyte>(Plane<T> from) =>
+            new((Vector3D<sbyte>)from.Normal, Scalar.As<T, sbyte>(from.Distance));
 
         /// <summary>
         /// Converts a <see cref="Plane{T}"/> into one with a <typeparamref name="T"/> of <see cref="byte"/>
         /// </summary>
         /// <param name="from">The source matrix</param>
         /// <returns>The <see cref="byte"/> matrix</returns>
-        public static explicit operator Plane<byte>(Plane<T> from)
-            => new((Vector3D<byte>) from.Normal, Scalar.As<T, byte>(from.Distance));
+        public static explicit operator Plane<byte>(Plane<T> from) =>
+            new((Vector3D<byte>)from.Normal, Scalar.As<T, byte>(from.Distance));
 
         /// <summary>
         /// Converts a <see cref="Plane{T}"/> into one with a <typeparamref name="T"/> of <see cref="ushort"/>
         /// </summary>
         /// <param name="from">The source matrix</param>
         /// <returns>The <see cref="ushort"/> matrix</returns>
-        public static explicit operator Plane<ushort>(Plane<T> from)
-            => new((Vector3D<ushort>) from.Normal, Scalar.As<T, ushort>(from.Distance));
+        public static explicit operator Plane<ushort>(Plane<T> from) =>
+            new((Vector3D<ushort>)from.Normal, Scalar.As<T, ushort>(from.Distance));
 
         /// <summary>
         /// Converts a <see cref="Plane{T}"/> into one with a <typeparamref name="T"/> of <see cref="short"/>
         /// </summary>
         /// <param name="from">The source matrix</param>
         /// <returns>The <see cref="short"/> matrix</returns>
-        public static explicit operator Plane<short>(Plane<T> from)
-            => new((Vector3D<short>) from.Normal, Scalar.As<T, short>(from.Distance));
+        public static explicit operator Plane<short>(Plane<T> from) =>
+            new((Vector3D<short>)from.Normal, Scalar.As<T, short>(from.Distance));
 
         /// <summary>
         /// Converts a <see cref="Plane{T}"/> into one with a <typeparamref name="T"/> of <see cref="uint"/>
         /// </summary>
         /// <param name="from">The source matrix</param>
         /// <returns>The <see cref="uint"/> matrix</returns>
-        public static explicit operator Plane<uint>(Plane<T> from)
-            => new((Vector3D<uint>) from.Normal, Scalar.As<T, uint>(from.Distance));
+        public static explicit operator Plane<uint>(Plane<T> from) =>
+            new((Vector3D<uint>)from.Normal, Scalar.As<T, uint>(from.Distance));
 
         /// <summary>
         /// Converts a <see cref="Plane{T}"/> into one with a <typeparamref name="T"/> of <see cref="int"/>
         /// </summary>
         /// <param name="from">The source matrix</param>
         /// <returns>The <see cref="int"/> matrix</returns>
-        public static explicit operator Plane<int>(Plane<T> from)
-            => new((Vector3D<int>) from.Normal, Scalar.As<T, int>(from.Distance));
+        public static explicit operator Plane<int>(Plane<T> from) =>
+            new((Vector3D<int>)from.Normal, Scalar.As<T, int>(from.Distance));
 
         /// <summary>
         /// Converts a <see cref="Plane{T}"/> into one with a <typeparamref name="T"/> of <see cref="ulong"/>
         /// </summary>
         /// <param name="from">The source matrix</param>
         /// <returns>The <see cref="ulong"/> matrix</returns>
-        public static explicit operator Plane<ulong>(Plane<T> from)
-            => new((Vector3D<ulong>) from.Normal, Scalar.As<T, ulong>(from.Distance));
+        public static explicit operator Plane<ulong>(Plane<T> from) =>
+            new((Vector3D<ulong>)from.Normal, Scalar.As<T, ulong>(from.Distance));
 
         /// <summary>
         /// Converts a <see cref="Plane{T}"/> into one with a <typeparamref name="T"/> of <see cref="long"/>
         /// </summary>
         /// <param name="from">The source matrix</param>
         /// <returns>The <see cref="long"/> matrix</returns>
-        public static explicit operator Plane<long>(Plane<T> from)
-            => new((Vector3D<long>) from.Normal, Scalar.As<T, long>(from.Distance));
-        
+        public static explicit operator Plane<long>(Plane<T> from) =>
+            new((Vector3D<long>)from.Normal, Scalar.As<T, long>(from.Distance));
+
         /// <summary>
         /// Returns this plane casted to <typeparamref name="TOther"></typeparamref>
         /// </summary>
         /// <typeparam name="TOther">The type to cast to</typeparam>
         /// <returns>The casted plane</returns>
-        public Plane<TOther> As<TOther>() where TOther : unmanaged, IFormattable, IEquatable<TOther>, IComparable<TOther>
+        public Plane<TOther> As<TOther>()
+            where TOther : unmanaged, IFormattable, IEquatable<TOther>, IComparable<TOther>
         {
             return new(Normal.As<TOther>(), Scalar.As<T, TOther>(Distance));
         }
     }
-}
+}

sources/Maths/Maths/PublicAPI/net10.0-android/PublicAPI.Shipped.txt

@@ -0,0 +1 @@
+#nullable enable

sources/Maths/Maths/PublicAPI/net10.0-android/PublicAPI.Unshipped.txt

@@ -0,0 +1 @@
+#nullable enable

sources/Maths/Maths/Scalar.Bitwise/Scalar.Not.cs

@@ -10,7 +10,8 @@ static partial class Scalar
         /// <summary>
         /// Performs Not on supported types
         /// </summary>
-        public static T Not<T>(T value) where T : unmanaged
+        public static T Not<T>(T value)
+            where T : unmanaged
         {
             return Byte(value);
 
@@ -19,113 +20,113 @@ static T Byte(T value)
             {
                 if (typeof(T) == typeof(byte))
                 {
-                    return (T) (object) (byte) (~ (byte) (object) value);
+                    return (T)(object)(byte)(~((byte)(object)value) & byte.MaxValue);
                 }
 
                 return SByte(value);
             }
-        
+
             [MethodImpl(MaxOpt)]
             static T SByte(T value)
             {
                 if (typeof(T) == typeof(sbyte))
                 {
-                    return (T) (object) (sbyte) (~ (sbyte) (object) value);
+                    return (T)(object)(sbyte)(~(sbyte)(object)value);
                 }
 
                 return UInt16(value);
             }
-        
+
             [MethodImpl(MaxOpt)]
             static T UInt16(T value)
             {
                 if (typeof(T) == typeof(ushort))
                 {
-                    return (T) (object) (ushort) (~ (ushort) (object) value);
+                    return (T)(object)(ushort)(~(ushort)(object)value);
                 }
 
                 return Int16(value);
             }
-        
+
             [MethodImpl(MaxOpt)]
             static T Int16(T value)
             {
                 if (typeof(T) == typeof(short))
                 {
-                    return (T) (object) (short) (~ (short) (object) value);
+                    return (T)(object)(short)(~(short)(object)value);
                 }
 
                 return UInt32(value);
             }
-        
+
             [MethodImpl(MaxOpt)]
             static T UInt32(T value)
             {
                 if (typeof(T) == typeof(uint))
                 {
-                    return (T) (object) (uint) (~ (uint) (object) value);
+                    return (T)(object)(uint)(~(uint)(object)value);
                 }
 
                 return Int32(value);
             }
-        
+
             [MethodImpl(MaxOpt)]
             static T Int32(T value)
             {
                 if (typeof(T) == typeof(int))
                 {
-                    return (T) (object) (int) (~ (int) (object) value);
+                    return (T)(object)(int)(~(int)(object)value);
                 }
 
                 return UInt64(value);
             }
-        
+
             [MethodImpl(MaxOpt)]
             static T UInt64(T value)
             {
                 if (typeof(T) == typeof(ulong))
                 {
-                    return (T) (object) (ulong) (~ (ulong) (object) value);
+                    return (T)(object)(ulong)(~(ulong)(object)value);
                 }
 
                 return Int64(value);
             }
-        
+
             [MethodImpl(MaxOpt)]
             static T Int64(T value)
             {
                 if (typeof(T) == typeof(long))
                 {
-                    return (T) (object) (long) (~ (long) (object) value);
+                    return (T)(object)(long)(~(long)(object)value);
                 }
 
                 return Single(value);
             }
-        
+
             [MethodImpl(MaxOpt)]
             static T Single(T value)
             {
                 if (typeof(T) == typeof(float))
                 {
-                    var res = ~ Unsafe.As<T, uint>(ref value);
+                    var res = ~Unsafe.As<T, uint>(ref value);
                     return Unsafe.As<uint, T>(ref res);
                 }
 
                 return Double(value);
             }
-        
+
             [MethodImpl(MaxOpt)]
             static T Double(T value)
             {
                 if (typeof(T) == typeof(double))
                 {
-                    var res = ~ Unsafe.As<T, ulong>(ref value);
+                    var res = ~Unsafe.As<T, ulong>(ref value);
                     return Unsafe.As<ulong, T>(ref res);
                 }
 
                 return Other(value);
             }
-        
+
             [MethodImpl(MaxOpt)]
             static T Other(T value)
             {
@@ -134,4 +135,4 @@ static T Other(T value)
             }
         }
     }
-}
+}