Subjects.cs

using System.Runtime.CompilerServices;

namespace DivRemProof;

/// <summary>
/// Все измеряемые методы. Деление на константу, остаток от той же константы
/// и оба действия рядом: со знаком и без, на трёх делителях, на 32 и 64 битах,
/// с делителем в переменной, через Math.DivRem, через приведение к знаковому
/// типу и на разборе числа по цифрам.
///
/// Каждый способ вынесен в отдельный метод с NoInlining, чтобы компилятор
/// не встроил его в тело замера и чтобы метод было видно в листинге.
///
/// Значения берутся из массива: на константе компилятор посчитал бы всё
/// заранее и замер показал бы пустой цикл.
/// </summary>
public static class Subjects
{
    // ================= делитель 10, int =================

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static int SignedDiv(int[] values)
    {
        int total = 0;
        for (int i = 0; i < values.Length; i++)
        {
            total += values[i] / 10;
        }

        return total;
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static int SignedRem(int[] values)
    {
        int total = 0;
        for (int i = 0; i < values.Length; i++)
        {
            total += values[i] % 10;
        }

        return total;
    }

    /// <summary>
    /// Оба действия над одним значением и одной константой.
    /// </summary>
    [MethodImpl(MethodImplOptions.NoInlining)]
    public static int SignedDivRem(int[] values)
    {
        int total = 0;
        for (int i = 0; i < values.Length; i++)
        {
            int value = values[i];
            total += value / 10 + value % 10;
        }

        return total;
    }

    /// <summary>
    /// То же самое, но действия записаны отдельными операторами. Проверяет,
    /// зависит ли результат от того, стоят они в одном выражении или в двух.
    /// </summary>
    [MethodImpl(MethodImplOptions.NoInlining)]
    public static int SignedDivRemSplit(int[] values)
    {
        int total = 0;
        for (int i = 0; i < values.Length; i++)
        {
            int value = values[i];
            int quotient = value / 10;
            int remainder = value % 10;

            total += quotient + remainder;
        }

        return total;
    }

    /// <summary>
    /// То же самое в обратном порядке: сначала остаток, потом деление.
    /// </summary>
    [MethodImpl(MethodImplOptions.NoInlining)]
    public static int SignedRemDiv(int[] values)
    {
        int total = 0;
        for (int i = 0; i < values.Length; i++)
        {
            int value = values[i];
            total += value % 10 + value / 10;
        }

        return total;
    }

    /// <summary>
    /// Тот же результат через Math.DivRem: оба ответа за один вызов.
    /// </summary>
    [MethodImpl(MethodImplOptions.NoInlining)]
    public static int SignedMathDivRem(int[] values)
    {
        int total = 0;
        for (int i = 0; i < values.Length; i++)
        {
            (int quotient, int remainder) = Math.DivRem(values[i], 10);
            total += quotient + remainder;
        }

        return total;
    }

    // ================= делитель 10, uint =================

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static uint UnsignedDiv(uint[] values)
    {
        uint total = 0;
        for (int i = 0; i < values.Length; i++)
        {
            total += values[i] / 10;
        }

        return total;
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static uint UnsignedRem(uint[] values)
    {
        uint total = 0;
        for (int i = 0; i < values.Length; i++)
        {
            total += values[i] % 10;
        }

        return total;
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static uint UnsignedDivRem(uint[] values)
    {
        uint total = 0;
        for (int i = 0; i < values.Length; i++)
        {
            uint value = values[i];
            total += value / 10 + value % 10;
        }

        return total;
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static uint UnsignedDivRemSplit(uint[] values)
    {
        uint total = 0;
        for (int i = 0; i < values.Length; i++)
        {
            uint value = values[i];
            uint quotient = value / 10;
            uint remainder = value % 10;

            total += quotient + remainder;
        }

        return total;
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static uint UnsignedRemDiv(uint[] values)
    {
        uint total = 0;
        for (int i = 0; i < values.Length; i++)
        {
            uint value = values[i];
            total += value % 10 + value / 10;
        }

        return total;
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static uint UnsignedMathDivRem(uint[] values)
    {
        uint total = 0;
        for (int i = 0; i < values.Length; i++)
        {
            (uint quotient, uint remainder) = Math.DivRem(values[i], 10u);
            total += quotient + remainder;
        }

        return total;
    }

    /// <summary>
    /// Остаток выведен вычитанием: rem = value - value / 10 * 10.
    /// Деление здесь заведомо одно, переиспользовать компилятору нечего.
    /// </summary>
    [MethodImpl(MethodImplOptions.NoInlining)]
    public static int SignedManualRem(int[] values)
    {
        int total = 0;
        for (int i = 0; i < values.Length; i++)
        {
            int value = values[i];
            int quotient = value / 10;

            total += quotient + (value - quotient * 10);
        }

        return total;
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static uint UnsignedManualRem(uint[] values)
    {
        uint total = 0;
        for (int i = 0; i < values.Length; i++)
        {
            uint value = values[i];
            uint quotient = value / 10;

            total += quotient + (value - quotient * 10);
        }

        return total;
    }

    /// <summary>
    /// Обходной путь, который первым приходит в голову: посчитать в знаковом
    /// типе и привести обратно. Значения положительные, ответ тот же.
    /// </summary>
    [MethodImpl(MethodImplOptions.NoInlining)]
    public static uint UnsignedViaSigned(uint[] values)
    {
        uint total = 0;
        for (int i = 0; i < values.Length; i++)
        {
            int value = (int)values[i];
            total += (uint)(value / 10 + value % 10);
        }

        return total;
    }

    // ================= другие делители =================

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static int SignedDivRem3(int[] values)
    {
        int total = 0;
        for (int i = 0; i < values.Length; i++)
        {
            int value = values[i];
            total += value / 3 + value % 3;
        }

        return total;
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static uint UnsignedDivRem3(uint[] values)
    {
        uint total = 0;
        for (int i = 0; i < values.Length; i++)
        {
            uint value = values[i];
            total += value / 3 + value % 3;
        }

        return total;
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static int SignedDivRem100(int[] values)
    {
        int total = 0;
        for (int i = 0; i < values.Length; i++)
        {
            int value = values[i];
            total += value / 100 + value % 100;
        }

        return total;
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static uint UnsignedDivRem100(uint[] values)
    {
        uint total = 0;
        for (int i = 0; i < values.Length; i++)
        {
            uint value = values[i];
            total += value / 100 + value % 100;
        }

        return total;
    }

    // ================= делитель равен степени двойки =================

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static int SignedPow2DivRem(int[] values)
    {
        int total = 0;
        for (int i = 0; i < values.Length; i++)
        {
            int value = values[i];
            total += value / 16 + value % 16;
        }

        return total;
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static uint UnsignedPow2DivRem(uint[] values)
    {
        uint total = 0;
        for (int i = 0; i < values.Length; i++)
        {
            uint value = values[i];
            total += value / 16 + value % 16;
        }

        return total;
    }

    // ================= делитель в переменной =================

    /// <summary>
    /// Делитель не константа, а параметр. Замены умножением тут нет, работает
    /// машинная команда деления, а она выдаёт оба ответа разом.
    /// Контрольная пара к замерам на константе.
    /// </summary>
    [MethodImpl(MethodImplOptions.NoInlining)]
    public static int SignedVarDivRem(int[] values, int divisor)
    {
        int total = 0;
        for (int i = 0; i < values.Length; i++)
        {
            int value = values[i];
            total += value / divisor + value % divisor;
        }

        return total;
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static uint UnsignedVarDivRem(uint[] values, uint divisor)
    {
        uint total = 0;
        for (int i = 0; i < values.Length; i++)
        {
            uint value = values[i];
            total += value / divisor + value % divisor;
        }

        return total;
    }

    // ================= 64 бита =================

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static long SignedLongDivRem(long[] values)
    {
        long total = 0;
        for (int i = 0; i < values.Length; i++)
        {
            long value = values[i];
            total += value / 10 + value % 10;
        }

        return total;
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static ulong UnsignedLongDivRem(ulong[] values)
    {
        ulong total = 0;
        for (int i = 0; i < values.Length; i++)
        {
            ulong value = values[i];
            total += value / 10 + value % 10;
        }

        return total;
    }

    // ================= разбор числа по цифрам =================

    /// <summary>
    /// Цикл, ради которого деление и остаток и пишут рядом: разбор числа
    /// на десятичные цифры. Здесь оба действия идут на каждом витке.
    /// </summary>
    [MethodImpl(MethodImplOptions.NoInlining)]
    public static int SignedDigits(int[] values, byte[] buffer)
    {
        int total = 0;
        for (int i = 0; i < values.Length; i++)
        {
            int value = values[i];
            int count = 0;

            do
            {
                buffer[count++] = (byte)(value % 10);
                value /= 10;
            }
            while (value != 0);

            total += count;
        }

        return total;
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static int UnsignedDigits(uint[] values, byte[] buffer)
    {
        int total = 0;
        for (int i = 0; i < values.Length; i++)
        {
            uint value = values[i];
            int count = 0;

            do
            {
                buffer[count++] = (byte)(value % 10);
                value /= 10;
            }
            while (value != 0);

            total += count;
        }

        return total;
    }
}