From 3798b2f0b18ff9110786ae5a4a900e27edaf712b Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Tue, 23 Nov 2021 09:22:52 -0800
Subject: [PATCH 01/16] Adding an INumberBase interface to the generic math
 proposal

---
 accepted/2021/statics-in-interfaces/README.md | 122 ++++++++++--------
 1 file changed, 66 insertions(+), 56 deletions(-)

diff --git a/accepted/2021/statics-in-interfaces/README.md b/accepted/2021/statics-in-interfaces/README.md
index e82d89d98..390a0fbd4 100644
--- a/accepted/2021/statics-in-interfaces/README.md
+++ b/accepted/2021/statics-in-interfaces/README.md
@@ -196,14 +196,15 @@ interface "IModulusOperators<TSelf, TOther, TResult>"
 interface "IMultiplicativeIdentity<TSelf, TResult>"
 interface "IMultiplyOperators<TSelf, TOther, TResult>"
 interface "INumber<TSelf>"
+interface "INumberBase<TSelf>"
 interface "IParseable<TSelf>"
 interface "ISerializable"
 interface "IShiftOperators<TSelf, TOther, TResult>"
-interface "ISignedNumber<TSelf>"
+interface "ISignedNumberBase<TSelf>"
 interface "ISpanFormattable"
 interface "ISpanParseable<TSelf>"
 interface "ISubtractionOperators<TSelf, TOther, TResult>"
-interface "IUnsignedNumber<TSelf>"
+interface "IUnsignedNumberBase<TSelf>"
 interface "IUnaryNegationOperators<TSelf, TResult>"
 interface "IUnaryPlusOperators<TSelf, TResult>"
 interface "IVector<TSelf, TScalar>"
@@ -223,39 +224,42 @@ interface "IVector<TSelf, TScalar>"
 
 "IEquatable<T>"                                 <|-- "IEqualityOperators<TSelf, TOther>"
 
-"ISignedNumber<TSelf>"                          <|-- "IFloatingPoint<TSelf>"
+"ISignedNumberBase<TSelf>"                      <|-- "IFloatingPoint<TSelf>"
 
-"IAdditionOperators<TSelf, TOther, TResult>"    <|-- "INumber<TSelf>"
-"IAdditiveIdentity<TSelf, TResult>"             <|-- "INumber<TSelf>"
 "IComparisonOperators<TSelf, TOther>"           <|-- "INumber<TSelf>"
 "IDecrementOperators<TSelf>"                    <|-- "INumber<TSelf>"
 "IDivisionOperators<TSelf, TOther, TResult>"    <|-- "INumber<TSelf>"
 "IIncrementOperators<TSelf>"                    <|-- "INumber<TSelf>"
 "IModulusOperators<TSelf, TOther, TResult>"     <|-- "INumber<TSelf>"
 "IMultiplicativeIdentity<TSelf, TResult>"       <|-- "INumber<TSelf>"
-"IMultiplyOperators<TSelf, TOther, TResult>"    <|-- "INumber<TSelf>"
+"INumberBase<TSelf>"                            <|-- "INumber<TSelf>"
 "ISpanFormattable"                              <|-- "INumber<TSelf>"
 "ISpanParseable<TSelf>"                         <|-- "INumber<TSelf>"
-"ISubtractionOperators<TSelf, TOther, TResult>" <|-- "INumber<TSelf>"
 "IUnaryNegationOperators<TSelf, TResult>"       <|-- "INumber<TSelf>"
-"IUnaryPlusOperators<TSelf, TResult>"           <|-- "INumber<TSelf>"
 
-"INumber<TSelf>"                                <|-- "ISignedNumber<TSelf>"
+"IAdditionOperators<TSelf, TOther, TResult>"    <|-- "INumberBase<TSelf>"
+"IAdditiveIdentity<TSelf, TResult>"             <|-- "INumberBase<TSelf>"
+"IEqualityOperators<TSelf, TOther>"             <|-- "INumberBase<TSelf>"
+"IMultiplyOperators<TSelf, TOther, TResult>"    <|-- "INumberBase<TSelf>"
+"ISubtractionOperators<TSelf, TOther, TResult>" <|-- "INumberBase<TSelf>"
+"IUnaryPlusOperators<TSelf, TResult>"           <|-- "INumberBase<TSelf>"
+
+"INumberBase<TSelf>"                            <|-- "ISignedNumberBase<TSelf>"
 
 "IFormattable"                                  <|-- "ISpanFormattable"
 
 "IParseable<TSelf>"                             <|-- "ISpanParseable<TSelf>"
 
-"INumber<TSelf>"                                <|-- "IUnsignedNumber<TSelf>"
+"INumberBase<TSelf>"                            <|-- "IUnsignedNumberBase<TSelf>"
 
 "IAdditionOperators<TSelf, TOther, TResult>"    <|-- "IVector<TSelf, TScalar>"
 "IAdditiveIdentity<TSelf, TResult>"             <|-- "IVector<TSelf, TScalar>"
 "IBitwiseOperators<TSelf, TOther, TResult>"     <|-- "IVector<TSelf, TScalar>"
 "IComparisonOperators<TSelf, TOther>"           <|-- "IVector<TSelf, TScalar>"
-"IDecrementOperators<TSelf>"                    <|-- "INumber<TSelf>"
+"IDecrementOperators<TSelf>"                    <|-- "IVector<TSelf, TScalar>"
 "IDivisionOperators<TSelf, TOther, TResult>"    <|-- "IVector<TSelf, TScalar>"
-"IIncrementOperators<TSelf>"                    <|-- "INumber<TSelf>"
-"IModulusOperators<TSelf, TOther, TResult>"     <|-- "INumber<TSelf>"
+"IIncrementOperators<TSelf>"                    <|-- "IVector<TSelf, TScalar>"
+"IModulusOperators<TSelf, TOther, TResult>"     <|-- "IVector<TSelf, TScalar>"
 "IMultiplicativeIdentity<TSelf, TResult>"       <|-- "IVector<TSelf, TScalar>"
 "IMultiplyOperators<TSelf, TOther, TResult>"    <|-- "IVector<TSelf, TScalar>"
 "ISpanFormattable"                              <|-- "IVector<TSelf, TScalar>"
@@ -296,13 +300,13 @@ class "Vector4"
 "IBinaryInteger<TSelf>"                         <|-- "Byte"
 "IConvertible"                                  <|-- "Byte"
 "IMinMaxValue<TSelf>"                           <|-- "Byte"
-"IUnsignedNumber<TSelf>"                        <|-- "Byte"
+"IUnsignedNumberBase<TSelf>"                    <|-- "Byte"
 "ValueType"                                     <|-- "Byte"
 
 "IBinaryInteger<TSelf>"                         <|-- "Char"
 "IConvertible"                                  <|-- "Char"
 "IMinMaxValue<TSelf>"                           <|-- "Char"
-"IUnsignedNumber<TSelf>"                        <|-- "Char"
+"IUnsignedNumberBase<TSelf>"                    <|-- "Char"
 "ValueType"                                     <|-- "Char"
 
 "IComparisonOperators<TSelf, TOther>"           <|-- "DateOnly"
@@ -337,7 +341,7 @@ class "Vector4"
 "IDeserializationCallback"                      <|-- "Decimal"
 "IMinMaxValue<TSelf>"                           <|-- "Decimal"
 "ISerializable"                                 <|-- "Decimal"
-"ISignedNumber<TSelf>"                          <|-- "Decimal"
+"ISignedNumberBase<TSelf>"                      <|-- "Decimal"
 "ValueType"                                     <|-- "Decimal"
 
 "IBinaryFloatingPoint<TSelf>"                   <|-- "Double"
@@ -362,31 +366,31 @@ class "Vector4"
 "IBinaryInteger<TSelf>"                         <|-- "Int16"
 "IConvertible"                                  <|-- "Int16"
 "IMinMaxValue<TSelf>"                           <|-- "Int16"
-"ISignedNumber<TSelf>"                          <|-- "Int16"
+"ISignedNumberBase<TSelf>"                      <|-- "Int16"
 "ValueType"                                     <|-- "Int16"
 
 "IBinaryInteger<TSelf>"                         <|-- "Int32"
 "IConvertible"                                  <|-- "Int32"
 "IMinMaxValue<TSelf>"                           <|-- "Int32"
-"ISignedNumber<TSelf>"                          <|-- "Int32"
+"ISignedNumberBase<TSelf>"                      <|-- "Int32"
 "ValueType"                                     <|-- "Int32"
 
 "IBinaryInteger<TSelf>"                         <|-- "Int64"
 "IConvertible"                                  <|-- "Int64"
 "IMinMaxValue<TSelf>"                           <|-- "Int64"
-"ISignedNumber<TSelf>"                          <|-- "Int64"
+"ISignedNumberBase<TSelf>"                      <|-- "Int64"
 "ValueType"                                     <|-- "Int64"
 
 "IBinaryInteger<TSelf>"                         <|-- "IntPtr"
 "IMinMaxValue<TSelf>"                           <|-- "IntPtr"
-"ISignedNumber<TSelf>"                          <|-- "IntPtr"
+"ISignedNumberBase<TSelf>"                      <|-- "IntPtr"
 "ISerializable"                                 <|-- "IntPtr"
 "ValueType"                                     <|-- "IntPtr"
 
 "IBinaryInteger<TSelf>"                         <|-- "SByte"
 "IConvertible"                                  <|-- "SByte"
 "IMinMaxValue<TSelf>"                           <|-- "SByte"
-"ISignedNumber<TSelf>"                          <|-- "SByte"
+"ISignedNumberBase<TSelf>"                      <|-- "SByte"
 "ValueType"                                     <|-- "SByte"
 
 "IBinaryFloatingPoint<TSelf>"                   <|-- "Single"
@@ -416,25 +420,25 @@ class "Vector4"
 "IBinaryInteger<TSelf>"                         <|-- "UInt16"
 "IConvertible"                                  <|-- "UInt16"
 "IMinMaxValue<TSelf>"                           <|-- "UInt16"
-"IUnsignedNumber<TSelf>"                        <|-- "UInt16"
+"IUnsignedNumberBase<TSelf>"                    <|-- "UInt16"
 "ValueType"                                     <|-- "UInt16"
 
 "IBinaryInteger<TSelf>"                         <|-- "UInt32"
 "IConvertible"                                  <|-- "UInt32"
 "IMinMaxValue<TSelf>"                           <|-- "UInt32"
-"IUnsignedNumber<TSelf>"                        <|-- "UInt32"
+"IUnsignedNumberBase<TSelf>"                    <|-- "UInt32"
 "ValueType"                                     <|-- "UInt32"
 
 "IBinaryInteger<TSelf>"                         <|-- "UInt64"
 "IConvertible"                                  <|-- "UInt64"
 "IMinMaxValue<TSelf>"                           <|-- "UInt64"
-"IUnsignedNumber<TSelf>"                        <|-- "UInt64"
+"IUnsignedNumberBase<TSelf>"                    <|-- "UInt64"
 "ValueType"                                     <|-- "UInt64"
 
 "IBinaryInteger<TSelf>"                         <|-- "UIntPtr"
 "IMinMaxValue<TSelf>"                           <|-- "UIntPtr"
 "ISerializable"                                 <|-- "UIntPtr"
-"IUnsignedNumber<TSelf>"                        <|-- "UIntPtr"
+"IUnsignedNumberBase<TSelf>"                    <|-- "UIntPtr"
 "ValueType"                                     <|-- "UIntPtr"
 
 "Object"                                        <|-- "ValueType"
@@ -451,7 +455,7 @@ class "Vector4"
 @enduml
 -->
 
-![UML](http://www.plantuml.com/plantuml/svg/r9ZDRjim3CVlVeeWv_NGZmKx5CNMZsuvP0dcf7VQOL9kifn9T3SFU_Yb7QecbXpAHZ5WlHHao9z8IVbJo7lBOBWgL4AQqQmWny5m_66v9APIJpTeW4jZp-SfgjMRmNpAzsYs_x-WhHHV30Df3pXUecRYscK5eoz9WwblLGbCUZqhIVFVX63SUEjPepaGyRagijO0_a4MExPpLHORC90fRFEVpuCfP5ktpelN3sYOl3MkCJTOeEO6vw8PPj4GAFe5Z-Tr1Kfba7zh1D43sUwdUVEz0aLSYvsuQ0xkYNp2OntLx6rf2c3s3sH2UW8_xq1L64oSbCjALRPZ_vEjYpQASl3lj91JTrpgmDMTWR48cGftbZwVlhSdwJsjk6CPAQqrBWyKasv0Xqx1VIXKMsLi8E-XB0jjfTeMJng0QmZYVQpBcQdAHiRVORuDSZ5f3WhCDYO9Qz2WzU_yzz6H884jNvp-oFvbXXKu-ex5m98E8ktHN3-kijW61o8hsTLxWUHWaPEWEKfU4otBTrzqqX3xs1sHvqaIbY2Ht7hRuzynZkQ9SSIpngl9fqHjhKmvy2vmgH6K-1V18SfOlq8jySFv02LwM0krn8_lTihUb9H4Gw1uuxGxfSl8RQ54prQXbeXfAtRKJzizNN4m-PnycFyCIWBlj5YGbzYxH_-Hr5y7snuxlGHHmCKFVWdNHsW5tBzNNA6e_rXwfTPwQR20YnTZ2TTRJyEu7i8gu99SWRM3uMNDE7mshkx1EECQ6ATQrNkEEHNeEQQhbKL-SMDE1QWNkwmoXSwyqLNXZ8yLBPtn2TJA6MFDnwDTw_HarngTxLepDiwSPbynPsUcUnscfDSxjJnM_tZeph7ONtQnl-vYV-55O-Md7nNczUQ5_xpx5mtFwCpt7P-yyvqdRqS1PyC-RTXdVqgrOvi8WY28elv6GGmSmYO7H0RW0HxvOw3MrqdiQlG6__Vjr1MzDTtNxQsxqq8c63VSZPf25jb_1YoBxDbRQObD_8ULlrWKQ_vRGAnO42iMn1eMn1gMNffr4pjqlBNfU4tByI9UF4UikgzagdXDFV7c-7WrGFpT91C-NmqKJmQAXs0GRmQCtp9WRtktOLLspLYLi-L6vCgpk36hulQiogv9g-9MhOeRjYfxjgqATPyogJWbd2mIpju8bv5dk7m3uSVbmk24B_xR5nSDmaV3oQDfh3yN7Jbsx3G0OE78mr9NdiiSTAvOw5V3me67DMlFXHMi6GiFFInTM-PYBRuCXYC7GnSB1i62NR7R8oaM38e5WsB1e5YmA_RyH8e5WsB1e5WmA1PCYZN4WbD7mx6ZCPr4WshHADihJwo2GV9WK3mO90kcTrOJK90i6ZIBbdD7Ophvc_Nw12hU4awyfPnuku_5W_pnFi5gs8wZWtWsG3oisEBTGF6m1ukNnLUy6JYU3HWFkwnuDN0ylcpUE3f7YtcYSUmV3S95ksoUdwD9jcYJpIDqjClc8JgQP8issJn7HwjidAJ3FGo7it8UfiEFsOAliF5zw76S_dJWka8BRw_GWjnBj4_t6gtVzuhiFSCDyNuCyFBn_VxpzVaB)
+![UML](http://www.plantuml.com/plantuml/svg/h9ZDSjCm4CVlVefCplJG3p8SEXteHy67a0nEUbyxcrGWoq5Q5ypmyBXbwZIoDf8ruSBiUlSdhRJTlzgFXa1JNSf4A4AzXW97u_JJQYL8L6gsHGrKQNEvo52ktuqMCtf4tVx_3KqjwMhiI7l2T8MA13LTbZFwMYZGpRsiW8JQp2kXw7-2CovjFHlK1oA-rcNE1j0lON1WEJTLkGKDkKJEVxbmfWZ37bqlNZsX9j5RunOBZIKgiZXNTfX1BK2AF_1yNpSWPGx53oj8F0ap_3RlVjOjc1ecpH5DpZFntt2gWegzhtG9HFqBcGerXTyF86jq9awhLIrhCx3-QUiIMoaAO7gQpsa6BiMrRlVf6eoxj3beWv1BzzVijJbwHvOzYZKDt6KcDWfNdWrbMr2kY-e-UdPSvwIXY1W-IsL2zhTy6HMu0VSIFNINCvUr2On_mA8DwcAo0YJeDYPnZweH--_oxyc9Pr8oFr_noEXjCeCwkDT2OCc0MMxJx7fQLcY18oyhsPCBZc310WN3LfnZelrJFXQTM9eGUY9-sKduKNIGp7PxG3bzMg-PUCdkKWCeuM9zY9Ag8-mbN3SFK89rrBENmBlsK6nruWayXP6nWPHW9Jf8IOQyrIsC9PBUvxjL8aEA7IeCAVn1vICDUbaS80Kz1uAgY-jgQ_XPGBwvUM3_pPOu7fQX83inlaxcHHVVzypBBBxvULpKAuN7HIaKZukIAXuNfLayBbL7tLsKYl6uA3dpufeZdLsKm36uYA79us8bZySbXGHZHkFhXd3yQjmyWkwCMo2SATdiEHQYn9vZjbuRf9qR2r62tDbLdSjTrfsgoyxuN8jLPtm1kUwCLD7fvArrVlRMcboyjUQaEtEMVyU2EZFRgp0JQYDtvlFkdo-zSoptbrtkhxlSNtXfhVpoDvH5iztnNq__ol9CBlg-qxCFVUVP-ud3QTddbjtkC65-1_GqyxzIxHWdOnW8ed2Vun14pHqGDu0EwBW_XMKz2H5YVUvvctZ-mHxlPcXLPstz88pzev-qp5uVMhTiulS7Iyz5iSP_2uWL2s9D5iIA1R5YwJnjDx55n-is7Iyta7WJBvxJLxklnAru3KJnvlXuCq3yhyuiF5yD54y6YeTW42y6ZDyoOAVzhWshucQiolKi9tBbNToOLN5xLcNNf5LngrR53LkLFTjMXNQVCgau9Pmi4cxU29VMRRZz0k75fFkPINpn7twuQ10-MbOUZUE9ST61PST2HoeMbZnPotZZCWSxLopiLx6muCcQjSU55QmP2oyTIzUMUR46NmR3aeDX5miMmO9TiVC150i6nO91iM1IBDWLUteanO91iM1GB1WK2oR5QcB1ggDXsT6OJg91jMYKxGKxLi4WUJ0e7WoI1UEPLGSK98i6pQ9btT6OJaQlrpjGyPPmuYtbnDjzB1xaZ_SELirsR1t4am7YRUWMRmQAjpbOl0s-uit0yMR0U9jbnPk1u_cmUUNe72tcYSQsVpG85-soUNwE9jcYJJQFqD4kcuVeQ98jscJp71sjid6I3lSm7CxAUPWEF-OKV8MDxw77SVdfmFyL6dXxXGRaNg9vkjTe_BvNPEyTJiJx6E3v_Ulj-_FZ1m00)
 
 ### Base Interfaces
 
@@ -667,21 +671,30 @@ The numeric interfaces build upon the base interfaces by defining the core abstr
 ```csharp
 namespace System
 {
-    public interface INumber<TSelf>
+    public interface INumberBase<TSelf>
         : IAdditionOperators<TSelf, TSelf, TSelf>,
           IAdditiveIdentity<TSelf, TSelf>,
-          IComparisonOperators<TSelf, TSelf>,   // implies IEqualityOperators<TSelf, TSelf>
+          IEqualityOperators<TSelf, TSelf>,     // implies IEquatable<TSelf>
+          IMultiplyOperators<TSelf, TSelf>,
+          ISubtractionOperators<TSelf, TSelf, TSelf>,
+          IUnaryPlusOperators<TSelf, TSelf>
+        where TSelf : INumberBase<TSelf>
+    {
+        // Alias for AdditiveIdentity
+        static abstract TSelf Zero { get; }
+    }
+
+    public interface INumber<TSelf>
+        : IComparisonOperators<TSelf, TSelf>,   // implies IEqualityOperators<TSelf, TSelf>
           IDecrementOperators<TSelf>,
           IDivisionOperators<TSelf, TSelf, TSelf>,
           IIncrementOperators<TSelf>,
           IModulusOperators<TSelf, TSelf, TSelf>,
           IMultiplicativeIdentity<TSelf, TSelf>,
-          IMultiplyOperators<TSelf, TSelf, TSelf>,
+          INumberBase<TSelf>,
           ISpanFormattable,                     // implies IFormattable
           ISpanParseable<TSelf>,                // implies IParseable<TSelf>
-          ISubtractionOperators<TSelf, TSelf, TSelf>,
-          IUnaryNegationOperators<TSelf, TSelf>,
-          IUnaryPlusOperators<TSelf, TSelf>
+          IUnaryNegationOperators<TSelf, TSelf>
         where TSelf : INumber<TSelf>
     {
         // For the Create methods, there is some concern over users implementing them. It is not necessarily trivial to take an arbitrary TOther
@@ -703,9 +716,6 @@ namespace System
         // Alias for MultiplicativeIdentity
         static abstract TSelf One { get; }
 
-        // Alias for AdditiveIdentity
-        static abstract TSelf Zero { get; }
-
         // Abs mirrors Math.Abs and returns the same type. This can fail for MinValue of signed integer types
         // Swift has an associated type that can be used here, which would require an additional type parameter in .NET
         // However that would hinder the reusability of these interfaces in constraints
@@ -737,20 +747,20 @@ namespace System
         static abstract bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider, out TSelf result);
     }
 
-    public interface ISignedNumber<TSelf>
-        : INumber<TSelf>
-        where TSelf : ISignedNumber<TSelf>
+    public interface ISignedNumberBase<TSelf>
+        : INumberBase<TSelf>
+        where TSelf : ISignedNumberBase<TSelf>
     {
-        // It's not possible to check for lack of an interface in a constraint, so ISignedNumber<TSelf> is likely required
+        // It's not possible to check for lack of an interface in a constraint, so ISignedNumberBase<TSelf> is likely required
 
         static abstract TSelf NegativeOne { get; }
     }
 
-    public interface IUnsignedNumber<TSelf>
-        : INumber<TSelf>
-        where TSelf : IUnsignedNumber<TSelf>
+    public interface IUnsignedNumberBase<TSelf>
+        : INumberBase<TSelf>
+        where TSelf : IUnsignedNumberBase<TSelf>
     {
-        // It's not possible to check for lack of an interface in a constraint, so IUnsignedNumber<TSelf> is likely required
+        // It's not possible to check for lack of an interface in a constraint, so IUnsignedNumberBase<TSelf> is likely required
     }
 
     public interface IBinaryNumber<TSelf>
@@ -790,7 +800,7 @@ namespace System
     }
 
     public interface IFloatingPoint<TSelf>
-        : ISignedNumber<TSelf>
+        : ISignedNumberBase<TSelf>
         where TSelf : IFloatingPoint<TSelf>
     {
         // This currently implies IEEE floating-point types and so decimal does not implement it
@@ -1219,7 +1229,7 @@ namespace System
         : IBinaryInteger<byte>,
           IConvertible,
           IMinMaxValue<byte>,
-          IUnsignedNumber<byte>
+          IUnsignedNumberBase<byte>
     {
     }
 
@@ -1227,7 +1237,7 @@ namespace System
         : IBinaryInteger<char>,
           IConvertible,
           IMinMaxValue<char>,
-          IUnsignedNumber<char>
+          IUnsignedNumberBase<char>
     {
     }
 
@@ -1273,7 +1283,7 @@ namespace System
           IDeserializationCallback,
           IMinMaxValue<decimal>,
           ISerializable,
-          ISignedNumber<decimal>
+          ISignedNumberBase<decimal>
     {
         // Decimal defines a few additional operations like Ceiling, Floor, Round, and Truncate
         // The rest of the IEEE operations are missing.
@@ -1313,7 +1323,7 @@ namespace System
         : IBinaryInteger<short>,
           IConvertible,
           IMinMaxValue<short>,
-          ISignedNumber<short>
+          ISignedNumberBase<short>
     {
     }
 
@@ -1321,7 +1331,7 @@ namespace System
         : IBinaryInteger<int>,
           IConvertible,
           IMinMaxValue<int>,
-          ISignedNumber<int>
+          ISignedNumberBase<int>
     {
     }
 
@@ -1329,7 +1339,7 @@ namespace System
         : IBinaryInteger<long>,
           IConvertible,
           IMinMaxValue<long>,
-          ISignedNumber<long>
+          ISignedNumberBase<long>
     {
     }
 
@@ -1337,7 +1347,7 @@ namespace System
         : IBinaryInteger<nint>,
           IMinMaxValue<nint>,
           ISerializable,
-          ISignedNumber<nint>
+          ISignedNumberBase<nint>
     {
     }
 
@@ -1345,7 +1355,7 @@ namespace System
         : IBinaryInteger<sbyte>,
           IConvertible,
           IMinMaxValue<sbyte>,
-          ISignedNumber<sbyte>
+          ISignedNumberBase<sbyte>
     {
     }
 
@@ -1384,7 +1394,7 @@ namespace System
         : IBinaryInteger<ushort>,
           IConvertible,
           IMinMaxValue<ushort>,
-          IUnsignedNumber<ushort>
+          IUnsignedNumberBase<ushort>
     {
     }
 
@@ -1392,7 +1402,7 @@ namespace System
         : IBinaryInteger<uint>,
           IConvertible,
           IMinMaxValue<uint>,
-          IUnsignedNumber<uint>
+          IUnsignedNumberBase<uint>
     {
     }
 
@@ -1400,7 +1410,7 @@ namespace System
         : IBinaryInteger<ulong>,
           IConvertible,
           IMinMaxValue<ulong>,
-          IUnsignedNumber<ulong>
+          IUnsignedNumberBase<ulong>
     {
     }
 
@@ -1408,7 +1418,7 @@ namespace System
         : IBinaryInteger<nuint>,
           IMinMaxValue<nuint>,
           ISerializable,
-          IUnsignedNumber<nuint>
+          IUnsignedNumberBase<nuint>
     {
     }
 }

From 4bd41de25f741a0cb3f12706b5fe4359b5d6dae4 Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Fri, 14 Jan 2022 14:43:15 -0800
Subject: [PATCH 02/16] Move DivRem down to IBinaryInteger

---
 accepted/2021/statics-in-interfaces/README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/accepted/2021/statics-in-interfaces/README.md b/accepted/2021/statics-in-interfaces/README.md
index 390a0fbd4..a08582d00 100644
--- a/accepted/2021/statics-in-interfaces/README.md
+++ b/accepted/2021/statics-in-interfaces/README.md
@@ -724,8 +724,6 @@ namespace System
 
         static abstract TSelf Clamp(TSelf value, TSelf min, TSelf max);
 
-        static abstract (TSelf Quotient, TSelf Remainder) DivRem(TSelf left, TSelf right);
-
         static abstract TSelf Max(TSelf x, TSelf y);
 
         static abstract TSelf Min(TSelf x, TSelf y);
@@ -788,6 +786,8 @@ namespace System
         // Returning int is currently what BitOperations does, however this can be cumbersome or prohibitive
         // in various algorithms where returning TSelf is better.
 
+        static abstract (TSelf Quotient, TSelf Remainder) DivRem(TSelf left, TSelf right);
+
         static abstract TSelf LeadingZeroCount(TSelf value);
 
         static abstract TSelf PopCount(TSelf value);

From caf5c28ba62dd3c619ac036601de956235d3c27a Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Fri, 14 Jan 2022 16:25:36 -0800
Subject: [PATCH 03/16] Splitting apart IFloatingPoint into IFloatingPoint and
 IFloatingPointIeee754 + a few I*Functions interfaces

---
 accepted/2021/statics-in-interfaces/README.md | 261 +++++++++++-------
 1 file changed, 157 insertions(+), 104 deletions(-)

diff --git a/accepted/2021/statics-in-interfaces/README.md b/accepted/2021/statics-in-interfaces/README.md
index a08582d00..b6f75c5b6 100644
--- a/accepted/2021/statics-in-interfaces/README.md
+++ b/accepted/2021/statics-in-interfaces/README.md
@@ -175,7 +175,7 @@ The overall design has been influenced by the existing .NET surface area, the Sw
 @startuml
 interface "IAdditionOperators<TSelf, TOther, TResult>"
 interface "IAdditiveIdentity<TSelf, TResult>"
-interface "IBinaryFloatingPoint<TSelf>"
+interface "IBinaryFloatingPointIeee754<TSelf>"
 interface "IBinaryInteger<TSelf>"
 interface "IBinaryNumber<TSelf>"
 interface "IBitwiseOperators<TSelf, TOther, TResult>"
@@ -188,9 +188,13 @@ interface "IDeserializationCallback"
 interface "IDivisionOperators<TSelf, TOther, TResult>"
 interface "IEqualityOperators<TSelf, TOther>"
 interface "IEquatable<T>"
+interface "IExponentialFunctions<TSelf>"
 interface "IFloatingPoint<TSelf>"
-interface "IIncrementOperators<TSelf>"
+interface "IFloatingPointIeee754<TSelf>"
 interface "IFormattable"
+interface "IHyperbolicFunctions<TSelf>"
+interface "IIncrementOperators<TSelf>"
+interface "ILogarithmicFunctions<TSelf>"
 interface "IMinMaxValue<TSelf>"
 interface "IModulusOperators<TSelf, TOther, TResult>"
 interface "IMultiplicativeIdentity<TSelf, TResult>"
@@ -198,19 +202,22 @@ interface "IMultiplyOperators<TSelf, TOther, TResult>"
 interface "INumber<TSelf>"
 interface "INumberBase<TSelf>"
 interface "IParseable<TSelf>"
+interface "IPowerFunctions<TSelf>"
+interface "IRootFunctions<TSelf>"
 interface "ISerializable"
 interface "IShiftOperators<TSelf, TOther, TResult>"
 interface "ISignedNumberBase<TSelf>"
 interface "ISpanFormattable"
 interface "ISpanParseable<TSelf>"
 interface "ISubtractionOperators<TSelf, TOther, TResult>"
+interface "ITrigonometricFunctions<TSelf>"
 interface "IUnsignedNumberBase<TSelf>"
 interface "IUnaryNegationOperators<TSelf, TResult>"
 interface "IUnaryPlusOperators<TSelf, TResult>"
 interface "IVector<TSelf, TScalar>"
 
-"IBinaryNumber<TSelf>"                          <|-- "IBinaryFloatingPoint<TSelf>"
-"IFloatingPoint<TSelf>"                         <|-- "IBinaryFloatingPoint<TSelf>"
+"IBinaryNumber<TSelf>"                          <|-- "IBinaryFloatingPointIeee754<TSelf>"
+"IFloatingPointIeee754<TSelf>"                  <|-- "IBinaryFloatingPointIeee754<TSelf>"
 
 "IBinaryNumber<TSelf>"                          <|-- "IBinaryInteger<TSelf>"
 "IShiftOperators<TSelf, TOther, TResult>"       <|-- "IBinaryInteger<TSelf>"
@@ -226,6 +233,14 @@ interface "IVector<TSelf, TScalar>"
 
 "ISignedNumberBase<TSelf>"                      <|-- "IFloatingPoint<TSelf>"
 
+"IExponentialFunctions<TSelf>"                  <|-- "IFloatingPointIeee754<TSelf>"
+"IHyperbolicFunctions<TSelf>"                   <|-- "IFloatingPointIeee754<TSelf>"
+"ILogarithmicFunctions<TSelf>"                  <|-- "IFloatingPointIeee754<TSelf>"
+"IFloatingPoint<TSelf>"                         <|-- "IFloatingPointIeee754<TSelf>"
+"IPowerFunctions<TSelf>"                        <|-- "IFloatingPointIeee754<TSelf>"
+"IRootFunctions<TSelf>"                         <|-- "IFloatingPointIeee754<TSelf>"
+"ITrigonometricFunctions<TSelf>"                <|-- "IFloatingPointIeee754<TSelf>"
+
 "IComparisonOperators<TSelf, TOther>"           <|-- "INumber<TSelf>"
 "IDecrementOperators<TSelf>"                    <|-- "INumber<TSelf>"
 "IDivisionOperators<TSelf, TOther, TResult>"    <|-- "INumber<TSelf>"
@@ -344,7 +359,7 @@ class "Vector4"
 "ISignedNumberBase<TSelf>"                      <|-- "Decimal"
 "ValueType"                                     <|-- "Decimal"
 
-"IBinaryFloatingPoint<TSelf>"                   <|-- "Double"
+"IBinaryFloatingPointIeee754<TSelf>"            <|-- "Double"
 "IConvertible"                                  <|-- "Double"
 "IMinMaxValue<TSelf>"                           <|-- "Double"
 "ValueType"                                     <|-- "Double"
@@ -359,7 +374,7 @@ class "Vector4"
 "ISpanParseable<TSelf>"                         <|-- "Guid"
 "ValueType"                                     <|-- "Guid"
 
-"IBinaryFloatingPoint<TSelf>"                   <|-- "Half"
+"IBinaryFloatingPointIeee754<TSelf>"            <|-- "Half"
 "IMinMaxValue<TSelf>"                           <|-- "Half"
 "ValueType"                                     <|-- "Half"
 
@@ -393,7 +408,7 @@ class "Vector4"
 "ISignedNumberBase<TSelf>"                      <|-- "SByte"
 "ValueType"                                     <|-- "SByte"
 
-"IBinaryFloatingPoint<TSelf>"                   <|-- "Single"
+"IBinaryFloatingPointIeee754<TSelf>"            <|-- "Single"
 "IConvertible"                                  <|-- "Single"
 "IMinMaxValue<TSelf>"                           <|-- "Single"
 "ValueType"                                     <|-- "Single"
@@ -455,7 +470,7 @@ class "Vector4"
 @enduml
 -->
 
-![UML](http://www.plantuml.com/plantuml/svg/h9ZDSjCm4CVlVefCplJG3p8SEXteHy67a0nEUbyxcrGWoq5Q5ypmyBXbwZIoDf8ruSBiUlSdhRJTlzgFXa1JNSf4A4AzXW97u_JJQYL8L6gsHGrKQNEvo52ktuqMCtf4tVx_3KqjwMhiI7l2T8MA13LTbZFwMYZGpRsiW8JQp2kXw7-2CovjFHlK1oA-rcNE1j0lON1WEJTLkGKDkKJEVxbmfWZ37bqlNZsX9j5RunOBZIKgiZXNTfX1BK2AF_1yNpSWPGx53oj8F0ap_3RlVjOjc1ecpH5DpZFntt2gWegzhtG9HFqBcGerXTyF86jq9awhLIrhCx3-QUiIMoaAO7gQpsa6BiMrRlVf6eoxj3beWv1BzzVijJbwHvOzYZKDt6KcDWfNdWrbMr2kY-e-UdPSvwIXY1W-IsL2zhTy6HMu0VSIFNINCvUr2On_mA8DwcAo0YJeDYPnZweH--_oxyc9Pr8oFr_noEXjCeCwkDT2OCc0MMxJx7fQLcY18oyhsPCBZc310WN3LfnZelrJFXQTM9eGUY9-sKduKNIGp7PxG3bzMg-PUCdkKWCeuM9zY9Ag8-mbN3SFK89rrBENmBlsK6nruWayXP6nWPHW9Jf8IOQyrIsC9PBUvxjL8aEA7IeCAVn1vICDUbaS80Kz1uAgY-jgQ_XPGBwvUM3_pPOu7fQX83inlaxcHHVVzypBBBxvULpKAuN7HIaKZukIAXuNfLayBbL7tLsKYl6uA3dpufeZdLsKm36uYA79us8bZySbXGHZHkFhXd3yQjmyWkwCMo2SATdiEHQYn9vZjbuRf9qR2r62tDbLdSjTrfsgoyxuN8jLPtm1kUwCLD7fvArrVlRMcboyjUQaEtEMVyU2EZFRgp0JQYDtvlFkdo-zSoptbrtkhxlSNtXfhVpoDvH5iztnNq__ol9CBlg-qxCFVUVP-ud3QTddbjtkC65-1_GqyxzIxHWdOnW8ed2Vun14pHqGDu0EwBW_XMKz2H5YVUvvctZ-mHxlPcXLPstz88pzev-qp5uVMhTiulS7Iyz5iSP_2uWL2s9D5iIA1R5YwJnjDx55n-is7Iyta7WJBvxJLxklnAru3KJnvlXuCq3yhyuiF5yD54y6YeTW42y6ZDyoOAVzhWshucQiolKi9tBbNToOLN5xLcNNf5LngrR53LkLFTjMXNQVCgau9Pmi4cxU29VMRRZz0k75fFkPINpn7twuQ10-MbOUZUE9ST61PST2HoeMbZnPotZZCWSxLopiLx6muCcQjSU55QmP2oyTIzUMUR46NmR3aeDX5miMmO9TiVC150i6nO91iM1IBDWLUteanO91iM1GB1WK2oR5QcB1ggDXsT6OJg91jMYKxGKxLi4WUJ0e7WoI1UEPLGSK98i6pQ9btT6OJaQlrpjGyPPmuYtbnDjzB1xaZ_SELirsR1t4am7YRUWMRmQAjpbOl0s-uit0yMR0U9jbnPk1u_cmUUNe72tcYSQsVpG85-soUNwE9jcYJJQFqD4kcuVeQ98jscJp71sjid6I3lSm7CxAUPWEF-OKV8MDxw77SVdfmFyL6dXxXGRaNg9vkjTe_BvNPEyTJiJx6E3v_Ulj-_FZ1m00)
+![UML](http://www.plantuml.com/plantuml/svg/h9ZDKjim4CVlVefCpkN01saF3DFoGSbCQJ8uuRvsDebQMKhbDU1E7xw63WwHb8sib0kpwzLFkxAi_ogVIm93LI4JeGZD77BizOTVPZD1GglH2WsGDkNP94Kv_z2RZ6Y9flb_ZsKbwRpl6VQ8mnag4bItexpH5qA1gM-a1X9gCTP2qH0HFvwU_1ld3HysdWKQ9k9xLMHR0-X9bDYngajThC109d6R_spY7IBAhIlenAj7D2ISEQumDrYW8ejpReULQ0H8yHj8Q7K9KcQG_xI2nACekx_KwrzL0wQQgSIA9k-QN3-lj4950kHDfVANFFt5REm89Y9WpzneKm2H--vkwwQQJ4kHyxaCLT3wVzCBC8AMnIxUdL1tyFm0iaB_SpshP5LsV4LtZKkifCZ1y_NnO-gEKrbVb_le0af_QMCm9K8cjppLJsZujRlNclY8zEqZSDvtkXHpwbXgAXOAPpkgIbUWVBkiVSYNdLOP6SWZpjg94GkjT85aTcswgIf3Ifc-dfwu06ysRXRjcB6ioi3u1yoRe3OcpK62QM8I_-dTs_ftzkVW84n3-ECYdXoVj5_9WZTf22pf87OEpQgdOOKMsDl9IZRqbEUqi415jINvFw83P30MdLYY6RWY0RgSR3_3MB9VW1DUmbaQyt4oIjoBPN9o7CUq7ZkmEAPVzFPZkYgvVvwyriGmaw1lmuKw9vFJ83CrCvJWrfYZ3DN-kNHe0NbAM4ku8vVGWuEZk3qIns0fRZFLcHBOvB2KfCi5sS9O_LV0dRajYI75A1H32hyRyAIE_IrB2kWqWwgBszMMabf0PdCpGFlca7ZkIA4WPs1qdSnb8MhVCqr_nEPdS34jBuEBK2W65o5L32v6inXSZ7Wnk1WLOt2nSXQ0g_TVkoY1Ot0HXoQ3YvGy1fVa4igorx-e2VjlnkKIJ6jS0U58oNh3CH45EexHV5uYhTsOYmBasjPL9h4rhrLLjCRNIinQunRal3M6YWu7xwtZe_VMuEIzDIRJcgFi1-RKckb6XQbG2xasNx9_UUcjOxevxNHptkdcn5DhvjUV0oVrQir_M_rpopCuSNs7HvzSvz7fmEEqx6FBRZ9Ct1yKGlgilwNQCKu4CH14qTp7OH4nTq3S038Wu_u4blK5Oi1wplazuzh2BdVFrAe-zkv16FjhQtIRlJwq_cKJlp_OUYwADVzRGAnO42iMn8e5iHPBvscxYIqwNhVfUBc1n9juyPY-scmjRiLR88etnyUx0UA_pGVW-M2WU39Gl0M3U3LW_941E-tTXbKvDMDLhYQdaJlluiQiYjkpAgSchOfRjIfksAgSsROgjFkKISKfuMIHSFD6kCm1ml4N21yxmxIVVF4VVhXe43vQLXwDiwvvqO5bnq97Qh6mv5ZBUFCo1pjNBEnNYuK5nvgrvuKLh1aBBnrBrvPriGPV1iEIWs4N2nR1Wbsnsnqe5WoA1ODYmQHOi2lsS4-A1ODYmQ1OC2WMJ8hLn89LHyEoep6TH8DgqIZR4tQiWa7oO50y62GBnZEh3YX85WsQHSkwep6Tp5wlTw3YBU74Myg9j_jOFCWVxnsicktOEeWd0yJRq2tU31HlSx1u6tp5cu7ZpO3nDikADmF7ys7ppD4vMimJZMt_Q10kscNp_1nDiaMRR1wXerqs3z7H95kqoUOvEbfbuoGTxc4ud9NpC1q-rXHyXutleMDSVZhmTuK6tbwX0RcNQ9xkDHg_dnKvUuSRudqCyFZwyVBv_lO5)
 
 ### Base Interfaces
 
@@ -799,90 +814,129 @@ namespace System
         static abstract TSelf TrailingZeroCount(TSelf value);
     }
 
-    public interface IFloatingPoint<TSelf>
-        : ISignedNumberBase<TSelf>
-        where TSelf : IFloatingPoint<TSelf>
+    public interface IExponentialFunctions<TSelf>
+        where TSelf : IExponentialFunctions<TSelf>
     {
-        // This currently implies IEEE floating-point types and so decimal does not implement it
-        // If we want decimal to implement it, we would need to move several methods down and define
-        // some IeeeFloatingPoint interface instead. This wasn't done for simplicity and because decimal
-        // is not an industry standard type.
+        static abstract TSelf Exp(TSelf x);
 
-        // TODO: The Exponent and Signifcand need to be exposed here
-        // They should return INumber<TSelf> here and IBinaryNumber<TSelf> on IBinaryFloatingPoint<TSelf>
+        // IEEE defines n to be an integral type, but not the size
 
-        // TODO: We may want to expose constants related to the subnormal and finite boundaries
+        static abstract TSelf ScaleB<TInteger>(TSelf x, TInteger n)
+            where TInteger : IBinaryInteger<TInteger>;
 
-        // The following constants are defined by System.Math and System.MathF today
+        // The following methods are approved but not yet implemented in the libraries
 
-        static abstract TSelf E { get; }
+        static abstract TSelf ExpM1(TSelf x);
 
-        static abstract TSelf PI { get; }
+        static abstract TSelf Exp2(TSelf x);
 
-        static abstract TSelf Tau { get; }
+        static abstract TSelf Exp2M1(TSelf x);
 
-        // The following methods are defined by System.Math and System.MathF today
-        // Exposing them on the interfaces means they will become available as statics on the primitive types
-        // This, in a way, obsoletes Math/MathF and brings float/double inline with how non-primitive types support similar functionality
-        // API review will need to determine if we'll want to continue adding APIs to Math/MathF in the future
+        static abstract TSelf Exp10(TSelf x);
 
-        static abstract TSelf Acos(TSelf x);
+        static abstract TSelf Exp10M1(TSelf x);
+    }
 
+    public interface IHyperbolicFunctions<TSelf>
+        where TSelf : IHyperbolicFunctions<TSelf>
+    {
         static abstract TSelf Acosh(TSelf x);
 
-        static abstract TSelf Asin(TSelf x);
-
         static abstract TSelf Asinh(TSelf x);
 
-        static abstract TSelf Atan(TSelf x);
+        static abstract TSelf Atanh(TSelf x);
 
-        static abstract TSelf Atan2(TSelf y, TSelf x);
+        static abstract TSelf Cosh(TSelf x);
 
-        static abstract TSelf Atanh(TSelf x);
+        static abstract TSelf Sinh(TSelf x);
 
-        static abstract TSelf BitIncrement(TSelf x);
+        static abstract TSelf Tanh(TSelf x);
+    }
 
-        static abstract TSelf BitDecrement(TSelf x);
+    public interface ILogarithmicFunctions<TSelf>
+        where TSelf : ILogarithmicFunctions<TSelf>
+    {
+        // IEEE defines the result to be an integral type, but not the size
+
+        static abstract TInteger ILogB<TInteger>(TSelf x)
+            where TInteger : IBinaryInteger<TInteger>;
+
+        static abstract TSelf Log(TSelf x);
+
+        static abstract TSelf Log(TSelf x, TSelf newBase);
+
+        static abstract TSelf Log2(TSelf x);
+
+        static abstract TSelf Log10(TSelf x);
+
+        // The following methods are approved but not yet implemented in the libraries
+
+        static abstract TSelf LogP1(TSelf x);
+
+        static abstract TSelf Log2P1(TSelf x);
+
+        static abstract TSelf Log10P1(TSelf x);
+    }
+
+    public interface IPowerFunctions<TSelf>
+        where TSelf : IPowerFunctions<TSelf>
+    {
+        static abstract TSelf Pow(TSelf x, TSelf y);
+    }
 
+    public interface IRootFunctions<TSelf>
+        where TSelf : IRootFunctions<TSelf>
+    {
         static abstract TSelf Cbrt(TSelf x);
 
-        static abstract TSelf Ceiling(TSelf x);
+        static abstract TSelf Sqrt(TSelf x);
 
-        // CopySign is likely more general purpose and may apply to any signed number type
-        // It may even be applicable to unsigned numbers where it simply returns x, for convenience
+        // The following methods are approved but not yet implemented in the libraries
 
-        static abstract TSelf CopySign(TSelf x, TSelf y);
+        static abstract TSelf Root(TSelf x, TSelf n);
+    }
 
-        static abstract TSelf Cos(TSelf x);
+    public interface ITrigonometricFunctions<TSelf>
+        where TSelf : ITrigonometricFunctions<TSelf>
+    {
+        static abstract TSelf Acos(TSelf x);
 
-        static abstract TSelf Cosh(TSelf x);
+        static abstract TSelf Asin(TSelf x);
 
-        static abstract TSelf Exp(TSelf x);
+        static abstract TSelf Atan(TSelf x);
 
-        static abstract TSelf Floor(TSelf x);
+        static abstract TSelf Atan2(TSelf y, TSelf x);
 
-        static abstract TSelf FusedMultiplyAdd(TSelf x, TSelf y, TSelf z);
+        static abstract TSelf Cos(TSelf x);
 
-        static abstract TSelf IEEERemainder(TSelf x, TSelf y);
+        static abstract TSelf Sin(TSelf x);
 
-        // IEEE defines the result to be an integral type, but not the size
+        static abstract TSelf Tan(TSelf x);
 
-        static abstract TInteger ILogB<TInteger>(TSelf x)
-            where TInteger : IBinaryInteger<TInteger>;
+        // The following methods are approved but not yet implemented in the libraries
 
-        static abstract TSelf Log(TSelf x);
+        static abstract TSelf AcosPi(TSelf x);
 
-        static abstract TSelf Log(TSelf x, TSelf newBase);
+        static abstract TSelf AsinPi(TSelf x);
 
-        static abstract TSelf Log2(TSelf x);
+        static abstract TSelf AtanPi(TSelf x);
 
-        static abstract TSelf Log10(TSelf x);
+        static abstract TSelf Atan2Pi(TSelf y, TSelf x);
 
-        static abstract TSelf MaxMagnitude(TSelf x, TSelf y);
+        static abstract TSelf CosPi(TSelf x);
 
-        static abstract TSelf MinMagnitude(TSelf x, TSelf y);
+        static abstract TSelf SinPi(TSelf x);
 
-        static abstract TSelf Pow(TSelf x, TSelf y);
+        static abstract TSelf TanPi(TSelf x);
+    }
+
+    public interface IFloatingPoint<TSelf>
+        : ISignedNumberBase<TSelf>
+        where TSelf : IFloatingPoint<TSelf>
+    {
+        static abstract TSelf Ceiling(TSelf x);
+
+        static abstract TSelf Floor(TSelf x);
 
         static abstract TSelf Round(TSelf x);
 
@@ -894,22 +948,53 @@ namespace System
         static abstract TSelf Round<TInteger>(TSelf x, TInteger digits, MidpointRounding mode)
             where TInteger : IBinaryInteger<TInteger>;
 
-        // IEEE defines n to be an integral type, but not the size
+        static abstract TSelf Truncate(TSelf x);
+    }
 
-        static abstract TSelf ScaleB<TInteger>(TSelf x, TInteger n)
-            where TInteger : IBinaryInteger<TInteger>;
+    public interface IFloatingPointIeee754<TSelf>
+        : IExponentialFunctions<TSelf>,
+          IFloatingPoint<TSelf>,
+          IHyperbolicFunctions<TSelf>,
+          ILogarithmicFunctions<TSelf>,
+          IPowerFunctions<TSelf>,
+          IRootFunctions<TSelf>,
+          ITrigonometricFunctions<TSelf>
+        where TSelf : IFloatingPointIeee754<TSelf>
+    {
+        // TODO: The Exponent and Signifcand need to be exposed here
+        // They should return INumber<TSelf> here and IBinaryNumber<TSelf> on IBinaryFloatingPointIeee754<TSelf>
 
-        static abstract TSelf Sin(TSelf x);
+        // TODO: We may want to expose constants related to the subnormal and finite boundaries
 
-        static abstract TSelf Sinh(TSelf x);
+        // The following constants are defined by System.Math and System.MathF today
 
-        static abstract TSelf Sqrt(TSelf x);
+        static abstract TSelf E { get; }
 
-        static abstract TSelf Tan(TSelf x);
+        static abstract TSelf PI { get; }
 
-        static abstract TSelf Tanh(TSelf x);
+        static abstract TSelf Tau { get; }
 
-        static abstract TSelf Truncate(TSelf x);
+        // The following methods are defined by System.Math and System.MathF today
+        // Exposing them on the interfaces means they will become available as statics on the primitive types
+        // This, in a way, obsoletes Math/MathF and brings float/double inline with how non-primitive types support similar functionality
+        // API review will need to determine if we'll want to continue adding APIs to Math/MathF in the future
+
+        static abstract TSelf BitIncrement(TSelf x);
+
+        static abstract TSelf BitDecrement(TSelf x);
+
+        // CopySign is likely more general purpose and may apply to any signed number type
+        // It may even be applicable to unsigned numbers where it simply returns x, for convenience
+
+        static abstract TSelf CopySign(TSelf x, TSelf y);
+
+        static abstract TSelf FusedMultiplyAdd(TSelf x, TSelf y, TSelf z);
+
+        static abstract TSelf IEEERemainder(TSelf x, TSelf y);
+
+        static abstract TSelf MaxMagnitude(TSelf x, TSelf y);
+
+        static abstract TSelf MinMagnitude(TSelf x, TSelf y);
 
         // The following members are exposed on the floating-point types as constants today
         // This may be of concern when implementing the interface
@@ -944,36 +1029,10 @@ namespace System
 
         // The following methods are approved but not yet implemented in the libraries
 
-        static abstract TSelf AcosPi(TSelf x);
-
-        static abstract TSelf AsinPi(TSelf x);
-
-        static abstract TSelf AtanPi(TSelf x);
-
-        static abstract TSelf Atan2Pi(TSelf y, TSelf x);
-
         static abstract TSelf Compound(TSelf x, TSelf n);
 
-        static abstract TSelf CosPi(TSelf x);
-
-        static abstract TSelf ExpM1(TSelf x);
-
-        static abstract TSelf Exp2(TSelf x);
-
-        static abstract TSelf Exp2M1(TSelf x);
-
-        static abstract TSelf Exp10(TSelf x);
-
-        static abstract TSelf Exp10M1(TSelf x);
-
         static abstract TSelf Hypot(TSelf x, TSelf y);
 
-        static abstract TSelf LogP1(TSelf x);
-
-        static abstract TSelf Log2P1(TSelf x);
-
-        static abstract TSelf Log10P1(TSelf x);
-
         static abstract TSelf MaxMagnitudeNumber(TSelf x, TSelf y);
 
         static abstract TSelf MaxNumber(TSelf x, TSelf y);
@@ -982,12 +1041,6 @@ namespace System
 
         static abstract TSelf MinNumber(TSelf x, TSelf y);
 
-        static abstract TSelf Root(TSelf x, TSelf n);
-
-        static abstract TSelf SinPi(TSelf x);
-
-        static abstract TSelf TanPi(TSelf x);
-
         // The majority of the IEEE required operations are listed below
         // This doesn't include the recommended operations such as sin, cos, acos, etc
 
@@ -1120,16 +1173,16 @@ namespace System
         //  TSelf SetPayloadSignaling(TSelf x);
     }
 
-    public interface IBinaryFloatingPoint<TSelf>
+    public interface IBinaryFloatingPointIeee754<TSelf>
         : IBinaryNumber<TSelf>,
-          IFloatingPoint<TSelf>
-        where TSelf : IBinaryFloatingPoint<TSelf>
+          IFloatingPointIeee754<TSelf>
+        where TSelf : IBinaryFloatingPointIeee754<TSelf>
     {
     }
 
-    public interface IDecimalFloatingPoint<TSelf>
-        : IFloatingPoint<TSelf>
-        where TSelf : IDecimalFloatingPoint<TSelf>
+    public interface IDecimalFloatingPointIeee754<TSelf>
+        : IFloatingPointIeee754<TSelf>
+        where TSelf : IDecimalFloatingPointIeee754<TSelf>
     {
         // This interface is defined for convenience of viewing the IEEE requirements
         // it would not actually be defined until the .NET libraries requires it
@@ -1292,7 +1345,7 @@ namespace System
     }
 
     public struct Double
-        : IBinaryFloatingPoint<double>,
+        : IBinaryFloatingPointIeee754<double>,
           IConvertible,
           IMinMaxValue<double>
     {
@@ -1314,7 +1367,7 @@ namespace System
     }
 
     public struct Half
-        : IBinaryFloatingPoint<Half>,
+        : IBinaryFloatingPointIeee754<Half>,
           IMinMaxValue<Half>
     {
     }
@@ -1360,7 +1413,7 @@ namespace System
     }
 
     public struct Single
-        : IBinaryFloatingPoint<float>,
+        : IBinaryFloatingPointIeee754<float>,
           IConvertible,
           IMinMaxValue<float>
     {

From da4d53962a10aa77af089258bd5330d62f11fb0f Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Fri, 14 Jan 2022 16:29:38 -0800
Subject: [PATCH 04/16] Ensure decimal is properly updated to implement
 IFloatingPoint

---
 accepted/2021/statics-in-interfaces/README.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/accepted/2021/statics-in-interfaces/README.md b/accepted/2021/statics-in-interfaces/README.md
index b6f75c5b6..f0a19b0ae 100644
--- a/accepted/2021/statics-in-interfaces/README.md
+++ b/accepted/2021/statics-in-interfaces/README.md
@@ -354,9 +354,9 @@ class "Vector4"
 
 "IConvertible"                                  <|-- "Decimal"
 "IDeserializationCallback"                      <|-- "Decimal"
+"IFloatingPoint<TSelf>"                         <|-- "Decimal"
 "IMinMaxValue<TSelf>"                           <|-- "Decimal"
 "ISerializable"                                 <|-- "Decimal"
-"ISignedNumberBase<TSelf>"                      <|-- "Decimal"
 "ValueType"                                     <|-- "Decimal"
 
 "IBinaryFloatingPointIeee754<TSelf>"            <|-- "Double"
@@ -470,7 +470,7 @@ class "Vector4"
 @enduml
 -->
 
-![UML](http://www.plantuml.com/plantuml/svg/h9ZDKjim4CVlVefCpkN01saF3DFoGSbCQJ8uuRvsDebQMKhbDU1E7xw63WwHb8sib0kpwzLFkxAi_ogVIm93LI4JeGZD77BizOTVPZD1GglH2WsGDkNP94Kv_z2RZ6Y9flb_ZsKbwRpl6VQ8mnag4bItexpH5qA1gM-a1X9gCTP2qH0HFvwU_1ld3HysdWKQ9k9xLMHR0-X9bDYngajThC109d6R_spY7IBAhIlenAj7D2ISEQumDrYW8ejpReULQ0H8yHj8Q7K9KcQG_xI2nACekx_KwrzL0wQQgSIA9k-QN3-lj4950kHDfVANFFt5REm89Y9WpzneKm2H--vkwwQQJ4kHyxaCLT3wVzCBC8AMnIxUdL1tyFm0iaB_SpshP5LsV4LtZKkifCZ1y_NnO-gEKrbVb_le0af_QMCm9K8cjppLJsZujRlNclY8zEqZSDvtkXHpwbXgAXOAPpkgIbUWVBkiVSYNdLOP6SWZpjg94GkjT85aTcswgIf3Ifc-dfwu06ysRXRjcB6ioi3u1yoRe3OcpK62QM8I_-dTs_ftzkVW84n3-ECYdXoVj5_9WZTf22pf87OEpQgdOOKMsDl9IZRqbEUqi415jINvFw83P30MdLYY6RWY0RgSR3_3MB9VW1DUmbaQyt4oIjoBPN9o7CUq7ZkmEAPVzFPZkYgvVvwyriGmaw1lmuKw9vFJ83CrCvJWrfYZ3DN-kNHe0NbAM4ku8vVGWuEZk3qIns0fRZFLcHBOvB2KfCi5sS9O_LV0dRajYI75A1H32hyRyAIE_IrB2kWqWwgBszMMabf0PdCpGFlca7ZkIA4WPs1qdSnb8MhVCqr_nEPdS34jBuEBK2W65o5L32v6inXSZ7Wnk1WLOt2nSXQ0g_TVkoY1Ot0HXoQ3YvGy1fVa4igorx-e2VjlnkKIJ6jS0U58oNh3CH45EexHV5uYhTsOYmBasjPL9h4rhrLLjCRNIinQunRal3M6YWu7xwtZe_VMuEIzDIRJcgFi1-RKckb6XQbG2xasNx9_UUcjOxevxNHptkdcn5DhvjUV0oVrQir_M_rpopCuSNs7HvzSvz7fmEEqx6FBRZ9Ct1yKGlgilwNQCKu4CH14qTp7OH4nTq3S038Wu_u4blK5Oi1wplazuzh2BdVFrAe-zkv16FjhQtIRlJwq_cKJlp_OUYwADVzRGAnO42iMn8e5iHPBvscxYIqwNhVfUBc1n9juyPY-scmjRiLR88etnyUx0UA_pGVW-M2WU39Gl0M3U3LW_941E-tTXbKvDMDLhYQdaJlluiQiYjkpAgSchOfRjIfksAgSsROgjFkKISKfuMIHSFD6kCm1ml4N21yxmxIVVF4VVhXe43vQLXwDiwvvqO5bnq97Qh6mv5ZBUFCo1pjNBEnNYuK5nvgrvuKLh1aBBnrBrvPriGPV1iEIWs4N2nR1Wbsnsnqe5WoA1ODYmQHOi2lsS4-A1ODYmQ1OC2WMJ8hLn89LHyEoep6TH8DgqIZR4tQiWa7oO50y62GBnZEh3YX85WsQHSkwep6Tp5wlTw3YBU74Myg9j_jOFCWVxnsicktOEeWd0yJRq2tU31HlSx1u6tp5cu7ZpO3nDikADmF7ys7ppD4vMimJZMt_Q10kscNp_1nDiaMRR1wXerqs3z7H95kqoUOvEbfbuoGTxc4ud9NpC1q-rXHyXutleMDSVZhmTuK6tbwX0RcNQ9xkDHg_dnKvUuSRudqCyFZwyVBv_lO5)
+![UML](http://www.plantuml.com/plantuml/svg/h9ZFKziw4CVl_YioEJyEGCXx1uPvvGSbCwN9u8JxsjaaQcKfbTQ0E_tZ6-ZWO5dPo4gvCBjUVQJL3trN-TyI62eBcGX5Q1QGOwy_-ZIV2n9QZTTeWBInvzCKvUAVtdHCApIR_mzeIqaNVK-p9npDKP6WgcxbZRuK2anrApMGKCk95ef6YFZlsU1FEs_uI14kqJ0HNyiYsnb0py9YnwokTB460vd4NVxpgRU9i3jdi1Mldj2GQFLnZRd10XKvd0itpA8H8CLF8A7L5KYPGVxT2H9FmdPVr9iV9KX15PE94qtUERbvMMk5YWJ8srBbh-Fq9zFO4Kn4m9wvrQO0elRQtLLhD9cM8kV7Cb91y_z5By48MXNxUFT2tSFB8yWI_T_rl9IbxRX4znkNM4kH0t_wF6sgZbsrJvVpwHAiFxK968kGoHrVzJCQVkuUj2O-8dq_1AtrJbTYGHrJJSLIuNnFLkaQb6-NrH_vjDCo8mDvn5qxDMAfbIwGpBvDDrCs99NPs-s9I_2EfXv5kyr4bZOm_X5pqgQEINEGO3OnYV_sxktyE_zrT1Ic8Vnr4K-E7xHVoO8tQGWiwI1sBitDPyCAJR2tbvKqz9JdrB10HNKb-I-Y0sGm5fqueXau8m6wdEo-mrYoNu0JNi8P6dE4M2NknJ5vEOvZEfzTM2JJBtg7CTigUVWuUQs9OIP1PwCDTMuJha1kvSfHWajZZZ9IXu-bGmd8Ky9AmZrZ2RquU8fJ8t4Cdj8kfZfJ0eiSbf9qUI0x6AV-2dWproanf0Y5uaZXRmEUrB6-PKa1bMPGTd6xsb5I1yXiRWRelXmIpnif5EGsZCoJVon4xNkcw8_O_0mkekJbS14AnU0Yf8h1HMWMXuiGBmuNeM8SBbRE0d3LuNCN8N0SBkBIv70naiVZabo2jRt-PKNOVpUkLc1gune8nqfM3STK5DXoZ1SBYxHrOouAa5jRbvdSjhfHPL4Rdqinhuqxa8lQ62aw7dwqJay-MiF1Hsj2fZR7sJVCgJRJHeQfK4kvDLz7_xhejMFMx7RMx7VMx7ZczFpsS-2qMc_vxxD_uNY6WxRl-EI_jlFaREXnElQfOmz-bse7DxN3G1X6zsc7FQ87H0Um0tRqpm8T1Inoh_LD0SSl_j-GZCVt76aOA6prMQhXpnpx95lstz7ejht-QDsrmjzvuCMciForjB3O4XORmc93M6pyddgRr4tpzJNDrnC8NyFZS_VbPLlRBRusH7ojUBuN0B_S3uH_lnGGNmk8huq1NmkG7nQWh_si3AqoBKQhNDwSddJhMNfXMgMNvxfABrAhz59TL-a5QvLfsLgbldtqfAbIy3e_nck5uQcqyFm_W1yxbschr_xdpmOTagFhpkbqr-MW4xRDXeaKcxRCjXxFOIwykTZmlcBRXjbKsWwieJJPyD1iFROuM8UwXEkMuNIR2PV0u9QOuKDC34w9mIKnk2G6jyGCQ69YS4eCBed19J4u9cQK57TDXstJhRsWMsfqZkqvJwpW53cS4eTJP73yPfc0fiZedXaTzat7xkHdrjidK7oVGF6ro-7hUOoFyVDzWcNONaS7V1qQyFNIZUy5nBTxCBvUVF6zWFbUW7ovo-9h0VFvO_CIMsUwzyvq6_lJCJYwnzRxPph6HlVOUWjDzzXw4qstsEWUM--ZwHvRxwJntWpZCJayHuSVRi6tCF_x0lku_Ed0pHMOnzaABiZx4kxJPskuVfyjCdk6Xypz6E3fxVFrw-Fz6m00)
 
 ### Base Interfaces
 
@@ -1334,9 +1334,9 @@ namespace System
     public struct Decimal
         : IConvertible,
           IDeserializationCallback,
+          IFloatingPoint<decimal>,
           IMinMaxValue<decimal>,
-          ISerializable,
-          ISignedNumberBase<decimal>
+          ISerializable
     {
         // Decimal defines a few additional operations like Ceiling, Floor, Round, and Truncate
         // The rest of the IEEE operations are missing.

From b361044ad711b02db609af4b66bbe64eaa8f5416 Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Sun, 27 Mar 2022 08:50:31 -0700
Subject: [PATCH 05/16] Adding System.Numerics.BigInteger

---
 accepted/2021/statics-in-interfaces/README.md | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/accepted/2021/statics-in-interfaces/README.md b/accepted/2021/statics-in-interfaces/README.md
index f0a19b0ae..79066cdf4 100644
--- a/accepted/2021/statics-in-interfaces/README.md
+++ b/accepted/2021/statics-in-interfaces/README.md
@@ -1478,6 +1478,15 @@ namespace System
 
 namespace System.Numerics
 {
+    public struct BigInteger
+        : IBinaryInteger<BigInteger>,
+          IMinMaxValue<BigInteger>,
+          ISignedNumberBase<BigInteger>,
+          ISpanFormattable,
+          ISpanParseable<BigInteger>
+    {
+    }
+
     public struct Vector<T> : IVector<Vector<T>, T>
     {
     }
@@ -1520,7 +1529,6 @@ There are several types which may benefit from some interface support. These inc
 * System.Range
 * System.Tuple
 * System.ValueTuple
-* System.Numerics.BigInteger
 * System.Numerics.Complex
 * System.Numerics.Matrix3x2
 * System.Numerics.Matrix4x4

From af34c4c2cb31db3eb36effd03c59cba5fac1899c Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Sun, 27 Mar 2022 08:53:00 -0700
Subject: [PATCH 06/16] Remove `checked operators` that aren't going to be
 supported by the language

---
 accepted/2021/statics-in-interfaces/README.md | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/accepted/2021/statics-in-interfaces/README.md b/accepted/2021/statics-in-interfaces/README.md
index 79066cdf4..3fae382f8 100644
--- a/accepted/2021/statics-in-interfaces/README.md
+++ b/accepted/2021/statics-in-interfaces/README.md
@@ -624,8 +624,6 @@ namespace System
         // Likewise the name IModulusOperators doesn't fit with the other names, so a better one is needed
 
         static abstract TResult operator %(TSelf left, TOther right);
-
-        static abstract TResult checked operator %(TSelf left, TOther right);
     }
 
     public interface IUnaryNegationOperators<TSelf, TResult>
@@ -640,8 +638,6 @@ namespace System
         where TSelf : IUnaryPlusOperators<TSelf, TResult>
     {
         static abstract TResult operator +(TSelf value);
-
-        static abstract TResult checked operator +(TSelf value);
     }
 
     public interface IBitwiseOperators<TSelf, TOther, TResult>

From 0c65a0a4a6b6c45e5f5ef375a0528974bb020a20 Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Sun, 27 Mar 2022 09:00:59 -0700
Subject: [PATCH 07/16] Moving IDecrementOperators, IIncrementOperators,
 IMultiplicativeIdentity, and IUnaryNegationOperators down to INumberBase

---
 accepted/2021/statics-in-interfaces/README.md | 24 +++++++++----------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/accepted/2021/statics-in-interfaces/README.md b/accepted/2021/statics-in-interfaces/README.md
index 3fae382f8..4d70ecdc1 100644
--- a/accepted/2021/statics-in-interfaces/README.md
+++ b/accepted/2021/statics-in-interfaces/README.md
@@ -242,22 +242,22 @@ interface "IVector<TSelf, TScalar>"
 "ITrigonometricFunctions<TSelf>"                <|-- "IFloatingPointIeee754<TSelf>"
 
 "IComparisonOperators<TSelf, TOther>"           <|-- "INumber<TSelf>"
-"IDecrementOperators<TSelf>"                    <|-- "INumber<TSelf>"
 "IDivisionOperators<TSelf, TOther, TResult>"    <|-- "INumber<TSelf>"
-"IIncrementOperators<TSelf>"                    <|-- "INumber<TSelf>"
 "IModulusOperators<TSelf, TOther, TResult>"     <|-- "INumber<TSelf>"
-"IMultiplicativeIdentity<TSelf, TResult>"       <|-- "INumber<TSelf>"
 "INumberBase<TSelf>"                            <|-- "INumber<TSelf>"
 "ISpanFormattable"                              <|-- "INumber<TSelf>"
 "ISpanParseable<TSelf>"                         <|-- "INumber<TSelf>"
-"IUnaryNegationOperators<TSelf, TResult>"       <|-- "INumber<TSelf>"
 
 "IAdditionOperators<TSelf, TOther, TResult>"    <|-- "INumberBase<TSelf>"
 "IAdditiveIdentity<TSelf, TResult>"             <|-- "INumberBase<TSelf>"
+"IDecrementOperators<TSelf>"                    <|-- "INumberBase<TSelf>"
 "IEqualityOperators<TSelf, TOther>"             <|-- "INumberBase<TSelf>"
+"IIncrementOperators<TSelf>"                    <|-- "INumberBase<TSelf>"
+"IMultiplicativeIdentity<TSelf, TResult>"       <|-- "INumberBase<TSelf>"
 "IMultiplyOperators<TSelf, TOther, TResult>"    <|-- "INumberBase<TSelf>"
 "ISubtractionOperators<TSelf, TOther, TResult>" <|-- "INumberBase<TSelf>"
 "IUnaryPlusOperators<TSelf, TResult>"           <|-- "INumberBase<TSelf>"
+"IUnaryNegationOperators<TSelf, TResult>"       <|-- "INumberBase<TSelf>"
 
 "INumberBase<TSelf>"                            <|-- "ISignedNumberBase<TSelf>"
 
@@ -685,27 +685,30 @@ namespace System
     public interface INumberBase<TSelf>
         : IAdditionOperators<TSelf, TSelf, TSelf>,
           IAdditiveIdentity<TSelf, TSelf>,
+          IDecrementOperators<TSelf>,
           IEqualityOperators<TSelf, TSelf>,     // implies IEquatable<TSelf>
+          IIncrementOperators<TSelf>,
+          IMultiplicativeIdentity<TSelf, TSelf>,
           IMultiplyOperators<TSelf, TSelf>,
           ISubtractionOperators<TSelf, TSelf, TSelf>,
-          IUnaryPlusOperators<TSelf, TSelf>
+          IUnaryPlusOperators<TSelf, TSelf>,
+          IUnaryNegationOperators<TSelf, TSelf>
         where TSelf : INumberBase<TSelf>
     {
+        // Alias for MultiplicativeIdentity
+        static abstract TSelf One { get; }
+
         // Alias for AdditiveIdentity
         static abstract TSelf Zero { get; }
     }
 
     public interface INumber<TSelf>
         : IComparisonOperators<TSelf, TSelf>,   // implies IEqualityOperators<TSelf, TSelf>
-          IDecrementOperators<TSelf>,
           IDivisionOperators<TSelf, TSelf, TSelf>,
-          IIncrementOperators<TSelf>,
           IModulusOperators<TSelf, TSelf, TSelf>,
-          IMultiplicativeIdentity<TSelf, TSelf>,
           INumberBase<TSelf>,
           ISpanFormattable,                     // implies IFormattable
           ISpanParseable<TSelf>,                // implies IParseable<TSelf>
-          IUnaryNegationOperators<TSelf, TSelf>
         where TSelf : INumber<TSelf>
     {
         // For the Create methods, there is some concern over users implementing them. It is not necessarily trivial to take an arbitrary TOther
@@ -724,9 +727,6 @@ namespace System
         // There is an open question on whether properties like IsSigned, IsBinary, IsFixedWidth, Base/Radix, and others are beneficial
         // We could expose them for trivial checks or users could be required to check for the corresponding correct interfaces
 
-        // Alias for MultiplicativeIdentity
-        static abstract TSelf One { get; }
-
         // Abs mirrors Math.Abs and returns the same type. This can fail for MinValue of signed integer types
         // Swift has an associated type that can be used here, which would require an additional type parameter in .NET
         // However that would hinder the reusability of these interfaces in constraints

From 6095e41873e84a2722f7f3b915eba0cffff0426f Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Sun, 27 Mar 2022 09:39:39 -0700
Subject: [PATCH 08/16] Explicitly show the new constants for the primitive
 types

---
 accepted/2021/statics-in-interfaces/README.md | 54 +++++++++++++++++++
 1 file changed, 54 insertions(+)

diff --git a/accepted/2021/statics-in-interfaces/README.md b/accepted/2021/statics-in-interfaces/README.md
index 4d70ecdc1..5aadb11f4 100644
--- a/accepted/2021/statics-in-interfaces/README.md
+++ b/accepted/2021/statics-in-interfaces/README.md
@@ -1280,6 +1280,10 @@ namespace System
           IMinMaxValue<byte>,
           IUnsignedNumberBase<byte>
     {
+        public const byte AdditiveIdentity = 0;
+        public const byte MultiplicativeIdentity = 1;
+        public const byte One = 1;
+        public const byte Zero = 0;
     }
 
     public struct Char
@@ -1338,6 +1342,14 @@ namespace System
         // The rest of the IEEE operations are missing.
 
         // Decimal and some other types likewise define "friendly" names for operators, should we expose them?
+
+        // Decimal exposes a member named MinusOne
+
+        public const decimal AdditiveIdentity = 0;
+        public const decimal MultiplicativeIdentity = 1;
+        public const decimal NegativeOne = 1;
+        public const decimal One = 1;
+        public const decimal Zero = 0;
     }
 
     public struct Double
@@ -1345,6 +1357,11 @@ namespace System
           IConvertible,
           IMinMaxValue<double>
     {
+        public const double AdditiveIdentity = 0;
+        public const double MultiplicativeIdentity = 1;
+        public const double NegativeOne = 1;
+        public const double One = 1;
+        public const double Zero = 0;
     }
 
     public class Enum
@@ -1374,6 +1391,11 @@ namespace System
           IMinMaxValue<short>,
           ISignedNumberBase<short>
     {
+        public const short AdditiveIdentity = 0;
+        public const short MultiplicativeIdentity = 1;
+        public const short NegativeOne = 1;
+        public const short One = 1;
+        public const short Zero = 0;
     }
 
     public struct Int32
@@ -1382,6 +1404,11 @@ namespace System
           IMinMaxValue<int>,
           ISignedNumberBase<int>
     {
+        public const int AdditiveIdentity = 0;
+        public const int MultiplicativeIdentity = 1;
+        public const int NegativeOne = 1;
+        public const int One = 1;
+        public const int Zero = 0;
     }
 
     public struct Int64
@@ -1390,6 +1417,11 @@ namespace System
           IMinMaxValue<long>,
           ISignedNumberBase<long>
     {
+        public const long AdditiveIdentity = 0;
+        public const long MultiplicativeIdentity = 1;
+        public const long NegativeOne = 1;
+        public const long One = 1;
+        public const long Zero = 0;
     }
 
     public struct IntPtr
@@ -1406,6 +1438,11 @@ namespace System
           IMinMaxValue<sbyte>,
           ISignedNumberBase<sbyte>
     {
+        public const sbyte AdditiveIdentity = 0;
+        public const sbyte MultiplicativeIdentity = 1;
+        public const sbyte NegativeOne = 1;
+        public const sbyte One = 1;
+        public const sbyte Zero = 0;
     }
 
     public struct Single
@@ -1413,6 +1450,11 @@ namespace System
           IConvertible,
           IMinMaxValue<float>
     {
+        public const float AdditiveIdentity = 0;
+        public const float MultiplicativeIdentity = 1;
+        public const float NegativeOne = 1;
+        public const float One = 1;
+        public const float Zero = 0;
     }
 
     public struct TimeOnly
@@ -1445,6 +1487,10 @@ namespace System
           IMinMaxValue<ushort>,
           IUnsignedNumberBase<ushort>
     {
+        public const ushort AdditiveIdentity = 0;
+        public const ushort MultiplicativeIdentity = 1;
+        public const ushort One = 1;
+        public const ushort Zero = 0;
     }
 
     public struct UInt32
@@ -1453,6 +1499,10 @@ namespace System
           IMinMaxValue<uint>,
           IUnsignedNumberBase<uint>
     {
+        public const uint AdditiveIdentity = 0;
+        public const uint MultiplicativeIdentity = 1;
+        public const uint One = 1;
+        public const uint Zero = 0;
     }
 
     public struct UInt64
@@ -1461,6 +1511,10 @@ namespace System
           IMinMaxValue<ulong>,
           IUnsignedNumberBase<ulong>
     {
+        public const ulong AdditiveIdentity = 0;
+        public const ulong MultiplicativeIdentity = 1;
+        public const ulong One = 1;
+        public const ulong Zero = 0;
     }
 
     public struct UIntPtr

From f9847c90a2f51d55c6b7f8caed37fcadd4766290 Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Sun, 27 Mar 2022 09:45:51 -0700
Subject: [PATCH 09/16] Adding System.Numerics.Complex

---
 accepted/2021/statics-in-interfaces/README.md | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/accepted/2021/statics-in-interfaces/README.md b/accepted/2021/statics-in-interfaces/README.md
index 5aadb11f4..7bf1421c1 100644
--- a/accepted/2021/statics-in-interfaces/README.md
+++ b/accepted/2021/statics-in-interfaces/README.md
@@ -1537,6 +1537,17 @@ namespace System.Numerics
     {
     }
 
+    public struct Complex
+        : IAdditionOperators<Complex, double, Complex>,
+          IDivisionOperators<Complex, Complex, Complex>,
+          IDivisionOperators<Complex, double, Complex>,
+          IFormattable,
+          IMultiplyOperators<Complex, double, Complex>,
+          INumberBase<Complex>,
+          ISubtractionOperators<Complex, double, Complex>
+    {
+    }
+
     public struct Vector<T> : IVector<Vector<T>, T>
     {
     }
@@ -1579,7 +1590,6 @@ There are several types which may benefit from some interface support. These inc
 * System.Range
 * System.Tuple
 * System.ValueTuple
-* System.Numerics.Complex
 * System.Numerics.Matrix3x2
 * System.Numerics.Matrix4x4
 * System.Numerics.Plane

From 4878eb4dc029ecab7992e9ba3062ea2e32a38175 Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Mon, 28 Mar 2022 08:34:39 -0700
Subject: [PATCH 10/16] Adding BigInteger and Complex to the UML metadata

---
 accepted/2021/statics-in-interfaces/README.md | 28 ++++++++++++++++++-
 1 file changed, 27 insertions(+), 1 deletion(-)

diff --git a/accepted/2021/statics-in-interfaces/README.md b/accepted/2021/statics-in-interfaces/README.md
index 7bf1421c1..0256ed559 100644
--- a/accepted/2021/statics-in-interfaces/README.md
+++ b/accepted/2021/statics-in-interfaces/README.md
@@ -281,8 +281,10 @@ interface "IVector<TSelf, TScalar>"
 "ISubtractionOperators<TSelf, TOther, TResult>" <|-- "IVector<TSelf, TScalar>"
 "IUnaryNegationOperators<TSelf, TResult>"       <|-- "IVector<TSelf, TScalar>"
 
+class "BigInteger"
 class "Byte"
 class "Char"
+class "Complex"
 class "DateOnly"
 class "DateTime"
 class "DateTimeOffset"
@@ -312,6 +314,10 @@ class "Vector2"
 class "Vector3"
 class "Vector4"
 
+"IBinaryInteger<TSelf>"                         <|-- "BigInteger"
+"ISignedNumberBase<TSelf>"                      <|-- "BigInteger"
+"ValueType"                                     <|-- "BigInteger"
+
 "IBinaryInteger<TSelf>"                         <|-- "Byte"
 "IConvertible"                                  <|-- "Byte"
 "IMinMaxValue<TSelf>"                           <|-- "Byte"
@@ -324,6 +330,21 @@ class "Vector4"
 "IUnsignedNumberBase<TSelf>"                    <|-- "Char"
 "ValueType"                                     <|-- "Char"
 
+"IAdditionOperators<TSelf, TOther, TResult>"    <|-- "Complex"
+"IDivisionOperators<TSelf, TOther, TResult>"    <|-- "Complex"
+"IDivisionOperators<TSelf, TOther, TResult>"    <|-- "Complex"
+"IFormattable"                                  <|-- "Complex"
+"IExponentialFunctions<TSelf>"                  <|-- "Complex"
+"IHyperbolicFunctions<TSelf>"                   <|-- "Complex"
+"ILogarithmicFunctions<TSelf>"                  <|-- "Complex"
+"IMultiplyOperators<TSelf, TOther, TResult>"    <|-- "Complex"
+"INumberBase<TSelf>"                            <|-- "Complex"
+"IPowerFunctions<TSelf>"                        <|-- "Complex"
+"IRootFunctions<TSelf>"                         <|-- "Complex"
+"ITrigonometricFunctions<TSelf>"                <|-- "Complex"
+"ISubtractionOperators<TSelf, TOther, TResult>" <|-- "Complex"
+"ValueType"                                     <|-- "Complex"
+
 "IComparisonOperators<TSelf, TOther>"           <|-- "DateOnly"
 "IMinMaxValue<TSelf>"                           <|-- "DateOnly"
 "ISpanFormattable"                              <|-- "DateOnly"
@@ -1530,7 +1551,6 @@ namespace System.Numerics
 {
     public struct BigInteger
         : IBinaryInteger<BigInteger>,
-          IMinMaxValue<BigInteger>,
           ISignedNumberBase<BigInteger>,
           ISpanFormattable,
           ISpanParseable<BigInteger>
@@ -1542,8 +1562,14 @@ namespace System.Numerics
           IDivisionOperators<Complex, Complex, Complex>,
           IDivisionOperators<Complex, double, Complex>,
           IFormattable,
+          // IExponentialFunctions<Complex>,
+          // IHyperbolicFunctions<Complex>,
+          // ILogarithmicFunctions<Complex>,
           IMultiplyOperators<Complex, double, Complex>,
           INumberBase<Complex>,
+          // IPowerFunctions<Complex>
+          // IRootFunctions<Complex>,
+          // ITrigonometricFunctions<Complex>,
           ISubtractionOperators<Complex, double, Complex>
     {
     }

From 7dfb4a127ea959b5cb5d0dc544adf65dbbfa4506 Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Tue, 29 Mar 2022 08:11:28 -0700
Subject: [PATCH 11/16] Moving a IsNegative, CopySign, and Max/MinMagnitude
 down to INumber

---
 accepted/2021/statics-in-interfaces/README.md | 23 ++++++++-----------
 1 file changed, 10 insertions(+), 13 deletions(-)

diff --git a/accepted/2021/statics-in-interfaces/README.md b/accepted/2021/statics-in-interfaces/README.md
index 0256ed559..f18770d32 100644
--- a/accepted/2021/statics-in-interfaces/README.md
+++ b/accepted/2021/statics-in-interfaces/README.md
@@ -756,10 +756,18 @@ namespace System
 
         static abstract TSelf Clamp(TSelf value, TSelf min, TSelf max);
 
+        static abstract TSelf CopySign(TSelf x, TSelf y);
+
+        static abstract bool IsNegative(TSelf value);
+
         static abstract TSelf Max(TSelf x, TSelf y);
 
+        static abstract TSelf MaxMagnitude(TSelf x, TSelf y);
+
         static abstract TSelf Min(TSelf x, TSelf y);
 
+        static abstract TSelf MinMagnitude(TSelf x, TSelf y);
+
         static abstract TSelf Parse(string s, NumberStyles style, IFormatProvider? provider);
 
         static abstract TSelf Parse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider);
@@ -906,6 +914,8 @@ namespace System
     {
         static abstract TSelf Cbrt(TSelf x);
 
+        static abstract TSelf Hypot(TSelf x, TSelf y);
+
         static abstract TSelf Sqrt(TSelf x);
 
         // The following methods are approved but not yet implemented in the libraries
@@ -1000,19 +1010,10 @@ namespace System
 
         static abstract TSelf BitDecrement(TSelf x);
 
-        // CopySign is likely more general purpose and may apply to any signed number type
-        // It may even be applicable to unsigned numbers where it simply returns x, for convenience
-
-        static abstract TSelf CopySign(TSelf x, TSelf y);
-
         static abstract TSelf FusedMultiplyAdd(TSelf x, TSelf y, TSelf z);
 
         static abstract TSelf IEEERemainder(TSelf x, TSelf y);
 
-        static abstract TSelf MaxMagnitude(TSelf x, TSelf y);
-
-        static abstract TSelf MinMagnitude(TSelf x, TSelf y);
-
         // The following members are exposed on the floating-point types as constants today
         // This may be of concern when implementing the interface
 
@@ -1034,8 +1035,6 @@ namespace System
 
         static abstract bool IsNaN(TSelf value);
 
-        static abstract bool IsNegative(TSelf value);
-
         static abstract bool IsNegativeInfinity(TSelf value);
 
         static abstract bool IsNormal(TSelf value);
@@ -1048,8 +1047,6 @@ namespace System
 
         static abstract TSelf Compound(TSelf x, TSelf n);
 
-        static abstract TSelf Hypot(TSelf x, TSelf y);
-
         static abstract TSelf MaxMagnitudeNumber(TSelf x, TSelf y);
 
         static abstract TSelf MaxNumber(TSelf x, TSelf y);

From 5b97f5c9c014df62c160622a0a3d913c15caa719 Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Tue, 29 Mar 2022 08:24:31 -0700
Subject: [PATCH 12/16] Expose methods allowing getting the underlying
 bytes/parts of a binary integer or IEEE 754 floating-point number

---
 accepted/2021/statics-in-interfaces/README.md | 49 +++++++++++++++++--
 1 file changed, 44 insertions(+), 5 deletions(-)

diff --git a/accepted/2021/statics-in-interfaces/README.md b/accepted/2021/statics-in-interfaces/README.md
index f18770d32..42dbea3e1 100644
--- a/accepted/2021/statics-in-interfaces/README.md
+++ b/accepted/2021/statics-in-interfaces/README.md
@@ -758,6 +758,8 @@ namespace System
 
         static abstract TSelf CopySign(TSelf x, TSelf y);
 
+        // IsEven, IsOdd, IsZero
+
         static abstract bool IsNegative(TSelf value);
 
         static abstract TSelf Max(TSelf x, TSelf y);
@@ -837,6 +839,20 @@ namespace System
         static abstract TSelf RotateRight(TSelf value, TSelf rotateAmount);
 
         static abstract TSelf TrailingZeroCount(TSelf value);
+
+        // These methods allow getting the underlying bytes that represent the binary integer
+
+        void CopyTo(Span<byte> destination);
+
+        void CopyTo(byte[] destination);
+
+        void CopyTo(byte[] destination, int startIndex);
+
+        nuint GetByteCount();
+
+        nuint GetBitLength();
+
+        bool TryCopyTo(Span<byte> destination);
     }
 
     public interface IExponentialFunctions<TSelf>
@@ -988,11 +1004,6 @@ namespace System
           ITrigonometricFunctions<TSelf>
         where TSelf : IFloatingPointIeee754<TSelf>
     {
-        // TODO: The Exponent and Signifcand need to be exposed here
-        // They should return INumber<TSelf> here and IBinaryNumber<TSelf> on IBinaryFloatingPointIeee754<TSelf>
-
-        // TODO: We may want to expose constants related to the subnormal and finite boundaries
-
         // The following constants are defined by System.Math and System.MathF today
 
         static abstract TSelf E { get; }
@@ -1017,6 +1028,8 @@ namespace System
         // The following members are exposed on the floating-point types as constants today
         // This may be of concern when implementing the interface
 
+        // TODO: We may want to expose constants related to the subnormal and finite boundaries
+
         static abstract TSelf Epsilon { get; }
 
         static abstract TSelf NaN { get; }
@@ -1055,6 +1068,32 @@ namespace System
 
         static abstract TSelf MinNumber(TSelf x, TSelf y);
 
+        // These methods allow getting the underlying bytes that represent the IEEE 754 floating-point
+
+        void CopyExponentTo(Span<byte> destination);
+
+        void CopyExponentTo(byte[] destination);
+
+        void CopyExponentTo(byte[] destination, int startIndex);
+
+        nuint GetExponentByteCount();
+
+        nuint GetExponentBitLength();
+
+        bool TryCopyExponentTo(Span<byte> destination);
+
+        void CopySignificandTo(Span<byte> destination);
+
+        void CopySignificandTo(byte[] destination);
+
+        void CopySignificandTo(byte[] destination, int startIndex);
+
+        nuint GetSignificandByteCount();
+
+        nuint GetSignificandBitLength();
+
+        bool TryCopySignificandTo(Span<byte> destination);
+
         // The majority of the IEEE required operations are listed below
         // This doesn't include the recommended operations such as sin, cos, acos, etc
 

From fc962deb0c3578040d3f456d1f2099819388f4ff Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Thu, 31 Mar 2022 18:14:35 -0700
Subject: [PATCH 13/16] Updating the majority of the design doc to match the
 API review feedback

---
 accepted/2021/statics-in-interfaces/README.md | 2879 ++++++++++++++---
 1 file changed, 2475 insertions(+), 404 deletions(-)

diff --git a/accepted/2021/statics-in-interfaces/README.md b/accepted/2021/statics-in-interfaces/README.md
index 42dbea3e1..7848777ab 100644
--- a/accepted/2021/statics-in-interfaces/README.md
+++ b/accepted/2021/statics-in-interfaces/README.md
@@ -111,7 +111,7 @@ After thinking over the possible implementations, Jeff realizes that the only re
 
 Jeff learns that a future version of .NET will offer a new feature called static abstracts in interfaces. Such a feature will have the .NET Libraries expose a set of interfaces that allow Jeff to implement the desired method without requiring users types to take a dependency on types they declared.
 
-The .NET Libraries are exposing interfaces such as:
+The .NET Libraries are exposing interfaces such as (NOTE: simplified names/examples are given below):
 ```csharp
 public interface IAdditionOperators<TSelf>
     where TSelf : IAdditionOperators<TSelf>
@@ -173,25 +173,30 @@ The overall design has been influenced by the existing .NET surface area, the Sw
 
 <!--
 @startuml
+interface "IComparable"
+interface "IComparable<T>"
+interface "IConvertible"
+interface "IDeserializationCallback"
+interface "IEquatable<T>"
+interface "IFormattable"
+interface "IParsable<TSelf>"
+interface "ISerializable"
+interface "ISpanFormattable"
+interface "ISpanParsable<TSelf>"
+
 interface "IAdditionOperators<TSelf, TOther, TResult>"
 interface "IAdditiveIdentity<TSelf, TResult>"
 interface "IBinaryFloatingPointIeee754<TSelf>"
 interface "IBinaryInteger<TSelf>"
 interface "IBinaryNumber<TSelf>"
 interface "IBitwiseOperators<TSelf, TOther, TResult>"
-interface "IComparable"
-interface "IComparable<T>"
 interface "IComparisonOperators<TSelf, TOther>"
-interface "IConvertible"
 interface "IDecrementOperators<TSelf>"
-interface "IDeserializationCallback"
 interface "IDivisionOperators<TSelf, TOther, TResult>"
 interface "IEqualityOperators<TSelf, TOther>"
-interface "IEquatable<T>"
 interface "IExponentialFunctions<TSelf>"
 interface "IFloatingPoint<TSelf>"
 interface "IFloatingPointIeee754<TSelf>"
-interface "IFormattable"
 interface "IHyperbolicFunctions<TSelf>"
 interface "IIncrementOperators<TSelf>"
 interface "ILogarithmicFunctions<TSelf>"
@@ -201,19 +206,15 @@ interface "IMultiplicativeIdentity<TSelf, TResult>"
 interface "IMultiplyOperators<TSelf, TOther, TResult>"
 interface "INumber<TSelf>"
 interface "INumberBase<TSelf>"
-interface "IParseable<TSelf>"
 interface "IPowerFunctions<TSelf>"
 interface "IRootFunctions<TSelf>"
-interface "ISerializable"
 interface "IShiftOperators<TSelf, TOther, TResult>"
-interface "ISignedNumberBase<TSelf>"
-interface "ISpanFormattable"
-interface "ISpanParseable<TSelf>"
+interface "ISignedNumber<TSelf>"
 interface "ISubtractionOperators<TSelf, TOther, TResult>"
 interface "ITrigonometricFunctions<TSelf>"
-interface "IUnsignedNumberBase<TSelf>"
 interface "IUnaryNegationOperators<TSelf, TResult>"
 interface "IUnaryPlusOperators<TSelf, TResult>"
+interface "IUnsignedNumber<TSelf>"
 interface "IVector<TSelf, TScalar>"
 
 "IBinaryNumber<TSelf>"                          <|-- "IBinaryFloatingPointIeee754<TSelf>"
@@ -231,12 +232,13 @@ interface "IVector<TSelf, TScalar>"
 
 "IEquatable<T>"                                 <|-- "IEqualityOperators<TSelf, TOther>"
 
-"ISignedNumberBase<TSelf>"                      <|-- "IFloatingPoint<TSelf>"
+"INumber<TSelf>"                                <|-- "IFloatingPoint<TSelf>"
+"ISignedNumber<TSelf>"                          <|-- "IFloatingPoint<TSelf>"
 
 "IExponentialFunctions<TSelf>"                  <|-- "IFloatingPointIeee754<TSelf>"
+"IFloatingPoint<TSelf>"                         <|-- "IFloatingPointIeee754<TSelf>"
 "IHyperbolicFunctions<TSelf>"                   <|-- "IFloatingPointIeee754<TSelf>"
 "ILogarithmicFunctions<TSelf>"                  <|-- "IFloatingPointIeee754<TSelf>"
-"IFloatingPoint<TSelf>"                         <|-- "IFloatingPointIeee754<TSelf>"
 "IPowerFunctions<TSelf>"                        <|-- "IFloatingPointIeee754<TSelf>"
 "IRootFunctions<TSelf>"                         <|-- "IFloatingPointIeee754<TSelf>"
 "ITrigonometricFunctions<TSelf>"                <|-- "IFloatingPointIeee754<TSelf>"
@@ -246,7 +248,7 @@ interface "IVector<TSelf, TScalar>"
 "IModulusOperators<TSelf, TOther, TResult>"     <|-- "INumber<TSelf>"
 "INumberBase<TSelf>"                            <|-- "INumber<TSelf>"
 "ISpanFormattable"                              <|-- "INumber<TSelf>"
-"ISpanParseable<TSelf>"                         <|-- "INumber<TSelf>"
+"ISpanParsable<TSelf>"                          <|-- "INumber<TSelf>"
 
 "IAdditionOperators<TSelf, TOther, TResult>"    <|-- "INumberBase<TSelf>"
 "IAdditiveIdentity<TSelf, TResult>"             <|-- "INumberBase<TSelf>"
@@ -259,13 +261,9 @@ interface "IVector<TSelf, TScalar>"
 "IUnaryPlusOperators<TSelf, TResult>"           <|-- "INumberBase<TSelf>"
 "IUnaryNegationOperators<TSelf, TResult>"       <|-- "INumberBase<TSelf>"
 
-"INumberBase<TSelf>"                            <|-- "ISignedNumberBase<TSelf>"
-
 "IFormattable"                                  <|-- "ISpanFormattable"
 
-"IParseable<TSelf>"                             <|-- "ISpanParseable<TSelf>"
-
-"INumberBase<TSelf>"                            <|-- "IUnsignedNumberBase<TSelf>"
+"IParsable<TSelf>"                              <|-- "ISpanParsable<TSelf>"
 
 "IAdditionOperators<TSelf, TOther, TResult>"    <|-- "IVector<TSelf, TScalar>"
 "IAdditiveIdentity<TSelf, TResult>"             <|-- "IVector<TSelf, TScalar>"
@@ -315,19 +313,19 @@ class "Vector3"
 class "Vector4"
 
 "IBinaryInteger<TSelf>"                         <|-- "BigInteger"
-"ISignedNumberBase<TSelf>"                      <|-- "BigInteger"
+"ISignedNumber<TSelf>"                          <|-- "BigInteger"
 "ValueType"                                     <|-- "BigInteger"
 
 "IBinaryInteger<TSelf>"                         <|-- "Byte"
 "IConvertible"                                  <|-- "Byte"
 "IMinMaxValue<TSelf>"                           <|-- "Byte"
-"IUnsignedNumberBase<TSelf>"                    <|-- "Byte"
+"IUnsignedNumber<TSelf>"                        <|-- "Byte"
 "ValueType"                                     <|-- "Byte"
 
 "IBinaryInteger<TSelf>"                         <|-- "Char"
 "IConvertible"                                  <|-- "Char"
 "IMinMaxValue<TSelf>"                           <|-- "Char"
-"IUnsignedNumberBase<TSelf>"                    <|-- "Char"
+"IUnsignedNumber<TSelf>"                        <|-- "Char"
 "ValueType"                                     <|-- "Char"
 
 "IAdditionOperators<TSelf, TOther, TResult>"    <|-- "Complex"
@@ -348,7 +346,7 @@ class "Vector4"
 "IComparisonOperators<TSelf, TOther>"           <|-- "DateOnly"
 "IMinMaxValue<TSelf>"                           <|-- "DateOnly"
 "ISpanFormattable"                              <|-- "DateOnly"
-"ISpanParseable<TSelf>"                         <|-- "DateOnly"
+"ISpanParsable<TSelf>"                          <|-- "DateOnly"
 "ValueType"                                     <|-- "DateOnly"
 
 "IAdditionOperators<TSelf, TOther, TResult>"    <|-- "DateTime"
@@ -358,7 +356,7 @@ class "Vector4"
 "IMinMaxValue<TSelf>"                           <|-- "DateTime"
 "ISerializable"                                 <|-- "DateTime"
 "ISpanFormattable"                              <|-- "DateTime"
-"ISpanParseable<TSelf>"                         <|-- "DateTime"
+"ISpanParsable<TSelf>"                          <|-- "DateTime"
 "ISubtractionOperators<TSelf, TOther, TResult>" <|-- "DateTime"
 "ValueType"                                     <|-- "DateTime"
 
@@ -369,7 +367,7 @@ class "Vector4"
 "IMinMaxValue<TSelf>"                           <|-- "DateTimeOffset"
 "ISerializable"                                 <|-- "DateTimeOffset"
 "ISpanFormattable"                              <|-- "DateTimeOffset"
-"ISpanParseable<TSelf>"                         <|-- "DateTimeOffset"
+"ISpanParsable<TSelf>"                          <|-- "DateTimeOffset"
 "ISubtractionOperators<TSelf, TOther, TResult>" <|-- "DateTimeOffset"
 "ValueType"                                     <|-- "DateTimeOffset"
 
@@ -392,7 +390,7 @@ class "Vector4"
 
 "IComparisonOperators<TSelf, TOther>"           <|-- "Guid"
 "ISpanFormattable"                              <|-- "Guid"
-"ISpanParseable<TSelf>"                         <|-- "Guid"
+"ISpanParsable<TSelf>"                          <|-- "Guid"
 "ValueType"                                     <|-- "Guid"
 
 "IBinaryFloatingPointIeee754<TSelf>"            <|-- "Half"
@@ -402,31 +400,31 @@ class "Vector4"
 "IBinaryInteger<TSelf>"                         <|-- "Int16"
 "IConvertible"                                  <|-- "Int16"
 "IMinMaxValue<TSelf>"                           <|-- "Int16"
-"ISignedNumberBase<TSelf>"                      <|-- "Int16"
+"ISignedNumber<TSelf>"                          <|-- "Int16"
 "ValueType"                                     <|-- "Int16"
 
 "IBinaryInteger<TSelf>"                         <|-- "Int32"
 "IConvertible"                                  <|-- "Int32"
 "IMinMaxValue<TSelf>"                           <|-- "Int32"
-"ISignedNumberBase<TSelf>"                      <|-- "Int32"
+"ISignedNumber<TSelf>"                          <|-- "Int32"
 "ValueType"                                     <|-- "Int32"
 
 "IBinaryInteger<TSelf>"                         <|-- "Int64"
 "IConvertible"                                  <|-- "Int64"
 "IMinMaxValue<TSelf>"                           <|-- "Int64"
-"ISignedNumberBase<TSelf>"                      <|-- "Int64"
+"ISignedNumber<TSelf>"                          <|-- "Int64"
 "ValueType"                                     <|-- "Int64"
 
 "IBinaryInteger<TSelf>"                         <|-- "IntPtr"
 "IMinMaxValue<TSelf>"                           <|-- "IntPtr"
-"ISignedNumberBase<TSelf>"                      <|-- "IntPtr"
+"ISignedNumber<TSelf>"                          <|-- "IntPtr"
 "ISerializable"                                 <|-- "IntPtr"
 "ValueType"                                     <|-- "IntPtr"
 
 "IBinaryInteger<TSelf>"                         <|-- "SByte"
 "IConvertible"                                  <|-- "SByte"
 "IMinMaxValue<TSelf>"                           <|-- "SByte"
-"ISignedNumberBase<TSelf>"                      <|-- "SByte"
+"ISignedNumber<TSelf>"                          <|-- "SByte"
 "ValueType"                                     <|-- "SByte"
 
 "IBinaryFloatingPointIeee754<TSelf>"            <|-- "Single"
@@ -437,7 +435,7 @@ class "Vector4"
 "IComparisonOperators<TSelf, TOther>"           <|-- "TimeOnly"
 "IMinMaxValue<TSelf>"                           <|-- "TimeOnly"
 "ISpanFormattable"                              <|-- "TimeOnly"
-"ISpanParseable<TSelf>"                         <|-- "TimeOnly"
+"ISpanParsable<TSelf>"                          <|-- "TimeOnly"
 "ISubtractionOperators<TSelf, TOther, TResult>" <|-- "TimeOnly"
 "ValueType"                                     <|-- "TimeOnly"
 
@@ -449,32 +447,34 @@ class "Vector4"
 "IMultiplicativeIdentity<TSelf, TResult>"       <|-- "TimeSpan"
 "IMultiplyOperators<TSelf, TOther, TResult>"    <|-- "TimeSpan"
 "ISpanFormattable"                              <|-- "TimeSpan"
+"ISpanParsable<TSelf>"                          <|-- "TimeSpan"
 "ISubtractionOperators<TSelf, TOther, TResult>" <|-- "TimeSpan"
 "IUnaryNegationOperators<TSelf, TResult>"       <|-- "TimeSpan"
+"IUnaryPlusOperators<TSelf, TResult>"           <|-- "TimeSpan"
 "ValueType"                                     <|-- "TimeSpan"
 
 "IBinaryInteger<TSelf>"                         <|-- "UInt16"
 "IConvertible"                                  <|-- "UInt16"
 "IMinMaxValue<TSelf>"                           <|-- "UInt16"
-"IUnsignedNumberBase<TSelf>"                    <|-- "UInt16"
+"IUnsignedNumber<TSelf>"                        <|-- "UInt16"
 "ValueType"                                     <|-- "UInt16"
 
 "IBinaryInteger<TSelf>"                         <|-- "UInt32"
 "IConvertible"                                  <|-- "UInt32"
 "IMinMaxValue<TSelf>"                           <|-- "UInt32"
-"IUnsignedNumberBase<TSelf>"                    <|-- "UInt32"
+"IUnsignedNumber<TSelf>"                        <|-- "UInt32"
 "ValueType"                                     <|-- "UInt32"
 
 "IBinaryInteger<TSelf>"                         <|-- "UInt64"
 "IConvertible"                                  <|-- "UInt64"
 "IMinMaxValue<TSelf>"                           <|-- "UInt64"
-"IUnsignedNumberBase<TSelf>"                    <|-- "UInt64"
+"IUnsignedNumber<TSelf>"                        <|-- "UInt64"
 "ValueType"                                     <|-- "UInt64"
 
 "IBinaryInteger<TSelf>"                         <|-- "UIntPtr"
 "IMinMaxValue<TSelf>"                           <|-- "UIntPtr"
 "ISerializable"                                 <|-- "UIntPtr"
-"IUnsignedNumberBase<TSelf>"                    <|-- "UIntPtr"
+"IUnsignedNumber<TSelf>"                        <|-- "UIntPtr"
 "ValueType"                                     <|-- "UIntPtr"
 
 "Object"                                        <|-- "ValueType"
@@ -502,10 +502,10 @@ Some of the code below assumes that https://github.com/dotnet/csharplang/issues/
 ```csharp
 namespace System
 {
-    public interface IParseable<TSelf>
-        where TSelf : IParseable<TSelf>
+    public interface IParsable<TSelf>
+        where TSelf : IParsable<TSelf>
     {
-        // These do not take NumberStyles as not all parseable types are numbers (such as Guid)
+        // These do not take NumberStyles as not all Parsable types are numbers (such as Guid)
         // Instead, INumber<TSelf> exposes additional parse methods that do take NumberStyles
 
         static abstract TSelf Parse(string s, IFormatProvider? provider);
@@ -513,27 +513,45 @@ namespace System
         static abstract bool TryParse(string s, IFormatProvider? provider, out TSelf result);
     }
 
-    public interface ISpanParseable<TSelf> : IParseable<TSelf>
-        where TSelf : ISpanParseable<TSelf>
+    public interface ISpanParsable<TSelf> : IParsable<TSelf>
+        where TSelf : ISpanParsable<TSelf>
     {
-        // This inherits from IParseable, much as ISpanFormattable is planned to inherit from IFormattable
+        // This inherits from IParsable, much as ISpanFormattable is planned to inherit from IFormattable
 
         static abstract TSelf Parse(ReadOnlySpan<char> s, IFormatProvider? provider);
 
         static abstract bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, out TSelf result);
     }
+}
 
-    public interface IEqualityOperators<TSelf, TOther> : IEquatable<TOther>
-        where TSelf : IEqualityOperators<TSelf, TOther>
+namespace System.Numerics
+{
+    public interface IAdditionOperators<TSelf, TOther, TResult>
+        where TSelf : IAdditionOperators<TSelf, TOther, TResult>
     {
-        // Given this takes two generic parameters, we could simply call it IEquatable<TSelf, TOther>
+        // An additive identity is not exposed here as it may be problematic for cases like
+        // DateTime that implements both IAdditionOperators<DateTime, DateTime> and IAdditionOperators<DateTime, TimeSpan>
+        // This would require overloading by return type and may be problematic for some scenarios where TOther might not have an additive identity
 
-        // This should not be `IEqualityOperators<TSelf>` as there are types like `Complex` where
-        // TOther can be `double` and represent an optimization, both in size and perf
+        // We can't assume TOther + TSelf is valid as not everything is commutative
 
-        static abstract bool operator ==(TSelf left, TOther right);
+        // We can't expose TSelf - TOther as some types only support one of the operations
 
-        static abstract bool operator !=(TSelf left, TOther right);
+        static abstract TResult operator +(TSelf left, TOther right);
+
+        static abstract TResult operator checked +(TSelf left, TOther right);
+    }
+
+    public interface IBitwiseOperators<TSelf, TOther, TResult>
+        where TSelf : IBitwiseOperators<TSelf, TOther, TResult>
+    {
+        static abstract TResult operator &(TSelf left, TOther right);
+
+        static abstract TResult operator |(TSelf left, TOther right);
+
+        static abstract TResult operator ^(TSelf left, TOther right);
+
+        static abstract TResult operator ~(TSelf value);
     }
 
     public interface IComparisonOperators<TSelf, TOther> : IComparable, IComparable<TOther>, IEqualityOperators<TSelf, TOther>
@@ -553,34 +571,33 @@ namespace System
         static abstract bool operator >=(TSelf left, TOther right);
     }
 
-    public interface IAdditiveIdentity<TSelf, TResult>
-        where TSelf : IAdditiveIdentity<TSelf, TResult>
+    public interface IDecrementOperators<TSelf>
+        where TSelf : IDecrementOperators<TSelf>
     {
-        static abstract TResult AdditiveIdentity { get; }
+        static abstract TSelf operator --(TSelf value);
+
+        static abstract TSelf operator checked --(TSelf value);
     }
 
-    public interface IAdditionOperators<TSelf, TOther, TResult>
-        where TSelf : IAdditionOperators<TSelf, TOther, TResult>
+    public interface IDivisionOperators<TSelf, TOther, TResult>
+        where TSelf : IDivisionOperators<TSelf, TOther, TResult>
     {
-        // An additive identity is not exposed here as it may be problematic for cases like
-        // DateTime that implements both IAdditionOperators<DateTime, DateTime> and IAdditionOperators<DateTime, TimeSpan>
-        // This would require overloading by return type and may be problematic for some scenarios where TOther might not have an additive identity
-
-        // We can't assume TOther + TSelf is valid as not everything is commutative
-
-        // We can't expose TSelf - TOther as some types only support one of the operations
-
-        static abstract TResult operator +(TSelf left, TOther right);
+        static abstract TResult operator /(TSelf left, TOther right);
 
-        static abstract TResult checked operator +(TSelf left, TOther right);
+        static abstract TResult operator checked /(TSelf left, TOther right);
     }
 
-    public interface ISubtractionOperators<TSelf, TOther, TResult>
-        where TSelf : ISubtractionOperators<TSelf, TOther, TResult>
+    public interface IEqualityOperators<TSelf, TOther> : IEquatable<TOther>
+        where TSelf : IEqualityOperators<TSelf, TOther>
     {
-        static abstract TResult operator -(TSelf left, TOther right);
+        // Given this takes two generic parameters, we could simply call it IEquatable<TSelf, TOther>
 
-        static abstract TResult checked operator -(TSelf left, TOther right);
+        // This should not be `IEqualityOperators<TSelf>` as there are types like `Complex` where
+        // TOther can be `double` and represent an optimization, both in size and perf
+
+        static abstract bool operator ==(TSelf left, TOther right);
+
+        static abstract bool operator !=(TSelf left, TOther right);
     }
 
     public interface IIncrementOperators<TSelf>
@@ -596,21 +613,17 @@ namespace System
 
         static abstract TSelf operator ++(TSelf value);
 
-        static abstract TSelf checked operator ++(TSelf value);
+        static abstract TSelf operator checked ++(TSelf value);
     }
 
-    public interface IDecrementOperators<TSelf>
-        where TSelf : IDecrementOperators<TSelf>
+    public interface IModulusOperators<TSelf, TOther, TResult>
+        where TSelf : IModulusOperators<TSelf, TOther, TResult>
     {
-        static abstract TSelf operator --(TSelf value);
+        // The ECMA name is op_Modulus and so the behavior isn't actually "remainder" with regards to negative values
 
-        static abstract TSelf checked operator --(TSelf value);
-    }
+        // Likewise the name IModulusOperators doesn't fit with the other names, so a better one is needed
 
-    public interface IMultiplicativeIdentity<TSelf, TResult>
-        where TSelf : IMultiplicativeIdentity<TSelf, TResult>
-    {
-        static abstract TResult MultiplicativeIdentity { get; }
+        static abstract TResult operator %(TSelf left, TOther right);
     }
 
     public interface IMultiplyOperators<TSelf, TOther, TResult>
@@ -626,25 +639,26 @@ namespace System
 
         static abstract TResult operator *(TSelf left, TOther right);
 
-        static abstract TResult checked operator *(TSelf left, TOther right);
+        static abstract TResult operator checked *(TSelf left, TOther right);
     }
 
-    public interface IDivisionOperators<TSelf, TOther, TResult>
-        where TSelf : IDivisionOperators<TSelf, TOther, TResult>
+    public interface IShiftOperators<TSelf, TOther, TResult>
+        where TSelf : IShiftOperators<TSelf, TOther, TResult>
     {
-        static abstract TResult operator /(TSelf left, TOther right);
+        static abstract TResult operator <<(TSelf value, TOther shiftAmount);
+
+        static abstract TResult operator >>(TSelf value, TOther shiftAmount);
 
-        static abstract TResult checked operator /(TSelf left, TOther right);
+        // Logical right shift
+        static abstract TResult operator >>>(TSelf value, TOther shiftAmount);
     }
 
-    public interface IModulusOperators<TSelf, TOther, TResult>
-        where TSelf : IModulusOperators<TSelf, TOther, TResult>
+    public interface ISubtractionOperators<TSelf, TOther, TResult>
+        where TSelf : ISubtractionOperators<TSelf, TOther, TResult>
     {
-        // The ECMA name is op_Modulus and so the behavior isn't actually "remainder" with regards to negative values
-
-        // Likewise the name IModulusOperators doesn't fit with the other names, so a better one is needed
+        static abstract TResult operator -(TSelf left, TOther right);
 
-        static abstract TResult operator %(TSelf left, TOther right);
+        static abstract TResult operator checked -(TSelf left, TOther right);
     }
 
     public interface IUnaryNegationOperators<TSelf, TResult>
@@ -652,7 +666,7 @@ namespace System
     {
         static abstract TResult operator -(TSelf value);
 
-        static abstract TResult checked operator -(TSelf value);
+        static abstract TResult operator checked -(TSelf value);
     }
 
     public interface IUnaryPlusOperators<TSelf, TResult>
@@ -660,28 +674,14 @@ namespace System
     {
         static abstract TResult operator +(TSelf value);
     }
+}
 
-    public interface IBitwiseOperators<TSelf, TOther, TResult>
-        where TSelf : IBitwiseOperators<TSelf, TOther, TResult>
-    {
-        static abstract TResult operator &(TSelf left, TOther right);
-
-        static abstract TResult operator |(TSelf left, TOther right);
-
-        static abstract TResult operator ^(TSelf left, TOther right);
-
-        static abstract TResult operator ~(TSelf value);
-    }
-
-    public interface IShiftOperators<TSelf, TOther, TResult>
-        where TSelf : IShiftOperators<TSelf, TOther, TResult>
+namespace System.Numerics
+{
+    public interface IAdditiveIdentity<TSelf, TResult>
+        where TSelf : IAdditiveIdentity<TSelf, TResult>
     {
-        static abstract TResult operator <<(TSelf value, TOther shiftAmount);
-
-        static abstract TResult operator >>(TSelf value, TOther shiftAmount);
-
-        // Logical right shift
-        static abstract TResult operator >>>(TSelf value, TOther shiftAmount);
+        static abstract TResult AdditiveIdentity { get; }
     }
 
     public interface IMinMaxValue<TSelf>
@@ -693,6 +693,12 @@ namespace System
 
         static abstract TSelf MaxValue { get; }
     }
+
+    public interface IMultiplicativeIdentity<TSelf, TResult>
+        where TSelf : IMultiplicativeIdentity<TSelf, TResult>
+    {
+        static abstract TResult MultiplicativeIdentity { get; }
+    }
 }
 ```
 
@@ -701,170 +707,13 @@ namespace System
 The numeric interfaces build upon the base interfaces by defining the core abstraction that most users are expected to interact with.
 
 ```csharp
-namespace System
+namespace System.Numerics
 {
-    public interface INumberBase<TSelf>
-        : IAdditionOperators<TSelf, TSelf, TSelf>,
-          IAdditiveIdentity<TSelf, TSelf>,
-          IDecrementOperators<TSelf>,
-          IEqualityOperators<TSelf, TSelf>,     // implies IEquatable<TSelf>
-          IIncrementOperators<TSelf>,
-          IMultiplicativeIdentity<TSelf, TSelf>,
-          IMultiplyOperators<TSelf, TSelf>,
-          ISubtractionOperators<TSelf, TSelf, TSelf>,
-          IUnaryPlusOperators<TSelf, TSelf>,
-          IUnaryNegationOperators<TSelf, TSelf>
-        where TSelf : INumberBase<TSelf>
-    {
-        // Alias for MultiplicativeIdentity
-        static abstract TSelf One { get; }
-
-        // Alias for AdditiveIdentity
-        static abstract TSelf Zero { get; }
-    }
-
-    public interface INumber<TSelf>
-        : IComparisonOperators<TSelf, TSelf>,   // implies IEqualityOperators<TSelf, TSelf>
-          IDivisionOperators<TSelf, TSelf, TSelf>,
-          IModulusOperators<TSelf, TSelf, TSelf>,
-          INumberBase<TSelf>,
-          ISpanFormattable,                     // implies IFormattable
-          ISpanParseable<TSelf>,                // implies IParseable<TSelf>
-        where TSelf : INumber<TSelf>
-    {
-        // For the Create methods, there is some concern over users implementing them. It is not necessarily trivial to take an arbitrary TOther
-        // and convert it into an arbitrary TSelf. If you know the type of TOther, you may be able to optimize in a few ways. Otherwise, you
-        // may have to fail and throw in the worst case.
-
-        static abstract TSelf Create<TOther>(TOther value)
-            where TOther : INumber<TOther>;
-
-        static abstract TSelf CreateSaturating<TOther>(TOther value)
-            where TOther : INumber<TOther>;
-
-        static abstract TSelf CreateTruncating<TOther>(TOther value)
-            where TOther : INumber<TOther>;
-
-        // There is an open question on whether properties like IsSigned, IsBinary, IsFixedWidth, Base/Radix, and others are beneficial
-        // We could expose them for trivial checks or users could be required to check for the corresponding correct interfaces
-
-        // Abs mirrors Math.Abs and returns the same type. This can fail for MinValue of signed integer types
-        // Swift has an associated type that can be used here, which would require an additional type parameter in .NET
-        // However that would hinder the reusability of these interfaces in constraints
-
-        static abstract TSelf Abs(TSelf value);
-
-        static abstract TSelf Clamp(TSelf value, TSelf min, TSelf max);
-
-        static abstract TSelf CopySign(TSelf x, TSelf y);
-
-        // IsEven, IsOdd, IsZero
-
-        static abstract bool IsNegative(TSelf value);
-
-        static abstract TSelf Max(TSelf x, TSelf y);
-
-        static abstract TSelf MaxMagnitude(TSelf x, TSelf y);
-
-        static abstract TSelf Min(TSelf x, TSelf y);
-
-        static abstract TSelf MinMagnitude(TSelf x, TSelf y);
-
-        static abstract TSelf Parse(string s, NumberStyles style, IFormatProvider? provider);
-
-        static abstract TSelf Parse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider);
-
-        // Math only exposes this Sign for signed types, but it is well-defined for unsigned types
-        // it can simply never return -1 and only 0 or 1 instead
-
-        static abstract int Sign(TSelf value);
-
-        static abstract bool TryCreate<TOther>(TOther value, out TSelf result)
-            where TOther : INumber<TOther>;
-
-        static abstract bool TryParse([NotNullWhen(true)] string? s, NumberStyles style, IFormatProvider? provider, out TSelf result);
-
-        static abstract bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider, out TSelf result);
-    }
-
-    public interface ISignedNumberBase<TSelf>
-        : INumberBase<TSelf>
-        where TSelf : ISignedNumberBase<TSelf>
-    {
-        // It's not possible to check for lack of an interface in a constraint, so ISignedNumberBase<TSelf> is likely required
-
-        static abstract TSelf NegativeOne { get; }
-    }
-
-    public interface IUnsignedNumberBase<TSelf>
-        : INumberBase<TSelf>
-        where TSelf : IUnsignedNumberBase<TSelf>
-    {
-        // It's not possible to check for lack of an interface in a constraint, so IUnsignedNumberBase<TSelf> is likely required
-    }
-
-    public interface IBinaryNumber<TSelf>
-        : IBitwiseOperators<TSelf, TSelf, TSelf>,
-          INumber<TSelf>
-        where TSelf : IBinaryNumber<TSelf>
-    {
-        // Having the bitwise operators on IBinaryNumber<TSelf> means they will be available to floating-point types
-        // The operations are well-defined [for floats] but many languages don't directly expose them, we already support
-        // them in SIMD contexts today, as do most languages with SIMD support, so there is not great concern here.
-
-        static abstract bool IsPow2(TSelf value);
-
-        static abstract TSelf Log2(TSelf value);
-    }
-
-    public interface IBinaryInteger<TSelf>
-        : IBinaryNumber<TSelf>,
-          IShiftOperators<TSelf, TSelf, TSelf>
-        where TSelf : IBinaryInteger<TSelf>
-    {
-        // We might want to support "big multiplication" for fixed width types
-        // This would return a tuple (TSelf high, TSelf low) or similar, to match what we do for System.Math
-
-        // Returning int is currently what BitOperations does, however this can be cumbersome or prohibitive
-        // in various algorithms where returning TSelf is better.
-
-        static abstract (TSelf Quotient, TSelf Remainder) DivRem(TSelf left, TSelf right);
-
-        static abstract TSelf LeadingZeroCount(TSelf value);
-
-        static abstract TSelf PopCount(TSelf value);
-
-        static abstract TSelf RotateLeft(TSelf value, TSelf rotateAmount);
-
-        static abstract TSelf RotateRight(TSelf value, TSelf rotateAmount);
-
-        static abstract TSelf TrailingZeroCount(TSelf value);
-
-        // These methods allow getting the underlying bytes that represent the binary integer
-
-        void CopyTo(Span<byte> destination);
-
-        void CopyTo(byte[] destination);
-
-        void CopyTo(byte[] destination, int startIndex);
-
-        nuint GetByteCount();
-
-        nuint GetBitLength();
-
-        bool TryCopyTo(Span<byte> destination);
-    }
-
     public interface IExponentialFunctions<TSelf>
         where TSelf : IExponentialFunctions<TSelf>
     {
         static abstract TSelf Exp(TSelf x);
 
-        // IEEE defines n to be an integral type, but not the size
-
-        static abstract TSelf ScaleB<TInteger>(TSelf x, TInteger n)
-            where TInteger : IBinaryInteger<TInteger>;
-
         // The following methods are approved but not yet implemented in the libraries
 
         static abstract TSelf ExpM1(TSelf x);
@@ -897,11 +746,6 @@ namespace System
     public interface ILogarithmicFunctions<TSelf>
         where TSelf : ILogarithmicFunctions<TSelf>
     {
-        // IEEE defines the result to be an integral type, but not the size
-
-        static abstract TInteger ILogB<TInteger>(TSelf x)
-            where TInteger : IBinaryInteger<TInteger>;
-
         static abstract TSelf Log(TSelf x);
 
         static abstract TSelf Log(TSelf x, TSelf newBase);
@@ -930,12 +774,12 @@ namespace System
     {
         static abstract TSelf Cbrt(TSelf x);
 
-        static abstract TSelf Hypot(TSelf x, TSelf y);
-
         static abstract TSelf Sqrt(TSelf x);
 
         // The following methods are approved but not yet implemented in the libraries
 
+        static abstract TSelf Hypot(TSelf x, TSelf y);
+
         static abstract TSelf Root(TSelf x, TSelf n);
     }
 
@@ -972,9 +816,96 @@ namespace System
 
         static abstract TSelf TanPi(TSelf x);
     }
+}
+
+namespace System.Numerics
+{
+    public interface IBinaryFloatingPointIeee754<TSelf>
+        : IBinaryNumber<TSelf>,
+          IFloatingPointIeee754<TSelf>
+        where TSelf : IBinaryFloatingPointIeee754<TSelf>
+    {
+    }
+
+    public interface IBinaryInteger<TSelf>
+        : IBinaryNumber<TSelf>,
+          IShiftOperators<TSelf, TSelf, TSelf>
+        where TSelf : IBinaryInteger<TSelf>
+    {
+        // We might want to support "big multiplication" for fixed width types
+        // This would return a tuple (TSelf high, TSelf low) or similar, to match what we do for System.Math
+
+        // Returning int is currently what BitOperations does, however this can be cumbersome or prohibitive
+        // in various algorithms where returning TSelf is better.
+
+        static abstract (TSelf Quotient, TSelf Remainder) DivRem(TSelf left, TSelf right);
+
+        static abstract TSelf LeadingZeroCount(TSelf value);
+
+        static abstract TSelf PopCount(TSelf value);
+
+        static abstract TSelf RotateLeft(TSelf value, TSelf rotateAmount);
+
+        static abstract TSelf RotateRight(TSelf value, TSelf rotateAmount);
+
+        static abstract TSelf TrailingZeroCount(TSelf value);
+
+        // These methods allow getting the underlying bytes that represent the binary integer
+
+        long GetBitLength();
+
+        int GetByteCount();
+
+        bool TryWriteLittleEndian(Span<byte> destination, out int bytesWritten);
+
+        int WriteLittleEndian(byte[] destination);
+
+        int WriteLittleEndian(byte[] destination, int startIndex);
+
+        int WriteLittleEndian(Span<byte> destination);
+    }
+
+    public interface IBinaryNumber<TSelf>
+        : IBitwiseOperators<TSelf, TSelf, TSelf>,
+          INumber<TSelf>
+        where TSelf : IBinaryNumber<TSelf>
+    {
+        // Having the bitwise operators on IBinaryNumber<TSelf> means they will be available to floating-point types
+        // The operations are well-defined [for floats] but many languages don't directly expose them, we already support
+        // them in SIMD contexts today, as do most languages with SIMD support, so there is not great concern here.
+
+        static abstract bool IsPow2(TSelf value);
+
+        static abstract TSelf Log2(TSelf value);
+    }
+
+    public interface IDecimalFloatingPointIeee754<TSelf>
+        : IFloatingPointIeee754<TSelf>
+        where TSelf : IDecimalFloatingPointIeee754<TSelf>
+    {
+        // This interface is defined for convenience of viewing the IEEE requirements
+        // it would not actually be defined until the .NET libraries requires it
+
+        // The majority of the IEEE required operations are listed below
+        // This doesn't include the recommended operations such as sin, cos, acos, etc
+
+        // 5.3.2
+        //  TSelf Quantize(TSelf x, TSelf y);
+        //  TSelf Quantum(TSelf x);
+
+        // 5.5.2
+        //  TDecEnc EncodeDecimal(TSelf x);
+        //  TSelf DecodeDecimal(TDecEnc x);
+        //  TBinEnc EncodeBinary(TSelf x);
+        //  TSelf DecodeBinary(TBinEnc x);
+
+        // 5.7.3
+        //  bool SameQuantum(TSelf x, TSelf y);
+    }
 
     public interface IFloatingPoint<TSelf>
-        : ISignedNumberBase<TSelf>
+        : INumber<TSelf>,
+          ISignedNumber<TSelf>
         where TSelf : IFloatingPoint<TSelf>
     {
         static abstract TSelf Ceiling(TSelf x);
@@ -983,13 +914,11 @@ namespace System
 
         static abstract TSelf Round(TSelf x);
 
-        static abstract TSelf Round<TInteger>(TSelf x, TInteger digits)
-            where TInteger : IBinaryInteger<TInteger>;
+        static abstract TSelf Round(TSelf x, int digits);
 
         static abstract TSelf Round(TSelf x, MidpointRounding mode);
 
-        static abstract TSelf Round<TInteger>(TSelf x, TInteger digits, MidpointRounding mode)
-            where TInteger : IBinaryInteger<TInteger>;
+        static abstract TSelf Round(TSelf x, int digits, MidpointRounding mode);
 
         static abstract TSelf Truncate(TSelf x);
     }
@@ -1008,7 +937,7 @@ namespace System
 
         static abstract TSelf E { get; }
 
-        static abstract TSelf PI { get; }
+        static abstract TSelf Pi { get; }
 
         static abstract TSelf Tau { get; }
 
@@ -1017,13 +946,21 @@ namespace System
         // This, in a way, obsoletes Math/MathF and brings float/double inline with how non-primitive types support similar functionality
         // API review will need to determine if we'll want to continue adding APIs to Math/MathF in the future
 
+        static abstract TSelf BitDecrement(TSelf x);
+
         static abstract TSelf BitIncrement(TSelf x);
 
-        static abstract TSelf BitDecrement(TSelf x);
+        static abstract TSelf FusedMultiplyAdd(TSelf left, TSelf right, TSelf addend);
+
+        static abstract TSelf Ieee754Remainder(TSelf left, TSelf right);
+
+        // IEEE defines the result to be an integral type, but not the size
+
+        static abstract int ILogB(TSelf x);
 
-        static abstract TSelf FusedMultiplyAdd(TSelf x, TSelf y, TSelf z);
+        // IEEE defines n to be an integral type, but not the size
 
-        static abstract TSelf IEEERemainder(TSelf x, TSelf y);
+        static abstract TSelf ScaleB(TSelf x, int n);
 
         // The following members are exposed on the floating-point types as constants today
         // This may be of concern when implementing the interface
@@ -1070,29 +1007,29 @@ namespace System
 
         // These methods allow getting the underlying bytes that represent the IEEE 754 floating-point
 
-        void CopyExponentTo(Span<byte> destination);
+        long GetExponentBitLength();
 
-        void CopyExponentTo(byte[] destination);
+        int GetExponentByteCount();
 
-        void CopyExponentTo(byte[] destination, int startIndex);
+        long GetSignificandBitLength();
 
-        nuint GetExponentByteCount();
+        int GetSignificandByteCount();
 
-        nuint GetExponentBitLength();
+        bool TryWriteExponentLittleEndian(Span<byte> destination, out int bytesWritten);
 
-        bool TryCopyExponentTo(Span<byte> destination);
+        bool TryWriteSignificandLittleEndian(Span<byte> destination, out int bytesWritten);
 
-        void CopySignificandTo(Span<byte> destination);
+        int WriteExponentLittleEndian(byte[] destination);
 
-        void CopySignificandTo(byte[] destination);
+        int WriteExponentLittleEndian(byte[] destination, int startIndex);
 
-        void CopySignificandTo(byte[] destination, int startIndex);
+        int WriteExponentLittleEndian(Span<byte> destination);
 
-        nuint GetSignificandByteCount();
+        int WriteSignificandLittleEndian(byte[] destination);
 
-        nuint GetSignificandBitLength();
+        int WriteSignificandLittleEndian(byte[] destination, int startIndex);
 
-        bool TryCopySignificandTo(Span<byte> destination);
+        int WriteSignificandLittleEndian(Span<byte> destination);
 
         // The majority of the IEEE required operations are listed below
         // This doesn't include the recommended operations such as sin, cos, acos, etc
@@ -1226,35 +1163,102 @@ namespace System
         //  TSelf SetPayloadSignaling(TSelf x);
     }
 
-    public interface IBinaryFloatingPointIeee754<TSelf>
-        : IBinaryNumber<TSelf>,
-          IFloatingPointIeee754<TSelf>
-        where TSelf : IBinaryFloatingPointIeee754<TSelf>
+    public interface INumber<TSelf>
+        : IComparisonOperators<TSelf, TSelf>,   // implies IEqualityOperators<TSelf, TSelf>
+          IModulusOperators<TSelf, TSelf, TSelf>,
+          INumberBase<TSelf>,
+          ISpanParsable<TSelf>                  // implies IParsable<TSelf>
+        where TSelf : INumber<TSelf>
     {
+        // For the Create methods, there is some concern over users implementing them. It is not necessarily trivial to take an arbitrary TOther
+        // and convert it into an arbitrary TSelf. If you know the type of TOther, you may be able to optimize in a few ways. Otherwise, you
+        // may have to fail and throw in the worst case.
+
+        static abstract TSelf Create<TOther>(TOther value)
+            where TOther : INumber<TOther>;
+
+        static abstract TSelf CreateSaturating<TOther>(TOther value)
+            where TOther : INumber<TOther>;
+
+        static abstract TSelf CreateTruncating<TOther>(TOther value)
+            where TOther : INumber<TOther>;
+
+        // There is an open question on whether properties like IsSigned, IsBinary, IsFixedWidth, Base/Radix, and others are beneficial
+        // We could expose them for trivial checks or users could be required to check for the corresponding correct interfaces
+
+        // Abs mirrors Math.Abs and returns the same type. This can fail for MinValue of signed integer types
+        // Swift has an associated type that can be used here, which would require an additional type parameter in .NET
+        // However that would hinder the reusability of these interfaces in constraints
+
+        static abstract TSelf Abs(TSelf value);
+
+        static abstract TSelf Clamp(TSelf value, TSelf min, TSelf max);
+
+        static abstract TSelf CopySign(TSelf value, TSelf sign);
+
+        // IsEven, IsOdd, IsZero
+
+        static abstract bool IsNegative(TSelf value);
+
+        static abstract TSelf Max(TSelf x, TSelf y);
+
+        static abstract TSelf MaxMagnitude(TSelf x, TSelf y);
+
+        static abstract TSelf Min(TSelf x, TSelf y);
+
+        static abstract TSelf MinMagnitude(TSelf x, TSelf y);
+
+        static abstract TSelf Parse(string s, NumberStyles style, IFormatProvider? provider);
+
+        static abstract TSelf Parse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider);
+
+        // Math only exposes this Sign for signed types, but it is well-defined for unsigned types
+        // it can simply never return -1 and only 0 or 1 instead
+
+        static abstract int Sign(TSelf value);
+
+        static abstract bool TryCreate<TOther>(TOther value, out TSelf result)
+            where TOther : INumber<TOther>;
+
+        static abstract bool TryParse([NotNullWhen(true)] string? s, NumberStyles style, IFormatProvider? provider, out TSelf result);
+
+        static abstract bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider, out TSelf result);
     }
 
-    public interface IDecimalFloatingPointIeee754<TSelf>
-        : IFloatingPointIeee754<TSelf>
-        where TSelf : IDecimalFloatingPointIeee754<TSelf>
+    public interface INumberBase<TSelf>
+        : IAdditionOperators<TSelf, TSelf, TSelf>,
+          IAdditiveIdentity<TSelf, TSelf>,
+          IDecrementOperators<TSelf>,
+          IDivisionOperators<TSelf, TSelf, TSelf>,
+          IEqualityOperators<TSelf, TSelf>,     // implies IEquatable<TSelf>
+          IIncrementOperators<TSelf>,
+          IMultiplicativeIdentity<TSelf, TSelf>,
+          IMultiplyOperators<TSelf, TSelf>,
+          ISpanFormattable,                     // implies IFormattable
+          ISubtractionOperators<TSelf, TSelf, TSelf>,
+          IUnaryPlusOperators<TSelf, TSelf>,
+          IUnaryNegationOperators<TSelf, TSelf>
+        where TSelf : INumberBase<TSelf>
     {
-        // This interface is defined for convenience of viewing the IEEE requirements
-        // it would not actually be defined until the .NET libraries requires it
+        // Alias for MultiplicativeIdentity
+        static abstract TSelf One { get; }
 
-        // The majority of the IEEE required operations are listed below
-        // This doesn't include the recommended operations such as sin, cos, acos, etc
+        // Alias for AdditiveIdentity
+        static abstract TSelf Zero { get; }
+    }
 
-        // 5.3.2
-        //  TSelf Quantize(TSelf x, TSelf y);
-        //  TSelf Quantum(TSelf x);
+    public interface ISignedNumber<TSelf>
+        where TSelf : INumberBase<TSelf>, ISignedNumber<TSelf>
+    {
+        // It's not possible to check for lack of an interface in a constraint, so ISignedNumber<TSelf> is likely required
 
-        // 5.5.2
-        //  TDecEnc EncodeDecimal(TSelf x);
-        //  TSelf DecodeDecimal(TDecEnc x);
-        //  TBinEnc EncodeBinary(TSelf x);
-        //  TSelf DecodeBinary(TBinEnc x);
+        static abstract TSelf NegativeOne { get; }
+    }
 
-        // 5.7.3
-        //  bool SameQuantum(TSelf x, TSelf y);
+    public interface IUnsignedNumber<TSelf>
+        where TSelf : INumberBase<TSelf>, IUnsignedNumber<TSelf>
+    {
+        // It's not possible to check for lack of an interface in a constraint, so IUnsignedNumber<TSelf> is likely required
     }
 }
 
@@ -1335,28 +1339,276 @@ namespace System
         : IBinaryInteger<byte>,
           IConvertible,
           IMinMaxValue<byte>,
-          IUnsignedNumberBase<byte>
-    {
-        public const byte AdditiveIdentity = 0;
-        public const byte MultiplicativeIdentity = 1;
-        public const byte One = 1;
-        public const byte Zero = 0;
+          IUnsignedNumber<byte>
+    {
+        public const byte AdditiveIdentity = 0;                                             // ? Expose
+        public const byte MaxValue = 255;                                                   // Existing
+        public const byte MinValue = 0;                                                     // Existing
+        public const byte MultiplicativeIdentity = 1;                                       // ? Expose
+        public const byte One = 1;                                                          // ? Expose
+        public const byte Zero = 0;                                                         // ? Expose
+
+        // Explicitly implemented interfaces
+        // * IAdditiveIdentity
+        //   * TSelf AdditiveIdentity { get; }
+        // * IMinMaxValue
+        //   * TSelf MaxValue { get; }
+        //   * TSelf MinValue { get; }
+        // * IMultiplicativeIdentity
+        //   * TSelf MultiplicativeIdentity { get; }
+        // * INumberBase
+        //   * TSelf One { get; }
+        //   * TSelf Zero { get; }
+        //
+        // * IAdditionOperators
+        //   * TSelf operator +(TSelf, TSelf)
+        //   * TSelf operator checked +(TSelf, TSelf)
+        // * IBitwiseOperators
+        //   * TSelf operator &(TSelf, TSelf)
+        //   * TSelf operator |(TSelf, TSelf)
+        //   * TSelf operator ^(TSelf, TSelf)
+        //   * TSelf operator ~(TSelf)
+        // * IComparisonOperators
+        //   * bool operator <(TSelf, TSelf)
+        //   * bool operator <=(TSelf, TSelf)
+        //   * bool operator >(TSelf, TSelf)
+        //   * bool operator >=(TSelf, TSelf)
+        // * IDecrementOperators
+        //   * TSelf operator --(TSelf)
+        //   * TSelf operator checked --(TSelf)
+        // * IDivisionOperators
+        //   * TSelf operator /(TSelf, TSelf)
+        //   * TSelf operator checked /(TSelf, TSelf)
+        // * IEqualityOperators
+        //   * bool operator ==(TSelf, TSelf)
+        //   * bool operator !=(TSelf, TSelf)
+        // * IIncrementOperators
+        //   * TSelf operator ++(TSelf)
+        //   * TSelf operator checked ++(TSelf)
+        // * IModulusOperators
+        //   * TSelf operator %(TSelf, TSelf)
+        // * IMultiplyOperators
+        //   * TSelf operator *(TSelf, TSelf)
+        //   * TSelf operator checked *(TSelf, TSelf)
+        // * IShiftOperators
+        //   * TSelf operator <<(TSelf, int)
+        //   * TSelf operator >>(TSelf, int)
+        //   * TSelf operator >>>(TSelf, int)
+        // * ISubtractionOperators
+        //   * TSelf operator -(TSelf, TSelf)
+        //   * TSelf operator checked -(TSelf, TSelf)
+        // * IUnaryNegationOperators
+        //   * TSelf operator -(TSelf)
+        //   * TSelf operator checked -(TSelf)
+        // * IUnaryPlusOperators
+        //   * TSelf operator +(TSelf)
+
+        // Implicitly Implemented interfaces
+        // * IBinaryInteger
+        //   * (TSelf, TSelf) DivRem(TSelf, TSelf)
+        //   * long GetBitLength()                                                          // Approved - NYI
+        //   * int GetByteCount()                                                           // Approved - NYI
+        //   * TSelf LeadingZeroCount(TSelf)
+        //   * TSelf PopCount(TSelf)
+        //   * TSelf RotateLeft(TSelf, int)
+        //   * TSelf RotateRight(TSelf, int)
+        //   * TSelf TrailingZeroCount(TSelf)
+        //   * bool TryWriteLittleEndian(byte[], out int)                                   // Approved - NYI
+        //   * int WriteLittleEndian(byte[])                                                // Approved - NYI
+        //   * int WriteLittleEndian(byte[], int)                                           // Approved - NYI
+        //   * int WriteLittleEndian(Span<byte>)                                            // Approved - NYI
+        // * IBinaryNumber                                                                  // Approved - NYI
+        //   * bool IsPow2(TSelf)
+        //   * TSelf Log2(TSelf)
+        // * IComparable                                                                    // Existing
+        //   * int CompareTo(object?)                                                       // * Existing
+        //   * int CompareTo(TSelf)                                                         // * Existing
+        // * IEquatable                                                                     // Existing
+        //   * bool Equals(TSelf)                                                           // * Existing
+        // * IFormattable                                                                   // Existing
+        //   * string ToString(string?, IFormatProvider?)                                   // * Existing
+        // * INumber
+        //   * TSelf Abs(TSelf)                                                             // ? Explicit
+        //   * TSelf Clamp(TSelf, TSelf, TSelf)
+        //   * TSelf CopySign(TSelf, TSelf)                                                 // ? Explicit
+        //   * TSelf CreateChecked(TOther)
+        //   * TSelf CreateSaturating(TOther)
+        //   * TSelf CreateTruncating(TOther)
+        //   * bool IsNegative(TSelf)                                                       // ? Explicit
+        //   * TSelf Max(TSelf, TSelf)
+        //   * TSelf MaxMagnitude(TSelf, TSelf)                                             // ? Explicit
+        //   * TSelf Min(TSelf, TSelf)
+        //   * TSelf MinMagnitude(TSelf, TSelf)                                             // ? Explicit
+        //   * TSelf Parse(string, NumberStyles, IFormatProvider?)                          // * Existing
+        //   * TSelf Parse(ReadOnlySpan<char>, NumberStyles, IFormatProvider?)              // * Existing - Optional Args
+        //   * int Sign(TSelf)
+        //   * bool TryCreate(TOther, out TSelf)
+        //   * bool TryParse(string?, NumberStyles, IFormatProvider?, out TSelf)            // * Existing
+        //   * bool TryParse(ReadOnlySpan<char>, NumberStyles, IFormatProvider?, out TSelf) // * Existing
+        // * IParsable
+        //   * TSelf Parse(string, IFormatProvider?)                                        // * Existing
+        //   * bool TryParse(string?, IFormatProvider?, out TSelf)
+        // * ISpanFormattable                                                               // Existing
+        //   * bool TryFormat(Span<char>, out int, ReadOnlySpan<char>, IFormatProvider?)    // * Existing - Optional Args
+        // * ISpanParsable
+        //   * TSelf Parse(ReadOnlySpan<char>, IFormatProvider?)
+        //   * bool TryParse(ReadOnlySpan<char>, IFormatProvider?, out TSelf)
     }
 
     public struct Char
         : IBinaryInteger<char>,
           IConvertible,
           IMinMaxValue<char>,
-          IUnsignedNumberBase<char>
-    {
+          IUnsignedNumber<char>
+    {
+        public const short AdditiveIdentity = 0;                                             // ? Expose
+        public const short MaxValue = 65535;                                                 // Existing
+        public const short MinValue = 0;                                                     // Existing
+        public const short MultiplicativeIdentity = 1;                                       // ? Expose
+        public const short One = 1;                                                          // ? Expose
+        public const short Zero = 0;                                                         // ? Expose
+
+        // Explicitly implemented interfaces
+        // * IAdditiveIdentity
+        //   * TSelf AdditiveIdentity { get; }
+        // * IMinMaxValue
+        //   * TSelf MaxValue { get; }
+        //   * TSelf MinValue { get; }
+        // * IMultiplicativeIdentity
+        //   * TSelf MultiplicativeIdentity { get; }
+        // * INumberBase
+        //   * TSelf One { get; }
+        //   * TSelf Zero { get; }
+        //
+        // * IAdditionOperators
+        //   * TSelf operator +(TSelf, TSelf)
+        //   * TSelf operator checked +(TSelf, TSelf)
+        // * IBitwiseOperators
+        //   * TSelf operator &(TSelf, TSelf)
+        //   * TSelf operator |(TSelf, TSelf)
+        //   * TSelf operator ^(TSelf, TSelf)
+        //   * TSelf operator ~(TSelf)
+        // * IComparisonOperators
+        //   * bool operator <(TSelf, TSelf)
+        //   * bool operator <=(TSelf, TSelf)
+        //   * bool operator >(TSelf, TSelf)
+        //   * bool operator >=(TSelf, TSelf)
+        // * IDecrementOperators
+        //   * TSelf operator --(TSelf)
+        //   * TSelf operator checked --(TSelf)
+        // * IDivisionOperators
+        //   * TSelf operator /(TSelf, TSelf)
+        //   * TSelf operator checked /(TSelf, TSelf)
+        // * IEqualityOperators
+        //   * bool operator ==(TSelf, TSelf)
+        //   * bool operator !=(TSelf, TSelf)
+        // * IIncrementOperators
+        //   * TSelf operator ++(TSelf)
+        //   * TSelf operator checked ++(TSelf)
+        // * IModulusOperators
+        //   * TSelf operator %(TSelf, TSelf)
+        // * IMultiplyOperators
+        //   * TSelf operator *(TSelf, TSelf)
+        //   * TSelf operator checked *(TSelf, TSelf)
+        // * IShiftOperators
+        //   * TSelf operator <<(TSelf, int)
+        //   * TSelf operator >>(TSelf, int)
+        //   * TSelf operator >>>(TSelf, int)
+        // * ISubtractionOperators
+        //   * TSelf operator -(TSelf, TSelf)
+        //   * TSelf operator checked -(TSelf, TSelf)
+        // * IUnaryNegationOperators
+        //   * TSelf operator -(TSelf)
+        //   * TSelf operator checked -(TSelf)
+        // * IUnaryPlusOperators
+        //   * TSelf operator +(TSelf)
+
+        // Implicitly Implemented interfaces
+        // * IBinaryInteger
+        //   * (TSelf, TSelf) DivRem(TSelf, TSelf)
+        //   * long GetBitLength()                                                          // Approved - NYI
+        //   * int GetByteCount()                                                           // Approved - NYI
+        //   * TSelf LeadingZeroCount(TSelf)
+        //   * TSelf PopCount(TSelf)
+        //   * TSelf RotateLeft(TSelf, int)
+        //   * TSelf RotateRight(TSelf, int)
+        //   * TSelf TrailingZeroCount(TSelf)
+        //   * bool TryWriteLittleEndian(byte[], out int)                                   // Approved - NYI
+        //   * int WriteLittleEndian(byte[])                                                // Approved - NYI
+        //   * int WriteLittleEndian(byte[], int)                                           // Approved - NYI
+        //   * int WriteLittleEndian(Span<byte>)                                            // Approved - NYI
+        // * IBinaryNumber                                                                  // Approved - NYI
+        //   * bool IsPow2(TSelf)
+        //   * TSelf Log2(TSelf)
+        // * IComparable                                                                    // Existing
+        //   * int CompareTo(object?)                                                       // * Existing
+        //   * int CompareTo(TSelf)                                                         // * Existing
+        // * IEquatable                                                                     // Existing
+        //   * bool Equals(TSelf)                                                           // * Existing
+        // * IFormattable                                                                   // Existing
+        //   * string ToString(string?, IFormatProvider?)                                   // * Existing - Explicit
+        // * INumber
+        //   * TSelf Abs(TSelf)                                                             // ? Explicit
+        //   * TSelf Clamp(TSelf, TSelf, TSelf)
+        //   * TSelf CopySign(TSelf, TSelf)                                                 // ? Explicit
+        //   * TSelf CreateChecked(TOther)
+        //   * TSelf CreateSaturating(TOther)
+        //   * TSelf CreateTruncating(TOther)
+        //   * bool IsNegative(TSelf)                                                       // ? Explicit
+        //   * TSelf Max(TSelf, TSelf)
+        //   * TSelf MaxMagnitude(TSelf, TSelf)                                             // ? Explicit
+        //   * TSelf Min(TSelf, TSelf)
+        //   * TSelf MinMagnitude(TSelf, TSelf)                                             // ? Explicit
+        //   * TSelf Parse(string, NumberStyles, IFormatProvider?)                          // ? Explicit
+        //   * TSelf Parse(ReadOnlySpan<char>, NumberStyles, IFormatProvider?)              // ? Explicit
+        //   * int Sign(TSelf)
+        //   * bool TryCreate(TOther, out TSelf)
+        //   * bool TryParse(string?, NumberStyles, IFormatProvider?, out TSelf)            // ? Explicit
+        //   * bool TryParse(ReadOnlySpan<char>, NumberStyles, IFormatProvider?, out TSelf) // ? Explicit
+        // * IParsable
+        //   * TSelf Parse(string, IFormatProvider?)                                        // ? Explicit
+        //   * bool TryParse(string?, IFormatProvider?, out TSelf)                          // ? Explicit
+        // * ISpanFormattable                                                               // Existing
+        //   * bool TryFormat(Span<char>, out int, ReadOnlySpan<char>, IFormatProvider?)    // * Existing - Explicit
+        // * ISpanParsable
+        //   * TSelf Parse(ReadOnlySpan<char>, IFormatProvider?)                            // ? Explicit
+        //   * bool TryParse(ReadOnlySpan<char>, IFormatProvider?, out TSelf)               // ? Explicit
     }
 
     public struct DateOnly
         : IComparisonOperators<DateOnly, DateOnly>,
           IMinMaxValue<DateOnly>,
           ISpanFormattable,
-          ISpanParseable<DateOnly>
-    {
+          ISpanParsable<DateOnly>
+    {
+        // Implicitly Implemented interfaces
+        // * IMinMaxValue
+        //   * TSelf MaxValue { get; }                                                      // * Existing
+        //   * TSelf MinValue { get; }                                                      // * Existing
+        //
+        // * IComparable                                                                    // Existing
+        //   * int CompareTo(object?)                                                       // * Existing
+        //   * int CompareTo(TSelf)                                                         // * Existing
+        // * IComparisonOperators
+        //   * bool operator <(TSelf, TSelf)                                                // * Existing
+        //   * bool operator <=(TSelf, TSelf)                                               // * Existing
+        //   * bool operator >(TSelf, TSelf)                                                // * Existing
+        //   * bool operator >=(TSelf, TSelf)                                               // * Existing
+        // * IEqualityOperators
+        //   * bool operator ==(TSelf, TSelf)                                               // * Existing
+        //   * bool operator !=(TSelf, TSelf)                                               // * Existing
+        // * IEquatable                                                                     // Existing
+        //   * bool Equals(TSelf)                                                           // * Existing
+        // * IFormattable                                                                   // Existing
+        //   * string ToString(string?, IFormatProvider?)                                   // * Existing
+        // * IParsable
+        //   * TSelf Parse(string, IFormatProvider?)
+        //   * bool TryParse(string?, IFormatProvider?, out TSelf)
+        // * ISpanFormattable                                                               // Existing
+        //   * bool TryFormat(Span<char>, out int, ReadOnlySpan<char>, IFormatProvider?)    // * Existing
+        // * ISpanParsable
+        //   * TSelf Parse(ReadOnlySpan<char>, IFormatProvider?)
+        //   * bool TryParse(ReadOnlySpan<char>, IFormatProvider?, out TSelf)
     }
 
     public struct DateTime
@@ -1367,10 +1619,50 @@ namespace System
           IMinMaxValue<DateTime>,
           ISerializable,
           ISpanFormattable,
-          ISpanParseable<DateTime>,
+          ISpanParsable<DateTime>,
           ISubtractionOperators<DateTime, TimeSpan, DateTime>,
           ISubtractionOperators<DateTime, DateTime, TimeSpan>
     {
+        public static readonly DateTime MaxValue;                                           // Existing
+        public static readonly DateTime MinValue;                                           // Existing
+
+        // Explicitly Implemented interfaces
+        // * IAdditiveIdentity
+        //   * TSelf AdditiveIdentity { get; }
+        // * IMinMaxValue
+        //   * TSelf MaxValue { get; }
+        //   * TSelf MinValue { get; }
+
+        // Implicitly Implemented interfaces
+        // * IAdditionOperators
+        //   * TSelf operator +(TSelf, TSelf)                                               // * Existing
+        //   * TSelf operator checked +(TSelf, TSelf)
+        // * IComparable                                                                    // Existing
+        //   * int CompareTo(object?)                                                       // * Existing
+        //   * int CompareTo(TSelf)                                                         // * Existing
+        // * IComparisonOperators
+        //   * bool operator <(TSelf, TSelf)                                                // * Existing
+        //   * bool operator <=(TSelf, TSelf)                                               // * Existing
+        //   * bool operator >(TSelf, TSelf)                                                // * Existing
+        //   * bool operator >=(TSelf, TSelf)                                               // * Existing
+        // * IEqualityOperators
+        //   * bool operator ==(TSelf, TSelf)                                               // * Existing
+        //   * bool operator !=(TSelf, TSelf)                                               // * Existing
+        // * IEquatable                                                                     // Existing
+        //   * bool Equals(TSelf)                                                           // * Existing
+        // * IFormattable                                                                   // Existing
+        //   * string ToString(string?, IFormatProvider?)                                   // * Existing
+        // * IParsable
+        //   * TSelf Parse(string, IFormatProvider?)                                        // * Existing
+        //   * bool TryParse(string?, IFormatProvider?, out TSelf)
+        // * ISpanFormattable                                                               // Existing
+        //   * bool TryFormat(Span<char>, out int, ReadOnlySpan<char>, IFormatProvider?)    // * Existing
+        // * ISpanParsable
+        //   * TSelf Parse(ReadOnlySpan<char>, IFormatProvider?)
+        //   * bool TryParse(ReadOnlySpan<char>, IFormatProvider?, out TSelf)
+        // * ISubtractionOperators
+        //   * TSelf operator -(TSelf, TSelf)                                               // * Existing
+        //   * TSelf operator checked -(TSelf, TSelf)
     }
 
     public struct DateTimeOffset
@@ -1381,11 +1673,52 @@ namespace System
           IMinMaxValue<DateTimeOffset>,
           ISerializable,
           ISpanFormattable,
-          ISpanParseable<DateTimeOffset>,
+          ISpanParsable<DateTimeOffset>,
           ISubtractionOperators<DateTimeOffset, TimeSpan, DateTimeOffset>,
           ISubtractionOperators<DateTimeOffset, DateTimeOffset, TimeSpan>
     {
         // TODO: DateTimeOffset defines an implicit conversion to DateTime, should that be modeled in the interfaces?
+
+        public static readonly DateTimeOffset MaxValue;                                     // Existing
+        public static readonly DateTimeOffset MinValue;                                     // Existing
+
+        // Explicitly Implemented interfaces
+        // * IAdditiveIdentity
+        //   * TSelf AdditiveIdentity { get; }
+        // * IMinMaxValue
+        //   * TSelf MaxValue { get; }
+        //   * TSelf MinValue { get; }
+
+        // Implicitly Implemented interfaces
+        // * IAdditionOperators
+        //   * TSelf operator +(TSelf, TSelf)                                               // * Existing
+        //   * TSelf operator checked +(TSelf, TSelf)
+        // * IComparable                                                                    // Existing
+        //   * int CompareTo(object?)                                                       // * Existing
+        //   * int CompareTo(TSelf)                                                         // * Existing
+        // * IComparisonOperators
+        //   * bool operator <(TSelf, TSelf)                                                // * Existing
+        //   * bool operator <=(TSelf, TSelf)                                               // * Existing
+        //   * bool operator >(TSelf, TSelf)                                                // * Existing
+        //   * bool operator >=(TSelf, TSelf)                                               // * Existing
+        // * IEqualityOperators
+        //   * bool operator ==(TSelf, TSelf)                                               // * Existing
+        //   * bool operator !=(TSelf, TSelf)                                               // * Existing
+        // * IEquatable                                                                     // Existing
+        //   * bool Equals(TSelf)                                                           // * Existing
+        // * IFormattable                                                                   // Existing
+        //   * string ToString(string?, IFormatProvider?)                                   // * Existing
+        // * IParsable
+        //   * TSelf Parse(string, IFormatProvider?)                                        // * Existing
+        //   * bool TryParse(string?, IFormatProvider?, out TSelf)
+        // * ISpanFormattable                                                               // Existing
+        //   * bool TryFormat(Span<char>, out int, ReadOnlySpan<char>, IFormatProvider?)    // * Existing
+        // * ISpanParsable
+        //   * TSelf Parse(ReadOnlySpan<char>, IFormatProvider?)
+        //   * bool TryParse(ReadOnlySpan<char>, IFormatProvider?, out TSelf)
+        // * ISubtractionOperators
+        //   * TSelf operator -(TSelf, TSelf)                                               // * Existing
+        //   * TSelf operator checked -(TSelf, TSelf)
     }
 
     public struct Decimal
@@ -1402,11 +1735,104 @@ namespace System
 
         // Decimal exposes a member named MinusOne
 
-        public const decimal AdditiveIdentity = 0;
-        public const decimal MultiplicativeIdentity = 1;
-        public const decimal NegativeOne = 1;
-        public const decimal One = 1;
-        public const decimal Zero = 0;
+        public const decimal AdditiveIdentity = 0;                                          // ? Expose
+        public const decimal MaxValue = 79228162514264337593543950335m;                     // Existing
+        public const decimal MinusOne = -1;                                                 // Existing - "Conflicts" with NegativeOne
+        public const decimal MinValue = -79228162514264337593543950335m;                    // Existing
+        public const decimal MultiplicativeIdentity = 1;                                    // ? Expose
+        public const decimal NegativeOne = -1                                               // ? Expose
+        public const decimal One = 1;                                                       // Existing
+        public const decimal Zero = 0;                                                      // Existing
+
+        // Explicitly implemented interfaces
+        // * IAdditiveIdentity
+        //   * TSelf AdditiveIdentity { get; }
+        // * IMinMaxValue
+        //   * TSelf MaxValue { get; }
+        //   * TSelf MinValue { get; }
+        // * IMultiplicativeIdentity
+        //   * TSelf MultiplicativeIdentity { get; }
+        // * INumberBase
+        //   * TSelf One { get; }
+        //   * TSelf Zero { get; }
+        // * ISignedNumber
+        //   * TSelf NegativeOne { get; }
+
+        // Implicitly implemented interfaces
+        // * IAdditionOperators
+        //   * TSelf operator +(TSelf, TSelf)                                               // * Existing
+        //   * TSelf operator checked +(TSelf, TSelf)                                       // ? Explicit
+        // * IComparable                                                                    // Existing
+        //   * int CompareTo(object?)                                                       // * Existing
+        //   * int CompareTo(TSelf)                                                         // * Existing
+        // * IComparisonOperators
+        //   * bool operator <(TSelf, TSelf)                                                // * Existing
+        //   * bool operator <=(TSelf, TSelf)                                               // * Existing
+        //   * bool operator >(TSelf, TSelf)                                                // * Existing
+        //   * bool operator >=(TSelf, TSelf)                                               // * Existing
+        // * IDecrementOperators
+        //   * TSelf operator --(TSelf)                                                     // * Existing
+        //   * TSelf operator checked --(TSelf)                                             // ? Explicit
+        // * IDivisionOperators
+        //   * TSelf operator /(TSelf, TSelf)                                               // * Existing
+        //   * TSelf operator checked /(TSelf, TSelf)                                       // ? Explicit
+        // * IEqualityOperators
+        //   * bool operator ==(TSelf, TSelf)                                               // * Existing
+        //   * bool operator !=(TSelf, TSelf)                                               // * Existing
+        // * IEquatable                                                                     // Existing
+        //   * bool Equals(TSelf)                                                           // * Existing
+        // * IFloatingPoint
+        //   * TSelf Ceiling(TSelf)                                                         // * Existing
+        //   * TSelf Floor(TSelf)                                                           // * Existing
+        //   * TSelf Round(TSelf)                                                           // * Existing
+        //   * TSelf Round(TSelf, int)                                                      // * Existing
+        //   * TSelf Round(TSelf, MidpointRounding)                                         // * Existing
+        //   * TSelf Round(TSelf, int, MidpointRounding)                                    // * Existing
+        //   * TSelf Truncate(TSelf)                                                        // * Existing
+        // * IFormattable                                                                   // Existing
+        //   * string ToString(string?, IFormatProvider?)                                   // * Existing
+        // * IIncrementOperators
+        //   * TSelf operator ++(TSelf)                                                     // * Existing
+        //   * TSelf operator checked ++(TSelf)                                             // ? Explicit
+        // * IModulusOperators
+        //   * TSelf operator %(TSelf, TSelf)                                               // Existing
+        // * IMultiplyOperators
+        //   * TSelf operator *(TSelf, TSelf)                                               // * Existing
+        //   * TSelf operator checked *(TSelf, TSelf)                                       // ? Explicit
+        // * INumber
+        //   * TSelf Abs(TSelf)
+        //   * TSelf Clamp(TSelf, TSelf, TSelf)
+        //   * TSelf CopySign(TSelf, TSelf)
+        //   * TSelf CreateChecked(TOther)
+        //   * TSelf CreateSaturating(TOther)
+        //   * TSelf CreateTruncating(TOther)
+        //   * bool IsNegative(TSelf)
+        //   * TSelf Max(TSelf, TSelf)
+        //   * TSelf MaxMagnitude(TSelf, TSelf)
+        //   * TSelf Min(TSelf, TSelf)
+        //   * TSelf MinMagnitude(TSelf, TSelf)
+        //   * TSelf Parse(string, NumberStyles, IFormatProvider?)                          // * Existing
+        //   * TSelf Parse(ReadOnlySpan<char>, NumberStyles, IFormatProvider?)              // * Existing
+        //   * int Sign(TSelf)
+        //   * bool TryCreate(TOther, out TSelf)
+        //   * bool TryParse(string?, NumberStyles, IFormatProvider?, out TSelf)            // * Existing
+        //   * bool TryParse(ReadOnlySpan<char>, NumberStyles, IFormatProvider?, out TSelf) // * Existing
+        // * IParsable
+        //   * TSelf Parse(string, IFormatProvider?)                                        // * Existing
+        //   * bool TryParse(string?, IFormatProvider?, out TSelf)
+        // * ISpanFormattable
+        //   * bool TryFormat(Span<char>, out int, ReadOnlySpan<char>, IFormatProvider?)    // * Existing
+        // * ISpanParsable
+        //   * TSelf Parse(ReadOnlySpan<char>, IFormatProvider?)
+        //   * bool TryParse(ReadOnlySpan<char>, IFormatProvider?, out TSelf)
+        // * ISubtractionOperators
+        //   * TSelf operator -(TSelf, TSelf)                                               // * Existing
+        //   * TSelf operator checked -(TSelf, TSelf)                                       // ? Explicit
+        // * IUnaryNegationOperators
+        //   * TSelf operator -(TSelf)                                                      // * Existing
+        //   * TSelf operator checked -(TSelf)                                              // ? Explicit
+        // * IUnaryPlusOperators
+        //   * TSelf operator +(TSelf)                                                      // * Existing
     }
 
     public struct Double
@@ -1414,11 +1840,199 @@ namespace System
           IConvertible,
           IMinMaxValue<double>
     {
-        public const double AdditiveIdentity = 0;
-        public const double MultiplicativeIdentity = 1;
-        public const double NegativeOne = 1;
-        public const double One = 1;
-        public const double Zero = 0;
+        public const double AdditiveIdentity = 0;                                           // ? Expose
+        public const double E = Math.E;
+        public const double MaxValue = 1.7976931348623157E+308;                             // Existing
+        public const double MinValue = -1.7976931348623157E+308;                            // Existing
+        public const double MultiplicativeIdentity = 1;                                     // ? Expose
+        public const double NegativeOne = -1                                                // ? Expose
+        public const double NegativeZero = -0.0;
+        public const double One = 1;                                                        // ? Expose
+        public const double Pi = Math.PI;
+        public const double Tau = Math.Tau;
+        public const double Zero = 0;                                                       // ? Expose
+
+        // Explicitly implemented interfaces
+        // * IAdditiveIdentity
+        //   * TSelf AdditiveIdentity { get; }
+        // * IMinMaxValue
+        //   * TSelf MaxValue { get; }
+        //   * TSelf MinValue { get; }
+        // * IMultiplicativeIdentity
+        //   * TSelf MultiplicativeIdentity { get; }
+        // * INumberBase
+        //   * TSelf One { get; }
+        //   * TSelf Zero { get; }
+        // * ISignedNumber
+        //   * TSelf NegativeOne { get; }
+        //
+        // * IAdditionOperators
+        //   * TSelf operator +(TSelf, TSelf)
+        //   * TSelf operator checked +(TSelf, TSelf)
+        // * IBitwiseOperators
+        //   * TSelf operator &(TSelf, TSelf)
+        //   * TSelf operator |(TSelf, TSelf)
+        //   * TSelf operator ^(TSelf, TSelf)
+        //   * TSelf operator ~(TSelf)
+        // * IDecrementOperators
+        //   * TSelf operator --(TSelf)
+        //   * TSelf operator checked --(TSelf)
+        // * IDivisionOperators
+        //   * TSelf operator /(TSelf, TSelf)
+        //   * TSelf operator checked /(TSelf, TSelf)
+        // * IIncrementOperators
+        //   * TSelf operator ++(TSelf)
+        //   * TSelf operator checked ++(TSelf)
+        // * IModulusOperators
+        //   * TSelf operator %(TSelf, TSelf)
+        // * IMultiplyOperators
+        //   * TSelf operator *(TSelf, TSelf)
+        //   * TSelf operator checked *(TSelf, TSelf)
+        // * ISubtractionOperators
+        //   * TSelf operator -(TSelf, TSelf)
+        //   * TSelf operator checked -(TSelf, TSelf)
+        // * IUnaryNegationOperators
+        //   * TSelf operator -(TSelf)
+        //   * TSelf operator checked -(TSelf)
+        // * IUnaryPlusOperators
+        //   * TSelf operator +(TSelf)
+
+        // Implicitly implemented interfaces
+        // * IBinaryNumber
+        //   * bool IsPow2(TSelf)
+        //   * TSelf Log2(TSelf)
+        // * IComparable                                                                    // Existing
+        //   * int CompareTo(object?)                                                       // * Existing
+        //   * int CompareTo(TSelf)                                                         // * Existing
+        // * IComparisonOperators
+        //   * bool operator <(TSelf, TSelf)                                                // * Existing
+        //   * bool operator <=(TSelf, TSelf)                                               // * Existing
+        //   * bool operator >(TSelf, TSelf)                                                // * Existing
+        //   * bool operator >=(TSelf, TSelf)                                               // * Existing
+        // * IEqualityOperators
+        //   * bool operator ==(TSelf, TSelf)                                               // * Existing
+        //   * bool operator !=(TSelf, TSelf)                                               // * Existing
+        // * IEquatable                                                                     // Existing
+        //   * bool Equals(TSelf)                                                           // * Existing
+        // * IExponentialFunctions
+        //   * TSelf Exp(TSelf)
+        //   * TSelf ExpM1(TSelf)                                                           // Approved - NYI
+        //   * TSelf Exp2(TSelf)                                                            // Approved - NYI
+        //   * TSelf Exp2M1(TSelf)                                                          // Approved - NYI
+        //   * TSelf Exp10(TSelf)                                                           // Approved - NYI
+        //   * TSelf Exp10M1(TSelf)                                                         // Approved - NYI
+        // * IFloatingPoint
+        //   * TSelf Ceiling(TSelf)
+        //   * TSelf Floor(TSelf)
+        //   * TSelf Round(TSelf)
+        //   * TSelf Round(TSelf, int)
+        //   * TSelf Round(TSelf, MidpointRounding)
+        //   * TSelf Round(TSelf, int, MidpointRounding)
+        //   * TSelf Truncate(TSelf)
+        // * IFloatingPointIeee754
+        //   * TSelf E { get; }                                                             // ? Explicit
+        //   * TSelf Epsilon { get; }                                                       // ? Explicit
+        //   * TSelf NaN { get; }                                                           // ? Explicit
+        //   * TSelf NegativeInfinity { get; }                                              // ? Explicit
+        //   * TSelf NegativeZero { get; }                                                  // ? Explicit
+        //   * TSelf Pi { get; }                                                            // ? Explicit
+        //   * TSelf PositiveInfinity { get; }                                              // ? Explicit
+        //   * TSelf Tau { get; }                                                           // ? Explicit
+        //   * TSelf BitDecrement(TSelf)
+        //   * TSelf BitIncrement(TSelf)
+        //   * TSelf Compound(TSelf, TSelf)                                                 // Approved - NYI
+        //   * TSelf FusedMultiplyAdd(TSelf, TSelf, TSelf)
+        //   * long GetExponentBitLength()                                                  // Approved - NYI
+        //   * int GetExponentByteCount()                                                   // Approved - NYI
+        //   * long GetSignificandBitLength()                                               // Approved - NYI
+        //   * int GetSignificandByteCount()                                                // Approved - NYI
+        //   * TSelf Ieee754Remainder(TSelf, TSelf)
+        //   * int ILogB(TSelf)
+        //   * bool IsFinite(TSelf)                                                         // * Existing
+        //   * bool IsInfinity(TSelf)                                                       // * Existing
+        //   * bool IsNaN(TSelf)                                                            // * Existing
+        //   * bool IsNegativeInfinity(TSelf)                                               // * Existing
+        //   * bool IsNormal(TSelf)                                                         // * Existing
+        //   * bool IsPositiveInfinity(TSelf)                                               // * Existing
+        //   * bool IsSubnormal(TSelf)                                                      // * Existing
+        //   * TSelf MaxMagnitudeNumber(TSelf, TSelf)                                       // Approved - NYI
+        //   * TSelf MaxNumber(TSelf, TSelf)                                                // Approved - NYI
+        //   * TSelf MinMagnitudeNumber(TSelf, TSelf)                                       // Approved - NYI
+        //   * TSelf MinNumber(TSelf, TSelf)                                                // Approved - NYI
+        //   * TSelf ScaleB(TSelf, int)
+        //   * bool TryWriteExponentLittleEndian(byte[], out int)                           // Approved - NYI
+        //   * bool TryWriteSignificandLittleEndian(byte[], out int)                        // Approved - NYI
+        //   * int WriteExponentLittleEndian(byte[])                                        // Approved - NYI
+        //   * int WriteExponentLittleEndian(byte[], int)                                   // Approved - NYI
+        //   * int WriteExponentLittleEndian(Span<byte>)                                    // Approved - NYI
+        //   * int WriteSignificandLittleEndian(byte[])                                     // Approved - NYI
+        //   * int WriteSignificandLittleEndian(byte[], int)                                // Approved - NYI
+        //   * int WriteSignificandLittleEndian(Span<byte>)                                 // Approved - NYI
+        // * IFormattable                                                                   // Existing
+        //   * string ToString(string?, IFormatProvider?)                                   // * Existing
+        // * IHyperbolicFunctions
+        //   * TSelf Acosh(TSelf)
+        //   * TSelf Asinh(TSelf)
+        //   * TSelf Atanh(TSelf)
+        //   * TSelf Cosh(TSelf)
+        //   * TSelf Sinh(TSelf)
+        //   * TSelf Tanh(TSelf)
+        // * ILogarithmicFunctions
+        //   * TSelf Log(TSelf)
+        //   * TSelf Log(TSelf, TSelf)
+        //   * TSelf LogP1(TSelf)                                                           // Approved - NYI
+        //   * TSelf Log2(TSelf)
+        //   * TSelf Log2P1(TSelf)                                                          // Approved - NYI
+        //   * TSelf Log10(TSelf)
+        //   * TSelf Log10P1(TSelf)                                                         // Approved - NYI
+        // * INumber
+        //   * TSelf Abs(TSelf)
+        //   * TSelf Clamp(TSelf, TSelf, TSelf)
+        //   * TSelf CopySign(TSelf, TSelf)
+        //   * TSelf CreateChecked(TOther)
+        //   * TSelf CreateSaturating(TOther)
+        //   * TSelf CreateTruncating(TOther)
+        //   * bool IsNegative(TSelf)                                                       // * Existing
+        //   * TSelf Max(TSelf, TSelf)
+        //   * TSelf MaxMagnitude(TSelf, TSelf)
+        //   * TSelf Min(TSelf, TSelf)
+        //   * TSelf MinMagnitude(TSelf, TSelf)
+        //   * TSelf Parse(string, NumberStyles, IFormatProvider?)                          // * Existing
+        //   * TSelf Parse(ReadOnlySpan<char>, NumberStyles, IFormatProvider?)              // * Existing
+        //   * int Sign(TSelf)
+        //   * bool TryCreate(TOther, out TSelf)
+        //   * bool TryParse(string?, NumberStyles, IFormatProvider?, out TSelf)            // * Existing
+        //   * bool TryParse(ReadOnlySpan<char>, NumberStyles, IFormatProvider?, out TSelf) // * Existing
+        // * IParsable
+        //   * TSelf Parse(string, IFormatProvider?)                                        // * Existing
+        //   * bool TryParse(string?, IFormatProvider?, out TSelf)
+        // * IPowerFunctions
+        //   * TSelf Pow(TSelf, TSelf)
+        // * IRootFunctions
+        //   * TSelf Cbrt(TSelf)
+        //   * TSelf Hypot(TSelf, TSelf)                                                    // Approved - NYI
+        //   * TSelf Sqrt(TSelf)
+        //   * TSelf Root(TSelf, TSelf)                                                     // Approved - NYI
+        // * ISpanFormattable
+        //   * bool TryFormat(Span<char>, out int, ReadOnlySpan<char>, IFormatProvider?)    // * Existing
+        // * ISpanParsable
+        //   * TSelf Parse(ReadOnlySpan<char>, IFormatProvider?)
+        //   * bool TryParse(ReadOnlySpan<char>, IFormatProvider?, out TSelf)
+        // * ITrigonometricFunctions
+        //   * TSelf Acos(TSelf)
+        //   * TSelf AcosPi(TSelf)                                                          // Approved - NYI
+        //   * TSelf Asin(TSelf)
+        //   * TSelf AsinPi(TSelf)                                                          // Approved - NYI
+        //   * TSelf Atan(TSelf)
+        //   * TSelf AtanPi(TSelf)                                                          // Approved - NYI
+        //   * TSelf Atan2(TSelf, TSelf)
+        //   * TSelf Atan2Pi(TSelf, TSelf)                                                  // Approved - NYI
+        //   * TSelf Cos(TSelf)
+        //   * TSelf CosPi(TSelf)                                                           // Approved - NYI
+        //   * TSelf Sin(TSelf)
+        //   * TSelf SinPi(TSelf)                                                           // Approved - NYI
+        //   * TSelf Tan(TSelf)
+        //   * TSelf TanPi(TSelf)                                                           // Approved - NYI
     }
 
     public class Enum
@@ -1432,74 +2046,830 @@ namespace System
     public struct Guid
         : IComparisonOperators<Guid, Guid>,
           ISpanFormattable,
-          ISpanParseable<Guid>
-    {
+          ISpanParsable<Guid>
+    {
+        // Implicitly implemented interfaces
+        // * IComparable                                                                    // Existing
+        //   * int CompareTo(object?)                                                       // * Existing
+        //   * int CompareTo(TSelf)                                                         // * Existing
+        // * IComparisonOperators
+        //   * bool operator <(TSelf, TSelf)                                                // * Existing
+        //   * bool operator <=(TSelf, TSelf)                                               // * Existing
+        //   * bool operator >(TSelf, TSelf)                                                // * Existing
+        //   * bool operator >=(TSelf, TSelf)                                               // * Existing
+        // * IEqualityOperators
+        //   * bool operator ==(TSelf, TSelf)                                               // * Existing
+        //   * bool operator !=(TSelf, TSelf)                                               // * Existing
+        // * IEquatable                                                                     // Existing
+        //   * bool Equals(TSelf)                                                           // * Existing
+        // * IFormattable                                                                   // Existing
+        //   * string ToString(string?, IFormatProvider?)                                   // * Existing
+        // * IParsable
+        //   * TSelf Parse(string, IFormatProvider?)
+        //   * bool TryParse(string?, IFormatProvider?, out TSelf)
+        // * ISpanFormattable
+        //   * bool TryFormat(Span<char>, out int, ReadOnlySpan<char>, IFormatProvider?)    // * Existing
+        // * ISpanParsable
+        //   * TSelf Parse(ReadOnlySpan<char>, IFormatProvider?)
+        //   * bool TryParse(ReadOnlySpan<char>, IFormatProvider?, out TSelf)
     }
 
     public struct Half
         : IBinaryFloatingPointIeee754<Half>,
           IMinMaxValue<Half>
     {
+        // Explicitly implemented interfaces
+        // * IAdditiveIdentity
+        //   * TSelf AdditiveIdentity { get; }
+        // * IMultiplicativeIdentity
+        //   * TSelf MultiplicativeIdentity { get; }
+        // * INumberBase
+        //   * TSelf One { get; }
+        //   * TSelf Zero { get; }
+        // * ISignedNumber
+        //   * TSelf NegativeOne { get; }
+        //
+        // * IBitwiseOperators
+        //   * TSelf operator &(TSelf, TSelf)
+        //   * TSelf operator |(TSelf, TSelf)
+        //   * TSelf operator ^(TSelf, TSelf)
+        //   * TSelf operator ~(TSelf)
+
+        // Implicitly implemented interfaces
+        // * IMinMaxValue
+        //   * TSelf MaxValue { get; }                                                      // * Existing
+        //   * TSelf MinValue { get; }                                                      // * Existing
+        //
+        // * IAdditionOperators
+        //   * TSelf operator +(TSelf, TSelf)
+        //   * TSelf operator checked +(TSelf, TSelf)
+        // * IBinaryNumber
+        //   * bool IsPow2(TSelf)
+        //   * TSelf Log2(TSelf)
+        // * IComparable                                                                    // Existing
+        //   * int CompareTo(object?)                                                       // * Existing
+        //   * int CompareTo(TSelf)                                                         // * Existing
+        // * IComparisonOperators
+        //   * bool operator <(TSelf, TSelf)                                                // * Existing
+        //   * bool operator <=(TSelf, TSelf)                                               // * Existing
+        //   * bool operator >(TSelf, TSelf)                                                // * Existing
+        //   * bool operator >=(TSelf, TSelf)                                               // * Existing
+        // * IDecrementOperators
+        //   * TSelf operator --(TSelf)
+        //   * TSelf operator checked --(TSelf)
+        // * IDivisionOperators
+        //   * TSelf operator /(TSelf, TSelf)
+        //   * TSelf operator checked /(TSelf, TSelf)
+        // * IEqualityOperators
+        //   * bool operator ==(TSelf, TSelf)                                               // * Existing
+        //   * bool operator !=(TSelf, TSelf)                                               // * Existing
+        // * IEquatable                                                                     // Existing
+        //   * bool Equals(TSelf)                                                           // * Existing
+        // * IExponentialFunctions
+        //   * TSelf Exp(TSelf)
+        //   * TSelf ExpM1(TSelf)                                                           // Approved - NYI
+        //   * TSelf Exp2(TSelf)                                                            // Approved - NYI
+        //   * TSelf Exp2M1(TSelf)                                                          // Approved - NYI
+        //   * TSelf Exp10(TSelf)                                                           // Approved - NYI
+        //   * TSelf Exp10M1(TSelf)                                                         // Approved - NYI
+        // * IFloatingPoint
+        //   * TSelf Ceiling(TSelf)
+        //   * TSelf Floor(TSelf)
+        //   * TSelf Round(TSelf)
+        //   * TSelf Round(TSelf, int)
+        //   * TSelf Round(TSelf, MidpointRounding)
+        //   * TSelf Round(TSelf, int, MidpointRounding)
+        //   * TSelf Truncate(TSelf)
+        // * IFloatingPointIeee754
+        //   * TSelf E { get; }
+        //   * TSelf Epsilon { get; }                                                       // * Existing
+        //   * TSelf NaN { get; }                                                           // * Existing
+        //   * TSelf NegativeInfinity { get; }                                              // * Existing
+        //   * TSelf NegativeZero { get; }
+        //   * TSelf Pi { get; }
+        //   * TSelf PositiveInfinity { get; }                                              // * Existing
+        //   * TSelf Tau { get; }
+        //   * TSelf BitDecrement(TSelf)
+        //   * TSelf BitIncrement(TSelf)
+        //   * TSelf Compound(TSelf, TSelf)                                                 // Approved - NYI
+        //   * TSelf FusedMultiplyAdd(TSelf, TSelf, TSelf)
+        //   * long GetExponentBitLength()                                                  // Approved - NYI
+        //   * int GetExponentByteCount()                                                   // Approved - NYI
+        //   * long GetSignificandBitLength()                                               // Approved - NYI
+        //   * int GetSignificandByteCount()                                                // Approved - NYI
+        //   * TSelf Ieee754Remainder(TSelf, TSelf)
+        //   * int ILogB(TSelf)
+        //   * bool IsFinite(TSelf)                                                         // * Existing
+        //   * bool IsInfinity(TSelf)                                                       // * Existing
+        //   * bool IsNaN(TSelf)                                                            // * Existing
+        //   * bool IsNegativeInfinity(TSelf)                                               // * Existing
+        //   * bool IsNormal(TSelf)                                                         // * Existing
+        //   * bool IsPositiveInfinity(TSelf)                                               // * Existing
+        //   * bool IsSubnormal(TSelf)                                                      // * Existing
+        //   * TSelf MaxMagnitudeNumber(TSelf, TSelf)                                       // Approved - NYI
+        //   * TSelf MaxNumber(TSelf, TSelf)                                                // Approved - NYI
+        //   * TSelf MinMagnitudeNumber(TSelf, TSelf)                                       // Approved - NYI
+        //   * TSelf MinNumber(TSelf, TSelf)                                                // Approved - NYI
+        //   * TSelf ScaleB(TSelf, int)
+        //   * bool TryWriteExponentLittleEndian(byte[], out int)                           // Approved - NYI
+        //   * bool TryWriteSignificandLittleEndian(byte[], out int)                        // Approved - NYI
+        //   * int WriteExponentLittleEndian(byte[])                                        // Approved - NYI
+        //   * int WriteExponentLittleEndian(byte[], int)                                   // Approved - NYI
+        //   * int WriteExponentLittleEndian(Span<byte>)                                    // Approved - NYI
+        //   * int WriteSignificandLittleEndian(byte[])                                     // Approved - NYI
+        //   * int WriteSignificandLittleEndian(byte[], int)                                // Approved - NYI
+        //   * int WriteSignificandLittleEndian(Span<byte>)                                 // Approved - NYI
+        // * IFormattable                                                                   // Existing
+        //   * string ToString(string?, IFormatProvider?)                                   // * Existing
+        // * IHyperbolicFunctions
+        //   * TSelf Acosh(TSelf)
+        //   * TSelf Asinh(TSelf)
+        //   * TSelf Atanh(TSelf)
+        //   * TSelf Cosh(TSelf)
+        //   * TSelf Sinh(TSelf)
+        //   * TSelf Tanh(TSelf)
+        // * IIncrementOperators
+        //   * TSelf operator ++(TSelf)
+        //   * TSelf operator checked ++(TSelf)
+        // * ILogarithmicFunctions
+        //   * TSelf Log(TSelf)
+        //   * TSelf Log(TSelf, TSelf)
+        //   * TSelf LogP1(TSelf)                                                           // Approved - NYI
+        //   * TSelf Log2(TSelf)
+        //   * TSelf Log2P1(TSelf)                                                          // Approved - NYI
+        //   * TSelf Log10(TSelf)
+        //   * TSelf Log10P1(TSelf)                                                         // Approved - NYI
+        // * IModulusOperators
+        //   * TSelf operator %(TSelf, TSelf)
+        // * IMultiplyOperators
+        //   * TSelf operator *(TSelf, TSelf)
+        //   * TSelf operator checked *(TSelf, TSelf)
+        // * INumber
+        //   * TSelf Abs(TSelf)
+        //   * TSelf Clamp(TSelf, TSelf, TSelf)
+        //   * TSelf CopySign(TSelf, TSelf)
+        //   * TSelf CreateChecked(TOther)
+        //   * TSelf CreateSaturating(TOther)
+        //   * TSelf CreateTruncating(TOther)
+        //   * bool IsNegative(TSelf)                                                       // * Existing
+        //   * TSelf Max(TSelf, TSelf)
+        //   * TSelf MaxMagnitude(TSelf, TSelf)
+        //   * TSelf Min(TSelf, TSelf)
+        //   * TSelf MinMagnitude(TSelf, TSelf)
+        //   * TSelf Parse(string, NumberStyles, IFormatProvider?)                          // * Existing
+        //   * TSelf Parse(ReadOnlySpan<char>, NumberStyles, IFormatProvider?)              // * Existing
+        //   * int Sign(TSelf)
+        //   * bool TryCreate(TOther, out TSelf)
+        //   * bool TryParse(string?, NumberStyles, IFormatProvider?, out TSelf)            // * Existing
+        //   * bool TryParse(ReadOnlySpan<char>, NumberStyles, IFormatProvider?, out TSelf) // * Existing
+        // * IParsable
+        //   * TSelf Parse(string, IFormatProvider?)                                        // * Existing
+        //   * bool TryParse(string?, IFormatProvider?, out TSelf)
+        // * IPowerFunctions
+        //   * TSelf Pow(TSelf, TSelf)
+        // * IRootFunctions
+        //   * TSelf Cbrt(TSelf)
+        //   * TSelf Hypot(TSelf, TSelf)                                                    // Approved - NYI
+        //   * TSelf Sqrt(TSelf)
+        //   * TSelf Root(TSelf, TSelf)                                                     // Approved - NYI
+        // * ISpanFormattable
+        //   * bool TryFormat(Span<char>, out int, ReadOnlySpan<char>, IFormatProvider?)    // * Existing
+        // * ISpanParsable
+        //   * TSelf Parse(ReadOnlySpan<char>, IFormatProvider?)
+        //   * bool TryParse(ReadOnlySpan<char>, IFormatProvider?, out TSelf)
+        // * ISubtractionOperators
+        //   * TSelf operator -(TSelf, TSelf)
+        //   * TSelf operator checked -(TSelf, TSelf)
+        // * ITrigonometricFunctions
+        //   * TSelf Acos(TSelf)
+        //   * TSelf AcosPi(TSelf)                                                          // Approved - NYI
+        //   * TSelf Asin(TSelf)
+        //   * TSelf AsinPi(TSelf)                                                          // Approved - NYI
+        //   * TSelf Atan(TSelf)
+        //   * TSelf AtanPi(TSelf)                                                          // Approved - NYI
+        //   * TSelf Atan2(TSelf, TSelf)
+        //   * TSelf Atan2Pi(TSelf, TSelf)                                                  // Approved - NYI
+        //   * TSelf Cos(TSelf)
+        //   * TSelf CosPi(TSelf)                                                           // Approved - NYI
+        //   * TSelf Sin(TSelf)
+        //   * TSelf SinPi(TSelf)                                                           // Approved - NYI
+        //   * TSelf Tan(TSelf)
+        //   * TSelf TanPi(TSelf)                                                           // Approved - NYI
+        // * IUnaryNegationOperators
+        //   * TSelf operator -(TSelf)
+        //   * TSelf operator checked -(TSelf)
+        // * IUnaryPlusOperators
+        //   * TSelf operator +(TSelf)
     }
 
     public struct Int16
         : IBinaryInteger<short>,
           IConvertible,
           IMinMaxValue<short>,
-          ISignedNumberBase<short>
-    {
-        public const short AdditiveIdentity = 0;
-        public const short MultiplicativeIdentity = 1;
-        public const short NegativeOne = 1;
-        public const short One = 1;
-        public const short Zero = 0;
+          ISignedNumber<short>
+    {
+        public const short AdditiveIdentity = 0;                                        // ? Expose
+        public const short MaxValue = 32767;                                            // Existing
+        public const short MinValue = -32768;                                           // Existing
+        public const short MultiplicativeIdentity = 1;                                  // ? Expose
+        public const short NegativeOne = -1;                                            // ? Expose
+        public const short One = 1;                                                     // ? Expose
+        public const short Zero = 0;                                                    // ? Expose
+
+        // Explicitly implemented interfaces
+        // * IAdditiveIdentity
+        //   * TSelf AdditiveIdentity { get; }
+        // * IMinMaxValue
+        //   * TSelf MaxValue { get; }
+        //   * TSelf MinValue { get; }
+        // * IMultiplicativeIdentity
+        //   * TSelf MultiplicativeIdentity { get; }
+        // * INumberBase
+        //   * One { get; }
+        //   * Zero { get; }
+        // * ISignedNumber
+        //   * TSelf NegativeOne { get; }
+        //
+        // * IAdditionOperators
+        //   * TSelf operator +(TSelf, TSelf)
+        //   * TSelf operator checked +(TSelf, TSelf)
+        // * IBitwiseOperators
+        //   * TSelf operator &(TSelf, TSelf)
+        //   * TSelf operator |(TSelf, TSelf)
+        //   * TSelf operator ^(TSelf, TSelf)
+        //   * TSelf operator ~(TSelf)
+        // * IComparisonOperators
+        //   * bool operator <(TSelf, TSelf)
+        //   * bool operator <=(TSelf, TSelf)
+        //   * bool operator >(TSelf, TSelf)
+        //   * bool operator >=(TSelf, TSelf)
+        // * IDecrementOperators
+        //   * TSelf operator --(TSelf)
+        //   * TSelf operator checked --(TSelf)
+        // * IDivisionOperators
+        //   * TSelf operator /(TSelf, TSelf)
+        //   * TSelf operator checked /(TSelf, TSelf)
+        // * IEqualityOperators
+        //   * bool operator ==(TSelf, TSelf)
+        //   * bool operator !=(TSelf, TSelf)
+        // * IIncrementOperators
+        //   * TSelf operator ++(TSelf)
+        //   * TSelf operator checked ++(TSelf)
+        // * IModulusOperators
+        //   * TSelf operator %(TSelf, TSelf)
+        // * IMultiplyOperators
+        //   * TSelf operator *(TSelf, TSelf)
+        //   * TSelf operator checked *(TSelf, TSelf)
+        // * IShiftOperators
+        //   * TSelf operator <<(TSelf, int)
+        //   * TSelf operator >>(TSelf, int)
+        //   * TSelf operator >>>(TSelf, int)
+        // * ISubtractionOperators
+        //   * TSelf operator -(TSelf, TSelf)
+        //   * TSelf operator checked -(TSelf, TSelf)
+        // * IUnaryNegationOperators
+        //   * TSelf operator -(TSelf)
+        //   * TSelf operator checked -(TSelf)
+        // * IUnaryPlusOperators
+        //   * TSelf operator +(TSelf)
+
+        // Implicitly Implemented interfaces
+        // * IBinaryInteger
+        //   * (TSelf, TSelf) DivRem(TSelf, TSelf)
+        //   * long GetBitLength()                                                          // Approved - NYI
+        //   * int GetByteCount()                                                           // Approved - NYI
+        //   * TSelf LeadingZeroCount(TSelf)
+        //   * TSelf PopCount(TSelf)
+        //   * TSelf RotateLeft(TSelf, int)
+        //   * TSelf RotateRight(TSelf, int)
+        //   * TSelf TrailingZeroCount(TSelf)
+        //   * bool TryWriteLittleEndian(byte[], out int)                                   // Approved - NYI
+        //   * int WriteLittleEndian(byte[])                                                // Approved - NYI
+        //   * int WriteLittleEndian(byte[], int)                                           // Approved - NYI
+        //   * int WriteLittleEndian(Span<byte>)                                            // Approved - NYI
+        // * IBinaryNumber                                                                  // Approved - NYI
+        //   * bool IsPow2(TSelf)
+        //   * TSelf Log2(TSelf)
+        // * IComparable                                                                    // Existing
+        //   * int CompareTo(object?)                                                       // * Existing
+        //   * int CompareTo(TSelf)                                                         // * Existing
+        // * IEquatable                                                                     // Existing
+        //   * bool Equals(TSelf)                                                           // * Existing
+        // * IFormattable                                                                   // Existing
+        //   * string ToString(string?, IFormatProvider?)                                   // * Existing
+        // * INumber
+        //   * TSelf Abs(TSelf)
+        //   * TSelf Clamp(TSelf, TSelf, TSelf)
+        //   * TSelf CopySign(TSelf, TSelf)
+        //   * TSelf CreateChecked(TOther)
+        //   * TSelf CreateSaturating(TOther)
+        //   * TSelf CreateTruncating(TOther)
+        //   * bool IsNegative(TSelf)
+        //   * TSelf Max(TSelf, TSelf)
+        //   * TSelf MaxMagnitude(TSelf, TSelf)
+        //   * TSelf Min(TSelf, TSelf)
+        //   * TSelf MinMagnitude(TSelf, TSelf)
+        //   * TSelf Parse(string, NumberStyles, IFormatProvider?)                          // * Existing
+        //   * TSelf Parse(ReadOnlySpan<char>, NumberStyles, IFormatProvider?)              // * Existing - Optional Args
+        //   * int Sign(TSelf)
+        //   * bool TryCreate(TOther, out TSelf)
+        //   * bool TryParse(string?, NumberStyles, IFormatProvider?, out TSelf)            // * Existing
+        //   * bool TryParse(ReadOnlySpan<char>, NumberStyles, IFormatProvider?, out TSelf) // * Existing
+        // * IParsable
+        //   * TSelf Parse(string, IFormatProvider?)                                        // * Existing
+        //   * bool TryParse(string?, IFormatProvider?, out TSelf)
+        // * ISpanFormattable
+        //   * bool TryFormat(Span<char>, out int, ReadOnlySpan<char>, IFormatProvider?)    // * Existing - Optional Args
+        // * ISpanParsable
+        //   * TSelf Parse(ReadOnlySpan<char>, IFormatProvider?)
+        //   * bool TryParse(ReadOnlySpan<char>, IFormatProvider?, out TSelf)
     }
 
     public struct Int32
         : IBinaryInteger<int>,
           IConvertible,
           IMinMaxValue<int>,
-          ISignedNumberBase<int>
-    {
-        public const int AdditiveIdentity = 0;
-        public const int MultiplicativeIdentity = 1;
-        public const int NegativeOne = 1;
-        public const int One = 1;
-        public const int Zero = 0;
+          ISignedNumber<int>
+    {
+        public const int AdditiveIdentity = 0;                                        // ? Expose
+        public const int MaxValue = 2147483647;                                       // Existing
+        public const int MinValue = -2147483648;                                      // Existing
+        public const int MultiplicativeIdentity = 1;                                  // ? Expose
+        public const int NegativeOne = -1;                                            // ? Expose
+        public const int One = 1;                                                     // ? Expose
+        public const int Zero = 0;                                                    // ? Expose
+
+        // Explicitly implemented interfaces
+        // * IAdditiveIdentity
+        //   * TSelf AdditiveIdentity { get; }
+        // * IMinMaxValue
+        //   * TSelf MaxValue { get; }
+        //   * TSelf MinValue { get; }
+        // * IMultiplicativeIdentity
+        //   * TSelf MultiplicativeIdentity { get; }
+        // * INumberBase
+        //   * One { get; }
+        //   * Zero { get; }
+        // * ISignedNumber
+        //   * TSelf NegativeOne { get; }
+        //
+        // * IAdditionOperators
+        //   * TSelf operator +(TSelf, TSelf)
+        //   * TSelf operator checked +(TSelf, TSelf)
+        // * IBitwiseOperators
+        //   * TSelf operator &(TSelf, TSelf)
+        //   * TSelf operator |(TSelf, TSelf)
+        //   * TSelf operator ^(TSelf, TSelf)
+        //   * TSelf operator ~(TSelf)
+        // * IComparisonOperators
+        //   * bool operator <(TSelf, TSelf)
+        //   * bool operator <=(TSelf, TSelf)
+        //   * bool operator >(TSelf, TSelf)
+        //   * bool operator >=(TSelf, TSelf)
+        // * IDecrementOperators
+        //   * TSelf operator --(TSelf)
+        //   * TSelf operator checked --(TSelf)
+        // * IDivisionOperators
+        //   * TSelf operator /(TSelf, TSelf)
+        //   * TSelf operator checked /(TSelf, TSelf)
+        // * IEqualityOperators
+        //   * bool operator ==(TSelf, TSelf)
+        //   * bool operator !=(TSelf, TSelf)
+        // * IIncrementOperators
+        //   * TSelf operator ++(TSelf)
+        //   * TSelf operator checked ++(TSelf)
+        // * IModulusOperators
+        //   * TSelf operator %(TSelf, TSelf)
+        // * IMultiplyOperators
+        //   * TSelf operator *(TSelf, TSelf)
+        //   * TSelf operator checked *(TSelf, TSelf)
+        // * IShiftOperators
+        //   * TSelf operator <<(TSelf, int)
+        //   * TSelf operator >>(TSelf, int)
+        //   * TSelf operator >>>(TSelf, int)
+        // * ISubtractionOperators
+        //   * TSelf operator -(TSelf, TSelf)
+        //   * TSelf operator checked -(TSelf, TSelf)
+        // * IUnaryNegationOperators
+        //   * TSelf operator -(TSelf)
+        //   * TSelf operator checked -(TSelf)
+        // * IUnaryPlusOperators
+        //   * TSelf operator +(TSelf)
+
+        // Implicitly Implemented interfaces
+        // * IBinaryInteger
+        //   * (TSelf, TSelf) DivRem(TSelf, TSelf)
+        //   * long GetBitLength()                                                          // Approved - NYI
+        //   * int GetByteCount()                                                           // Approved - NYI
+        //   * TSelf LeadingZeroCount(TSelf)
+        //   * TSelf PopCount(TSelf)
+        //   * TSelf RotateLeft(TSelf, int)
+        //   * TSelf RotateRight(TSelf, int)
+        //   * TSelf TrailingZeroCount(TSelf)
+        //   * bool TryWriteLittleEndian(byte[], out int)                                   // Approved - NYI
+        //   * int WriteLittleEndian(byte[])                                                // Approved - NYI
+        //   * int WriteLittleEndian(byte[], int)                                           // Approved - NYI
+        //   * int WriteLittleEndian(Span<byte>)                                            // Approved - NYI
+        // * IBinaryNumber
+        //   * bool IsPow2(TSelf)
+        //   * TSelf Log2(TSelf)
+        // * IComparable                                                                    // Existing
+        //   * int CompareTo(object?)                                                       // * Existing
+        //   * int CompareTo(TSelf)                                                         // * Existing
+        // * IEquatable                                                                     // Existing
+        //   * bool Equals(TSelf)                                                           // * Existing
+        // * IFormattable                                                                   // Existing
+        //   * string ToString(string?, IFormatProvider?)                                   // * Existing
+        // * INumber
+        //   * TSelf Abs(TSelf)
+        //   * TSelf Clamp(TSelf, TSelf, TSelf)
+        //   * TSelf CopySign(TSelf, TSelf)
+        //   * TSelf CreateChecked(TOther)
+        //   * TSelf CreateSaturating(TOther)
+        //   * TSelf CreateTruncating(TOther)
+        //   * bool IsNegative(TSelf)
+        //   * TSelf Max(TSelf, TSelf)
+        //   * TSelf MaxMagnitude(TSelf, TSelf)
+        //   * TSelf Min(TSelf, TSelf)
+        //   * TSelf MinMagnitude(TSelf, TSelf)
+        //   * TSelf Parse(string, NumberStyles, IFormatProvider?)                          // * Existing
+        //   * TSelf Parse(ReadOnlySpan<char>, NumberStyles, IFormatProvider?)              // * Existing - Optional Args
+        //   * int Sign(TSelf)
+        //   * bool TryCreate(TOther, out TSelf)
+        //   * bool TryParse(string?, NumberStyles, IFormatProvider?, out TSelf)            // * Existing
+        //   * bool TryParse(ReadOnlySpan<char>, NumberStyles, IFormatProvider?, out TSelf) // * Existing
+        // * IParsable
+        //   * TSelf Parse(string, IFormatProvider?)                                        // * Existing
+        //   * bool TryParse(string?, IFormatProvider?, out TSelf)
+        // * ISpanFormattable
+        //   * bool TryFormat(Span<char>, out int, ReadOnlySpan<char>, IFormatProvider?)    // * Existing - Optional Args
+        // * ISpanParsable
+        //   * TSelf Parse(ReadOnlySpan<char>, IFormatProvider?)
+        //   * bool TryParse(ReadOnlySpan<char>, IFormatProvider?, out TSelf)
     }
 
     public struct Int64
         : IBinaryInteger<long>,
           IConvertible,
           IMinMaxValue<long>,
-          ISignedNumberBase<long>
-    {
-        public const long AdditiveIdentity = 0;
-        public const long MultiplicativeIdentity = 1;
-        public const long NegativeOne = 1;
-        public const long One = 1;
-        public const long Zero = 0;
+          ISignedNumber<long>
+    {
+        public const long AdditiveIdentity = 0;                                        // ? Expose
+        public const long MaxValue = 9223372036854775807;                              // Existing
+        public const long MinValue = -9223372036854775808;                             // Existing
+        public const long MultiplicativeIdentity = 1;                                  // ? Expose
+        public const long NegativeOne = -1;                                            // ? Expose
+        public const long One = 1;                                                     // ? Expose
+        public const long Zero = 0;                                                    // ? Expose
+
+        // Explicitly implemented interfaces
+        // * IAdditiveIdentity
+        //   * TSelf AdditiveIdentity { get; }
+        // * IMinMaxValue
+        //   * TSelf MaxValue { get; }
+        //   * TSelf MinValue { get; }
+        // * IMultiplicativeIdentity
+        //   * TSelf MultiplicativeIdentity { get; }
+        // * INumberBase
+        //   * One { get; }
+        //   * Zero { get; }
+        // * ISignedNumber
+        //   * TSelf NegativeOne { get; }
+        //
+        // * IAdditionOperators
+        //   * TSelf operator +(TSelf, TSelf)
+        //   * TSelf operator checked +(TSelf, TSelf)
+        // * IBitwiseOperators
+        //   * TSelf operator &(TSelf, TSelf)
+        //   * TSelf operator |(TSelf, TSelf)
+        //   * TSelf operator ^(TSelf, TSelf)
+        //   * TSelf operator ~(TSelf)
+        // * IComparisonOperators
+        //   * bool operator <(TSelf, TSelf)
+        //   * bool operator <=(TSelf, TSelf)
+        //   * bool operator >(TSelf, TSelf)
+        //   * bool operator >=(TSelf, TSelf)
+        // * IDecrementOperators
+        //   * TSelf operator --(TSelf)
+        //   * TSelf operator checked --(TSelf)
+        // * IDivisionOperators
+        //   * TSelf operator /(TSelf, TSelf)
+        //   * TSelf operator checked /(TSelf, TSelf)
+        // * IEqualityOperators
+        //   * bool operator ==(TSelf, TSelf)
+        //   * bool operator !=(TSelf, TSelf)
+        // * IIncrementOperators
+        //   * TSelf operator ++(TSelf)
+        //   * TSelf operator checked ++(TSelf)
+        // * IModulusOperators
+        //   * TSelf operator %(TSelf, TSelf)
+        // * IMultiplyOperators
+        //   * TSelf operator *(TSelf, TSelf)
+        //   * TSelf operator checked *(TSelf, TSelf)
+        // * IShiftOperators
+        //   * TSelf operator <<(TSelf, int)
+        //   * TSelf operator >>(TSelf, int)
+        //   * TSelf operator >>>(TSelf, int)
+        // * ISubtractionOperators
+        //   * TSelf operator -(TSelf, TSelf)
+        //   * TSelf operator checked -(TSelf, TSelf)
+        // * IUnaryNegationOperators
+        //   * TSelf operator -(TSelf)
+        //   * TSelf operator checked -(TSelf)
+        // * IUnaryPlusOperators
+        //   * TSelf operator +(TSelf)
+
+        // Implicitly Implemented interfaces
+        // * IBinaryInteger
+        //   * (TSelf, TSelf) DivRem(TSelf, TSelf)
+        //   * long GetBitLength()                                                          // Approved - NYI
+        //   * int GetByteCount()                                                           // Approved - NYI
+        //   * TSelf LeadingZeroCount(TSelf)
+        //   * TSelf PopCount(TSelf)
+        //   * TSelf RotateLeft(TSelf, int)
+        //   * TSelf RotateRight(TSelf, int)
+        //   * TSelf TrailingZeroCount(TSelf)
+        //   * bool TryWriteLittleEndian(byte[], out int)                                   // Approved - NYI
+        //   * int WriteLittleEndian(byte[])                                                // Approved - NYI
+        //   * int WriteLittleEndian(byte[], int)                                           // Approved - NYI
+        //   * int WriteLittleEndian(Span<byte>)                                            // Approved - NYI
+        // * IBinaryNumber
+        //   * bool IsPow2(TSelf)
+        //   * TSelf Log2(TSelf)
+        // * IComparable                                                                    // Existing
+        //   * int CompareTo(object?)                                                       // * Existing
+        //   * int CompareTo(TSelf)                                                         // * Existing
+        // * IEquatable                                                                     // Existing
+        //   * bool Equals(TSelf)                                                           // * Existing
+        // * IFormattable                                                                   // Existing
+        //   * string ToString(string?, IFormatProvider?)                                   // * Existing
+        // * INumber
+        //   * TSelf Abs(TSelf)
+        //   * TSelf Clamp(TSelf, TSelf, TSelf)
+        //   * TSelf CopySign(TSelf, TSelf)
+        //   * TSelf CreateChecked(TOther)
+        //   * TSelf CreateSaturating(TOther)
+        //   * TSelf CreateTruncating(TOther)
+        //   * bool IsNegative(TSelf)
+        //   * TSelf Max(TSelf, TSelf)
+        //   * TSelf MaxMagnitude(TSelf, TSelf)
+        //   * TSelf Min(TSelf, TSelf)
+        //   * TSelf MinMagnitude(TSelf, TSelf)
+        //   * TSelf Parse(string, NumberStyles, IFormatProvider?)                          // * Existing
+        //   * TSelf Parse(ReadOnlySpan<char>, NumberStyles, IFormatProvider?)              // * Existing - Optional Args
+        //   * int Sign(TSelf)
+        //   * bool TryCreate(TOther, out TSelf)
+        //   * bool TryParse(string?, NumberStyles, IFormatProvider?, out TSelf)            // * Existing
+        //   * bool TryParse(ReadOnlySpan<char>, NumberStyles, IFormatProvider?, out TSelf) // * Existing
+        // * IParsable
+        //   * TSelf Parse(string, IFormatProvider?)                                        // * Existing
+        //   * bool TryParse(string?, IFormatProvider?, out TSelf)
+        // * ISpanFormattable
+        //   * bool TryFormat(Span<char>, out int, ReadOnlySpan<char>, IFormatProvider?)    // * Existing - Optional Args
+        // * ISpanParsable
+        //   * TSelf Parse(ReadOnlySpan<char>, IFormatProvider?)
+        //   * bool TryParse(ReadOnlySpan<char>, IFormatProvider?, out TSelf)
     }
 
     public struct IntPtr
         : IBinaryInteger<nint>,
           IMinMaxValue<nint>,
           ISerializable,
-          ISignedNumberBase<nint>
-    {
+          ISignedNumber<nint>
+    {
+        public static readonly IntPtr Zero = 0;                                       // Existing
+
+        // Explicitly implemented interfaces
+        // * IAdditiveIdentity
+        //   * TSelf AdditiveIdentity { get; }
+        // * IMultiplicativeIdentity
+        //   * TSelf MultiplicativeIdentity { get; }
+        // * INumberBase
+        //   * One { get; }
+        //   * Zero { get; }
+        // * ISignedNumber
+        //   * TSelf NegativeOne { get; }
+        //
+        // * IAdditionOperators
+        //   * TSelf operator +(TSelf, TSelf)
+        //   * TSelf operator checked +(TSelf, TSelf)
+        // * IBitwiseOperators
+        //   * TSelf operator &(TSelf, TSelf)
+        //   * TSelf operator |(TSelf, TSelf)
+        //   * TSelf operator ^(TSelf, TSelf)
+        //   * TSelf operator ~(TSelf)
+        // * IComparisonOperators
+        //   * bool operator <(TSelf, TSelf)
+        //   * bool operator <=(TSelf, TSelf)
+        //   * bool operator >(TSelf, TSelf)
+        //   * bool operator >=(TSelf, TSelf)
+        // * IDecrementOperators
+        //   * TSelf operator --(TSelf)
+        //   * TSelf operator checked --(TSelf)
+        // * IDivisionOperators
+        //   * TSelf operator /(TSelf, TSelf)
+        //   * TSelf operator checked /(TSelf, TSelf)
+        // * IIncrementOperators
+        //   * TSelf operator ++(TSelf)
+        //   * TSelf operator checked ++(TSelf)
+        // * IModulusOperators
+        //   * TSelf operator %(TSelf, TSelf)
+        // * IMultiplyOperators
+        //   * TSelf operator *(TSelf, TSelf)
+        //   * TSelf operator checked *(TSelf, TSelf)
+        // * IShiftOperators
+        //   * TSelf operator <<(TSelf, int)
+        //   * TSelf operator >>(TSelf, int)
+        //   * TSelf operator >>>(TSelf, int)
+        // * ISubtractionOperators
+        //   * TSelf operator -(TSelf, TSelf)
+        //   * TSelf operator checked -(TSelf, TSelf)
+        // * IUnaryNegationOperators
+        //   * TSelf operator -(TSelf)
+        //   * TSelf operator checked -(TSelf)
+        // * IUnaryPlusOperators
+        //   * TSelf operator +(TSelf)
+
+        // Implicitly Implemented interfaces
+        // * IMinMaxValue
+        //   * TSelf MaxValue { get; }                                                      // * Existing
+        //   * TSelf MinValue { get; }                                                      // * Existing
+        //
+        // * IBinaryInteger
+        //   * (TSelf, TSelf) DivRem(TSelf, TSelf)
+        //   * long GetBitLength()                                                          // Approved - NYI
+        //   * int GetByteCount()                                                           // Approved - NYI
+        //   * TSelf LeadingZeroCount(TSelf)
+        //   * TSelf PopCount(TSelf)
+        //   * TSelf RotateLeft(TSelf, int)
+        //   * TSelf RotateRight(TSelf, int)
+        //   * TSelf TrailingZeroCount(TSelf)
+        //   * bool TryWriteLittleEndian(byte[], out int)                                   // Approved - NYI
+        //   * int WriteLittleEndian(byte[])                                                // Approved - NYI
+        //   * int WriteLittleEndian(byte[], int)                                           // Approved - NYI
+        //   * int WriteLittleEndian(Span<byte>)                                            // Approved - NYI
+        // * IBinaryNumber
+        //   * bool IsPow2(TSelf)
+        //   * TSelf Log2(TSelf)
+        // * IComparable                                                                    // Existing
+        //   * int CompareTo(object?)                                                       // * Existing
+        //   * int CompareTo(TSelf)                                                         // * Existing
+        // * IEqualityOperators
+        //   * bool operator ==(TSelf, TSelf)                                               // * Existing
+        //   * bool operator !=(TSelf, TSelf)                                               // * Existing
+        // * IEquatable                                                                     // Existing
+        //   * bool Equals(TSelf)                                                           // * Existing
+        // * IFormattable                                                                   // Existing
+        //   * string ToString(string?, IFormatProvider?)                                   // * Existing
+        // * INumber
+        //   * TSelf Abs(TSelf)
+        //   * TSelf Clamp(TSelf, TSelf, TSelf)
+        //   * TSelf CopySign(TSelf, TSelf)
+        //   * TSelf CreateChecked(TOther)
+        //   * TSelf CreateSaturating(TOther)
+        //   * TSelf CreateTruncating(TOther)
+        //   * bool IsNegative(TSelf)
+        //   * TSelf Max(TSelf, TSelf)
+        //   * TSelf MaxMagnitude(TSelf, TSelf)
+        //   * TSelf Min(TSelf, TSelf)
+        //   * TSelf MinMagnitude(TSelf, TSelf)
+        //   * TSelf Parse(string, NumberStyles, IFormatProvider?)                          // * Existing
+        //   * TSelf Parse(ReadOnlySpan<char>, NumberStyles, IFormatProvider?)              // * Existing - Optional Args
+        //   * int Sign(TSelf)
+        //   * bool TryCreate(TOther, out TSelf)
+        //   * bool TryParse(string?, NumberStyles, IFormatProvider?, out TSelf)            // * Existing
+        //   * bool TryParse(ReadOnlySpan<char>, NumberStyles, IFormatProvider?, out TSelf) // * Existing
+        // * IParsable
+        //   * TSelf Parse(string, IFormatProvider?)                                        // * Existing
+        //   * bool TryParse(string?, IFormatProvider?, out TSelf)
+        // * ISpanFormattable
+        //   * bool TryFormat(Span<char>, out int, ReadOnlySpan<char>, IFormatProvider?)    // * Existing - Optional Args
+        // * ISpanParsable
+        //   * TSelf Parse(ReadOnlySpan<char>, IFormatProvider?)
+        //   * bool TryParse(ReadOnlySpan<char>, IFormatProvider?, out TSelf)
     }
 
     public struct SByte
         : IBinaryInteger<sbyte>,
           IConvertible,
           IMinMaxValue<sbyte>,
-          ISignedNumberBase<sbyte>
-    {
-        public const sbyte AdditiveIdentity = 0;
-        public const sbyte MultiplicativeIdentity = 1;
-        public const sbyte NegativeOne = 1;
-        public const sbyte One = 1;
-        public const sbyte Zero = 0;
+          ISignedNumber<sbyte>
+    {
+        public const sbyte AdditiveIdentity = 0;                                        // ? Expose
+        public const sbyte MaxValue = 127;                                              // Existing
+        public const sbyte MinValue = -128;                                             // Existing
+        public const sbyte MultiplicativeIdentity = 1;                                  // ? Expose
+        public const sbyte NegativeOne = -1;                                            // ? Expose
+        public const sbyte One = 1;                                                     // ? Expose
+        public const sbyte Zero = 0;                                                    // ? Expose
+
+        // Explicitly implemented interfaces
+        // * IAdditiveIdentity
+        //   * TSelf AdditiveIdentity { get; }
+        // * IMinMaxValue
+        //   * TSelf MaxValue { get; }
+        //   * TSelf MinValue { get; }
+        // * IMultiplicativeIdentity
+        //   * TSelf MultiplicativeIdentity { get; }
+        // * INumberBase
+        //   * One { get; }
+        //   * Zero { get; }
+        // * ISignedNumber
+        //   * TSelf NegativeOne { get; }
+        //
+        // * IAdditionOperators
+        //   * TSelf operator +(TSelf, TSelf)
+        //   * TSelf operator checked +(TSelf, TSelf)
+        // * IBitwiseOperators
+        //   * TSelf operator &(TSelf, TSelf)
+        //   * TSelf operator |(TSelf, TSelf)
+        //   * TSelf operator ^(TSelf, TSelf)
+        //   * TSelf operator ~(TSelf)
+        // * IComparisonOperators
+        //   * bool operator <(TSelf, TSelf)
+        //   * bool operator <=(TSelf, TSelf)
+        //   * bool operator >(TSelf, TSelf)
+        //   * bool operator >=(TSelf, TSelf)
+        // * IDecrementOperators
+        //   * TSelf operator --(TSelf)
+        //   * TSelf operator checked --(TSelf)
+        // * IDivisionOperators
+        //   * TSelf operator /(TSelf, TSelf)
+        //   * TSelf operator checked /(TSelf, TSelf)
+        // * IEqualityOperators
+        //   * bool operator ==(TSelf, TSelf)
+        //   * bool operator !=(TSelf, TSelf)
+        // * IIncrementOperators
+        //   * TSelf operator ++(TSelf)
+        //   * TSelf operator checked ++(TSelf)
+        // * IModulusOperators
+        //   * TSelf operator %(TSelf, TSelf)
+        // * IMultiplyOperators
+        //   * TSelf operator *(TSelf, TSelf)
+        //   * TSelf operator checked *(TSelf, TSelf)
+        // * IShiftOperators
+        //   * TSelf operator <<(TSelf, int)
+        //   * TSelf operator >>(TSelf, int)
+        //   * TSelf operator >>>(TSelf, int)
+        // * ISubtractionOperators
+        //   * TSelf operator -(TSelf, TSelf)
+        //   * TSelf operator checked -(TSelf, TSelf)
+        // * IUnaryNegationOperators
+        //   * TSelf operator -(TSelf)
+        //   * TSelf operator checked -(TSelf)
+        // * IUnaryPlusOperators
+        //   * TSelf operator +(TSelf)
+
+        // Implicitly Implemented interfaces
+        // * IBinaryInteger
+        //   * (TSelf, TSelf) DivRem(TSelf, TSelf)
+        //   * long GetBitLength()                                                          // Approved - NYI
+        //   * int GetByteCount()                                                           // Approved - NYI
+        //   * TSelf LeadingZeroCount(TSelf)
+        //   * TSelf PopCount(TSelf)
+        //   * TSelf RotateLeft(TSelf, int)
+        //   * TSelf RotateRight(TSelf, int)
+        //   * TSelf TrailingZeroCount(TSelf)
+        //   * bool TryWriteLittleEndian(byte[], out int)                                   // Approved - NYI
+        //   * int WriteLittleEndian(byte[])                                                // Approved - NYI
+        //   * int WriteLittleEndian(byte[], int)                                           // Approved - NYI
+        //   * int WriteLittleEndian(Span<byte>)                                            // Approved - NYI
+        // * IBinaryNumber
+        //   * bool IsPow2(TSelf)
+        //   * TSelf Log2(TSelf)
+        // * IComparable                                                                    // Existing
+        //   * int CompareTo(object?)                                                       // * Existing
+        //   * int CompareTo(TSelf)                                                         // * Existing
+        // * IEquatable                                                                     // Existing
+        //   * bool Equals(TSelf)                                                           // * Existing
+        // * IFormattable                                                                   // Existing
+        //   * string ToString(string?, IFormatProvider?)                                   // * Existing
+        // * INumber
+        //   * TSelf Abs(TSelf)
+        //   * TSelf Clamp(TSelf, TSelf, TSelf)
+        //   * TSelf CopySign(TSelf, TSelf)
+        //   * TSelf CreateChecked(TOther)
+        //   * TSelf CreateSaturating(TOther)
+        //   * TSelf CreateTruncating(TOther)
+        //   * bool IsNegative(TSelf)
+        //   * TSelf Max(TSelf, TSelf)
+        //   * TSelf MaxMagnitude(TSelf, TSelf)
+        //   * TSelf Min(TSelf, TSelf)
+        //   * TSelf MinMagnitude(TSelf, TSelf)
+        //   * TSelf Parse(string, NumberStyles, IFormatProvider?)                          // * Existing
+        //   * TSelf Parse(ReadOnlySpan<char>, NumberStyles, IFormatProvider?)              // * Existing - Optional Args
+        //   * int Sign(TSelf)
+        //   * bool TryCreate(TOther, out TSelf)
+        //   * bool TryParse(string?, NumberStyles, IFormatProvider?, out TSelf)            // * Existing
+        //   * bool TryParse(ReadOnlySpan<char>, NumberStyles, IFormatProvider?, out TSelf) // * Existing
+        // * IParsable
+        //   * TSelf Parse(string, IFormatProvider?)                                        // * Existing
+        //   * bool TryParse(string?, IFormatProvider?, out TSelf)
+        // * ISpanFormattable
+        //   * bool TryFormat(Span<char>, out int, ReadOnlySpan<char>, IFormatProvider?)    // * Existing - Optional Args
+        // * ISpanParsable
+        //   * TSelf Parse(ReadOnlySpan<char>, IFormatProvider?)
+        //   * bool TryParse(ReadOnlySpan<char>, IFormatProvider?, out TSelf)
     }
 
     public struct Single
@@ -1507,20 +2877,236 @@ namespace System
           IConvertible,
           IMinMaxValue<float>
     {
-        public const float AdditiveIdentity = 0;
-        public const float MultiplicativeIdentity = 1;
-        public const float NegativeOne = 1;
-        public const float One = 1;
-        public const float Zero = 0;
+        public const float AdditiveIdentity = 0;                                           // ? Expose
+        public const float E = MathF.E;
+        public const float MaxValue = 3.40282346638528859e+38f;                            // Existing
+        public const float MinValue = -3.40282346638528859e+38f;                           // Existing
+        public const float MultiplicativeIdentity = 1;                                     // ? Expose
+        public const float NegativeOne = -1                                                // ? Expose
+        public const float NegativeZero = -0.0f;
+        public const float One = 1;                                                        // ? Expose
+        public const float Pi = Math.PI;
+        public const float Tau = Math.Tau;
+        public const float Zero = 0;                                                       // ? Expose
+
+        // Explicitly implemented interfaces
+        // * IAdditiveIdentity
+        //   * TSelf AdditiveIdentity { get; }
+        // * IMinMaxValue
+        //   * TSelf MaxValue { get; }
+        //   * TSelf MinValue { get; }
+        // * IMultiplicativeIdentity
+        //   * TSelf MultiplicativeIdentity { get; }
+        // * INumberBase
+        //   * TSelf One { get; }
+        //   * TSelf Zero { get; }
+        // * ISignedNumber
+        //   * TSelf NegativeOne { get; }
+        //
+        // * IAdditionOperators
+        //   * TSelf operator +(TSelf, TSelf)
+        //   * TSelf operator checked +(TSelf, TSelf)
+        // * IBitwiseOperators
+        //   * TSelf operator &(TSelf, TSelf)
+        //   * TSelf operator |(TSelf, TSelf)
+        //   * TSelf operator ^(TSelf, TSelf)
+        //   * TSelf operator ~(TSelf)
+        // * IDecrementOperators
+        //   * TSelf operator --(TSelf)
+        //   * TSelf operator checked --(TSelf)
+        // * IDivisionOperators
+        //   * TSelf operator /(TSelf, TSelf)
+        //   * TSelf operator checked /(TSelf, TSelf)
+        // * IIncrementOperators
+        //   * TSelf operator ++(TSelf)
+        //   * TSelf operator checked ++(TSelf)
+        // * IModulusOperators
+        //   * TSelf operator %(TSelf, TSelf)
+        // * IMultiplyOperators
+        //   * TSelf operator *(TSelf, TSelf)
+        //   * TSelf operator checked *(TSelf, TSelf)
+        // * ISubtractionOperators
+        //   * TSelf operator -(TSelf, TSelf)
+        //   * TSelf operator checked -(TSelf, TSelf)
+        // * IUnaryNegationOperators
+        //   * TSelf operator -(TSelf)
+        //   * TSelf operator checked -(TSelf)
+        // * IUnaryPlusOperators
+        //   * TSelf operator +(TSelf)
+
+        // Implicitly implemented interfaces
+        // * IBinaryNumber
+        //   * bool IsPow2(TSelf)
+        //   * TSelf Log2(TSelf)
+        // * IComparable                                                                    // Existing
+        //   * int CompareTo(object?)                                                       // * Existing
+        //   * int CompareTo(TSelf)                                                         // * Existing
+        // * IComparisonOperators
+        //   * bool operator <(TSelf, TSelf)                                                // * Existing
+        //   * bool operator <=(TSelf, TSelf)                                               // * Existing
+        //   * bool operator >(TSelf, TSelf)                                                // * Existing
+        //   * bool operator >=(TSelf, TSelf)                                               // * Existing
+        // * IEqualityOperators
+        //   * bool operator ==(TSelf, TSelf)                                               // * Existing
+        //   * bool operator !=(TSelf, TSelf)                                               // * Existing
+        // * IEquatable                                                                     // Existing
+        //   * bool Equals(TSelf)                                                           // * Existing
+        // * IExponentialFunctions
+        //   * TSelf Exp(TSelf)
+        //   * TSelf ExpM1(TSelf)                                                           // Approved - NYI
+        //   * TSelf Exp2(TSelf)                                                            // Approved - NYI
+        //   * TSelf Exp2M1(TSelf)                                                          // Approved - NYI
+        //   * TSelf Exp10(TSelf)                                                           // Approved - NYI
+        //   * TSelf Exp10M1(TSelf)                                                         // Approved - NYI
+        // * IFloatingPoint
+        //   * TSelf Ceiling(TSelf)
+        //   * TSelf Floor(TSelf)
+        //   * TSelf Round(TSelf)
+        //   * TSelf Round(TSelf, int)
+        //   * TSelf Round(TSelf, MidpointRounding)
+        //   * TSelf Round(TSelf, int, MidpointRounding)
+        //   * TSelf Truncate(TSelf)
+        // * IFloatingPointIeee754
+        //   * TSelf E { get; }                                                             // ? Explicit
+        //   * TSelf Epsilon { get; }                                                       // ? Explicit
+        //   * TSelf NaN { get; }                                                           // ? Explicit
+        //   * TSelf NegativeInfinity { get; }                                              // ? Explicit
+        //   * TSelf NegativeZero { get; }                                                  // ? Explicit
+        //   * TSelf Pi { get; }                                                            // ? Explicit
+        //   * TSelf PositiveInfinity { get; }                                              // ? Explicit
+        //   * TSelf Tau { get; }                                                           // ? Explicit
+        //   * TSelf BitDecrement(TSelf)
+        //   * TSelf BitIncrement(TSelf)
+        //   * TSelf Compound(TSelf, TSelf)                                                 // Approved - NYI
+        //   * TSelf FusedMultiplyAdd(TSelf, TSelf, TSelf)
+        //   * long GetExponentBitLength()                                                  // Approved - NYI
+        //   * int GetExponentByteCount()                                                   // Approved - NYI
+        //   * long GetSignificandBitLength()                                               // Approved - NYI
+        //   * int GetSignificandByteCount()                                                // Approved - NYI
+        //   * TSelf Ieee754Remainder(TSelf, TSelf)
+        //   * int ILogB(TSelf)
+        //   * bool IsFinite(TSelf)                                                         // * Existing
+        //   * bool IsInfinity(TSelf)                                                       // * Existing
+        //   * bool IsNaN(TSelf)                                                            // * Existing
+        //   * bool IsNegativeInfinity(TSelf)                                               // * Existing
+        //   * bool IsNormal(TSelf)                                                         // * Existing
+        //   * bool IsPositiveInfinity(TSelf)                                               // * Existing
+        //   * bool IsSubnormal(TSelf)                                                      // * Existing
+        //   * TSelf MaxMagnitudeNumber(TSelf, TSelf)                                       // Approved - NYI
+        //   * TSelf MaxNumber(TSelf, TSelf)                                                // Approved - NYI
+        //   * TSelf MinMagnitudeNumber(TSelf, TSelf)                                       // Approved - NYI
+        //   * TSelf MinNumber(TSelf, TSelf)                                                // Approved - NYI
+        //   * TSelf ScaleB(TSelf, int)
+        //   * bool TryWriteExponentLittleEndian(byte[], out int)                           // Approved - NYI
+        //   * bool TryWriteSignificandLittleEndian(byte[], out int)                        // Approved - NYI
+        //   * int WriteExponentLittleEndian(byte[])                                        // Approved - NYI
+        //   * int WriteExponentLittleEndian(byte[], int)                                   // Approved - NYI
+        //   * int WriteExponentLittleEndian(Span<byte>)                                    // Approved - NYI
+        //   * int WriteSignificandLittleEndian(byte[])                                     // Approved - NYI
+        //   * int WriteSignificandLittleEndian(byte[], int)                                // Approved - NYI
+        //   * int WriteSignificandLittleEndian(Span<byte>)                                 // Approved - NYI
+        // * IFormattable                                                                   // Existing
+        //   * string ToString(string?, IFormatProvider?)                                   // * Existing
+        // * IHyperbolicFunctions
+        //   * TSelf Acosh(TSelf)
+        //   * TSelf Asinh(TSelf)
+        //   * TSelf Atanh(TSelf)
+        //   * TSelf Cosh(TSelf)
+        //   * TSelf Sinh(TSelf)
+        //   * TSelf Tanh(TSelf)
+        // * ILogarithmicFunctions
+        //   * TSelf Log(TSelf)
+        //   * TSelf Log(TSelf, TSelf)
+        //   * TSelf LogP1(TSelf)                                                           // Approved - NYI
+        //   * TSelf Log2(TSelf)
+        //   * TSelf Log2P1(TSelf)                                                          // Approved - NYI
+        //   * TSelf Log10(TSelf)
+        //   * TSelf Log10P1(TSelf)                                                         // Approved - NYI
+        // * INumber
+        //   * TSelf Abs(TSelf)
+        //   * TSelf Clamp(TSelf, TSelf, TSelf)
+        //   * TSelf CopySign(TSelf, TSelf)
+        //   * TSelf CreateChecked(TOther)
+        //   * TSelf CreateSaturating(TOther)
+        //   * TSelf CreateTruncating(TOther)
+        //   * bool IsNegative(TSelf)                                                       // * Existing
+        //   * TSelf Max(TSelf, TSelf)
+        //   * TSelf MaxMagnitude(TSelf, TSelf)
+        //   * TSelf Min(TSelf, TSelf)
+        //   * TSelf MinMagnitude(TSelf, TSelf)
+        //   * TSelf Parse(string, NumberStyles, IFormatProvider?)                          // * Existing
+        //   * TSelf Parse(ReadOnlySpan<char>, NumberStyles, IFormatProvider?)              // * Existing
+        //   * int Sign(TSelf)
+        //   * bool TryCreate(TOther, out TSelf)
+        //   * bool TryParse(string?, NumberStyles, IFormatProvider?, out TSelf)            // * Existing
+        //   * bool TryParse(ReadOnlySpan<char>, NumberStyles, IFormatProvider?, out TSelf) // * Existing
+        // * IParsable
+        //   * TSelf Parse(string, IFormatProvider?)                                        // * Existing
+        //   * bool TryParse(string?, IFormatProvider?, out TSelf)
+        // * IPowerFunctions
+        //   * TSelf Pow(TSelf, TSelf)
+        // * IRootFunctions
+        //   * TSelf Cbrt(TSelf)
+        //   * TSelf Hypot(TSelf, TSelf)                                                    // Approved - NYI
+        //   * TSelf Sqrt(TSelf)
+        //   * TSelf Root(TSelf, TSelf)                                                     // Approved - NYI
+        // * ISpanFormattable
+        //   * bool TryFormat(Span<char>, out int, ReadOnlySpan<char>, IFormatProvider?)    // * Existing
+        // * ISpanParsable
+        //   * TSelf Parse(ReadOnlySpan<char>, IFormatProvider?)
+        //   * bool TryParse(ReadOnlySpan<char>, IFormatProvider?, out TSelf)
+        // * ITrigonometricFunctions
+        //   * TSelf Acos(TSelf)
+        //   * TSelf AcosPi(TSelf)                                                          // Approved - NYI
+        //   * TSelf Asin(TSelf)
+        //   * TSelf AsinPi(TSelf)                                                          // Approved - NYI
+        //   * TSelf Atan(TSelf)
+        //   * TSelf AtanPi(TSelf)                                                          // Approved - NYI
+        //   * TSelf Atan2(TSelf, TSelf)
+        //   * TSelf Atan2Pi(TSelf, TSelf)                                                  // Approved - NYI
+        //   * TSelf Cos(TSelf)
+        //   * TSelf CosPi(TSelf)                                                           // Approved - NYI
+        //   * TSelf Sin(TSelf)
+        //   * TSelf SinPi(TSelf)                                                           // Approved - NYI
+        //   * TSelf Tan(TSelf)
+        //   * TSelf TanPi(TSelf)                                                           // Approved - NYI
     }
 
     public struct TimeOnly
         : IComparisonOperators<TimeOnly, TimeOnly>,
           IMinMaxValue<TimeOnly>,
           ISpanFormattable,
-          ISpanParseable<TimeOnly>,
+          ISpanParsable<TimeOnly>,
           ISubtractionOperators<TimeOnly, TimeOnly, TimeSpan>
     {
+        // Implicitly Implemented interfaces
+        // * IMinMaxValue
+        //   * TSelf MaxValue { get; }
+        //   * TSelf MinValue { get; }
+        //
+        // * IComparable                                                                    // Existing
+        //   * int CompareTo(object?)                                                       // * Existing
+        //   * int CompareTo(TSelf)                                                         // * Existing
+        // * IComparisonOperators
+        //   * bool operator <(TSelf, TSelf)                                                // * Existing
+        //   * bool operator <=(TSelf, TSelf)                                               // * Existing
+        //   * bool operator >(TSelf, TSelf)                                                // * Existing
+        //   * bool operator >=(TSelf, TSelf)                                               // * Existing
+        // * IEqualityOperators
+        //   * bool operator ==(TSelf, TSelf)                                               // * Existing
+        //   * bool operator !=(TSelf, TSelf)                                               // * Existing
+        // * IEquatable                                                                     // Existing
+        //   * bool Equals(TSelf)                                                           // * Existing
+        // * IFormattable                                                                   // Existing
+        //   * string ToString(string?, IFormatProvider?)                                   // * Existing
+        // * IParsable
+        //   * TSelf Parse(string, IFormatProvider?)
+        //   * bool TryParse(string?, IFormatProvider?, out TSelf)
+        // * ISpanFormattable                                                               // Existing
+        //   * bool TryFormat(Span<char>, out int, ReadOnlySpan<char>, IFormatProvider?)    // * Existing
+        // * ISpanParsable
+        //   * TSelf Parse(ReadOnlySpan<char>, IFormatProvider?)
+        //   * bool TryParse(ReadOnlySpan<char>, IFormatProvider?, out TSelf)
     }
 
     public struct TimeSpan
@@ -1532,54 +3118,539 @@ namespace System
           IMinMaxValue<TimeSpan>,
           IMultiplicativeIdentity<TimeSpan, double>,
           IMultiplyOperators<TimeSpan, double, TimeSpan>,
-          IUnaryNegationOperators<TimeSpan, TResult>,
           ISpanFormattable,
-          ISubtractionOperators<TimeSpan, TimeSpan, TimeSpan>
-    {
+          ISubtractionOperators<TimeSpan, TimeSpan, TimeSpan>,
+          IUnaryNegationOperators<TimeSpan, TimeSpan>
+          IUnaryPlusOperators<TimeSpan, TimeSpan>
+    {
+        public static readonly TimeSpan MaxValue;                                           // Existing
+        public static readonly TimeSpan MinValue;                                           // Existing
+
+        // Explicitly Implemented interfaces
+        // * IAdditiveIdentity
+        //   * TSelf AdditiveIdentity { get; }
+        // * IMinMaxValue
+        //   * TSelf MaxValue { get; }
+        //   * TSelf MinValue { get; }
+        // * IMultiplicativeIdentity
+        //   * TSelf MultiplicativeIdentity { get; }
+
+        // Implicitly Implemented interfaces
+        // * IAdditionOperators
+        //   * TSelf operator +(TSelf, TSelf)                                               // * Existing
+        //   * TSelf operator checked +(TSelf, TSelf)
+        // * IComparable                                                                    // Existing
+        //   * int CompareTo(object?)                                                       // * Existing
+        //   * int CompareTo(TSelf)                                                         // * Existing
+        // * IComparisonOperators
+        //   * bool operator <(TSelf, TSelf)                                                // * Existing
+        //   * bool operator <=(TSelf, TSelf)                                               // * Existing
+        //   * bool operator >(TSelf, TSelf)                                                // * Existing
+        //   * bool operator >=(TSelf, TSelf)                                               // * Existing
+        // * IDivisionOperators
+        //   * TSelf operator /(TSelf, TSelf)                                               // * Existing
+        //   * TSelf operator checked /(TSelf, TSelf)
+        // * IEqualityOperators
+        //   * bool operator ==(TSelf, TSelf)                                               // * Existing
+        //   * bool operator !=(TSelf, TSelf)                                               // * Existing
+        // * IEquatable                                                                     // Existing
+        //   * bool Equals(TSelf)                                                           // * Existing
+        // * IFormattable                                                                   // Existing
+        //   * string ToString(string?, IFormatProvider?)                                   // * Existing
+        // * IMultiplyOperators
+        //   * TSelf operator *(TSelf, TSelf)                                               // * Existing
+        //   * TSelf operator checked *(TSelf, TSelf)
+        // * IParsable
+        //   * TSelf Parse(string, IFormatProvider?)                                        // * Existing
+        //   * bool TryParse(string?, IFormatProvider?, out TSelf)
+        // * ISpanFormattable                                                               // Existing
+        //   * bool TryFormat(Span<char>, out int, ReadOnlySpan<char>, IFormatProvider?)    // * Existing
+        // * ISpanParsable
+        //   * TSelf Parse(ReadOnlySpan<char>, IFormatProvider?)
+        //   * bool TryParse(ReadOnlySpan<char>, IFormatProvider?, out TSelf)
+        // * ISubtractionOperators
+        //   * TSelf operator -(TSelf, TSelf)                                               // * Existing
+        //   * TSelf operator checked -(TSelf, TSelf)
+        // * IUnaryNegationOperators
+        //   * TSelf operator -(TSelf)                                                      // * Existing
+        //   * TSelf operator checked -(TSelf)
+        // * IUnaryPlusOperators
+        //   * TSelf operator +(TSelf)                                                      // * Existing
     }
 
     public struct UInt16
         : IBinaryInteger<ushort>,
           IConvertible,
           IMinMaxValue<ushort>,
-          IUnsignedNumberBase<ushort>
-    {
-        public const ushort AdditiveIdentity = 0;
-        public const ushort MultiplicativeIdentity = 1;
-        public const ushort One = 1;
-        public const ushort Zero = 0;
+          IUnsignedNumber<ushort>
+    {
+        public const short AdditiveIdentity = 0;                                             // ? Expose
+        public const short MaxValue = 65535;                                                 // Existing
+        public const short MinValue = 0;                                                     // Existing
+        public const short MultiplicativeIdentity = 1;                                       // ? Expose
+        public const short One = 1;                                                          // ? Expose
+        public const short Zero = 0;                                                         // ? Expose
+
+        // Explicitly implemented interfaces
+        // * IAdditiveIdentity
+        //   * TSelf AdditiveIdentity { get; }
+        // * IMinMaxValue
+        //   * TSelf MaxValue { get; }
+        //   * TSelf MinValue { get; }
+        // * IMultiplicativeIdentity
+        //   * TSelf MultiplicativeIdentity { get; }
+        // * INumberBase
+        //   * One { get; }
+        //   * Zero { get; }
+        //
+        // * IAdditionOperators
+        //   * TSelf operator +(TSelf, TSelf)
+        //   * TSelf operator checked +(TSelf, TSelf)
+        // * IBitwiseOperators
+        //   * TSelf operator &(TSelf, TSelf)
+        //   * TSelf operator |(TSelf, TSelf)
+        //   * TSelf operator ^(TSelf, TSelf)
+        //   * TSelf operator ~(TSelf)
+        // * IComparisonOperators
+        //   * bool operator <(TSelf, TSelf)
+        //   * bool operator <=(TSelf, TSelf)
+        //   * bool operator >(TSelf, TSelf)
+        //   * bool operator >=(TSelf, TSelf)
+        // * IDecrementOperators
+        //   * TSelf operator --(TSelf)
+        //   * TSelf operator checked --(TSelf)
+        // * IDivisionOperators
+        //   * TSelf operator /(TSelf, TSelf)
+        //   * TSelf operator checked /(TSelf, TSelf)
+        // * IEqualityOperators
+        //   * bool operator ==(TSelf, TSelf)
+        //   * bool operator !=(TSelf, TSelf)
+        // * IIncrementOperators
+        //   * TSelf operator ++(TSelf)
+        //   * TSelf operator checked ++(TSelf)
+        // * IModulusOperators
+        //   * TSelf operator %(TSelf, TSelf)
+        // * IMultiplyOperators
+        //   * TSelf operator *(TSelf, TSelf)
+        //   * TSelf operator checked *(TSelf, TSelf)
+        // * IShiftOperators
+        //   * TSelf operator <<(TSelf, int)
+        //   * TSelf operator >>(TSelf, int)
+        //   * TSelf operator >>>(TSelf, int)
+        // * ISubtractionOperators
+        //   * TSelf operator -(TSelf, TSelf)
+        //   * TSelf operator checked -(TSelf, TSelf)
+        // * IUnaryNegationOperators
+        //   * TSelf operator -(TSelf)
+        //   * TSelf operator checked -(TSelf)
+        // * IUnaryPlusOperators
+        //   * TSelf operator +(TSelf)
+
+        // Implicitly Implemented interfaces
+        // * IBinaryInteger
+        //   * (TSelf, TSelf) DivRem(TSelf, TSelf)
+        //   * long GetBitLength()                                                          // Approved - NYI
+        //   * int GetByteCount()                                                           // Approved - NYI
+        //   * TSelf LeadingZeroCount(TSelf)
+        //   * TSelf PopCount(TSelf)
+        //   * TSelf RotateLeft(TSelf, int)
+        //   * TSelf RotateRight(TSelf, int)
+        //   * TSelf TrailingZeroCount(TSelf)
+        //   * bool TryWriteLittleEndian(byte[], out int)                                   // Approved - NYI
+        //   * int WriteLittleEndian(byte[])                                                // Approved - NYI
+        //   * int WriteLittleEndian(byte[], int)                                           // Approved - NYI
+        //   * int WriteLittleEndian(Span<byte>)                                            // Approved - NYI
+        // * IBinaryNumber
+        //   * bool IsPow2(TSelf)
+        //   * TSelf Log2(TSelf)
+        // * IComparable                                                                    // Existing
+        //   * int CompareTo(object?)                                                       // * Existing
+        //   * int CompareTo(TSelf)                                                         // * Existing
+        // * IEquatable                                                                     // Existing
+        //   * bool Equals(TSelf)                                                           // * Existing
+        // * IFormattable                                                                   // Existing
+        //   * string ToString(string?, IFormatProvider?)                                   // * Existing
+        // * INumber
+        //   * TSelf Abs(TSelf)                                                             // ? Explicit
+        //   * TSelf Clamp(TSelf, TSelf, TSelf)
+        //   * TSelf CopySign(TSelf, TSelf)                                                 // ? Explicit
+        //   * TSelf CreateChecked(TOther)
+        //   * TSelf CreateSaturating(TOther)
+        //   * TSelf CreateTruncating(TOther)
+        //   * bool IsNegative(TSelf)                                                       // ? Explicit
+        //   * TSelf Max(TSelf, TSelf)
+        //   * TSelf MaxMagnitude(TSelf, TSelf)                                             // ? Explicit
+        //   * TSelf Min(TSelf, TSelf)
+        //   * TSelf MinMagnitude(TSelf, TSelf)                                             // ? Explicit
+        //   * TSelf Parse(string, NumberStyles, IFormatProvider?)                          // * Existing
+        //   * TSelf Parse(ReadOnlySpan<char>, NumberStyles, IFormatProvider?)              // * Existing - Optional Args
+        //   * int Sign(TSelf)
+        //   * bool TryCreate(TOther, out TSelf)
+        //   * bool TryParse(string?, NumberStyles, IFormatProvider?, out TSelf)            // * Existing
+        //   * bool TryParse(ReadOnlySpan<char>, NumberStyles, IFormatProvider?, out TSelf) // * Existing
+        // * IParsable
+        //   * TSelf Parse(string, IFormatProvider?)                                        // * Existing
+        //   * bool TryParse(string?, IFormatProvider?, out TSelf)
+        // * ISpanFormattable
+        //   * bool TryFormat(Span<char>, out int, ReadOnlySpan<char>, IFormatProvider?)    // * Existing - Optional Args
+        // * ISpanParsable
+        //   * TSelf Parse(ReadOnlySpan<char>, IFormatProvider?)
+        //   * bool TryParse(ReadOnlySpan<char>, IFormatProvider?, out TSelf)
     }
 
     public struct UInt32
         : IBinaryInteger<uint>,
           IConvertible,
           IMinMaxValue<uint>,
-          IUnsignedNumberBase<uint>
-    {
-        public const uint AdditiveIdentity = 0;
-        public const uint MultiplicativeIdentity = 1;
-        public const uint One = 1;
-        public const uint Zero = 0;
+          IUnsignedNumber<uint>
+    {
+        public const uint AdditiveIdentity = 0;                                             // ? Expose
+        public const uint MaxValue = 4294967295;                                            // Existing
+        public const uint MinValue = 0;                                                     // Existing
+        public const uint MultiplicativeIdentity = 1;                                       // ? Expose
+        public const uint One = 1;                                                          // ? Expose
+        public const uint Zero = 0;                                                         // ? Expose
+
+        // Explicitly implemented interfaces
+        // * IAdditiveIdentity
+        //   * TSelf AdditiveIdentity { get; }
+        // * IMinMaxValue
+        //   * TSelf MaxValue { get; }
+        //   * TSelf MinValue { get; }
+        // * IMultiplicativeIdentity
+        //   * TSelf MultiplicativeIdentity { get; }
+        // * INumberBase
+        //   * One { get; }
+        //   * Zero { get; }
+        //
+        // * IAdditionOperators
+        //   * TSelf operator +(TSelf, TSelf)
+        //   * TSelf operator checked +(TSelf, TSelf)
+        // * IBitwiseOperators
+        //   * TSelf operator &(TSelf, TSelf)
+        //   * TSelf operator |(TSelf, TSelf)
+        //   * TSelf operator ^(TSelf, TSelf)
+        //   * TSelf operator ~(TSelf)
+        // * IComparisonOperators
+        //   * bool operator <(TSelf, TSelf)
+        //   * bool operator <=(TSelf, TSelf)
+        //   * bool operator >(TSelf, TSelf)
+        //   * bool operator >=(TSelf, TSelf)
+        // * IDecrementOperators
+        //   * TSelf operator --(TSelf)
+        //   * TSelf operator checked --(TSelf)
+        // * IDivisionOperators
+        //   * TSelf operator /(TSelf, TSelf)
+        //   * TSelf operator checked /(TSelf, TSelf)
+        // * IEqualityOperators
+        //   * bool operator ==(TSelf, TSelf)
+        //   * bool operator !=(TSelf, TSelf)
+        // * IIncrementOperators
+        //   * TSelf operator ++(TSelf)
+        //   * TSelf operator checked ++(TSelf)
+        // * IModulusOperators
+        //   * TSelf operator %(TSelf, TSelf)
+        // * IMultiplyOperators
+        //   * TSelf operator *(TSelf, TSelf)
+        //   * TSelf operator checked *(TSelf, TSelf)
+        // * IShiftOperators
+        //   * TSelf operator <<(TSelf, int)
+        //   * TSelf operator >>(TSelf, int)
+        //   * TSelf operator >>>(TSelf, int)
+        // * ISubtractionOperators
+        //   * TSelf operator -(TSelf, TSelf)
+        //   * TSelf operator checked -(TSelf, TSelf)
+        // * IUnaryNegationOperators
+        //   * TSelf operator -(TSelf)
+        //   * TSelf operator checked -(TSelf)
+        // * IUnaryPlusOperators
+        //   * TSelf operator +(TSelf)
+
+        // Implicitly Implemented interfaces
+        // * IBinaryInteger
+        //   * (TSelf, TSelf) DivRem(TSelf, TSelf)
+        //   * long GetBitLength()                                                          // Approved - NYI
+        //   * int GetByteCount()                                                           // Approved - NYI
+        //   * TSelf LeadingZeroCount(TSelf)
+        //   * TSelf PopCount(TSelf)
+        //   * TSelf RotateLeft(TSelf, int)
+        //   * TSelf RotateRight(TSelf, int)
+        //   * TSelf TrailingZeroCount(TSelf)
+        //   * bool TryWriteLittleEndian(byte[], out int)                                   // Approved - NYI
+        //   * int WriteLittleEndian(byte[])                                                // Approved - NYI
+        //   * int WriteLittleEndian(byte[], int)                                           // Approved - NYI
+        //   * int WriteLittleEndian(Span<byte>)                                            // Approved - NYI
+        // * IBinaryNumber
+        //   * bool IsPow2(TSelf)
+        //   * TSelf Log2(TSelf)
+        // * IComparable                                                                    // Existing
+        //   * int CompareTo(object?)                                                       // * Existing
+        //   * int CompareTo(TSelf)                                                         // * Existing
+        // * IEquatable                                                                     // Existing
+        //   * bool Equals(TSelf)                                                           // * Existing
+        // * IFormattable                                                                   // Existing
+        //   * string ToString(string?, IFormatProvider?)                                   // * Existing
+        // * INumber
+        //   * TSelf Abs(TSelf)                                                             // ? Explicit
+        //   * TSelf Clamp(TSelf, TSelf, TSelf)
+        //   * TSelf CopySign(TSelf, TSelf)                                                 // ? Explicit
+        //   * TSelf CreateChecked(TOther)
+        //   * TSelf CreateSaturating(TOther)
+        //   * TSelf CreateTruncating(TOther)
+        //   * bool IsNegative(TSelf)                                                       // ? Explicit
+        //   * TSelf Max(TSelf, TSelf)
+        //   * TSelf MaxMagnitude(TSelf, TSelf)                                             // ? Explicit
+        //   * TSelf Min(TSelf, TSelf)
+        //   * TSelf MinMagnitude(TSelf, TSelf)                                             // ? Explicit
+        //   * TSelf Parse(string, NumberStyles, IFormatProvider?)                          // * Existing
+        //   * TSelf Parse(ReadOnlySpan<char>, NumberStyles, IFormatProvider?)              // * Existing - Optional Args
+        //   * int Sign(TSelf)
+        //   * bool TryCreate(TOther, out TSelf)
+        //   * bool TryParse(string?, NumberStyles, IFormatProvider?, out TSelf)            // * Existing
+        //   * bool TryParse(ReadOnlySpan<char>, NumberStyles, IFormatProvider?, out TSelf) // * Existing
+        // * IParsable
+        //   * TSelf Parse(string, IFormatProvider?)                                        // * Existing
+        //   * bool TryParse(string?, IFormatProvider?, out TSelf)
+        // * ISpanFormattable
+        //   * bool TryFormat(Span<char>, out int, ReadOnlySpan<char>, IFormatProvider?)    // * Existing - Optional Args
+        // * ISpanParsable
+        //   * TSelf Parse(ReadOnlySpan<char>, IFormatProvider?)
+        //   * bool TryParse(ReadOnlySpan<char>, IFormatProvider?, out TSelf)
     }
 
     public struct UInt64
         : IBinaryInteger<ulong>,
           IConvertible,
           IMinMaxValue<ulong>,
-          IUnsignedNumberBase<ulong>
-    {
-        public const ulong AdditiveIdentity = 0;
-        public const ulong MultiplicativeIdentity = 1;
-        public const ulong One = 1;
-        public const ulong Zero = 0;
+          IUnsignedNumber<ulong>
+    {
+        public const ulong AdditiveIdentity = 0;                                             // ? Expose
+        public const ulong MaxValue = 18446744073709551615;                                  // Existing
+        public const ulong MinValue = 0;                                                     // Existing
+        public const ulong MultiplicativeIdentity = 1;                                       // ? Expose
+        public const ulong One = 1;                                                          // ? Expose
+        public const ulong Zero = 0;                                                         // ? Expose
+
+        // Explicitly implemented interfaces
+        // * IAdditiveIdentity
+        //   * TSelf AdditiveIdentity { get; }
+        // * IMinMaxValue
+        //   * TSelf MaxValue { get; }
+        //   * TSelf MinValue { get; }
+        // * IMultiplicativeIdentity
+        //   * TSelf MultiplicativeIdentity { get; }
+        // * INumberBase
+        //   * One { get; }
+        //   * Zero { get; }
+        //
+        // * IAdditionOperators
+        //   * TSelf operator +(TSelf, TSelf)
+        //   * TSelf operator checked +(TSelf, TSelf)
+        // * IBitwiseOperators
+        //   * TSelf operator &(TSelf, TSelf)
+        //   * TSelf operator |(TSelf, TSelf)
+        //   * TSelf operator ^(TSelf, TSelf)
+        //   * TSelf operator ~(TSelf)
+        // * IComparisonOperators
+        //   * bool operator <(TSelf, TSelf)
+        //   * bool operator <=(TSelf, TSelf)
+        //   * bool operator >(TSelf, TSelf)
+        //   * bool operator >=(TSelf, TSelf)
+        // * IDecrementOperators
+        //   * TSelf operator --(TSelf)
+        //   * TSelf operator checked --(TSelf)
+        // * IDivisionOperators
+        //   * TSelf operator /(TSelf, TSelf)
+        //   * TSelf operator checked /(TSelf, TSelf)
+        // * IEqualityOperators
+        //   * bool operator ==(TSelf, TSelf)
+        //   * bool operator !=(TSelf, TSelf)
+        // * IIncrementOperators
+        //   * TSelf operator ++(TSelf)
+        //   * TSelf operator checked ++(TSelf)
+        // * IModulusOperators
+        //   * TSelf operator %(TSelf, TSelf)
+        // * IMultiplyOperators
+        //   * TSelf operator *(TSelf, TSelf)
+        //   * TSelf operator checked *(TSelf, TSelf)
+        // * IShiftOperators
+        //   * TSelf operator <<(TSelf, int)
+        //   * TSelf operator >>(TSelf, int)
+        //   * TSelf operator >>>(TSelf, int)
+        // * ISubtractionOperators
+        //   * TSelf operator -(TSelf, TSelf)
+        //   * TSelf operator checked -(TSelf, TSelf)
+        // * IUnaryNegationOperators
+        //   * TSelf operator -(TSelf)
+        //   * TSelf operator checked -(TSelf)
+        // * IUnaryPlusOperators
+        //   * TSelf operator +(TSelf)
+
+        // Implicitly Implemented interfaces
+        // * IBinaryInteger
+        //   * (TSelf, TSelf) DivRem(TSelf, TSelf)
+        //   * long GetBitLength()                                                          // Approved - NYI
+        //   * int GetByteCount()                                                           // Approved - NYI
+        //   * TSelf LeadingZeroCount(TSelf)
+        //   * TSelf PopCount(TSelf)
+        //   * TSelf RotateLeft(TSelf, int)
+        //   * TSelf RotateRight(TSelf, int)
+        //   * TSelf TrailingZeroCount(TSelf)
+        //   * bool TryWriteLittleEndian(byte[], out int)                                   // Approved - NYI
+        //   * int WriteLittleEndian(byte[])                                                // Approved - NYI
+        //   * int WriteLittleEndian(byte[], int)                                           // Approved - NYI
+        //   * int WriteLittleEndian(Span<byte>)                                            // Approved - NYI
+        // * IBinaryNumber
+        //   * bool IsPow2(TSelf)
+        //   * TSelf Log2(TSelf)
+        // * IComparable                                                                    // Existing
+        //   * int CompareTo(object?)                                                       // * Existing
+        //   * int CompareTo(TSelf)                                                         // * Existing
+        // * IEquatable                                                                     // Existing
+        //   * bool Equals(TSelf)                                                           // * Existing
+        // * IFormattable                                                                   // Existing
+        //   * string ToString(string?, IFormatProvider?)                                   // * Existing
+        // * INumber
+        //   * TSelf Abs(TSelf)                                                             // ? Explicit
+        //   * TSelf Clamp(TSelf, TSelf, TSelf)
+        //   * TSelf CopySign(TSelf, TSelf)                                                 // ? Explicit
+        //   * TSelf CreateChecked(TOther)
+        //   * TSelf CreateSaturating(TOther)
+        //   * TSelf CreateTruncating(TOther)
+        //   * bool IsNegative(TSelf)                                                       // ? Explicit
+        //   * TSelf Max(TSelf, TSelf)
+        //   * TSelf MaxMagnitude(TSelf, TSelf)                                             // ? Explicit
+        //   * TSelf Min(TSelf, TSelf)
+        //   * TSelf MinMagnitude(TSelf, TSelf)                                             // ? Explicit
+        //   * TSelf Parse(string, NumberStyles, IFormatProvider?)                          // * Existing
+        //   * TSelf Parse(ReadOnlySpan<char>, NumberStyles, IFormatProvider?)              // * Existing - Optional Args
+        //   * int Sign(TSelf)
+        //   * bool TryCreate(TOther, out TSelf)
+        //   * bool TryParse(string?, NumberStyles, IFormatProvider?, out TSelf)            // * Existing
+        //   * bool TryParse(ReadOnlySpan<char>, NumberStyles, IFormatProvider?, out TSelf) // * Existing
+        // * IParsable
+        //   * TSelf Parse(string, IFormatProvider?)                                        // * Existing
+        //   * bool TryParse(string?, IFormatProvider?, out TSelf)
+        // * ISpanFormattable
+        //   * bool TryFormat(Span<char>, out int, ReadOnlySpan<char>, IFormatProvider?)    // * Existing - Optional Args
+        // * ISpanParsable
+        //   * TSelf Parse(ReadOnlySpan<char>, IFormatProvider?)
+        //   * bool TryParse(ReadOnlySpan<char>, IFormatProvider?, out TSelf)
     }
 
     public struct UIntPtr
         : IBinaryInteger<nuint>,
           IMinMaxValue<nuint>,
           ISerializable,
-          IUnsignedNumberBase<nuint>
-    {
+          IUnsignedNumber<nuint>
+    {
+        public static readonly UIntPtr Zero = 0;                                      // Existing
+
+        // Explicitly implemented interfaces
+        // * IAdditiveIdentity
+        //   * TSelf AdditiveIdentity { get; }
+        // * IMultiplicativeIdentity
+        //   * TSelf MultiplicativeIdentity { get; }
+        // * INumberBase
+        //   * One { get; }
+        //   * Zero { get; }
+        //
+        // * IAdditionOperators
+        //   * TSelf operator +(TSelf, TSelf)
+        //   * TSelf operator checked +(TSelf, TSelf)
+        // * IBitwiseOperators
+        //   * TSelf operator &(TSelf, TSelf)
+        //   * TSelf operator |(TSelf, TSelf)
+        //   * TSelf operator ^(TSelf, TSelf)
+        //   * TSelf operator ~(TSelf)
+        // * IComparisonOperators
+        //   * bool operator <(TSelf, TSelf)
+        //   * bool operator <=(TSelf, TSelf)
+        //   * bool operator >(TSelf, TSelf)
+        //   * bool operator >=(TSelf, TSelf)
+        // * IDecrementOperators
+        //   * TSelf operator --(TSelf)
+        //   * TSelf operator checked --(TSelf)
+        // * IDivisionOperators
+        //   * TSelf operator /(TSelf, TSelf)
+        //   * TSelf operator checked /(TSelf, TSelf)
+        // * IIncrementOperators
+        //   * TSelf operator ++(TSelf)
+        //   * TSelf operator checked ++(TSelf)
+        // * IModulusOperators
+        //   * TSelf operator %(TSelf, TSelf)
+        // * IMultiplyOperators
+        //   * TSelf operator *(TSelf, TSelf)
+        //   * TSelf operator checked *(TSelf, TSelf)
+        // * IShiftOperators
+        //   * TSelf operator <<(TSelf, int)
+        //   * TSelf operator >>(TSelf, int)
+        //   * TSelf operator >>>(TSelf, int)
+        // * ISubtractionOperators
+        //   * TSelf operator -(TSelf, TSelf)
+        //   * TSelf operator checked -(TSelf, TSelf)
+        // * IUnaryNegationOperators
+        //   * TSelf operator -(TSelf)
+        //   * TSelf operator checked -(TSelf)
+        // * IUnaryPlusOperators
+        //   * TSelf operator +(TSelf)
+
+        // Implicitly Implemented interfaces
+        // * IBinaryInteger
+        //   * (TSelf, TSelf) DivRem(TSelf, TSelf)
+        //   * long GetBitLength()                                                          // Approved - NYI
+        //   * int GetByteCount()                                                           // Approved - NYI
+        //   * TSelf LeadingZeroCount(TSelf)
+        //   * TSelf PopCount(TSelf)
+        //   * TSelf RotateLeft(TSelf, int)
+        //   * TSelf RotateRight(TSelf, int)
+        //   * TSelf TrailingZeroCount(TSelf)
+        //   * bool TryWriteLittleEndian(byte[], out int)                                   // Approved - NYI
+        //   * int WriteLittleEndian(byte[])                                                // Approved - NYI
+        //   * int WriteLittleEndian(byte[], int)                                           // Approved - NYI
+        //   * int WriteLittleEndian(Span<byte>)                                            // Approved - NYI
+        // * IBinaryNumber
+        //   * bool IsPow2(TSelf)
+        //   * TSelf Log2(TSelf)
+        // * IComparable                                                                    // Existing
+        //   * int CompareTo(object?)                                                       // * Existing
+        //   * int CompareTo(TSelf)                                                         // * Existing
+        // * IEqualityOperators
+        //   * bool operator ==(TSelf, TSelf)                                               // * Existing
+        //   * bool operator !=(TSelf, TSelf)                                               // * Existing
+        // * IEquatable                                                                     // Existing
+        //   * bool Equals(TSelf)                                                           // * Existing
+        // * IFormattable                                                                   // Existing
+        //   * string ToString(string?, IFormatProvider?)                                   // * Existing
+        // * IMinMaxValue
+        //   * TSelf MaxValue { get; }                                                      // * Existing
+        //   * TSelf MinValue { get; }                                                      // * Existing
+        // * INumber
+        //   * TSelf Abs(TSelf)                                                             // ? Explicit
+        //   * TSelf Clamp(TSelf, TSelf, TSelf)
+        //   * TSelf CopySign(TSelf, TSelf)                                                 // ? Explicit
+        //   * TSelf CreateChecked(TOther)
+        //   * TSelf CreateSaturating(TOther)
+        //   * TSelf CreateTruncating(TOther)
+        //   * bool IsNegative(TSelf)                                                       // ? Explicit
+        //   * TSelf Max(TSelf, TSelf)
+        //   * TSelf MaxMagnitude(TSelf, TSelf)                                             // ? Explicit
+        //   * TSelf Min(TSelf, TSelf)
+        //   * TSelf MinMagnitude(TSelf, TSelf)                                             // ? Explicit
+        //   * TSelf Parse(string, NumberStyles, IFormatProvider?)                          // * Existing
+        //   * TSelf Parse(ReadOnlySpan<char>, NumberStyles, IFormatProvider?)              // * Existing - Optional Args
+        //   * int Sign(TSelf)
+        //   * bool TryCreate(TOther, out TSelf)
+        //   * bool TryParse(string?, NumberStyles, IFormatProvider?, out TSelf)            // * Existing
+        //   * bool TryParse(ReadOnlySpan<char>, NumberStyles, IFormatProvider?, out TSelf) // * Existing
+        // * IParsable
+        //   * TSelf Parse(string, IFormatProvider?)                                        // * Existing
+        //   * bool TryParse(string?, IFormatProvider?, out TSelf)
+        // * ISpanFormattable
+        //   * bool TryFormat(Span<char>, out int, ReadOnlySpan<char>, IFormatProvider?)    // * Existing - Optional Args
+        // * ISpanParsable
+        //   * TSelf Parse(ReadOnlySpan<char>, IFormatProvider?)
+        //   * bool TryParse(ReadOnlySpan<char>, IFormatProvider?, out TSelf)
     }
 }
 
@@ -1587,9 +3658,9 @@ namespace System.Numerics
 {
     public struct BigInteger
         : IBinaryInteger<BigInteger>,
-          ISignedNumberBase<BigInteger>,
+          ISignedNumber<BigInteger>,
           ISpanFormattable,
-          ISpanParseable<BigInteger>
+          ISpanParsable<BigInteger>
     {
     }
 

From 8eefb64728b30345f8d73a43b0920208e852c39d Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Fri, 1 Apr 2022 12:47:11 -0700
Subject: [PATCH 14/16] Updating the UML diagram

---
 accepted/2021/statics-in-interfaces/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/accepted/2021/statics-in-interfaces/README.md b/accepted/2021/statics-in-interfaces/README.md
index 7848777ab..5df32a258 100644
--- a/accepted/2021/statics-in-interfaces/README.md
+++ b/accepted/2021/statics-in-interfaces/README.md
@@ -491,7 +491,7 @@ class "Vector4"
 @enduml
 -->
 
-![UML](http://www.plantuml.com/plantuml/svg/h9ZFKziw4CVl_YioEJyEGCXx1uPvvGSbCwN9u8JxsjaaQcKfbTQ0E_tZ6-ZWO5dPo4gvCBjUVQJL3trN-TyI62eBcGX5Q1QGOwy_-ZIV2n9QZTTeWBInvzCKvUAVtdHCApIR_mzeIqaNVK-p9npDKP6WgcxbZRuK2anrApMGKCk95ef6YFZlsU1FEs_uI14kqJ0HNyiYsnb0py9YnwokTB460vd4NVxpgRU9i3jdi1Mldj2GQFLnZRd10XKvd0itpA8H8CLF8A7L5KYPGVxT2H9FmdPVr9iV9KX15PE94qtUERbvMMk5YWJ8srBbh-Fq9zFO4Kn4m9wvrQO0elRQtLLhD9cM8kV7Cb91y_z5By48MXNxUFT2tSFB8yWI_T_rl9IbxRX4znkNM4kH0t_wF6sgZbsrJvVpwHAiFxK968kGoHrVzJCQVkuUj2O-8dq_1AtrJbTYGHrJJSLIuNnFLkaQb6-NrH_vjDCo8mDvn5qxDMAfbIwGpBvDDrCs99NPs-s9I_2EfXv5kyr4bZOm_X5pqgQEINEGO3OnYV_sxktyE_zrT1Ic8Vnr4K-E7xHVoO8tQGWiwI1sBitDPyCAJR2tbvKqz9JdrB10HNKb-I-Y0sGm5fqueXau8m6wdEo-mrYoNu0JNi8P6dE4M2NknJ5vEOvZEfzTM2JJBtg7CTigUVWuUQs9OIP1PwCDTMuJha1kvSfHWajZZZ9IXu-bGmd8Ky9AmZrZ2RquU8fJ8t4Cdj8kfZfJ0eiSbf9qUI0x6AV-2dWproanf0Y5uaZXRmEUrB6-PKa1bMPGTd6xsb5I1yXiRWRelXmIpnif5EGsZCoJVon4xNkcw8_O_0mkekJbS14AnU0Yf8h1HMWMXuiGBmuNeM8SBbRE0d3LuNCN8N0SBkBIv70naiVZabo2jRt-PKNOVpUkLc1gune8nqfM3STK5DXoZ1SBYxHrOouAa5jRbvdSjhfHPL4Rdqinhuqxa8lQ62aw7dwqJay-MiF1Hsj2fZR7sJVCgJRJHeQfK4kvDLz7_xhejMFMx7RMx7VMx7ZczFpsS-2qMc_vxxD_uNY6WxRl-EI_jlFaREXnElQfOmz-bse7DxN3G1X6zsc7FQ87H0Um0tRqpm8T1Inoh_LD0SSl_j-GZCVt76aOA6prMQhXpnpx95lstz7ejht-QDsrmjzvuCMciForjB3O4XORmc93M6pyddgRr4tpzJNDrnC8NyFZS_VbPLlRBRusH7ojUBuN0B_S3uH_lnGGNmk8huq1NmkG7nQWh_si3AqoBKQhNDwSddJhMNfXMgMNvxfABrAhz59TL-a5QvLfsLgbldtqfAbIy3e_nck5uQcqyFm_W1yxbschr_xdpmOTagFhpkbqr-MW4xRDXeaKcxRCjXxFOIwykTZmlcBRXjbKsWwieJJPyD1iFROuM8UwXEkMuNIR2PV0u9QOuKDC34w9mIKnk2G6jyGCQ69YS4eCBed19J4u9cQK57TDXstJhRsWMsfqZkqvJwpW53cS4eTJP73yPfc0fiZedXaTzat7xkHdrjidK7oVGF6ro-7hUOoFyVDzWcNONaS7V1qQyFNIZUy5nBTxCBvUVF6zWFbUW7ovo-9h0VFvO_CIMsUwzyvq6_lJCJYwnzRxPph6HlVOUWjDzzXw4qstsEWUM--ZwHvRxwJntWpZCJayHuSVRi6tCF_x0lku_Ed0pHMOnzaABiZx4kxJPskuVfyjCdk6Xypz6E3fxVFrw-Fz6m00)
+![UML](http://www.plantuml.com/plantuml/svg/h9XBKzi-4C3l_XIPdFySU91_3mpJyg1ufZGPd73VE1j7hIobaWouqm_V6AY29MUZAEJ2x7hrq-gn3_5P6r2cAdd2X44rXnnx_VHIbajGCENOtw0_6v-xdyGZAiEyCLUeKJ7Wx3SO9iKbS3w5_6VRwFfN1QQJUoDL2SRulen0wTSH6VAvCofxcz8VbYr1ECpsHu_RilWocx5c6SCbAZ1IwLUp_thZeLcWMlszHrrninhd3tl4T8R2C5FRKPtM5qo0gc-u1CD4CP9Cc1GH_pyziKxvvkbAKw0YBBvNvNIZWNbY6eDMvLu7fZTkXsD_XRd24eLnp5qpziXqs1wxTuWpKuVvSlsybA8v3E0tbSYRC-tsfdKCX4N0GTtMIrHJoLbEJvcAe7tw9WjGp2pARRmx9kxW-G5uXTtVvQpYbTvnl-zMAhRaB8VGcst7r3jEvTrSzzC5wEwbZUGJAdftxgKqj4MsO7EpeyiPAmJE2CUpQceKv179PAnO8OKiqQXj9pzvYNiie7CQ7s_7Z7YbW-trjhK-OBxYM4oM0mVLfDRkrDJR-3lxSt0GbY3fi8mdnplTdQQ3RrS8BDaXa_iqvm3TiEkHFvgLj7eAccDXWHN6RKi-41rGL6BHYTFq1Er8K9MBFRZkGjUToI9X2Lrt2Lfuf3kmM2PHgwEPLC6EPNONkFtMxbV4_VUJBbenp2Geq7oeb-R2-qs24jv44RwuxGonxnJ5VUIG39hYlePsfIIxF9aSZDFM1RoYh3CqYNY9M4G8AQ904AHKV8nFmPrvEAdUz-nsR7S9Kb1_6hHFmTtnLj8A5Hvj5kM7QGEY0uu0kGFZGezercFYZy15jAe4Bg8O4BZe547W8eeCWKl5XtaNKRm8N4G22iNL--zTJ7KaS36PZS159YK2b-GSjExrBrZnzbRiMrLjq0gN2rX_QGA9uxELhy3WKF2wfHYp4Zt5S3xNQDPgp5a9V2tBQihNewv5LLhXQyLcLhW5FhT2AipXuBrqVFHU6foybqP6MN4u_O6viMBMMd76HC7NOkDzSo-iOjAUTjAUTzAUUEBC_FAljd6zNFF_7T2vencS-Bh3eq--ykXqqA5qv6D7_bki7Tmq40DX6BrlEIJYJ0-83k06tEWV2Mdq4SGYw_b00S-mVoRExDZNfXND2fRQ-Gf6Nm6_hr0Wjsnz1NgCAVARqud8elrbUhfepsPZ2nOYor9Oimb0M5a8AmjXZOMmnbgRr2RPJ_i_SEeyupAFYTEO94uJaJWs1d5usOxJw2LEKvOu3LJYrBN4yViMfsQzFiJscRprW7cRZUGjlpplMVLjz2wNzmym3pyoUIo0_EqD0VZxMa1vAg0yV7_pKe3vhGBiFM6t35l5Yx5LJc-gH9V-5o_CLl7oR9NT8cqLBzLMyO9jbRsoRHNRVNgRnKg9otbLt2eiBgKLbqyWVgoSiF_q3GxiWqj3ScbuyZGTWC-8H1uxEni0M7ZaiRGhpnX8Tgwni5-DXGVEKcdFg0jACml_z5YQ5Cn83keo38ySXf5KM08BUsANEqWi38c58R4m9HRsnEwla5WO4Wj3Oc58B8o9DVwMfqx3OwUXlKXBQccExH67n668F0o9XocoCFrcTNO2aQKjipGyTngxaw-t29z0vR73oLkNavVtiRp6dyS1GiTqDZh8Qm7aPMwVvmBAmo5xteRdUI_WF1LmNWeu3mVjURs7bBSlK1v_x9wyTKzByQRXf2zjmQKzDkpVqnPRscFJ5ZxjiM4JdxROqXwRzl5fZyqx-RWrut5Fpflv-37tTrPilZzw7AVtelvUeQiwla9NUto9RWBv6bqSsbjaxt-u8EyQqyFB-_F7s-id)
 
 ### Base Interfaces
 

From bd3bce83bc2c7591283abf6085f9315946f93a7f Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Fri, 1 Apr 2022 13:11:17 -0700
Subject: [PATCH 15/16] Ensure ReciprocalEstimate, ReciprocalSqrtEstimate, and
 SinCos are covered

---
 accepted/2021/statics-in-interfaces/README.md | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/accepted/2021/statics-in-interfaces/README.md b/accepted/2021/statics-in-interfaces/README.md
index 5df32a258..fd7b09d2a 100644
--- a/accepted/2021/statics-in-interfaces/README.md
+++ b/accepted/2021/statics-in-interfaces/README.md
@@ -798,6 +798,8 @@ namespace System.Numerics
 
         static abstract TSelf Sin(TSelf x);
 
+        static abstract (TSelf Sin, TSelf Cos) SinCos(TSelf x);
+
         static abstract TSelf Tan(TSelf x);
 
         // The following methods are approved but not yet implemented in the libraries
@@ -958,6 +960,10 @@ namespace System.Numerics
 
         static abstract int ILogB(TSelf x);
 
+        static abstract TSelf ReciprocalEstimate(TSelf x);
+
+        static abstract TSelf ReciprocalSqrtEstimate(TSelf x);
+
         // IEEE defines n to be an integral type, but not the size
 
         static abstract TSelf ScaleB(TSelf x, int n);
@@ -1959,6 +1965,8 @@ namespace System
         //   * TSelf MaxNumber(TSelf, TSelf)                                                // Approved - NYI
         //   * TSelf MinMagnitudeNumber(TSelf, TSelf)                                       // Approved - NYI
         //   * TSelf MinNumber(TSelf, TSelf)                                                // Approved - NYI
+        //   * TSelf ReciprocalEstimate(TSelf)
+        //   * TSelf ReciprocalSqrtEstimate(TSelf)
         //   * TSelf ScaleB(TSelf, int)
         //   * bool TryWriteExponentLittleEndian(byte[], out int)                           // Approved - NYI
         //   * bool TryWriteSignificandLittleEndian(byte[], out int)                        // Approved - NYI
@@ -2030,6 +2038,7 @@ namespace System
         //   * TSelf Cos(TSelf)
         //   * TSelf CosPi(TSelf)                                                           // Approved - NYI
         //   * TSelf Sin(TSelf)
+        //   * (TSelf, TSelf) SinCos(TSelf)
         //   * TSelf SinPi(TSelf)                                                           // Approved - NYI
         //   * TSelf Tan(TSelf)
         //   * TSelf TanPi(TSelf)                                                           // Approved - NYI
@@ -2170,6 +2179,8 @@ namespace System
         //   * TSelf MaxNumber(TSelf, TSelf)                                                // Approved - NYI
         //   * TSelf MinMagnitudeNumber(TSelf, TSelf)                                       // Approved - NYI
         //   * TSelf MinNumber(TSelf, TSelf)                                                // Approved - NYI
+        //   * TSelf ReciprocalEstimate(TSelf)
+        //   * TSelf ReciprocalSqrtEstimate(TSelf)
         //   * TSelf ScaleB(TSelf, int)
         //   * bool TryWriteExponentLittleEndian(byte[], out int)                           // Approved - NYI
         //   * bool TryWriteSignificandLittleEndian(byte[], out int)                        // Approved - NYI
@@ -2252,6 +2263,7 @@ namespace System
         //   * TSelf Cos(TSelf)
         //   * TSelf CosPi(TSelf)                                                           // Approved - NYI
         //   * TSelf Sin(TSelf)
+        //   * (TSelf, TSelf) SinCos(TSelf)
         //   * TSelf SinPi(TSelf)                                                           // Approved - NYI
         //   * TSelf Tan(TSelf)
         //   * TSelf TanPi(TSelf)                                                           // Approved - NYI
@@ -2996,6 +3008,8 @@ namespace System
         //   * TSelf MaxNumber(TSelf, TSelf)                                                // Approved - NYI
         //   * TSelf MinMagnitudeNumber(TSelf, TSelf)                                       // Approved - NYI
         //   * TSelf MinNumber(TSelf, TSelf)                                                // Approved - NYI
+        //   * TSelf ReciprocalEstimate(TSelf)
+        //   * TSelf ReciprocalSqrtEstimate(TSelf)
         //   * TSelf ScaleB(TSelf, int)
         //   * bool TryWriteExponentLittleEndian(byte[], out int)                           // Approved - NYI
         //   * bool TryWriteSignificandLittleEndian(byte[], out int)                        // Approved - NYI
@@ -3067,6 +3081,7 @@ namespace System
         //   * TSelf Cos(TSelf)
         //   * TSelf CosPi(TSelf)                                                           // Approved - NYI
         //   * TSelf Sin(TSelf)
+        //   * (TSelf, TSelf) SinCos(TSelf)
         //   * TSelf SinPi(TSelf)                                                           // Approved - NYI
         //   * TSelf Tan(TSelf)
         //   * TSelf TanPi(TSelf)                                                           // Approved - NYI

From 3c07dc6e79fe53a8f92cf18ed2d7781fb69db505 Mon Sep 17 00:00:00 2001
From: Tanner Gooding <tagoo@outlook.com>
Date: Fri, 1 Apr 2022 13:58:23 -0700
Subject: [PATCH 16/16] Adding missing semicolons

---
 accepted/2021/statics-in-interfaces/README.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/accepted/2021/statics-in-interfaces/README.md b/accepted/2021/statics-in-interfaces/README.md
index fd7b09d2a..e386ea495 100644
--- a/accepted/2021/statics-in-interfaces/README.md
+++ b/accepted/2021/statics-in-interfaces/README.md
@@ -1746,7 +1746,7 @@ namespace System
         public const decimal MinusOne = -1;                                                 // Existing - "Conflicts" with NegativeOne
         public const decimal MinValue = -79228162514264337593543950335m;                    // Existing
         public const decimal MultiplicativeIdentity = 1;                                    // ? Expose
-        public const decimal NegativeOne = -1                                               // ? Expose
+        public const decimal NegativeOne = -1;                                              // ? Expose
         public const decimal One = 1;                                                       // Existing
         public const decimal Zero = 0;                                                      // Existing
 
@@ -1851,7 +1851,7 @@ namespace System
         public const double MaxValue = 1.7976931348623157E+308;                             // Existing
         public const double MinValue = -1.7976931348623157E+308;                            // Existing
         public const double MultiplicativeIdentity = 1;                                     // ? Expose
-        public const double NegativeOne = -1                                                // ? Expose
+        public const double NegativeOne = -1;                                               // ? Expose
         public const double NegativeZero = -0.0;
         public const double One = 1;                                                        // ? Expose
         public const double Pi = Math.PI;
@@ -2894,7 +2894,7 @@ namespace System
         public const float MaxValue = 3.40282346638528859e+38f;                            // Existing
         public const float MinValue = -3.40282346638528859e+38f;                           // Existing
         public const float MultiplicativeIdentity = 1;                                     // ? Expose
-        public const float NegativeOne = -1                                                // ? Expose
+        public const float NegativeOne = -1;                                               // ? Expose
         public const float NegativeZero = -0.0f;
         public const float One = 1;                                                        // ? Expose
         public const float Pi = Math.PI;