Wo finde ich die "Clamp" -Funktion in .NET?

Ich möchte einen Wert xan einen Bereich klemmen [a, b]:

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

Das ist ziemlich einfach. Aber ich sehe keine Funktion "clamp" in der Klassenbibliothek - zumindest nicht in System.Math.

(Wenn Sie nicht wissen, dass ein Wert "geklemmt" werden soll, müssen Sie sicherstellen, dass er zwischen einigen Maximal- und Minimalwerten liegt. Wenn er größer als der Maximalwert ist, wird er durch den Maximalwert usw. ersetzt.)

Sie könnten eine Erweiterungsmethode schreiben:

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

BEARBEITEN: Erweiterungsmethoden werden in statische Klassen eingeteilt. Da dies eine recht einfache Funktion ist, sollte sie wahrscheinlich in einem Kernnamespace Ihres Projekts enthalten sein. Sie können die Methode dann in jeder Codedatei verwenden, die eine using-Direktive für den Namespace enthält, z

using Core.ExtensionMethods

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

.NET Core 2.0

Ab .NET Core 2.0 gibt es System.Mathjetzt eine ClampMethode, die stattdessen verwendet werden kann:

using System;

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

Verwenden Sie einfach Math.Minund Math.Max:

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

Versuchen:

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

Es gibt keinen, aber es ist nicht zu schwer, einen zu machen. Ich habe hier eine gefunden: Klammer

Es ist:

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

Und es kann verwendet werden wie:

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

Es gibt keinen im System.Math-Namespace

http://msdn.microsoft.com/en-us/library/system.math_members.aspx

Es gibt eine MathHelper-Klasse, in der sie für das XNA-Spielestudio verfügbar ist, wenn Sie dies tun:

http://msdn.microsoft.com/en-us/library/bb197892(v=XNAGameStudio.31).aspx

Teilen Sie einfach Lees Lösung mit den Problemen und Bedenken der Kommentare, wenn möglich:

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

Unterschiede:

• Der Methodenname verwendet das entsprechende Verb tense ( ed), um (weiter) anzuzeigen, dass der Wert nicht an Ort und Stelle geklemmt ist und stattdessen ein neuer Wert zurückgegeben wird (siehe Kommentar von @ JimBalter ).
• Ist null checkfür alle Eingaben geeignet (siehe Kommentar von @ JeppeStigNielsen ).
• Swaps minund maxif min > max(Siehe @ JeppeStigNielsens Kommentar ).

Einschränkungen: Keine einseitigen Klemmen. Wenn maxja NaN, wird immer zurückgegeben NaN(siehe Hermans Kommentar ).

Unter Verwendung der vorherigen Antworten habe ich es für meine Bedürfnisse auf den folgenden Code komprimiert. Auf diese Weise können Sie eine Zahl auch nur um ihre minimalen oder maximalen Werte klemmen.

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

Der folgende Code unterstützt die Angabe von Grenzen in beliebiger Reihenfolge (dh bound1 <= bound2oder bound2 <= bound1). Ich fand dies nützlich für Klemmwerte, die aus linearen Gleichungen ( y=mx+b) berechnet wurden, bei denen die Steigung der Linie zunehmen oder abnehmen kann.

Ich weiß: Der Code besteht aus fünf superhässlichen Operatoren für bedingte Ausdrücke . Die Sache ist, es funktioniert und die folgenden Tests beweisen es. Fühlen Sie sich frei, streng unnötige Klammern hinzuzufügen, wenn Sie dies wünschen.

Sie können problemlos andere Überladungen für andere numerische Typen erstellen und die Tests grundsätzlich kopieren / einfügen.

Warnung: Der Vergleich von Gleitkommazahlen ist nicht einfach. Dieser Code implementiert doubleVergleiche nicht robust. Verwenden Sie eine Gleitkomma-Vergleichsbibliothek, um die Verwendung von Vergleichsoperatoren zu ersetzen.

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

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

Wenn ich den Bereich eines Arguments in [min, max] validieren möchte, verwende ich die folgende praktische Klasse:

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

Die Klasse funktioniert für alle Objekte, die es gibt IComparable. Ich erstelle eine Instanz mit einem bestimmten Bereich:

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

Ich bestätige entweder ein Argument

range.Validate(value);

oder klemmen Sie das Argument an den Bereich:

var v = range.Validate(value);