Onde posso encontrar a função “clamp” no .NET?

Eu gostaria de fixar um valor xem um intervalo [a, b]:

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

Isso é bastante básico. Mas não vejo uma função "clamp" na biblioteca de classes - pelo menos não em System.Math.

(Para quem não sabe, "fixar" um valor é certificar-se de que ele está entre alguns valores máximo e mínimo. Se for maior que o valor máximo, ele será substituído pelo máximo, etc.)

Você pode escrever um método de extensão:

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

Os métodos de extensão vão em classes estáticas - uma vez que esta é uma função de baixo nível, provavelmente deve ir em algum namespace central em seu projeto. Você pode então usar o método em qualquer arquivo de código que contenha uma diretiva de uso para o namespace, por exemplo

using Core.ExtensionMethods

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

.NET Core 2.0

A partir do .NET Core 2.0 System.Mathagora existe um Clampmétodo que pode ser usado:

using System;

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

Basta usar Math.Mine Math.Max:

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

Experimentar:

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

Não existe um, mas não é muito difícil fazer um. Encontrei um aqui: braçadeira

Isto é:

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

E pode ser usado como:

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

Não há nenhum no System.Mathnamespace .

Há uma MathHelperclasse disponível para o estúdio de jogos XNA se for isso o que você está fazendo:

Apenas compartilhando a solução de Lee com os problemas e preocupações dos comentários tratados, sempre que possível:

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

Diferenças:

• O nome do método usa o tempo verbal apropriado ( ed) para (mais) indicar que o valor não está preso no local e que, em vez disso, um novo valor é retornado (consulte o comentário de @JimBalter ).
• É apropriado null checkem todas as entradas (veja o comentário de @JeppeStigNielsen ).
• Trocas mine maxif min > max(veja o comentário de @JeppeStigNielsen ).

Limitações: Sem grampos unilaterais. Se maxfor NaN, sempre retorna NaN(veja o comentário de Herman ).

Usando as respostas anteriores, eu condensava no código abaixo para minhas necessidades. Isso também permitirá que você fixe um número apenas por seu mínimo ou máximo.

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

O código a seguir suporta a especificação de limites em qualquer ordem (ou seja bound1 <= bound2, ou bound2 <= bound1). Eu achei isso útil para fixar valores calculados a partir de equações lineares (y=mx+b ), onde a inclinação da linha pode ser crescente ou decrescente.

Eu sei: o código consiste em cinco operadores de expressão condicional extremamente feios . A questão é que funciona e os testes abaixo provam isso. Sinta-se à vontade para adicionar parênteses estritamente desnecessários, se desejar.

Você pode criar facilmente outras sobrecargas para outros tipos numéricos e basicamente copiar / colar os testes.

Aviso: comparar números de ponto flutuante não é simples. Este código não implementa doublecomparações de forma robusta. Use uma biblioteca de comparação de ponto flutuante para substituir os usos de operadores de comparação.

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

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

Se eu quiser validar o intervalo de um argumento em [min, max], uso a seguinte classe útil:

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

A classe funciona para todos os objetos que são IComparable. Eu crio uma instância com um certo intervalo:

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

Eu posso validar um argumento

range.Validate(value);

ou fixe o argumento no intervalo:

var v = range.Validate(value);