internal static float8 UInt8ToFloat8(uint8 x)
{
int8 signed = (int8)x & 0x7FFF_FFFF;
int8 signMask = ((int8)x >> 31) & 0x4F00_0000;
return((float8)signed + (v256)signMask);
}
public int8 NextInt8(int8 min, int8 max)
{
Assert.IsNotSmaller(max.x0, min.x0);
Assert.IsNotSmaller(max.x1, min.x1);
Assert.IsNotSmaller(max.x2, min.x2);
Assert.IsNotSmaller(max.x3, min.x3);
Assert.IsNotSmaller(max.x4, min.x4);
Assert.IsNotSmaller(max.x5, min.x5);
Assert.IsNotSmaller(max.x6, min.x6);
Assert.IsNotSmaller(max.x7, min.x7);
if (Avx2.IsAvx2Supported)
{
max -= min;
v256 hiProd_lo = Avx2.mm256_mul_epu32(new v256(NextState(), 0, NextState(), 0, NextState(), 0, NextState(), 0), (long4)max.v4_0);
v256 hiProd_hi = Avx2.mm256_mul_epu32(new v256(NextState(), 0, NextState(), 0, NextState(), 0, NextState(), 0), (long4)max.v4_4);
hiProd_lo = Avx2.mm256_permutevar8x32_epi32(hiProd_lo, Avx.mm256_castsi128_si256(new v128(1, 3, 5, 7)));
hiProd_hi = Avx2.mm256_permutevar8x32_epi32(hiProd_hi, Avx.mm256_castsi128_si256(new v128(1, 3, 5, 7)));
return(min + Avx.mm256_set_m128i(Avx.mm256_castsi256_si128(hiProd_hi), Avx.mm256_castsi256_si128(hiProd_lo)));
}
else
{
Unity.Mathematics.Random rng = this;
return(new int8(rng.NextInt4(min.v4_0, max.v4_0), rng.NextInt4(min.v4_4, max.v4_4)));
}
}
internal static sbyte8 vrem_sbyte(sbyte8 dividend, sbyte8 divisor)
{
int8 castDividend = dividend;
int8 castDivisor = divisor;
return((sbyte8)(castDividend - ((int8)vdiv_byte_quotient(castDividend, castDivisor) * castDivisor)));
}
public static uint8 lcm(int8 x, int8 y)
{
uint8 absX = (uint8)abs(x);
uint8 absY = (uint8)abs(y);
return((absX / gcd(absX, absY)) * absY);
}
internal static sbyte8 vdivrem_sbyte(sbyte8 dividend, sbyte8 divisor, out sbyte8 remainder)
{
int8 castDividend = dividend;
int8 castDivisor = divisor;
int8 quotientCast = (int8)vdiv_byte_quotient(castDividend, castDivisor);
remainder = (sbyte8)(castDividend - quotientCast * castDivisor);
return((sbyte8)quotientCast);
}
public static int8 abs(int8 x)
{
if (Avx2.IsAvx2Supported)
{
return(Avx2.mm256_abs_epi32(x));
}
else
{
return(new int8(math.abs(x.v4_0), math.abs(x.v4_4)));
}
}
public static int8 max(int8 a, int8 b)
{
if (Avx2.IsAvx2Supported)
{
return(Avx2.mm256_max_epi32(a, b));
}
else
{
return(new int8(math.max(a.v4_0, b.v4_0), math.max(a.v4_4, b.v4_4)));
}
}
public static bool any(int8 x)
{
if (Avx2.IsAvx2Supported)
{
return(bitmask32(8 * sizeof(int)) != Avx2.mm256_movemask_epi8(Avx2.mm256_cmpeq_epi32(x, default(v256))));
}
else
{
return(math.any(x.v4_0) & math.any(x.v4_4));
}
}
public static int8 subadd(int8 a, int8 b)
{
if (Avx2.IsAvx2Supported)
{
return(a + Avx2.mm256_sign_epi32(b, new uint8(uint.MaxValue, 1, uint.MaxValue, 1, uint.MaxValue, 1, uint.MaxValue, 1)));
}
else
{
return(new int8(subadd(a.v4_0, b.v4_0), subadd(a.v4_4, b.v4_4)));
}
}
public static bool all_eq(int8 c)
{
if (Avx2.IsAvx2Supported)
{
return(Avx2.mm256_broadcastd_epi32(Avx.mm256_castsi256_si128(c)).Equals(c));
}
else
{
return(all_eq(c.v4_0) & all_eq(c.v4_4) & c.v4_0.Equals(c.v4_4));
}
}
public static float8 asfloat(int8 x)
{
if (Avx.IsAvxSupported)
{
return((v256)x);
}
else
{
return(*(float8 *)&x);
}
}
public static int8 andnot(int8 left, int8 right)
{
if (Avx2.IsAvx2Supported)
{
return(Avx2.mm256_andnot_si256(right, left));
}
else
{
return(new int8(andnot(left.v4_0, right.v4_0), andnot(left.v4_4, right.v4_4)));
}
}
public static int8 nabs(int8 x)
{
if (Avx2.IsAvx2Supported)
{
return(Avx2.mm256_sub_epi32(default(v256), Avx2.mm256_abs_epi32(x)));
}
else
{
return(new int8(nabs(x.v4_0), nabs(x.v4_4)));
}
}
public static bool all(int8 x)
{
if (Avx2.IsAvx2Supported)
{
return(0 == Avx2.mm256_movemask_epi8(Avx2.mm256_cmpeq_epi32(x, default(v256))));
}
else
{
return(math.all(x.v4_0) & math.all(x.v4_4));
}
}
public DebuggerProxy(int8 v)
{
x0 = v.x0;
x1 = v.x1;
x2 = v.x2;
x3 = v.x3;
x4 = v.x4;
x5 = v.x5;
x6 = v.x6;
x7 = v.x7;
}
public static int8 sign(int8 x)
{
if (Avx2.IsAvx2Supported)
{
return(Avx2.mm256_sign_epi32(new v256(1), x));
}
else
{
return(new int8(sign(x.v4_0), sign(x.v4_4)));
}
}
public static bool8 ispow2(int8 x)
{
if (Avx2.IsAvx2Supported)
{
return((v128)(new byte8(1) & (byte8)(int8)Avx2.mm256_and_si256(Avx2.mm256_cmpgt_epi32(x, default(v256)),
Avx2.mm256_cmpeq_epi32(default(v256), x & (x - 1)))));
}
else
{
return(new bool8(math.ispow2(x.v4_0), math.ispow2(x.v4_4)));
}
}
public static int8 rol(int8 x, int8 n)
{
if (Sse2.IsSse2Supported)
{
n &= 31;
return(shl(x, n) | shrl(x, -n & 31));
}
else
{
return(new int8(math.rol(x.x0, n.x0), math.rol(x.x1, n.x1), math.rol(x.x2, n.x2), math.rol(x.x3, n.x3), math.rol(x.x4, n.x4), math.rol(x.x5, n.x5), math.rol(x.x6, n.x6), math.rol(x.x7, n.x7)));
}
}
public static bool8 toboolsafe(int8 x)
{
if (Sse2.IsSse2Supported)
{
return((v128)(byte8)clamp(x, 0, 1));
}
else
{
byte8 temp = (byte8)clamp(x, 0, 1);
return(*(bool8 *)&temp);
}
}
internal static int8 Int8FromInt(int mask)
{
if (Avx2.IsAvx2Supported)
{
int8 shiftBoolsToSignBit = maxmath.shl(mask, new int8(31, 30, 29, 28, 27, 26, 25, 24));
return(shiftBoolsToSignBit >> 31);
}
else
{
return(new int8(mask << 31, mask << 30, mask << 29, mask << 28, mask << 27, mask << 26, mask << 25, mask << 24) >> 31);
}
}
public static int8 divrem(int8 dividend, int8 divisor, out int8 remainder)
{
remainder = default(v256);
return(new int8(divrem(dividend.x0, divisor.x0, out remainder.x0),
divrem(dividend.x1, divisor.x1, out remainder.x1),
divrem(dividend.x2, divisor.x2, out remainder.x2),
divrem(dividend.x3, divisor.x3, out remainder.x3),
divrem(dividend.x4, divisor.x4, out remainder.x4),
divrem(dividend.x5, divisor.x5, out remainder.x5),
divrem(dividend.x6, divisor.x6, out remainder.x6),
divrem(dividend.x7, divisor.x7, out remainder.x7)));
}
public static bool8 isdivisible(int8 dividend, int8 divisor)
{
Assert.AreNotEqual(0, divisor.x0);
Assert.AreNotEqual(0, divisor.x1);
Assert.AreNotEqual(0, divisor.x2);
Assert.AreNotEqual(0, divisor.x3);
Assert.AreNotEqual(0, divisor.x4);
Assert.AreNotEqual(0, divisor.x5);
Assert.AreNotEqual(0, divisor.x6);
Assert.AreNotEqual(0, divisor.x7);
return(dividend % divisor == 0);
}
public static int csum(int8 x)
{
if (Avx2.IsAvx2Supported)
{
v128 int4 = Sse2.add_epi32(Avx.mm256_castsi256_si128(x), Avx2.mm256_extracti128_si256(x, 1));
int4 = Sse2.add_epi32(int4, Sse2.shuffle_epi32(int4, Sse.SHUFFLE(0, 1, 2, 3)));
return(Sse2.add_epi32(int4, Sse2.shufflelo_epi16(int4, Sse.SHUFFLE(0, 0, 3, 2))).SInt0);
}
else
{
return(math.csum(x.v4_0 + x.v4_4));
}
}
public static int8 compareto(float8 x, float8 y)
{
if (Avx.IsAvxSupported)
{
int8 xGreatery = Avx.mm256_cmp_ps(x, y, (int)Avx.CMP.GT_OS);
int8 yGreaterx = Avx.mm256_cmp_ps(y, x, (int)Avx.CMP.GT_OS);
return((0 - xGreatery) + yGreaterx);
}
else
{
return(new int8(compareto(x.v4_0, y.v4_0),
compareto(x.v4_4, y.v4_4)));
}
}
public static int8 compareto(uint8 x, uint8 y)
{
if (Avx2.IsAvx2Supported)
{
int8 xGreatery = Operator.greater_mask_uint(x, y);
int8 yGreaterx = Operator.greater_mask_uint(y, x);
return((0 - xGreatery) + yGreaterx);
}
else
{
return(new int8(compareto(x.v4_0, y.v4_0),
compareto(x.v4_4, y.v4_4)));
}
}
public static int8 compareto(int8 x, int8 y)
{
if (Avx2.IsAvx2Supported)
{
int8 xGreatery = Avx2.mm256_cmpgt_epi32(x, y);
int8 yGreaterx = Avx2.mm256_cmpgt_epi32(y, x);
return((0 - xGreatery) + yGreaterx);
}
else
{
return(new int8(compareto(x.v4_0, y.v4_0),
compareto(x.v4_4, y.v4_4)));
}
}
public static int cprod(int8 x)
{
if (Avx2.IsAvx2Supported)
{
v128 result = Sse4_1.mullo_epi32(Avx.mm256_castsi256_si128(x),
Avx2.mm256_extracti128_si256(x, 1));
result = Sse4_1.mullo_epi32(result, Sse2.shuffle_epi32(result, Sse.SHUFFLE(0, 1, 2, 3)));
return(Sse4_1.mullo_epi32(result, Sse2.shufflelo_epi16(result, Sse.SHUFFLE(0, 0, 3, 2))).SInt0);
}
else
{
return(cprod(x.v4_0 * x.v4_4));
}
}
public static int8 avg(int8 x, int8 y)
{
int8 result = x + y;
// if the intermediate sum is positive add 1
if (Avx2.IsAvx2Supported)
{
result -= Avx2.mm256_cmpgt_epi32(result, default(v256));
}
else
{
result += toint8(result > 0);
}
return(result >> 1);
}
internal static short16 Short16FromInt(int mask)
{
if (Avx2.IsAvx2Supported)
{
int8 broadcast = mask;
int8 shiftBoolsToSignBit_Lo = maxmath.shl(broadcast, new int8(31, 30, 29, 28, 27, 26, 25, 24));
int8 shiftBoolsToSignBit_Hi = maxmath.shl(broadcast, new int8(23, 22, 21, 20, 19, 18, 17, 16));
short16 signSaturated = Avx2.mm256_permute4x64_epi64(Avx2.mm256_packs_epi16(shiftBoolsToSignBit_Lo, shiftBoolsToSignBit_Hi),
Sse.SHUFFLE(3, 1, 2, 0));
return(signSaturated >> 15);
}
else
{
return(new short16((short)(mask << 15), (short)(mask << 14), (short)(mask << 13), (short)(mask << 12), (short)(mask << 11), (short)(mask << 10), (short)(mask << 9), (short)(mask << 8), (short)(mask << 7), (short)(mask << 6), (short)(mask << 5), (short)(mask << 4), (short)(mask << 3), (short)(mask << 2), (short)(mask << 1), (short)mask) >> 15);
}
}
public static short8 avg(short8 x, short8 y)
{
int8 result = ((int8)x + (int8)y);
// if the intermediate sum is positive add 1
if (Avx2.IsAvx2Supported)
{
int8 isPositiveMask = Avx2.mm256_cmpgt_epi32(result, default(v256));
result = (result - isPositiveMask) >> 1;
return(Sse2.packs_epi32(Avx.mm256_castsi256_si128(result),
Avx2.mm256_extracti128_si256(result, 1)));
}
else
{
return(new short8(avg(x.v4_0, y.v4_0), avg(x.v4_4, y.v4_4)));
}
}
