Dove posso trovare la funzione "clamp" in .NET?

Vorrei bloccare un valore xsu un intervallo [a, b]:

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

Questo è abbastanza semplice. Ma non vedo una funzione "clamp" nella libreria di classi - almeno non in System.Math.

(Per chi non è consapevole di "bloccare" un valore è assicurarsi che si trovi tra alcuni valori massimo e minimo. Se è maggiore del valore massimo, viene sostituito dal massimo, ecc.)

Potresti scrivere un metodo di estensione:

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

I metodi di estensione vanno in classi statiche: poiché si tratta di una funzione di livello piuttosto basso, probabilmente dovrebbe andare in uno spazio dei nomi di base nel progetto. È quindi possibile utilizzare il metodo in qualsiasi file di codice che contiene una direttiva using per lo spazio dei nomi, ad es

using Core.ExtensionMethods

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

.NET Core 2.0

A partire da .NET Core 2.0 System.Mathora ha un fileClamp metodo che può essere utilizzato al suo posto:

using System;

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

Basta usare Math.Mine Math.Max:

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

Provare:

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

Non ce n'è uno, ma non è troppo difficile crearne uno. Ne ho trovato uno qui: clamp

È:

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 può essere utilizzato come:

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

Non ce System.Mathn'è uno nello spazio dei nomi .

C'è una MathHelperclasse in cui è disponibile per lo studio di giochi XNA se questo è ciò che stai facendo:

Basta condividere la soluzione di Lee con i problemi dei commenti e le preoccupazioni affrontate, ove possibile:

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

Differenze:

• Il nome del metodo utilizza il tempo verbale appropriato ( ed) per (ulteriormente) indicare che il valore non è bloccato sul posto e che, invece, viene restituito un nuovo valore (vedere il commento di @ JimBalter ).
• È appropriato null checkper tutti gli input (vedere il commento di @ JeppeStigNielsen ).
• Scambia mine maxif min > max(Vedi il commento di @ JeppeStigNielsen ).

Limitazioni: nessun morsetto unilaterale. Se maxè NaN, restituisce sempre NaN(vedere il commento di Herman ).

Utilizzando le risposte precedenti, l'ho condensato nel codice seguente per le mie esigenze. Ciò consentirà anche di bloccare un numero solo in base al suo minimo o massimo.

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

Il codice seguente supporta la specifica dei limiti in qualsiasi ordine (ad esempio bound1 <= bound2, o bound2 <= bound1). L'ho trovato utile per i valori di bloccaggio calcolati da equazioni lineari (y=mx+b ) in cui la pendenza della linea può essere crescente o decrescente.

Lo so: il codice è composto da cinque terribili operatori di espressioni condizionali . Il fatto è che funziona e i test seguenti lo dimostrano. Sentiti libero di aggiungere parentesi strettamente inutili se lo desideri.

Puoi facilmente creare altri overload per altri tipi numerici e sostanzialmente copiare / incollare i test.

Avvertenza: confrontare i numeri in virgola mobile non è semplice. Questo codice non implementa i doubleconfronti in modo affidabile. Utilizzare una libreria di confronto in virgola mobile per sostituire gli usi degli operatori di confronto.

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 test:

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 voglio convalidare l'intervallo di un argomento in [min, max], utilizzo la seguente pratica classe:

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

La classe funziona per tutti gli oggetti che sono IComparable. Creo un'istanza con un certo intervallo:

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

Convalido un argomento

range.Validate(value);

o blocca l'argomento all'intervallo:

var v = range.Validate(value);