Add System.Math.DivRem for ulong and other integers

[Maykeye]

Background and Motivation

Math.DivRem currently accepts only int32 and int64. When you are working with uint64, as of now it's easier to calculate division and remainder "by hand".
Which is not only surprising and slightly inconvenient, but it also may lead to suboptimal code if you are not aware of #5213

So for convenience I suggest adding DivRem for uint64 and since, these integers are not special, add for all other integer types while we are at it: uint32, [u]int16, [s]byte

Proposed API

namespace System
{
    public static partial class Math
    {
+          public static ulong DivRem(ulong a, ulong b, out ulong result)
+          public static uint DivRem(uint a, uint b, out uint result)
+          public static ushort DivRem(ushort a, ushort b, out ushort result)
+          public static short DivRem(short a, short b, out short result)
+          public static byte DivRem(byte a, byte b, out byte result)
+          public static sbyte DivRem(sbyte a, sbyte  b, out sbyte result)
          public static int DivRem(int a, int b, out int result)
     }

Usage Examples

Personally I ran into it when tried to use the function while formatting bit address inside of really large address space:

            bytes = Math.DivRem(bitOffset, 8ul, out bits);
            Console.WriteLine($"{bytes}+({bits}b)");

However looking for duplicates, I noticed that ulongs are implemented already(just not exposed), so here is the usage example from the very this exact repo.

Risks

There might be confusion what is called due to implicit conversions(when a=b=short, result=int)

[EgorBo]

I wish we could rename out result into out remainder 😕 it's so misleading

Tagging subscribers to this area: @tannergooding, @pgovind, @jeffhandley
See info in area-owners.md if you want to be subscribed.

[Wraith2]

It'd be neater to use a ValueTuple return and have (ulong Count, ulong Remainder) Math.DivRem(ulong value) et al.

[tannergooding]

I believe ValueTuple is also the pattern that will produce better codegen with the changes @CarolEidt has been working on to allow multiple returns from a single instruction.

[tannergooding]

Using value tuple

+          public static (byte Quotient, byte Remainder) DivRem(byte left, byte right);
+          public static (sbyte Quotient, sbyte Remainder) DivRem(sbyte left, sbyte right);
+          public static (short Quotient, short Remainder) DivRem(short left, short right);
+          public static (ushort Quotient, ushort Remainder) DivRem(ushort left, ushort right);
+          public static (int Quotient, int Remainder) DivRem(int left, int right);
+          public static (uint Quotient, uint Remainder) DivRem(uint left, uint right);
+          public static (long Quotient, long Remainder) DivRem(long left, long right);
+          public static (ulong Quotient, ulong Remainder) DivRem(ulong left, ulong right);
+          public static (nint Quotient, nint Remainder) DivRem(nint left, nint right);
+          public static (nuint Quotient, nuint Remainder) DivRem(nuint left, nuint right);

[terrajobst]

Video

• Let's move to the value tuple pattern
• Let's only addd the tuple pattern for the new overloads
• But let's also add value pattern overloads for the existing types

namespace System
{
    public static partial class Math
    {
        public static (byte Quotient, byte Remainder) DivRem(byte left, byte right);
        public static (sbyte Quotient, sbyte Remainder) DivRem(sbyte left, sbyte right);
        public static (short Quotient, short Remainder) DivRem(short left, short right);
        public static (ushort Quotient, ushort Remainder) DivRem(ushort left, ushort right);
        public static (int Quotient, int Remainder) DivRem(int left, int right);
        public static (uint Quotient, uint Remainder) DivRem(uint left, uint right);
        public static (long Quotient, long Remainder) DivRem(long left, long right);
        public static (ulong Quotient, ulong Remainder) DivRem(ulong left, ulong right);
        public static (nint Quotient, nint Remainder) DivRem(nint left, nint right);
        public static (nuint Quotient, nuint Remainder) DivRem(nuint left, nuint right);
     }
}