mirror of https://github.com/SixLabors/ImageSharp
James Jackson-South
6 years ago
28 changed files with 781 additions and 317 deletions
@ -0,0 +1,417 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using System.Numerics; |
|||
using System.Runtime.CompilerServices; |
|||
using System.Runtime.InteropServices; |
|||
|
|||
namespace SixLabors.ImageSharp |
|||
{ |
|||
/// <summary>
|
|||
/// Provides optimized static methods for trigonometric, logarithmic,
|
|||
/// and other common mathematical functions.
|
|||
/// </summary>
|
|||
internal static class Numerics |
|||
{ |
|||
/// <summary>
|
|||
/// Determine the Greatest CommonDivisor (GCD) of two numbers.
|
|||
/// </summary>
|
|||
public static int GreatestCommonDivisor(int a, int b) |
|||
{ |
|||
while (b != 0) |
|||
{ |
|||
int temp = b; |
|||
b = a % b; |
|||
a = temp; |
|||
} |
|||
|
|||
return a; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Determine the Least Common Multiple (LCM) of two numbers.
|
|||
/// </summary>
|
|||
public static int LeastCommonMultiple(int a, int b) |
|||
{ |
|||
// https://en.wikipedia.org/wiki/Least_common_multiple#Reduction_by_the_greatest_common_divisor
|
|||
return (a / GreatestCommonDivisor(a, b)) * b; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Calculates <paramref name="x"/> % 2
|
|||
/// </summary>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static int Modulo2(int x) => x & 1; |
|||
|
|||
/// <summary>
|
|||
/// Calculates <paramref name="x"/> % 4
|
|||
/// </summary>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static int Modulo4(int x) => x & 3; |
|||
|
|||
/// <summary>
|
|||
/// Calculates <paramref name="x"/> % 8
|
|||
/// </summary>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static int Modulo8(int x) => x & 7; |
|||
|
|||
/// <summary>
|
|||
/// Fast (x mod m) calculator, with the restriction that
|
|||
/// <paramref name="m"/> should be power of 2.
|
|||
/// </summary>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static int ModuloP2(int x, int m) => x & (m - 1); |
|||
|
|||
/// <summary>
|
|||
/// Returns the absolute value of a 32-bit signed integer.
|
|||
/// Uses bit shifting to speed up the operation compared to <see cref="Math"/>.
|
|||
/// </summary>
|
|||
/// <param name="x">
|
|||
/// A number that is greater than <see cref="int.MinValue"/>, but less than
|
|||
/// or equal to <see cref="int.MaxValue"/>
|
|||
/// </param>
|
|||
/// <returns>The <see cref="int"/></returns>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static int Abs(int x) |
|||
{ |
|||
int y = x >> 31; |
|||
return (x ^ y) - y; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Returns a specified number raised to the power of 2
|
|||
/// </summary>
|
|||
/// <param name="x">A single-precision floating-point number</param>
|
|||
/// <returns>The number <paramref name="x" /> raised to the power of 2.</returns>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static float Pow2(float x) => x * x; |
|||
|
|||
/// <summary>
|
|||
/// Returns a specified number raised to the power of 3
|
|||
/// </summary>
|
|||
/// <param name="x">A single-precision floating-point number</param>
|
|||
/// <returns>The number <paramref name="x" /> raised to the power of 3.</returns>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static float Pow3(float x) => x * x * x; |
|||
|
|||
/// <summary>
|
|||
/// Implementation of 1D Gaussian G(x) function
|
|||
/// </summary>
|
|||
/// <param name="x">The x provided to G(x).</param>
|
|||
/// <param name="sigma">The spread of the blur.</param>
|
|||
/// <returns>The Gaussian G(x)</returns>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static float Gaussian(float x, float sigma) |
|||
{ |
|||
const float Numerator = 1.0f; |
|||
float denominator = MathF.Sqrt(2 * MathF.PI) * sigma; |
|||
|
|||
float exponentNumerator = -x * x; |
|||
float exponentDenominator = 2 * Pow2(sigma); |
|||
|
|||
float left = Numerator / denominator; |
|||
float right = MathF.Exp(exponentNumerator / exponentDenominator); |
|||
|
|||
return left * right; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Returns the result of a normalized sine cardinal function for the given value.
|
|||
/// SinC(x) = sin(pi*x)/(pi*x).
|
|||
/// </summary>
|
|||
/// <param name="f">A single-precision floating-point number to calculate the result for.</param>
|
|||
/// <returns>
|
|||
/// The sine cardinal of <paramref name="f" />.
|
|||
/// </returns>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static float SinC(float f) |
|||
{ |
|||
if (MathF.Abs(f) > Constants.Epsilon) |
|||
{ |
|||
f *= MathF.PI; |
|||
float result = MathF.Sin(f) / f; |
|||
return MathF.Abs(result) < Constants.Epsilon ? 0F : result; |
|||
} |
|||
|
|||
return 1F; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Returns the value clamped to the inclusive range of min and max.
|
|||
/// </summary>
|
|||
/// <param name="value">The value to clamp.</param>
|
|||
/// <param name="min">The minimum inclusive value.</param>
|
|||
/// <param name="max">The maximum inclusive value.</param>
|
|||
/// <returns>The clamped <see cref="byte"/>.</returns>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static byte Clamp(byte value, byte min, byte max) |
|||
{ |
|||
// Order is important here as someone might set min to higher than max.
|
|||
if (value > max) |
|||
{ |
|||
return max; |
|||
} |
|||
|
|||
if (value < min) |
|||
{ |
|||
return min; |
|||
} |
|||
|
|||
return value; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Returns the value clamped to the inclusive range of min and max.
|
|||
/// </summary>
|
|||
/// <param name="value">The value to clamp.</param>
|
|||
/// <param name="min">The minimum inclusive value.</param>
|
|||
/// <param name="max">The maximum inclusive value.</param>
|
|||
/// <returns>The clamped <see cref="uint"/>.</returns>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static uint Clamp(uint value, uint min, uint max) |
|||
{ |
|||
if (value > max) |
|||
{ |
|||
return max; |
|||
} |
|||
|
|||
if (value < min) |
|||
{ |
|||
return min; |
|||
} |
|||
|
|||
return value; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Returns the value clamped to the inclusive range of min and max.
|
|||
/// </summary>
|
|||
/// <param name="value">The value to clamp.</param>
|
|||
/// <param name="min">The minimum inclusive value.</param>
|
|||
/// <param name="max">The maximum inclusive value.</param>
|
|||
/// <returns>The clamped <see cref="uint"/>.</returns>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static int Clamp(int value, int min, int max) |
|||
{ |
|||
if (value > max) |
|||
{ |
|||
return max; |
|||
} |
|||
|
|||
if (value < min) |
|||
{ |
|||
return min; |
|||
} |
|||
|
|||
return value; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Returns the value clamped to the inclusive range of min and max.
|
|||
/// </summary>
|
|||
/// <param name="value">The value to clamp.</param>
|
|||
/// <param name="min">The minimum inclusive value.</param>
|
|||
/// <param name="max">The maximum inclusive value.</param>
|
|||
/// <returns>The clamped <see cref="float"/>.</returns>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static float Clamp(float value, float min, float max) |
|||
{ |
|||
if (value > max) |
|||
{ |
|||
return max; |
|||
} |
|||
|
|||
if (value < min) |
|||
{ |
|||
return min; |
|||
} |
|||
|
|||
return value; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Returns the value clamped to the inclusive range of min and max.
|
|||
/// </summary>
|
|||
/// <param name="value">The value to clamp.</param>
|
|||
/// <param name="min">The minimum inclusive value.</param>
|
|||
/// <param name="max">The maximum inclusive value.</param>
|
|||
/// <returns>The clamped <see cref="double"/>.</returns>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static double Clamp(double value, double min, double max) |
|||
{ |
|||
if (value > max) |
|||
{ |
|||
return max; |
|||
} |
|||
|
|||
if (value < min) |
|||
{ |
|||
return min; |
|||
} |
|||
|
|||
return value; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Clamps the span values to the inclusive range of min and max.
|
|||
/// </summary>
|
|||
/// <param name="span">The span containing the values to clamp.</param>
|
|||
/// <param name="min">The minimum inclusive value.</param>
|
|||
/// <param name="max">The maximum inclusive value.</param>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static void Clamp(Span<byte> span, byte min, byte max) |
|||
{ |
|||
int reduced = ClampReduce(span, min, max); |
|||
|
|||
if (reduced > 0) |
|||
{ |
|||
for (int i = reduced; i < span.Length; i++) |
|||
{ |
|||
ref byte v = ref span[i]; |
|||
v = Clamp(v, min, max); |
|||
} |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Clamps the span values to the inclusive range of min and max.
|
|||
/// </summary>
|
|||
/// <param name="span">The span containing the values to clamp.</param>
|
|||
/// <param name="min">The minimum inclusive value.</param>
|
|||
/// <param name="max">The maximum inclusive value.</param>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static void Clamp(Span<uint> span, uint min, uint max) |
|||
{ |
|||
int reduced = ClampReduce(span, min, max); |
|||
|
|||
if (reduced > 0) |
|||
{ |
|||
for (int i = reduced; i < span.Length; i++) |
|||
{ |
|||
ref uint v = ref span[i]; |
|||
v = Clamp(v, min, max); |
|||
} |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Clamps the span values to the inclusive range of min and max.
|
|||
/// </summary>
|
|||
/// <param name="span">The span containing the values to clamp.</param>
|
|||
/// <param name="min">The minimum inclusive value.</param>
|
|||
/// <param name="max">The maximum inclusive value.</param>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static void Clamp(Span<int> span, int min, int max) |
|||
{ |
|||
int reduced = ClampReduce(span, min, max); |
|||
|
|||
if (reduced > 0) |
|||
{ |
|||
for (int i = reduced; i < span.Length; i++) |
|||
{ |
|||
ref int v = ref span[i]; |
|||
v = Clamp(v, min, max); |
|||
} |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Clamps the span values to the inclusive range of min and max.
|
|||
/// </summary>
|
|||
/// <param name="span">The span containing the values to clamp.</param>
|
|||
/// <param name="min">The minimum inclusive value.</param>
|
|||
/// <param name="max">The maximum inclusive value.</param>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static void Clamp(Span<float> span, float min, float max) |
|||
{ |
|||
int reduced = ClampReduce(span, min, max); |
|||
|
|||
if (reduced > 0) |
|||
{ |
|||
for (int i = reduced; i < span.Length; i++) |
|||
{ |
|||
ref float v = ref span[i]; |
|||
v = Clamp(v, min, max); |
|||
} |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Clamps the span values to the inclusive range of min and max.
|
|||
/// </summary>
|
|||
/// <param name="span">The span containing the values to clamp.</param>
|
|||
/// <param name="min">The minimum inclusive value.</param>
|
|||
/// <param name="max">The maximum inclusive value.</param>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static void Clamp(Span<double> span, double min, double max) |
|||
{ |
|||
int reduced = ClampReduce(span, min, max); |
|||
|
|||
if (reduced > 0) |
|||
{ |
|||
for (int i = reduced; i < span.Length; i++) |
|||
{ |
|||
ref double v = ref span[i]; |
|||
v = Clamp(v, min, max); |
|||
} |
|||
} |
|||
} |
|||
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
private static int ClampReduce<T>(Span<T> span, T min, T max) |
|||
where T : unmanaged |
|||
{ |
|||
if (Vector.IsHardwareAccelerated && span.Length >= Vector<T>.Count) |
|||
{ |
|||
int remainder = ModuloP2(span.Length, Vector<T>.Count); |
|||
int adjustedCount = span.Length - remainder; |
|||
|
|||
if (adjustedCount > 0) |
|||
{ |
|||
ClampImpl(span.Slice(0, adjustedCount), min, max); |
|||
} |
|||
|
|||
return adjustedCount; |
|||
} |
|||
|
|||
return 0; |
|||
} |
|||
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
private static void ClampImpl<T>(Span<T> span, T min, T max) |
|||
where T : unmanaged |
|||
{ |
|||
ref T sRef = ref MemoryMarshal.GetReference(span); |
|||
ref Vector<T> vsBase = ref Unsafe.As<T, Vector<T>>(ref MemoryMarshal.GetReference(span)); |
|||
var vmin = new Vector<T>(min); |
|||
var vmax = new Vector<T>(max); |
|||
|
|||
int n = span.Length / Vector<T>.Count; |
|||
int m = Modulo4(n); |
|||
int u = n - m; |
|||
|
|||
for (int i = 0; i < u; i += 4) |
|||
{ |
|||
ref Vector<T> vs0 = ref Unsafe.Add(ref vsBase, i); |
|||
ref Vector<T> vs1 = ref Unsafe.Add(ref vs0, 1); |
|||
ref Vector<T> vs2 = ref Unsafe.Add(ref vs0, 2); |
|||
ref Vector<T> vs3 = ref Unsafe.Add(ref vs0, 3); |
|||
|
|||
vs0 = Vector.Min(Vector.Max(vmin, vs0), vmax); |
|||
vs1 = Vector.Min(Vector.Max(vmin, vs1), vmax); |
|||
vs2 = Vector.Min(Vector.Max(vmin, vs2), vmax); |
|||
vs3 = Vector.Min(Vector.Max(vmin, vs3), vmax); |
|||
} |
|||
|
|||
if (m > 0) |
|||
{ |
|||
for (int i = u; i < n; i++) |
|||
{ |
|||
ref Vector<T> vs0 = ref Unsafe.Add(ref vsBase, i); |
|||
vs0 = Vector.Min(Vector.Max(vmin, vs0), vmax); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,42 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using BenchmarkDotNet.Attributes; |
|||
|
|||
namespace SixLabors.ImageSharp.Benchmarks.General.BasicMath |
|||
{ |
|||
public class ClampSpan |
|||
{ |
|||
private static readonly int[] A = new int[2048]; |
|||
private static readonly int[] B = new int[2048]; |
|||
|
|||
public void Setup() |
|||
{ |
|||
var r = new Random(); |
|||
|
|||
for (int i = 0; i < A.Length; i++) |
|||
{ |
|||
int x = r.Next(); |
|||
A[i] = x; |
|||
B[i] = x; |
|||
} |
|||
} |
|||
|
|||
[Benchmark(Baseline = true)] |
|||
public void ClampNoIntrinsics() |
|||
{ |
|||
for (int i = 0; i < A.Length; i++) |
|||
{ |
|||
ref int x = ref A[i]; |
|||
x = x.Clamp(64, 128); |
|||
} |
|||
} |
|||
|
|||
[Benchmark] |
|||
public void ClampVectorIntrinsics() |
|||
{ |
|||
Numerics.Clamp(B, 64, 128); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,265 @@ |
|||
// Copyright (c) Six Labors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
using System; |
|||
using Xunit; |
|||
|
|||
namespace SixLabors.ImageSharp.Tests.Helpers |
|||
{ |
|||
public class NumericsTests |
|||
{ |
|||
public delegate void SpanAction<T, in TArg, in TArg1>(Span<T> span, TArg arg, TArg1 arg1); |
|||
|
|||
[Theory] |
|||
[InlineData(0)] |
|||
[InlineData(1)] |
|||
[InlineData(2)] |
|||
[InlineData(3)] |
|||
[InlineData(4)] |
|||
[InlineData(100)] |
|||
[InlineData(123)] |
|||
[InlineData(53436353)] |
|||
public void Modulo2(int x) |
|||
{ |
|||
int actual = Numerics.Modulo2(x); |
|||
Assert.Equal(x % 2, actual); |
|||
} |
|||
|
|||
[Theory] |
|||
[InlineData(0)] |
|||
[InlineData(1)] |
|||
[InlineData(2)] |
|||
[InlineData(3)] |
|||
[InlineData(4)] |
|||
[InlineData(100)] |
|||
[InlineData(123)] |
|||
[InlineData(53436353)] |
|||
public void Modulo4(int x) |
|||
{ |
|||
int actual = Numerics.Modulo4(x); |
|||
Assert.Equal(x % 4, actual); |
|||
} |
|||
|
|||
[Theory] |
|||
[InlineData(0)] |
|||
[InlineData(1)] |
|||
[InlineData(2)] |
|||
[InlineData(6)] |
|||
[InlineData(7)] |
|||
[InlineData(8)] |
|||
[InlineData(100)] |
|||
[InlineData(123)] |
|||
[InlineData(53436353)] |
|||
[InlineData(975)] |
|||
public void Modulo8(int x) |
|||
{ |
|||
int actual = Numerics.Modulo8(x); |
|||
Assert.Equal(x % 8, actual); |
|||
} |
|||
|
|||
[Theory] |
|||
[InlineData(0, 2)] |
|||
[InlineData(1, 2)] |
|||
[InlineData(2, 2)] |
|||
[InlineData(0, 4)] |
|||
[InlineData(3, 4)] |
|||
[InlineData(5, 4)] |
|||
[InlineData(5, 8)] |
|||
[InlineData(8, 8)] |
|||
[InlineData(8, 16)] |
|||
[InlineData(15, 16)] |
|||
[InlineData(17, 16)] |
|||
[InlineData(17, 32)] |
|||
[InlineData(31, 32)] |
|||
[InlineData(32, 32)] |
|||
[InlineData(33, 32)] |
|||
public void Modulo2P(int x, int m) |
|||
{ |
|||
int actual = Numerics.ModuloP2(x, m); |
|||
Assert.Equal(x % m, actual); |
|||
} |
|||
|
|||
[Theory] |
|||
[InlineData(-5)] |
|||
[InlineData(-17)] |
|||
[InlineData(-12856)] |
|||
[InlineData(-32)] |
|||
[InlineData(-7425)] |
|||
[InlineData(5)] |
|||
[InlineData(17)] |
|||
[InlineData(12856)] |
|||
[InlineData(32)] |
|||
[InlineData(7425)] |
|||
public void Abs(int x) |
|||
{ |
|||
int expected = Math.Abs(x); |
|||
Assert.Equal(expected, Numerics.Abs(x)); |
|||
} |
|||
|
|||
[Theory] |
|||
[InlineData(-5)] |
|||
[InlineData(-17)] |
|||
[InlineData(-12856)] |
|||
[InlineData(-32)] |
|||
[InlineData(-7425)] |
|||
[InlineData(5)] |
|||
[InlineData(17)] |
|||
[InlineData(12856)] |
|||
[InlineData(32)] |
|||
[InlineData(7425)] |
|||
public void Pow2(float x) |
|||
{ |
|||
float expected = (float)Math.Pow(x, 2); |
|||
Assert.Equal(expected, Numerics.Pow2(x)); |
|||
} |
|||
|
|||
[Theory] |
|||
[InlineData(-5)] |
|||
[InlineData(-17)] |
|||
[InlineData(-12856)] |
|||
[InlineData(-32)] |
|||
[InlineData(5)] |
|||
[InlineData(17)] |
|||
[InlineData(12856)] |
|||
[InlineData(32)] |
|||
public void Pow3(float x) |
|||
{ |
|||
float expected = (float)Math.Pow(x, 3); |
|||
Assert.Equal(expected, Numerics.Pow3(x)); |
|||
} |
|||
|
|||
[Theory] |
|||
[InlineData(1, 1, 1)] |
|||
[InlineData(1, 42, 1)] |
|||
[InlineData(10, 8, 2)] |
|||
[InlineData(12, 18, 6)] |
|||
[InlineData(4536, 1000, 8)] |
|||
[InlineData(1600, 1024, 64)] |
|||
public void GreatestCommonDivisor(int a, int b, int expected) |
|||
{ |
|||
int actual = Numerics.GreatestCommonDivisor(a, b); |
|||
Assert.Equal(expected, actual); |
|||
} |
|||
|
|||
[Theory] |
|||
[InlineData(1, 1, 1)] |
|||
[InlineData(1, 42, 42)] |
|||
[InlineData(3, 4, 12)] |
|||
[InlineData(6, 4, 12)] |
|||
[InlineData(1600, 1024, 25600)] |
|||
[InlineData(3264, 100, 81600)] |
|||
public void LeastCommonMultiple(int a, int b, int expected) |
|||
{ |
|||
int actual = Numerics.LeastCommonMultiple(a, b); |
|||
Assert.Equal(expected, actual); |
|||
} |
|||
|
|||
[Theory] |
|||
[InlineData(64, 36, 96)] |
|||
[InlineData(128, 16, 196)] |
|||
[InlineData(567, 18, 142)] |
|||
[InlineData(1024, 0, 255)] |
|||
public void ClampByte(int length, byte min, byte max) |
|||
{ |
|||
TestClampSpan( |
|||
length, |
|||
min, |
|||
max, |
|||
(s, m1, m2) => Numerics.Clamp(s, m1, m2), |
|||
(v, m1, m2) => Numerics.Clamp(v, m1, m2)); |
|||
} |
|||
|
|||
[Theory] |
|||
[InlineData(64, 36, 96)] |
|||
[InlineData(128, 16, 196)] |
|||
[InlineData(567, 18, 142)] |
|||
[InlineData(1024, 0, 255)] |
|||
public void ClampInt(int length, int min, int max) |
|||
{ |
|||
TestClampSpan( |
|||
length, |
|||
min, |
|||
max, |
|||
(s, m1, m2) => Numerics.Clamp(s, m1, m2), |
|||
(v, m1, m2) => Numerics.Clamp(v, m1, m2)); |
|||
} |
|||
|
|||
[Theory] |
|||
[InlineData(64, 36, 96)] |
|||
[InlineData(128, 16, 196)] |
|||
[InlineData(567, 18, 142)] |
|||
[InlineData(1024, 0, 255)] |
|||
public void ClampUInt(int length, uint min, uint max) |
|||
{ |
|||
TestClampSpan( |
|||
length, |
|||
min, |
|||
max, |
|||
(s, m1, m2) => Numerics.Clamp(s, m1, m2), |
|||
(v, m1, m2) => Numerics.Clamp(v, m1, m2)); |
|||
} |
|||
|
|||
[Theory] |
|||
[InlineData(64, 36, 96)] |
|||
[InlineData(128, 16, 196)] |
|||
[InlineData(567, 18, 142)] |
|||
[InlineData(1024, 0, 255)] |
|||
public void ClampFloat(int length, float min, float max) |
|||
{ |
|||
TestClampSpan( |
|||
length, |
|||
min, |
|||
max, |
|||
(s, m1, m2) => Numerics.Clamp(s, m1, m2), |
|||
(v, m1, m2) => Numerics.Clamp(v, m1, m2)); |
|||
} |
|||
|
|||
[Theory] |
|||
[InlineData(64, 36, 96)] |
|||
[InlineData(128, 16, 196)] |
|||
[InlineData(567, 18, 142)] |
|||
[InlineData(1024, 0, 255)] |
|||
public void ClampDouble(int length, double min, double max) |
|||
{ |
|||
TestClampSpan( |
|||
length, |
|||
min, |
|||
max, |
|||
(s, m1, m2) => Numerics.Clamp(s, m1, m2), |
|||
(v, m1, m2) => Numerics.Clamp(v, m1, m2)); |
|||
} |
|||
|
|||
private static void TestClampSpan<T>( |
|||
int length, |
|||
T min, |
|||
T max, |
|||
SpanAction<T, T, T> clampAction, |
|||
Func<T, T, T, T> refClampFunc) |
|||
where T : unmanaged, IComparable<T> |
|||
{ |
|||
Span<T> actual = new T[length]; |
|||
|
|||
var r = new Random(); |
|||
for (int i = 0; i < length; i++) |
|||
{ |
|||
actual[i] = (T)Convert.ChangeType(r.Next(byte.MinValue, byte.MaxValue), typeof(T)); |
|||
} |
|||
|
|||
Span<T> expected = new T[length]; |
|||
actual.CopyTo(expected); |
|||
|
|||
for (int i = 0; i < expected.Length; i++) |
|||
{ |
|||
ref T v = ref expected[i]; |
|||
v = refClampFunc(v, min, max); |
|||
} |
|||
|
|||
clampAction(actual, min, max); |
|||
|
|||
for (int i = 0; i < expected.Length; i++) |
|||
{ |
|||
Assert.Equal(expected[i], actual[i]); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
Loading…
Reference in new issue