Де я можу знайти функцію “clamp” у .NET?

Я хотів би затиснути значення x в діапазоні [a, b]:

x = (x < a) ? a : ((x > b) ? b : x);

Це досить елементарно. Але я не бачу функції "затискач" у бібліотеці класів - принаймні, не в System.Math.

(Для неусвідомленого "затискання" значення полягає в тому, щоб переконатися, що воно знаходиться між деякими максимальними та мінімальними значеннями. Якщо воно перевищує максимальне значення, тоді воно замінюється максимальним тощо).

Ви можете написати метод розширення:

public static T Clamp<T>(this T val, T min, T max) where T : IComparable<T>
{
    if (val.CompareTo(min) < 0) return min;
    else if(val.CompareTo(max) > 0) return max;
    else return val;
}

Методи розширення йдуть у статичних класах - оскільки це досить низькорівнева функція, вона, ймовірно, повинна йти в якомусь основному просторі імен вашого проекту. Потім ви можете використовувати метод у будь-якому кодовому файлі, який містить директиву using для простору імен, наприклад

using Core.ExtensionMethods

int i = 4.Clamp(1, 3);

.NET Core 2.0

Починаючи з .NET Core 2.0 System.Mathтепер є Clampметод, який можна використовувати замість цього:

using System;

int i = Math.Clamp(4, 1, 3);

Просто використовуйте Math.Minта Math.Max:

x = Math.Min(Math.Max(x, a), b);

Спробуйте:

public static int Clamp(int value, int min, int max)  
{  
    return (value < min) ? min : (value > max) ? max : value;  
}

Немає такого, але зробити його не надто складно. Я знайшов його тут: затискач

Це є:

public static T Clamp<T>(T value, T max, T min)
    where T : System.IComparable<T> {
        T result = value;
        if (value.CompareTo(max) > 0)
            result = max;
        if (value.CompareTo(min) < 0)
            result = min;
        return result;
    }

І його можна використовувати, як:

int i = Clamp(12, 10, 0); -> i == 10
double d = Clamp(4.5, 10.0, 0.0); -> d == 4.5

У System.Mathпросторі імен його немає .

Існує MathHelperклас, де він доступний для ігрової студії XNA, якщо це саме те, що ви робите:

Просто поділіться рішенням Лі з вирішеними проблемами та зауваженнями, де це можливо:

public static T Clamped<T>(this T value, T min, T max) where T : IComparable<T> {
    if (value == null) throw new ArgumentNullException(nameof(value), "is null.");
    if (min == null) throw new ArgumentNullException(nameof(min), "is null.");
    if (max == null) throw new ArgumentNullException(nameof(max), "is null.");
    //If min <= max, clamp
    if (min.CompareTo(max) <= 0) return value.CompareTo(min) < 0 ? min : value.CompareTo(max) > 0 ? max : value;
    //If min > max, clamp on swapped min and max
    return value.CompareTo(max) < 0 ? max : value.CompareTo(min) > 0 ? min : value;
}

Відмінності:

• Назва методу використовує відповідний дієслівний час ( ed), щоб (далі) вказувати, що значення не затиснуте на місці, а замість цього повертається нове значення (Див. Коментар @ JimBalter ).
• Чи підходить null checkдля всіх входів (Див. Коментар @ JeppeStigNielsen ).
• Свопи minіmax якщо min > max(див коментар @ JeppeStigNielsen в ).

Обмеження: відсутність односторонніх затискачів. Якщо maxє NaN, завжди повертається NaN(Див. Коментар Германа ).

Використовуючи попередні відповіді, я звів його до коду нижче для своїх потреб. Це також дозволить вам затискати число лише на його мінімальне або максимальне значення.

public static class IComparableExtensions
{
    public static T Clamped<T>(this T value, T min, T max) 
        where T : IComparable<T>
    {
        return value.CompareTo(min) < 0 ? min : value.ClampedMaximum(max);
    }

    public static T ClampedMinimum<T>(this T value, T min)
        where T : IComparable<T>
    {
        return value.CompareTo(min) < 0 ? min : value;
    }

    public static T ClampedMaximum<T>(this T value, T max)
        where T : IComparable<T>
    {
        return value.CompareTo(max) > 0 ? max : value;
    }
}

Наведений нижче код підтримує вказівку меж у будь-якому порядку (тобто bound1 <= bound2, або bound2 <= bound1). Я знайшов це корисним для затискання значень, розрахованих з лінійних рівнянь ( y=mx+b), де нахил лінії може збільшуватися або зменшуватися.

Я знаю: Код складається з п’яти надпотворних операторів умовних виразів . Справа в тому, що це працює , і тести нижче підтверджують це. Не соромтеся додавати суворо непотрібні дужки, якщо ви цього бажаєте.

Ви можете легко створити інші перевантаження для інших числових типів і в основному скопіювати / вставити тести.

Попередження: Порівняти числа з плаваючою комою непросто. Цей код не реалізує doubleпорівняння надійно. Використовуйте бібліотеку порівняння з плаваючою комою, щоб замінити використання операторів порівняння.

public static class MathExtensions
{
    public static double Clamp(this double value, double bound1, double bound2)
    {
        return bound1 <= bound2 ? value <= bound1 ? bound1 : value >= bound2 ? bound2 : value : value <= bound2 ? bound2 : value >= bound1 ? bound1 : value;
    }
}

Тести xUnit / FluentAssertions:

public class MathExtensionsTests
{
    [Theory]
    [InlineData(0, 0, 0, 0)]
    [InlineData(0, 0, 2, 0)]
    [InlineData(-1, 0, 2, 0)]
    [InlineData(1, 0, 2, 1)]
    [InlineData(2, 0, 2, 2)]
    [InlineData(3, 0, 2, 2)]
    [InlineData(0, 2, 0, 0)]
    [InlineData(-1, 2, 0, 0)]
    [InlineData(1, 2, 0, 1)]
    [InlineData(2, 2, 0, 2)]
    [InlineData(3, 2, 0, 2)]
    public void MustClamp(double value, double bound1, double bound2, double expectedValue)
    {
        value.Clamp(bound1, bound2).Should().Be(expectedValue);
    }
}

Якщо я хочу перевірити діапазон аргументу в [min, max], я використовую такий зручний клас:

public class RangeLimit<T> where T : IComparable<T>
{
    public T Min { get; }
    public T Max { get; }
    public RangeLimit(T min, T max)
    {
        if (min.CompareTo(max) > 0)
            throw new InvalidOperationException("invalid range");
        Min = min;
        Max = max;
    }

    public void Validate(T param)
    {
        if (param.CompareTo(Min) < 0 || param.CompareTo(Max) > 0)
            throw new InvalidOperationException("invalid argument");
    }

    public T Clamp(T param) => param.CompareTo(Min) < 0 ? Min : param.CompareTo(Max) > 0 ? Max : param;
}

Клас працює для всіх об'єктів, які є IComparable. Я створюю екземпляр з певним діапазоном:

RangeLimit<int> range = new RangeLimit<int>(0, 100);

Я або підтверджую аргумент

range.Validate(value);

або затискаємо аргумент до діапазону:

var v = range.Validate(value);