Subjects.cs

using System.Runtime.CompilerServices;

namespace OverflowProof;

/// <summary>
/// Все измеряемые способы. У каждого NoInlining: иначе компилятор встроит
/// метод в тело замера и посчитает результат при сборке — переполнение
/// на константах он вычисляет сам и до выполнения дело не дойдёт.
/// </summary>
internal static class Subjects
{
    // ---------- цена проверки переполнения ----------

    /// <summary>Сложение без проверки. Так работает C# по умолчанию.</summary>
    [MethodImpl(MethodImplOptions.NoInlining)]
    internal static int SumUnchecked(int[] values)
    {
        int total = 0;
        for (int i = 0; i < values.Length; i++)
        {
            total = unchecked(total + values[i]);
        }

        return total;
    }

    /// <summary>То же сложение с проверкой на каждом шаге.</summary>
    [MethodImpl(MethodImplOptions.NoInlining)]
    internal static int SumChecked(int[] values)
    {
        int total = 0;
        for (int i = 0; i < values.Length; i++)
        {
            total = checked(total + values[i]);
        }

        return total;
    }

    /// <summary>Сложение в длинном типе: проверки нет, переполнения тоже.</summary>
    [MethodImpl(MethodImplOptions.NoInlining)]
    internal static long SumLong(int[] values)
    {
        long total = 0;
        for (int i = 0; i < values.Length; i++)
        {
            total += values[i];
        }

        return total;
    }

    // ---------- середина отрезка ----------

    /// <summary>Привычная запись. На больших границах переполняется.</summary>
    [MethodImpl(MethodImplOptions.NoInlining)]
    internal static int MidNaive(int low, int high) => (low + high) / 2;

    /// <summary>
    /// Середина через разность. Так написано в ArraySortHelper: сначала
    /// разность, потом сдвиг, переполнения нет.
    /// </summary>
    [MethodImpl(MethodImplOptions.NoInlining)]
    internal static int MidSubtract(int low, int high) => low + ((high - low) >> 1);

    /// <summary>
    /// Середина через беззнаковое сложение. Так написано в SpanHelpers:
    /// сумма двух неотрицательных int в uint помещается всегда, и одно
    /// вычитание на итерации экономится.
    /// </summary>
    [MethodImpl(MethodImplOptions.NoInlining)]
    internal static int MidUnsigned(int low, int high) => (int)(((uint)high + (uint)low) >> 1);

    // ---------- модуль числа ----------

    /// <summary>Модуль из библиотеки. На самом маленьком числе бросает исключение.</summary>
    [MethodImpl(MethodImplOptions.NoInlining)]
    internal static int AbsLibrary(int value) => Math.Abs(value);

    /// <summary>Модуль вручную. Исключения нет, но на том же числе результат неверный.</summary>
    [MethodImpl(MethodImplOptions.NoInlining)]
    internal static int AbsManual(int value) => value < 0 ? -value : value;

    /// <summary>
    /// Модуль без ветвления: знак получается сдвигом, дальше вычитание
    /// и исключающее или. Тот же неверный результат на самом маленьком числе.
    /// </summary>
    [MethodImpl(MethodImplOptions.NoInlining)]
    internal static int AbsBitwise(int value)
    {
        int mask = value >> 31;
        return (value + mask) ^ mask;
    }

    // ---------- деление ----------

    /// <summary>Деление, при котором на минус единице прилетает исключение.</summary>
    [MethodImpl(MethodImplOptions.NoInlining)]
    internal static int Divide(int left, int right) => left / right;

    /// <summary>Остаток от того же деления.</summary>
    [MethodImpl(MethodImplOptions.NoInlining)]
    internal static int Remainder(int left, int right) => left % right;
}