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

[ghost]

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

[Wraith2]

It may also be worth considering an analyzer that recommends moving from the out version to valuetuple version since it seems the new version will perform better.

[CarolEidt]

@tannergooding - I've updated my PR #37928, but we'll need to determine the appropriate naming (I simplistically appended a '2' to distinguish from the variant that returns a scalar).

@echesakovMSFT suggested we add a flag in the HW intrinsics table so that we don't have to special-case the methods that return ValueTuple in the JIT.

It may also be worth considering an analyzer that recommends moving from the out version to valuetuple version since it seems the new version will perform better.

For the mulx case, I found that I was able to get identical code by having the out version call the ValueTuple version, since the address-taking goes away once it's inlined.

[Symbai]

The legacy APIs have the benefit that it can be used in if-cases and saves one line:

if (Math.DivRem(12, 2, out int remainder) == 6)
{
  Console.WriteLine(remainder);
}

With tuple based it would not only be longer code but also more ugly:

var (result, remainder) = Math.DivRem(12, 2);
if (result  == 6)
{
  Console.WriteLine(remainder);
}

[tannergooding]

@Symbai, actually you can do this using C# pattern matching:

if (Math.DivRem(12, 2) is { Quotient: 6, Remainder: var remainder })
{
    Console.WriteLine(remainder);
}

https://sharplab.io/#v2:EYLgtghgzgLgpgJwDQxNMAfAAgJgIwCwAUFgMwAEu5AwuQN7HlOUVYAs5AsgBQCU9jZkICWAM3LcAIsIBuAJThhuAViTlS/YVHrkAigFcA9jGFwAdqnIA2NQsjCzAE0QhyMiAnIJFEB888AvryCQkwMRKGRlHgAnNze9k6IvADcIaEB6ZkRzOlYeFYSDjB6RibmMGrF5Ha+SQj80vKK3NUANnCileTVCMIA5gAWMME5YelCWADsEh1d5AD0XgPDanMlAKTLQyNpY+TZAUA==

[Symbai]

Didn't know that 👀

[tannergooding]

Closing, this was resolved in #45074