public sbyte4x4(sbyte4 c0, sbyte4 c1, sbyte4 c2, sbyte4 c3)
{
this.c0 = c0;
this.c1 = c1;
this.c2 = c2;
this.c3 = c3;
}
public sbyte4x4(sbyte v)
{
this.c0 = v;
this.c1 = v;
this.c2 = v;
this.c3 = v;
}
public static byte4 lcm(sbyte4 x, sbyte4 y)
{
byte4 absX = (byte4)abs(x);
byte4 absY = (byte4)abs(y);
return((absX / gcd(absX, absY)) * absY);
}
public sbyte4x2(sbyte m00, sbyte m01,
sbyte m10, sbyte m11,
sbyte m20, sbyte m21,
sbyte m30, sbyte m31)
{
this.c0 = new sbyte4(m00, m10, m20, m30);
this.c1 = new sbyte4(m01, m11, m21, m31);
}
public sbyte4x3(sbyte m00, sbyte m01, sbyte m02,
sbyte m10, sbyte m11, sbyte m12,
sbyte m20, sbyte m21, sbyte m22,
sbyte m30, sbyte m31, sbyte m32)
{
this.c0 = new sbyte4(m00, m10, m20, m30);
this.c1 = new sbyte4(m01, m11, m21, m31);
this.c2 = new sbyte4(m02, m12, m22, m32);
}
public static int csum(sbyte4 x)
{
short4 cast = x;
cast += cast.zwzw;
cast += cast.yyyy;
return(cast.x);
}
public static int cprod(sbyte4 x)
{
int4 cast = x;
cast *= cast.zwzw;
cast *= cast.yyyy;
return(cast.x);
}
public static bool4 isdivisible(sbyte4 dividend, sbyte4 divisor)
{
Assert.AreNotEqual(0, divisor.x);
Assert.AreNotEqual(0, divisor.y);
Assert.AreNotEqual(0, divisor.z);
Assert.AreNotEqual(0, divisor.w);
return(dividend % divisor == 0);
}
public sbyte4x4(sbyte m00, sbyte m01, sbyte m02, sbyte m03,
sbyte m10, sbyte m11, sbyte m12, sbyte m13,
sbyte m20, sbyte m21, sbyte m22, sbyte m23,
sbyte m30, sbyte m31, sbyte m32, sbyte m33)
{
this.c0 = new sbyte4(m00, m10, m20, m30);
this.c1 = new sbyte4(m01, m11, m21, m31);
this.c2 = new sbyte4(m02, m12, m22, m32);
this.c3 = new sbyte4(m03, m13, m23, m33);
}
public static void sbyte4()
{
Random8 rng = new Random8(135);
for (int i = 0; i < 64; i++)
{
sbyte4 x = rng.NextSByte4();
Assert.AreEqual(new sbyte4((sbyte)maxmath.lzcnt(x.x), (sbyte)maxmath.lzcnt(x.y), (sbyte)maxmath.lzcnt(x.z), (sbyte)maxmath.lzcnt(x.w)), maxmath.lzcnt(x));
}
}
public static sbyte4 subadd(sbyte4 a, sbyte4 b)
{
if (Ssse3.IsSsse3Supported)
{
return(a + Ssse3.sign_epi8(b, new byte4(255, 1, 255, 1)));
}
else
{
return(a - select(b, -b, new bool4(false, true, false, true)));
}
}
public static quarter4 asquarter(sbyte4 x)
{
if (Sse.IsSseSupported)
{
return((v128)x);
}
else
{
return(*(quarter4 *)&x);
}
}
internal static sbyte4 vdiv_sbyte(sbyte4 dividend, sbyte4 divisor)
{
Assert.AreNotEqual(divisor.x, 0);
Assert.AreNotEqual(divisor.y, 0);
Assert.AreNotEqual(divisor.z, 0);
Assert.AreNotEqual(divisor.w, 0);
v128 floatResult = vdiv_byte_quotient((int4)dividend, (int4)divisor);
return((sbyte4)(*(float4 *)&floatResult));
}
public static void sbyte4()
{
Random8 rng = new Random8(135);
for (int i = 0; i < 64; i++)
{
sbyte4 x = rng.NextSByte4();
byte4 n = rng.NextByte4();
Assert.AreEqual(new sbyte4((sbyte)_intpow(x.x, n.x), (sbyte)_intpow(x.y, n.y), (sbyte)_intpow(x.z, n.z), (sbyte)_intpow(x.w, n.w)), maxmath.intpow(x, n));
}
}
public static sbyte4 divrem(sbyte4 dividend, sbyte divisor, out sbyte4 remainder)
{
if (Constant.IsConstantExpression(divisor))
{
remainder = dividend % divisor;
return(dividend / divisor);
}
else
{
return(divrem(dividend, (sbyte4)divisor, out remainder));
}
}
public static void sbyte4()
{
Random8 rng = new Random8(135);
for (int i = 0; i < 64; i++)
{
sbyte4 x = rng.NextSByte4();
sbyte4 y = rng.NextSByte4();
Assert.AreEqual(new byte4((byte)_gcd(x.x, y.x), (byte)_gcd(x.y, y.y), (byte)_gcd(x.z, y.z), (byte)_gcd(x.w, y.w)), maxmath.gcd(x, y));
}
}
public static sbyte4 divrem(sbyte4 dividend, sbyte4 divisor, out sbyte4 remainder)
{
if (Sse2.IsSse2Supported)
{
return(Operator.vdivrem_sbyte(dividend, divisor, out remainder));
}
else
{
remainder = dividend % divisor;
return(dividend / divisor);
}
}
public static sbyte cmin(sbyte4 x)
{
if (Ssse3.IsSsse3Supported)
{
x = min(x, x.zwzw);
return(min(x, x.yyyy).x);
}
else
{
return((sbyte)math.min((int)x.x, math.min((int)x.y, math.min((int)x.z, (int)x.w))));
}
}
public static sbyte4 rol(sbyte4 x, sbyte4 n)
{
if (Sse2.IsSse2Supported)
{
n &= 7;
return((sbyte4)(shl((byte4)x, (byte4)n) | shrl((byte4)x, (byte4)(-n & 7))));
}
else
{
return(new sbyte4(rol(x.x, n.x), rol(x.y, n.y), rol(x.z, n.z), rol(x.w, n.w)));
}
}
internal static sbyte4 vrem_sbyte(sbyte4 dividend, sbyte4 divisor)
{
Assert.AreNotEqual(divisor.x, 0);
Assert.AreNotEqual(divisor.y, 0);
Assert.AreNotEqual(divisor.z, 0);
Assert.AreNotEqual(divisor.w, 0);
int4 castDividend = dividend;
int4 castDivisor = divisor;
v128 floatResult = vdiv_byte_quotient(castDividend, castDivisor);
return((sbyte4)(castDividend - ((int4)(*(float4 *)&floatResult) * castDivisor)));
}
public static sbyte2x2 operator %(sbyte2x2 left, sbyte2x2 right)
{
if (Sse2.IsSse2Supported)
{
sbyte4 fused = new sbyte4(left.c0, left.c1) % new sbyte4(right.c0, right.c1);
return(new sbyte2x2(fused.xy, fused.zw));
}
else
{
return(new sbyte2x2(left.c0 % right.c0, left.c1 % right.c1));
}
}
public static bool4 ispow2(sbyte4 x)
{
if (Sse2.IsSse2Supported)
{
v128 result = Sse2.and_si128(Sse2.and_si128(Sse2.cmpgt_epi8(x, default(v128)),
Sse2.cmpeq_epi8(default(v128), x & (x - 1))),
new sbyte16(1));
return(*(bool4 *)&result);
}
else
{
return(new bool4(math.ispow2(x.x), math.ispow2(x.y), math.ispow2(x.z), math.ispow2(x.w)));
}
}
public static sbyte2x2 operator %(sbyte2x2 left, sbyte right)
{
if (Sse2.IsSse2Supported)
{
if (!Constant.IsConstantExpression(right))
{
sbyte4 fused = new sbyte4(left.c0, left.c1) % right;
return(new sbyte2x2(fused.xy, fused.zw));
}
}
return(new sbyte2x2(left.c0 % right, left.c1 % right));
}
public static sbyte4 nabs(sbyte4 x)
{
if (Ssse3.IsSsse3Supported)
{
return(Sse2.sub_epi8(default(v128), Ssse3.abs_epi8(x)));
}
else if (Sse2.IsSse2Supported)
{
return(Mask.BlendV(-x, x, Sse2.cmpgt_epi8(default(v128), x)));
}
else
{
return(new sbyte4((sbyte)nabs((int)x.x), (sbyte)nabs((int)x.y), (sbyte)nabs((int)x.z), (sbyte)nabs((int)x.w)));
}
}
public static sbyte4 max(sbyte4 a, sbyte4 b)
{
if (Sse4_1.IsSse41Supported)
{
return(Sse4_1.max_epi8(a, b));
}
else if (Sse2.IsSse2Supported)
{
return(Mask.BlendV(a, b, Sse2.cmpgt_epi8(b, a)));
}
else
{
return(new sbyte4((sbyte)math.max(a.x, b.x), (sbyte)math.max(a.y, b.y), (sbyte)math.max(a.z, b.z), (sbyte)math.max(a.w, b.w)));
}
}
public static sbyte4 sign(sbyte4 x)
{
if (Ssse3.IsSsse3Supported)
{
return(Ssse3.sign_epi8(new sbyte4(1), x));
}
else if (Sse2.IsSse2Supported)
{
return(((sbyte4)Sse2.cmpgt_epi8(x, default(v128)) & 1) + Sse2.cmpgt_epi8(default(v128), x));
}
else
{
return((x >> 7) | (sbyte4)((byte4)(-x) >> 7));
}
}
public static void SByte4()
{
bool result = true;
Random32 x = new Random32(47);
for (int i = 0; i < Tests.SByte4.NUM_TESTS; i++)
{
bool4 b = x.NextBool4();
sbyte4 a = maxmath.negate(Tests.SByte4.TestData_LHS[i], b);
result &= math.all(a == (maxmath.select(Tests.SByte4.TestData_LHS[i], -Tests.SByte4.TestData_LHS[i], b)));
}
Assert.AreEqual(true, result);
}
internal static sbyte4 vdivrem_sbyte(sbyte4 dividend, sbyte4 divisor, out sbyte4 remainder)
{
Assert.AreNotEqual(divisor.x, 0);
Assert.AreNotEqual(divisor.y, 0);
Assert.AreNotEqual(divisor.z, 0);
Assert.AreNotEqual(divisor.w, 0);
int4 castDividend = dividend;
int4 castDivisor = divisor;
v128 floatResult = vdiv_byte_quotient(castDividend, castDivisor);
int4 quotientCast = (int4)(*(float4 *)&floatResult);
remainder = (sbyte4)(castDividend - quotientCast * castDivisor);
return((sbyte4)quotientCast);
}
public static void Cast_ToSByte()
{
bool result = true;
for (int i = 0; i < NUM_TESTS; i++)
{
sbyte4 x = (sbyte4)TestData_LHS[i];
result &= x.x == (sbyte)TestData_LHS[i].x &
x.y == (sbyte)TestData_LHS[i].y &
x.z == (sbyte)TestData_LHS[i].z &
x.w == (sbyte)TestData_LHS[i].w;
}
Assert.AreEqual(true, result);
}
public static sbyte4 avg(sbyte4 x, sbyte4 y)
{
short4 result = ((short4)x + (short4)y);
// if the intermediate sum is positive add 1
if (Sse2.IsSse2Supported)
{
result -= Sse2.cmpgt_epi16(result, default(v128));
}
else
{
result += toint8(result > 0);
}
return((sbyte4)(result >> 1));
}
public static extern sbyte mono_return_sbyte4 (sbyte4 s, int addend);
