নেট থেকে "ক্ল্যাম্প" ফাংশনটি কোথায় পাব?

Question 1

আমি xএকটি ব্যাপ্তির মান বাছাই করতে চাই [a, b]:

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

এটি বেশ বেসিক is অন্তত না - কিন্তু আমি বর্গ লাইব্রেরিতে একটি ফাংশন "বাতা" দেখতে না পান System.Math।

("ক্ল্যাম্প" অজ্ঞাত হওয়ার জন্য একটি মান হ'ল এটি নিশ্চিত করা হয় যে এটি কোনও সর্বোচ্চ এবং সর্বনিম্ন মানের মধ্যে রয়েছে। এটি যদি সর্বোচ্চ মানের চেয়ে বেশি হয় তবে এটি সর্বাধিক ইত্যাদি দ্বারা প্রতিস্থাপিত হয়))

Question 2

আপনি একটি এক্সটেনশন পদ্ধতি লিখতে পারেন:

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 Core.ExtensionMethods

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

.NET কোর 2.0

.NET কোর 2.0 দিয়ে শুরু করে System.Mathএখন একটি Clampপদ্ধতি রয়েছে যা পরিবর্তে ব্যবহার করা যেতে পারে:

using System;

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

Question 3

শুধু ব্যবহার করুন Math.Minএবং Math.Max:

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

Question 4

চেষ্টা করুন:

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

Question 5

একটি নেই, তবে এটি তৈরি করা খুব বেশি কঠিন নয়। আমি এখানে একটি পেয়েছি: বাতা

এইটা:

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

Question 6

System.Mathনেমস্পেসে একটিও নেই ।

এমন একটি MathHelperক্লাস রয়েছে যেখানে এটি এক্সএনএ গেম স্টুডিওর জন্য উপলব্ধ যদি এটি হয়ে থাকে যে আপনি যা করছেন:

Question 7

কেবলমাত্র লি'র সমাধান মন্তব্যগুলির সমস্যা এবং উদ্বেগের সাথে ভাগ করা , যেখানে সম্ভব:

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) থেকে (আরও) ব্যবহার করে ইঙ্গিত করে যে মানটি স্থানে চাপানো হয়নি এবং তার পরিবর্তে একটি নতুন মান ফিরে এসেছে ( @ জিমবাল্টারের মন্তব্য দেখুন )।
null checkসমস্ত ইনপুটগুলিতে উপযুক্ত হয় ( @ জেপ্পস্টিগনিয়েলসনের মন্তব্য দেখুন )।
অদলবদল minএবং maxযদি min > max( @ জেপিস্টিগনিয়েলসনের মন্তব্য দেখুন )।

সীমাবদ্ধতা: কোনও একতরফা বাতা নেই। যদি থাকে maxতবে NaNসর্বদা ফিরে আসে NaN( হারমানের মন্তব্য দেখুন )।

Question 8

পূর্ববর্তী উত্তরগুলি ব্যবহার করে, আমি এটি আমার প্রয়োজনের জন্য নীচের কোডে নিচে ঘনীভূত করেছি। এটি আপনাকে কেবল তার ন্যূনতম বা সর্বাধিক দ্বারা কোনও সংখ্যা বাতাতেও অনুমতি দেবে।

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

Question 9

নীচের কোডটি কোনও ক্রমে (যেমন bound1 <= bound2, বা bound2 <= bound1) নির্দিষ্টকরণের সীমাগুলি সমর্থন করে । লিনিয়ার সমীকরণগুলি ( y=mx+b) যেখানে লাইনটির opeালু বৃদ্ধি বা হ্রাস হতে পারে সেগুলি থেকে গণনা করা মানগুলিতে ক্ল্যাম্পিংয়ের জন্য আমি এই দরকারীটি পেয়েছি ।

আমি জানি: কোডটিতে পাঁচটি অতি-কুরুচিপূর্ণ শর্তসাপেক্ষ এক্সপ্রেশন অপারেটর রয়েছে । জিনিসটি হ'ল এটি কাজ করে এবং নীচের পরীক্ষাগুলি এটি প্রমাণ করে। আপনি যদি চান তবে কঠোরভাবে অপ্রয়োজনীয় প্রথম বন্ধনী যুক্ত করুন।

আপনি অন্যান্য সংখ্যার ধরণের জন্য খুব সহজেই অন্যান্য ওভারলোডগুলি তৈরি করতে পারেন এবং মূলত পরীক্ষাগুলি অনুলিপি / আটকান।

সতর্কতা: ভাসমান পয়েন্ট সংখ্যাগুলির তুলনা করা সহজ নয়। এই কোডটি doubleদৃ comp়তার সাথে তুলনা কার্যকর করে না । তুলনা অপারেটরগুলির ব্যবহারগুলি প্রতিস্থাপন করতে একটি ফ্লোটিং পয়েন্ট তুলনা লাইব্রেরি ব্যবহার করুন।

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 / ফ্লুয়েন্টসেসরেশন পরীক্ষা:

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

Question 10

যদি আমি [কমপক্ষে, সর্বাধিক] মধ্যে একটি আর্গুমেন্টের সীমাটি বৈধ করতে চাই, তবে আমি নীচের সহজ শ্রেণিটি ব্যবহার করি:

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