Où puis-je trouver la fonction «clamp» dans .NET?

Je voudrais fixer une valeur xà une plage [a, b]:

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

C'est assez basique. Mais je ne vois pas de fonction "clamp" dans la bibliothèque de classes - du moins pas dans System.Math.

(Pour ceux qui ne savent pas "bloquer" une valeur, il faut s'assurer qu'elle se situe entre des valeurs maximales et minimales. Si elle est supérieure à la valeur max, elle est remplacée par la valeur max, etc.)

Vous pouvez écrire une méthode d'extension:

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

Les méthodes d'extension vont dans des classes statiques - puisqu'il s'agit d'une fonction de bas niveau, elle devrait probablement aller dans un espace de noms de base de votre projet. Vous pouvez ensuite utiliser la méthode dans n'importe quel fichier de code contenant une directive using pour l'espace de noms, par exemple

using Core.ExtensionMethods

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

.NET Core 2.0

À partir de .NET Core 2.0, System.Mathune Clampméthode peut être utilisée à la place:

using System;

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

Utilisez simplement Math.Minet Math.Max:

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

Essayer:

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

Il n'y en a pas, mais ce n'est pas trop difficile d'en faire un. J'en ai trouvé un ici: pince

C'est:

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

Et il peut être utilisé comme:

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

Il n'y en a pas dans l' System.Mathespace de noms .

Il existe une MathHelperclasse où elle est disponible pour le studio de jeu XNA si c'est ce que vous faites:

Je partage simplement la solution de Lee avec les problèmes et préoccupations des commentaires traités, dans la mesure du possible:

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

Différences:

• Le nom de la méthode utilise le temps de verbe approprié ( ed) pour (plus loin) indiquer que la valeur n'est pas bloquée sur place, et qu'à la place, une nouvelle valeur est renvoyée (voir le commentaire de @ JimBalter ).
• Ne convient null checksur toutes les entrées (voir @ commentaire de JeppeStigNielsen ).
• Swaps minet maxif min > max(Voir le commentaire de @ JeppeStigNielsen ).

Limitations: pas de pinces unilatérales. Si maxest NaN, renvoie toujours NaN(voir le commentaire d'Herman ).

En utilisant les réponses précédentes, je l'ai condensé au code ci-dessous pour mes besoins. Cela vous permettra également de fixer un nombre uniquement par son min ou son max.

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

Le code ci-dessous prend en charge la spécification de limites dans n'importe quel ordre (c'est bound1 <= bound2-à- dire ou bound2 <= bound1). J'ai trouvé cela utile pour les valeurs de serrage calculées à partir d'équations linéaires ( y=mx+b) où la pente de la ligne peut être croissante ou décroissante.

Je sais: le code se compose de cinq opérateurs d'expression conditionnelle super-laids . Le fait est que cela fonctionne et les tests ci-dessous le prouvent. N'hésitez pas à ajouter des parenthèses strictement inutiles si vous le souhaitez.

Vous pouvez facilement créer d'autres surcharges pour d'autres types numériques et copier / coller les tests.

Attention: comparer des nombres à virgule flottante n'est pas simple. Ce code n'implémente pas les doublecomparaisons de manière robuste. Utilisez une bibliothèque de comparaison à virgule flottante pour remplacer les utilisations des opérateurs de comparaison.

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

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

Si je veux valider la plage d'un argument dans [min, max], j'utilise la classe pratique suivante:

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 fonctionne pour tous les objets qui le sont IComparable. Je crée une instance avec une certaine plage:

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

Je valide soit un argument

range.Validate(value);

ou fixez l'argument à la plage:

var v = range.Validate(value);