1739 lines
55 KiB
C#
1739 lines
55 KiB
C#
using Burst.Compiler.IL.Tests.Helpers;
|
|
using NUnit.Framework;
|
|
using Unity.Mathematics;
|
|
|
|
namespace Burst.Compiler.IL.Tests
|
|
{
|
|
[TestFixture]
|
|
internal partial class VectorsMaths
|
|
{
|
|
[TestCompiler]
|
|
public static ulong HalfToFloatAndDouble()
|
|
{
|
|
return math.asuint(new half {value = 0x0000})
|
|
+ math.asulong(new half {value = 0x1000});
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// asfloat
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float AsFloatInt4(ref int4 a)
|
|
{
|
|
return Vectors.ConvertToFloat(math.asfloat(a));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float AsFloatInt3(ref int3 a)
|
|
{
|
|
return Vectors.ConvertToFloat(math.asfloat(a));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float AsFloatInt2(ref int2 a)
|
|
{
|
|
return Vectors.ConvertToFloat(math.asfloat(a));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float AsFloatUInt4(ref uint4 a)
|
|
{
|
|
return Vectors.ConvertToFloat(math.asfloat(a));
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// asint
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static int AsIntFloat4(ref float4 a)
|
|
{
|
|
return Vectors.ConvertToInt(math.asint(a));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static int AsIntFloat3(ref float3 a)
|
|
{
|
|
return Vectors.ConvertToInt(math.asint(a));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static int AsIntFloat2(ref float2 a)
|
|
{
|
|
return Vectors.ConvertToInt(math.asint(a));
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// asuint
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static int AsUIntFloat4(ref float4 a)
|
|
{
|
|
return Vectors.ConvertToInt(math.asuint(a));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static int AsUIntFloat3(ref float3 a)
|
|
{
|
|
return Vectors.ConvertToInt(math.asuint(a));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static int AsUIntFloat2(ref float2 a)
|
|
{
|
|
return Vectors.ConvertToInt(math.asuint(a));
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// compress
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard)]
|
|
public static unsafe int CompressInt4(ref int4 value, ref bool4 mask)
|
|
{
|
|
var temp = default(TestCompressInt4);
|
|
|
|
var ptr = &temp.Value0;
|
|
var count = math.compress(ptr, 0, value, mask);
|
|
|
|
int result = 0;
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
result = result * 397 + ptr[i];
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// compress
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard)]
|
|
public static unsafe uint CompressUInt4(ref uint4 value, ref bool4 mask)
|
|
{
|
|
var temp = default(TestCompressUInt4);
|
|
|
|
var ptr = &temp.Value0;
|
|
var count = math.compress(ptr, 0, value, mask);
|
|
|
|
uint result = 0;
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
result = result * 397 + ptr[i];
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// compress
|
|
// ---------------------------------------------------------
|
|
// IL2CPP codegen on Android fixed in 2023.1
|
|
// ... but now it's broken on Switch
|
|
#if BURST_TESTS_ONLY || (UNITY_2023_1_OR_NEWER && !UNITY_SWITCH)
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard)]
|
|
public static unsafe float CompressFloat4(ref float4 value, ref bool4 mask)
|
|
{
|
|
var temp = default(TestCompressFloat4);
|
|
|
|
var ptr = &temp.Value0;
|
|
var count = math.compress(ptr, 0, value, mask);
|
|
|
|
float result = 0;
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
result = result * 397 + ptr[i];
|
|
}
|
|
|
|
return result;
|
|
}
|
|
#endif
|
|
|
|
// ---------------------------------------------------------
|
|
// count_bits
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static int CountBitsInt(int value)
|
|
{
|
|
return math.countbits(value);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static int CountBitsInt2(ref int2 value)
|
|
{
|
|
return Vectors.ConvertToInt(math.countbits(value));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static int CountBitsInt3(ref int3 value)
|
|
{
|
|
return Vectors.ConvertToInt(math.countbits(value));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static int CountBitsInt4(ref int4 value)
|
|
{
|
|
return Vectors.ConvertToInt(math.countbits(value));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static int CountBitsUInt(uint value)
|
|
{
|
|
return math.countbits(value);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static int CountBitsUInt2(ref uint2 value)
|
|
{
|
|
return Vectors.ConvertToInt(math.countbits(value));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static int CountBitsUInt3(ref uint3 value)
|
|
{
|
|
return Vectors.ConvertToInt(math.countbits(value));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static int CountBitsUInt4(ref uint4 value)
|
|
{
|
|
return Vectors.ConvertToInt(math.countbits(value));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static int CountBitsLong(long value)
|
|
{
|
|
return math.countbits(value);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static int CountBitsULong(ulong value)
|
|
{
|
|
return math.countbits(value);
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// lzcnt
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static int LzCntInt(int value)
|
|
{
|
|
return math.lzcnt(value);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static int LzCntInt2(ref int2 value)
|
|
{
|
|
return Vectors.ConvertToInt(math.lzcnt(value));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static int LzCntInt3(ref int3 value)
|
|
{
|
|
return Vectors.ConvertToInt(math.lzcnt(value));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static int LzCntInt4(ref int4 value)
|
|
{
|
|
return Vectors.ConvertToInt(math.lzcnt(value));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static int LzCntUInt(uint value)
|
|
{
|
|
return math.lzcnt(value);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static int LzCntUInt2(ref uint2 value)
|
|
{
|
|
return Vectors.ConvertToInt(math.lzcnt(value));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static int LzCntUInt3(ref uint3 value)
|
|
{
|
|
return Vectors.ConvertToInt(math.lzcnt(value));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static int LzCntUInt4(ref uint4 value)
|
|
{
|
|
return Vectors.ConvertToInt(math.lzcnt(value));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static int LzCntLong(long value)
|
|
{
|
|
return math.lzcnt(value);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static int LzCntULong(ulong value)
|
|
{
|
|
return math.lzcnt(value);
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// tzcnt
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static int TzCntInt(int value)
|
|
{
|
|
return math.tzcnt(value);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static int TzCntInt2(ref int2 value)
|
|
{
|
|
return Vectors.ConvertToInt(math.tzcnt(value));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static int TzCntInt3(ref int3 value)
|
|
{
|
|
return Vectors.ConvertToInt(math.tzcnt(value));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static int TzCntInt4(ref int4 value)
|
|
{
|
|
return Vectors.ConvertToInt(math.tzcnt(value));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static int TzCntUInt(uint value)
|
|
{
|
|
return math.tzcnt(value);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static int TzCntUInt2(ref uint2 value)
|
|
{
|
|
return Vectors.ConvertToInt(math.tzcnt(value));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static int TzCntUInt3(ref uint3 value)
|
|
{
|
|
return Vectors.ConvertToInt(math.tzcnt(value));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static int TzCntUInt4(ref uint4 value)
|
|
{
|
|
return Vectors.ConvertToInt(math.tzcnt(value));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static int TzCntLong(long value)
|
|
{
|
|
return math.tzcnt(value);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static int TzCntULong(ulong value)
|
|
{
|
|
return math.tzcnt(value);
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// min
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard)]
|
|
public static float Min4(ref float4 a, ref float4 b)
|
|
{
|
|
return Vectors.ConvertToFloat(math.min(a, b));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard)]
|
|
public static float Min3(ref float3 a, ref float3 b)
|
|
{
|
|
return Vectors.ConvertToFloat(math.min(a, b));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard)]
|
|
public static float Min2(ref float2 a, ref float2 b)
|
|
{
|
|
return Vectors.ConvertToFloat(math.min(a, b));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard)]
|
|
public static float Min(float a, float b)
|
|
{
|
|
return math.min(a, b);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard)]
|
|
public static int MinInt4(ref int4 a, ref int4 b)
|
|
{
|
|
return Vectors.ConvertToInt(math.min(a, b));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard)]
|
|
public static int MinInt3(ref int3 a, ref int3 b)
|
|
{
|
|
return Vectors.ConvertToInt(math.min(a, b));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard)]
|
|
public static int MinInt2(ref int2 a, ref int2 b)
|
|
{
|
|
return Vectors.ConvertToInt(math.min(a, b));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard)]
|
|
public static int MinInt(int a, int b)
|
|
{
|
|
return math.min(a, b);
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// max
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard)]
|
|
public static float Max4(ref float4 a, ref float4 b)
|
|
{
|
|
return Vectors.ConvertToFloat(math.max(a, b));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard)]
|
|
public static float Max3(ref float3 a, ref float3 b)
|
|
{
|
|
return Vectors.ConvertToFloat(math.max(a, b));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard)]
|
|
public static float Max2(ref float2 a, ref float2 b)
|
|
{
|
|
return Vectors.ConvertToFloat(math.max(a, b));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard)]
|
|
public static float Max(float a, float b)
|
|
{
|
|
return math.max(a, b);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard)]
|
|
public static int MaxInt4(ref int4 a, ref int4 b)
|
|
{
|
|
return Vectors.ConvertToInt(math.max(a, b));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard)]
|
|
public static int MaxInt3(ref int3 a, ref int3 b)
|
|
{
|
|
return Vectors.ConvertToInt(math.max(a, b));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard)]
|
|
public static int MaxInt2(ref int2 a, ref int2 b)
|
|
{
|
|
return Vectors.ConvertToInt(math.max(a, b));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard)]
|
|
public static float MaxInt(int a, int b)
|
|
{
|
|
return math.max(a, b);
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// lerp
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard, DataRange.ZeroExclusiveToOneInclusive|DataRange.Zero)]
|
|
public static float Lerp4(ref float4 a, ref float4 b, float w)
|
|
{
|
|
return Vectors.ConvertToFloat(math.lerp(a, b, w));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard, DataRange.ZeroExclusiveToOneInclusive | DataRange.Zero)]
|
|
public static float Lerp3(ref float3 a, ref float3 b, float w)
|
|
{
|
|
return Vectors.ConvertToFloat(math.lerp(a, b, w));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard, DataRange.ZeroExclusiveToOneInclusive | DataRange.Zero)]
|
|
public static float Lerp2(ref float2 a, ref float2 b, float w)
|
|
{
|
|
return Vectors.ConvertToFloat(math.lerp(a, b, w));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard, DataRange.ZeroExclusiveToOneInclusive | DataRange.Zero)]
|
|
public static float Lerp(float a, float b, float w)
|
|
{
|
|
return math.lerp(a, b, w);
|
|
}
|
|
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard, DataRange.ZeroExclusiveToOneInclusive | DataRange.Zero)]
|
|
public static float Lerp4_4(ref float4 a, ref float4 b, ref float4 w)
|
|
{
|
|
return Vectors.ConvertToFloat(math.lerp(a, b, w));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard, DataRange.ZeroExclusiveToOneInclusive | DataRange.Zero)]
|
|
public static float Lerp3_3(ref float3 a, ref float3 b, ref float3 w)
|
|
{
|
|
return Vectors.ConvertToFloat(math.lerp(a, b, w));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard, DataRange.ZeroExclusiveToOneInclusive | DataRange.Zero)]
|
|
public static float Lerp2_2(ref float2 a, ref float2 b, ref float2 w)
|
|
{
|
|
return Vectors.ConvertToFloat(math.lerp(a, b, w));
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// mad
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard, DataRange.Standard)]
|
|
public static float Mad4(ref float4 a, ref float4 b, ref float4 c)
|
|
{
|
|
return Vectors.ConvertToFloat(math.mad(a, b, c));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard, DataRange.Standard)]
|
|
public static float Mad3(ref float3 a, ref float3 b, ref float3 c)
|
|
{
|
|
return Vectors.ConvertToFloat(math.mad(a, b, c));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard, DataRange.Standard)]
|
|
public static float Mad2(ref float2 a, ref float2 b, ref float2 c)
|
|
{
|
|
return Vectors.ConvertToFloat(math.mad(a, b, c));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard, DataRange.Standard)]
|
|
public static float Mad(float a, float b, float c)
|
|
{
|
|
return math.mad(a, b, c);
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// clamp
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard, DataRange.Standard)]
|
|
public static float Clamp4(ref float4 x, ref float4 a, ref float4 b)
|
|
{
|
|
return Vectors.ConvertToFloat(math.clamp(x, a, b));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard, DataRange.Standard)]
|
|
public static float Clamp3(ref float3 x, ref float3 a, ref float3 b)
|
|
{
|
|
return Vectors.ConvertToFloat(math.clamp(x, a, b));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard, DataRange.Standard)]
|
|
public static float Clamp2(ref float2 x, ref float2 a, ref float2 b)
|
|
{
|
|
return Vectors.ConvertToFloat(math.clamp(x, a, b));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard, DataRange.Standard)]
|
|
public static float Clamp(float x, float a, float b)
|
|
{
|
|
return math.clamp(x, a, b);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard, DataRange.Standard)]
|
|
public static int ClampInt4(ref int4 x, ref int4 a, ref int4 b)
|
|
{
|
|
return Vectors.ConvertToInt(math.clamp(x, a, b));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard, DataRange.Standard)]
|
|
public static int ClampInt3(ref int3 x, ref int3 a, ref int3 b)
|
|
{
|
|
return Vectors.ConvertToInt(math.clamp(x, a, b));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard, DataRange.Standard)]
|
|
public static int ClampInt2(ref int2 x, ref int2 a, ref int2 b)
|
|
{
|
|
return Vectors.ConvertToInt(math.clamp(x, a, b));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard, DataRange.Standard)]
|
|
public static int ClampInt(int x, int a, int b)
|
|
{
|
|
return math.clamp(x, a, b);
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// saturate
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Saturate4(ref float4 x)
|
|
{
|
|
return Vectors.ConvertToFloat(math.saturate(x));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Saturate3(ref float3 x)
|
|
{
|
|
return Vectors.ConvertToFloat(math.saturate(x));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Saturate2(ref float2 x)
|
|
{
|
|
return Vectors.ConvertToFloat(math.saturate(x));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Saturate(float x)
|
|
{
|
|
return math.saturate(x);
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// abs
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Abs4(ref float4 x)
|
|
{
|
|
return Vectors.ConvertToFloat(math.abs(x));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Abs3(ref float3 x)
|
|
{
|
|
return Vectors.ConvertToFloat(math.abs(x));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Abs2(ref float2 x)
|
|
{
|
|
return Vectors.ConvertToFloat(math.abs(x));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Abs(float x)
|
|
{
|
|
return math.abs(x);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static double AbsDouble4(ref double4 x)
|
|
{
|
|
return Vectors.ConvertToDouble(math.abs(x));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static double AbsDouble3(ref double3 x)
|
|
{
|
|
return Vectors.ConvertToDouble(math.abs(x));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static double AbsDouble2(ref double2 x)
|
|
{
|
|
return Vectors.ConvertToDouble(math.abs(x));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static double AbsDouble(double x)
|
|
{
|
|
return math.abs(x);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static int AbsInt4(ref int4 x)
|
|
{
|
|
return Vectors.ConvertToInt(math.abs(x));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static int AbsInt3(ref int3 x)
|
|
{
|
|
return Vectors.ConvertToInt(math.abs(x));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static int AbsInt2(ref int2 x)
|
|
{
|
|
return Vectors.ConvertToInt(math.abs(x));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static int AbsInt(int x)
|
|
{
|
|
return math.abs(x);
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// dot
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard)]
|
|
public static float Dot4(ref float4 a, ref float4 b)
|
|
{
|
|
return math.dot(a, b);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard)]
|
|
public static float Dot3(ref float3 a, ref float3 b)
|
|
{
|
|
return math.dot(a, b);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard)]
|
|
public static float Dot2(ref float2 a, ref float2 b)
|
|
{
|
|
return math.dot(a, b);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard)]
|
|
public static float Dot(float a, float b)
|
|
{
|
|
return math.dot(a, b);
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// cmin
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.Standard & ~DataRange.NaN)] // TODO: Does no handle NaN correctly
|
|
public static float CMin4(ref float4 input)
|
|
{
|
|
return math.cmin(input);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard & ~DataRange.NaN)] // TODO: Does no handle NaN correctly
|
|
public static float CMin3(ref float3 input)
|
|
{
|
|
return math.cmin(input);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard & ~DataRange.NaN)] // TODO: Does no handle NaN correctly
|
|
public static float CMin2(ref float2 input)
|
|
{
|
|
return math.cmin(input);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float CMinInt4(ref int4 input)
|
|
{
|
|
return math.cmin(input);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float CMinInt3(ref int3 input)
|
|
{
|
|
return math.cmin(input);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float CMinInt2(ref int2 input)
|
|
{
|
|
return math.cmin(input);
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// cmax
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.Standard & ~DataRange.NaN)] // TODO: Does no handle NaN correctly
|
|
public static float CMax4(ref float4 input)
|
|
{
|
|
return math.cmax(input);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard & ~DataRange.NaN)] // TODO: Does no handle NaN correctly
|
|
public static float CMax3(ref float3 input)
|
|
{
|
|
return math.cmax(input);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard & ~DataRange.NaN)] // TODO: Does no handle NaN correctly
|
|
public static float CMax2(ref float2 input)
|
|
{
|
|
return math.cmax(input);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float CMaxInt4(ref int4 input)
|
|
{
|
|
return math.cmax(input);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float CMaxInt3(ref int3 input)
|
|
{
|
|
return math.cmax(input);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float CMaxInt2(ref int2 input)
|
|
{
|
|
return math.cmax(input);
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// csum
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static double CSum4d(ref double4 input)
|
|
{
|
|
return math.csum(input);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float CSum4(ref float4 input)
|
|
{
|
|
return math.csum(input);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float CSum3(ref float3 input)
|
|
{
|
|
return math.csum(input);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float CSum2(ref float2 input)
|
|
{
|
|
return math.csum(input);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float CSumInt4(ref int4 input)
|
|
{
|
|
return math.csum(input);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float CSumInt3(ref int3 input)
|
|
{
|
|
return math.csum(input);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float CSumInt2(ref int2 input)
|
|
{
|
|
return math.csum(input);
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// acos
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.MinusOneInclusiveToOneInclusive)]
|
|
public static float ACos4(ref float4 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.acos(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.MinusOneInclusiveToOneInclusive)]
|
|
public static float ACos3(ref float3 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.acos(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.MinusOneInclusiveToOneInclusive)]
|
|
public static float ACos2(ref float2 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.acos(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.MinusOneInclusiveToOneInclusive)]
|
|
public static float ACos(float input)
|
|
{
|
|
return math.acos(input);
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// asin
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.MinusOneInclusiveToOneInclusive)]
|
|
public static float ASin4(ref float4 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.asin(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.MinusOneInclusiveToOneInclusive)]
|
|
public static float ASin3(ref float3 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.asin(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.MinusOneInclusiveToOneInclusive)]
|
|
public static float ASin2(ref float2 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.asin(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.MinusOneInclusiveToOneInclusive)]
|
|
public static float ASin(float input)
|
|
{
|
|
return math.asin(input);
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// atan
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.MinusOneInclusiveToOneInclusive)]
|
|
public static float ATan_4(ref float4 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.atan(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.MinusOneInclusiveToOneInclusive)]
|
|
public static float ATan_3(ref float3 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.atan(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.MinusOneInclusiveToOneInclusive)]
|
|
public static float ATan_2(ref float2 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.atan(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.MinusOneInclusiveToOneInclusive)]
|
|
public static float ATan(float input)
|
|
{
|
|
return math.atan(input);
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// atan2
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.MinusOneInclusiveToOneInclusive, DataRange.MinusOneInclusiveToOneInclusive)]
|
|
public static float ATan2_4(ref float4 a, ref float4 b)
|
|
{
|
|
return Vectors.ConvertToFloat(math.atan2(a, b));
|
|
}
|
|
|
|
[TestCompiler(DataRange.MinusOneInclusiveToOneInclusive, DataRange.MinusOneInclusiveToOneInclusive)]
|
|
public static float ATan2_3(ref float3 a, ref float3 b)
|
|
{
|
|
return Vectors.ConvertToFloat(math.atan2(a, b));
|
|
}
|
|
|
|
[TestCompiler(DataRange.MinusOneInclusiveToOneInclusive, DataRange.MinusOneInclusiveToOneInclusive)]
|
|
public static float ATan2_2(ref float2 a, ref float2 b)
|
|
{
|
|
return Vectors.ConvertToFloat(math.atan2(a, b));
|
|
}
|
|
|
|
[TestCompiler(DataRange.MinusOneInclusiveToOneInclusive, DataRange.MinusOneInclusiveToOneInclusive)]
|
|
public static float ATan2(float a, float b)
|
|
{
|
|
return math.atan2(a, b);
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// cos
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static double Cos4d(ref double4 input)
|
|
{
|
|
return Vectors.ConvertToDouble(math.cos(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Cos4(ref float4 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.cos(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Cos3(ref float3 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.cos(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Cos2(ref float2 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.cos(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Cos(float input)
|
|
{
|
|
return math.cos(input);
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// cosh
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static double Cosh4d(ref double4 input)
|
|
{
|
|
return Vectors.ConvertToDouble(math.cosh(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Cosh4(ref float4 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.cosh(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Cosh3(ref float3 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.cosh(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Cosh2(ref float2 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.cosh(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Cosh(float input)
|
|
{
|
|
return math.cosh(input);
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// sin
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static double Sin4d(ref double4 input)
|
|
{
|
|
return Vectors.ConvertToDouble(math.sin(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Sin4(ref float4 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.sin(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Sin3(ref float3 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.sin(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Sin2(ref float2 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.sin(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Sin(float input)
|
|
{
|
|
return math.sin(input);
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// sinh
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Sinh4(ref float4 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.sinh(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Sinh3(ref float3 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.sinh(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Sinh2(ref float2 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.sinh(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Sinh(float input)
|
|
{
|
|
return math.sinh(input);
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// sincos
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float SinCos4(ref float4 input)
|
|
{
|
|
float4 sina, cosa;
|
|
math.sincos(input, out sina, out cosa);
|
|
return Vectors.ConvertToFloat(sina) + Vectors.ConvertToFloat(cosa) * 7.1f;
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float SinCos3(ref float3 input)
|
|
{
|
|
float3 sina, cosa;
|
|
math.sincos(input, out sina, out cosa);
|
|
return Vectors.ConvertToFloat(sina) + Vectors.ConvertToFloat(cosa) * 7.1f;
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float SinCos2(ref float2 input)
|
|
{
|
|
float2 sina, cosa;
|
|
math.sincos(input, out sina, out cosa);
|
|
return Vectors.ConvertToFloat(sina) + Vectors.ConvertToFloat(cosa) * 7.1f;
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float SinCos(float input)
|
|
{
|
|
float sina, cosa;
|
|
math.sincos(input, out sina, out cosa);
|
|
return sina + cosa * 7.1f;
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// tanh
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Tanh4(ref float4 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.tanh(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Tanh3(ref float3 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.tanh(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Tanh2(ref float2 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.tanh(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Tanh(float input)
|
|
{
|
|
return math.tanh(input);
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// sqrt
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Sqrt4(ref float4 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.sqrt(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Sqrt3(ref float3 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.sqrt(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Sqrt2(ref float2 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.sqrt(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Sqrt(float input)
|
|
{
|
|
return math.sqrt(input);
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// rsqrt
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float RSqrt4(ref float4 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.rsqrt(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float RSqrt3(ref float3 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.rsqrt(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float RSqrt2(ref float2 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.rsqrt(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float RSqrt(float input)
|
|
{
|
|
return math.rsqrt(input);
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// floor
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Floor4(ref float4 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.floor(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Floor3(ref float3 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.floor(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Floor2(ref float2 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.floor(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Floor(float input)
|
|
{
|
|
return math.floor(input);
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// ceil
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Ceil4(ref float4 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.ceil(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Ceil3(ref float3 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.ceil(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Ceil2(ref float2 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.ceil(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Ceil(float input)
|
|
{
|
|
return math.ceil(input);
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// round
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Round4(ref float4 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.round(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Round3(ref float3 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.round(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Round2(ref float2 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.round(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Round(float input)
|
|
{
|
|
return math.round(input);
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// frac
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Frac4(ref float4 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.frac(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Frac3(ref float3 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.frac(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Frac2(ref float2 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.frac(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Frac(float input)
|
|
{
|
|
return math.frac(input);
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// rcp
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Rcp4(ref float4 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.rcp(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Rcp3(ref float3 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.rcp(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Rcp2(ref float2 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.rcp(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Rcp(float input)
|
|
{
|
|
return math.rcp(input);
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// sign
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Sign4(ref float4 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.sign(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Sign3(ref float3 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.sign(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Sign2(ref float2 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.sign(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Sign(float input)
|
|
{
|
|
return math.sign(input);
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// pow
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.Standard & ~(DataRange.NaN | DataRange.Zero), DataRange.Standard)]
|
|
[TestCompiler(DataRange.Standard & ~(DataRange.NaN), DataRange.Standard & ~(DataRange.Zero))]
|
|
public static float Pow4(ref float4 a, ref float4 b)
|
|
{
|
|
return Vectors.ConvertToFloat(math.pow(a, b));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard & ~(DataRange.NaN | DataRange.Zero), DataRange.Standard)]
|
|
[TestCompiler(DataRange.Standard & ~(DataRange.NaN), DataRange.Standard & ~(DataRange.Zero))]
|
|
public static float Pow3(ref float3 a, ref float3 b)
|
|
{
|
|
return Vectors.ConvertToFloat(math.pow(a, b));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard & ~(DataRange.NaN | DataRange.Zero), DataRange.Standard)]
|
|
[TestCompiler(DataRange.Standard & ~(DataRange.NaN), DataRange.Standard & ~(DataRange.Zero))]
|
|
public static float Pow2(ref float2 a, ref float2 b)
|
|
{
|
|
return Vectors.ConvertToFloat(math.pow(a, b));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard & ~(DataRange.NaN | DataRange.Zero), DataRange.Standard)]
|
|
[TestCompiler(DataRange.Standard & ~(DataRange.NaN), DataRange.Standard & ~(DataRange.Zero))]
|
|
public static float Pow(float a, float b)
|
|
{
|
|
return math.pow(a, b);
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// exp
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Exp4(ref float4 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.exp(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Exp3(ref float3 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.exp(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Exp2(ref float2 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.exp(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Exp(float input)
|
|
{
|
|
return math.exp(input);
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// mod
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard)]
|
|
public static float Mod4(ref float4 a, ref float4 b)
|
|
{
|
|
return Vectors.ConvertToFloat(math.fmod(a, b));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard)]
|
|
public static float Mod3(ref float3 a, ref float3 b)
|
|
{
|
|
return Vectors.ConvertToFloat(math.fmod(a, b));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard)]
|
|
public static float Mod2(ref float2 a, ref float2 b)
|
|
{
|
|
return Vectors.ConvertToFloat(math.fmod(a, b));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard)]
|
|
public static float Mod(float a, float b)
|
|
{
|
|
return math.fmod(a, b);
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// normalize
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Normalize4(ref float4 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.normalize(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Normalize3(ref float3 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.normalize(input));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Normalize2(ref float2 input)
|
|
{
|
|
return Vectors.ConvertToFloat(math.normalize(input));
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// length
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Length4(ref float4 input)
|
|
{
|
|
return math.length(input);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Length3(ref float3 input)
|
|
{
|
|
return math.length(input);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Length2(ref float2 input)
|
|
{
|
|
return math.length(input);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static float Length(float input)
|
|
{
|
|
return math.length(input);
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// distance
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard)]
|
|
public static float Distance4(ref float4 a, ref float4 b)
|
|
{
|
|
return math.distance(a, b);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard)]
|
|
public static float Distance3(ref float3 a, ref float3 b)
|
|
{
|
|
return math.distance(a, b);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard)]
|
|
public static float Distance2(ref float2 a, ref float2 b)
|
|
{
|
|
return math.distance(a, b);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard)]
|
|
public static float Distance(float a, float b)
|
|
{
|
|
return math.distance(a, b);
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// cross
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard)]
|
|
public static float Cross3(ref float3 a, ref float3 b)
|
|
{
|
|
return Vectors.ConvertToFloat(math.cross(a, b));
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// smoothstep
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard, DataRange.ZeroExclusiveToOneInclusive | DataRange.Zero)]
|
|
public static float Smoothstep4(ref float4 a, ref float4 b, float w)
|
|
{
|
|
return Vectors.ConvertToFloat(math.smoothstep(a, b, w));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard, DataRange.ZeroExclusiveToOneInclusive | DataRange.Zero)]
|
|
public static float Smoothstep3(ref float3 a, ref float3 b, float w)
|
|
{
|
|
return Vectors.ConvertToFloat(math.smoothstep(a, b, w));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard, DataRange.ZeroExclusiveToOneInclusive | DataRange.Zero)]
|
|
public static float Smoothstep2(ref float2 a, ref float2 b, float w)
|
|
{
|
|
return Vectors.ConvertToFloat(math.smoothstep(a, b, w));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard, DataRange.ZeroExclusiveToOneInclusive | DataRange.Zero)]
|
|
public static float Smoothstep(float a, float b, float w)
|
|
{
|
|
return math.smoothstep(a, b, w);
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// any
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static bool Any4(ref float4 input)
|
|
{
|
|
return math.any(input);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static bool Any32(ref float3 input)
|
|
{
|
|
return math.any(input);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static bool Any(ref float2 input)
|
|
{
|
|
return math.any(input);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static bool AnyInt4(ref int4 input)
|
|
{
|
|
return math.any(input);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static bool AnyInt3(ref int3 input)
|
|
{
|
|
return math.any(input);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static bool AnyInt2(ref int2 input)
|
|
{
|
|
return math.any(input);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static bool AnyBool4(ref bool4 input)
|
|
{
|
|
return math.any(input);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static bool AnyBool3(ref bool3 input)
|
|
{
|
|
return math.any(input);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static bool AnyBool2(ref bool2 input)
|
|
{
|
|
return math.any(input);
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// all
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static bool All4(ref float4 input)
|
|
{
|
|
return math.all(input);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static bool All3(ref float3 input)
|
|
{
|
|
return math.all(input);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static bool All2(ref float2 input)
|
|
{
|
|
return math.all(input);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static bool AllInt4(ref int4 input)
|
|
{
|
|
return math.all(input);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static bool AllInt3(ref int3 input)
|
|
{
|
|
return math.all(input);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static bool AllInt2(ref int2 input)
|
|
{
|
|
return math.all(input);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static bool AllBool4(ref bool4 input)
|
|
{
|
|
return math.all(input);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static bool AllBool3(ref bool3 input)
|
|
{
|
|
return math.all(input);
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard)]
|
|
public static bool AllBool2(ref bool2 input)
|
|
{
|
|
return math.all(input);
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// select
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard, DataRange.Standard)]
|
|
public static float Select4(ref bool4 c, ref float4 a, ref float4 b)
|
|
{
|
|
return Vectors.ConvertToFloat(math.select(a, b, c));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard, DataRange.Standard)]
|
|
public static float Select3(ref bool3 c, ref float3 a, ref float3 b)
|
|
{
|
|
return Vectors.ConvertToFloat(math.select(a, b, c));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard, DataRange.Standard)]
|
|
public static float Select(ref bool2 c, ref float2 a, ref float2 b)
|
|
{
|
|
return Vectors.ConvertToFloat(math.select(a, b, c));
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// step
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard)]
|
|
public static float Step4(ref float4 a, ref float4 b)
|
|
{
|
|
return Vectors.ConvertToFloat(math.step(a, b));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard)]
|
|
public static float Step3(ref float3 a, ref float3 b)
|
|
{
|
|
return Vectors.ConvertToFloat(math.step(a, b));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard)]
|
|
public static float Step2(ref float2 a, ref float2 b)
|
|
{
|
|
return Vectors.ConvertToFloat(math.step(a, b));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard)]
|
|
public static float Step(float a, float b)
|
|
{
|
|
return math.step(a, b);
|
|
}
|
|
|
|
// ---------------------------------------------------------
|
|
// reflect
|
|
// ---------------------------------------------------------
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard)]
|
|
public static float Reflect4(ref float4 a, ref float4 b)
|
|
{
|
|
return Vectors.ConvertToFloat(math.reflect(a, b));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard)]
|
|
public static float Reflect3(ref float3 a, ref float3 b)
|
|
{
|
|
return Vectors.ConvertToFloat(math.reflect(a, b));
|
|
}
|
|
|
|
[TestCompiler(DataRange.Standard, DataRange.Standard)]
|
|
public static float Reflect2(ref float2 a, ref float2 b)
|
|
{
|
|
return Vectors.ConvertToFloat(math.reflect(a, b));
|
|
}
|
|
|
|
struct TestCompressInt4
|
|
{
|
|
#pragma warning disable 0649
|
|
public int Value0;
|
|
public int Value1;
|
|
public int Value2;
|
|
public int Value3;
|
|
#pragma warning restore 0649
|
|
}
|
|
|
|
struct TestCompressUInt4
|
|
{
|
|
#pragma warning disable 0649
|
|
public uint Value0;
|
|
public uint Value1;
|
|
public uint Value2;
|
|
public uint Value3;
|
|
#pragma warning restore 0649
|
|
}
|
|
|
|
struct TestCompressFloat4
|
|
{
|
|
#pragma warning disable 0649
|
|
public float Value0;
|
|
public float Value1;
|
|
public float Value2;
|
|
public float Value3;
|
|
#pragma warning restore 0649
|
|
}
|
|
}
|
|
}
|