public ulong3x4(ulong3 c0, ulong3 c1, ulong3 c2, ulong3 c3)
{
this.c0 = c0;
this.c1 = c1;
this.c2 = c2;
this.c3 = c3;
}
public static ulong3 lcm(long3 x, long3 y)
{
ulong3 absX = (ulong3)abs(x);
ulong3 absY = (ulong3)abs(y);
return((absX / gcd(absX, absY)) * absY);
}
public ulong3x2(ulong m00, ulong m01,
ulong m10, ulong m11,
ulong m20, ulong m21)
{
this.c0 = new ulong3(m00, m10, m20);
this.c1 = new ulong3(m01, m11, m21);
}
public static ulong3 tzcnt(ulong3 x)
{
if (Avx2.IsAvx2Supported)
{
ulong4 isZero = Avx2.mm256_cmpeq_epi64(x, default(v256));
x &= Avx2.mm256_sub_epi64(default(v256), x);
ulong3 y = x & 0x0000_0000_FFFF_FFFF;
ulong4 cmp = Avx2.mm256_cmpeq_epi64(y, default(v256));
ulong4 bits = Avx2.mm256_blendv_epi8(y, x >> 32, cmp);
ulong4 offset = Avx2.mm256_blendv_epi8((ulong4)0x03FF, (ulong4)0x03DF, cmp);
bits += 0x4330_0000_0000_0000ul;
bits = Avx.mm256_sub_pd(bits, new v256(4_503_599_627_370_496d));
bits = (bits >> 52) - offset;
return(Avx2.mm256_blendv_epi8(bits, new ulong4(64), isZero));
}
else
{
return(new ulong3((ulong)math.tzcnt(x.x), (ulong)math.tzcnt(x.y), (ulong)math.tzcnt(x.z)));
}
}
public static long indexof(ulong3 v, ulong x)
{
if (Avx2.IsAvx2Supported)
{
return(math.tzcnt(bitmask32(3 * sizeof(ulong)) & Avx.mm256_movemask_pd(Avx2.mm256_cmpeq_epi64(v, new ulong3(x)))));
}
else if (Sse2.IsSse2Supported)
{
v128 broadcast = new v128(x);
return(math.tzcnt(Sse2.movemask_pd(Operator.equals_mask_long(v._xy, broadcast)) |
(toint32(v.z == x) << 2)));
}
else
{
for (int i = 0; i < 3; i++)
{
if (v[i] == x)
{
return(i);
}
else
{
continue;
}
}
return(32);
}
}
public ulong3x4(ulong v)
{
this.c0 = v;
this.c1 = v;
this.c2 = v;
this.c3 = v;
}
public static void Constructor_ULong_ULong2()
{
ulong3 x = new ulong3(TestData_LHS[0].x, new ulong2(TestData_LHS[0].y, TestData_LHS[0].z));
Assert.AreEqual(x.x == TestData_LHS[0].x &
x.y == TestData_LHS[0].y &
x.z == TestData_LHS[0].z, true);
}
public ulong3x3(ulong m00, ulong m01, ulong m02,
ulong m10, ulong m11, ulong m12,
ulong m20, ulong m21, ulong m22)
{
this.c0 = new ulong3(m00, m10, m20);
this.c1 = new ulong3(m01, m11, m21);
this.c2 = new ulong3(m02, m12, m22);
}
public static bool3 isdivisible(ulong3 dividend, ulong3 divisor)
{
Assert.AreNotEqual(0ul, divisor.x);
Assert.AreNotEqual(0ul, divisor.y);
Assert.AreNotEqual(0ul, divisor.z);
return(dividend % divisor == 0);
}
public ulong3x4(ulong m00, ulong m01, ulong m02, ulong m03,
ulong m10, ulong m11, ulong m12, ulong m13,
ulong m20, ulong m21, ulong m22, ulong m23)
{
this.c0 = new ulong3(m00, m10, m20);
this.c1 = new ulong3(m01, m11, m21);
this.c2 = new ulong3(m02, m12, m22);
this.c3 = new ulong3(m03, m13, m23);
}
public ulong3 NextULong3(ulong3 max)
{
ulong3 result = ulong3.zero;
Common.umul128(NextState(), max.x, out result.x);
Common.umul128(NextState(), max.y, out result.y);
Common.umul128(NextState(), max.z, out result.z);
return(result);
}
public static ulong3 reversebits(ulong3 x)
{
x = ((x >> 1) & 0x5555_5555_5555_5555ul) | ((x & 0x5555_5555_5555_5555ul) << 1);
x = ((x >> 2) & 0x3333_3333_3333_3333ul) | ((x & 0x3333_3333_3333_3333ul) << 2);
x = ((x >> 4) & 0x0F0F_0F0F_0F0F_0F0Ful) | ((x & 0x0F0F_0F0F_0F0F_0F0Ful) << 4);
x = ((x >> 8) & 0x00FF_00FF_00FF_00FFul) | ((x & 0x00FF_00FF_00FF_00FFul) << 8);
x = ((x >> 16) & 0x0000_FFFF_0000_FFFFul) | ((x & 0x0000_FFFF_0000_FFFFul) << 16);
return((x >> 32) | (x << 32));
}
public static ulong3 subadd(ulong3 a, ulong3 b)
{
if (Avx2.IsAvx2Supported)
{
return(a + Avx2.mm256_blend_epi16(b, default(v256) - b, 0b0000_1111));
}
else
{
return(new ulong3(subadd(a.xy, b.xy), a.z - b.z));
}
}
public static ulong3 max(ulong3 a, ulong3 b)
{
if (Avx2.IsAvx2Supported)
{
return(Avx2.mm256_blendv_epi8(a, b, Operator.greater_mask_ulong(b, a)));
}
else
{
return(new ulong3(max(a.xy, b.xy), math.max(a.z, b.z)));
}
}
public static void ulong3()
{
Random64 rng = new Random64(135);
for (ulong i = 0; i < 64; i++)
{
ulong3 x = rng.NextULong3();
Assert.AreEqual(new ulong3((ulong)_intsqrt(x.x), (ulong)_intsqrt(x.y), (ulong)_intsqrt(x.z)), maxmath.intsqrt(x));
}
}
public static ulong3 addsub(ulong3 a, ulong3 b)
{
if (Avx2.IsAvx2Supported)
{
return(a + Avx2.mm256_blend_epi16(b, default(v256) - b, 0b1111_0000));
}
else
{
return(new ulong3(addsub(a.xy, b.xy), a.z + b.z));
}
}
public static void long3()
{
Random64 rng = new Random64(135);
for (long i = 0; i < 64; i++)
{
long3 x = rng.NextLong3();
ulong3 n = rng.NextULong3();
Assert.AreEqual(new long3((long)_intpow(x.x, n.x), (long)_intpow(x.y, n.y), (long)_intpow(x.z, n.z)), maxmath.intpow(x, n));
}
}
public static void ulong3()
{
Random64 rng = new Random64(135);
for (ulong i = 0; i < 64; i++)
{
ulong3 x = rng.NextULong3();
ulong3 y = rng.NextULong3();
Assert.AreEqual(new ulong3((ulong)_gcd(x.x, y.x), (ulong)_gcd(x.y, y.y), (ulong)_gcd(x.z, y.z)), maxmath.gcd(x, y));
}
}
public static bool3 ispow2(ulong3 x)
{
if (Avx2.IsAvx2Supported)
{
v128 result = new byte3(1) & ((byte3)(ulong3)Avx2.mm256_and_si256(Operator.greater_mask_ulong(x, default(v256)),
Avx2.mm256_cmpeq_epi64(default(v256), x & (x - 1))));
return(*(bool3 *)&result);
}
else
{
return(new bool3(ispow2(x.xy), ispow2(x.z)));
}
}
public static ulong cmin(ulong3 x)
{
if (Sse4_2.IsSse42Supported)
{
ulong2 temp = min(x.xy, x.yz);
return(min(temp, temp.yy).x);
}
else
{
return(math.min(x.x, math.min(x.y, x.z)));
}
}
public static ulong3 gcd(ulong3 x, ulong3 y)
{
if (Avx2.IsAvx2Supported)
{
v256 ZERO = default(v256);
v256 result = ZERO;
v256 result_if_zero_any = ZERO;
v256 x_is_zero = Avx2.mm256_cmpeq_epi64(x, ZERO);
v256 y_is_zero = Avx2.mm256_cmpeq_epi64(y, ZERO);
v256 any_zero = Avx2.mm256_or_si256(x_is_zero, y_is_zero);
result_if_zero_any = Avx2.mm256_blendv_epi8(result_if_zero_any, y, x_is_zero);
result_if_zero_any = Avx2.mm256_blendv_epi8(result_if_zero_any, x, y_is_zero);
v256 doneMask = any_zero;
v256 shift = tzcnt(x | y);
x = Avx2.mm256_srlv_epi64(x, tzcnt(x));
do
{
y = Avx2.mm256_srlv_epi64(y, tzcnt(y));
v256 tempX = x;
v256 x_greater_y = Operator.greater_mask_ulong(x, y);
x = Avx2.mm256_blendv_epi8(x, y, x_greater_y);
y = Avx2.mm256_blendv_epi8(y, tempX, x_greater_y);
y -= x;
v256 loopCheck = Avx2.mm256_andnot_si256(doneMask, Avx2.mm256_cmpeq_epi64(y, ZERO));
result = Avx2.mm256_blendv_epi8(result, x, loopCheck);
doneMask = Avx2.mm256_or_si256(doneMask, loopCheck);
} while (bitmask32(3 * sizeof(ulong)) != (bitmask32(3 * sizeof(ulong)) & Avx2.mm256_movemask_epi8(doneMask)));
result = Avx2.mm256_sllv_epi64(result, shift);
result = Avx2.mm256_blendv_epi8(result, result_if_zero_any, any_zero);
return(result);
}
else
{
return(new ulong3(gcd(x._xy, y._xy), gcd(x.z, y.z)));
}
}
public static void Multiply()
{
bool result = true;
for (int i = 0; i < NUM_TESTS; i++)
{
ulong3 x = TestData_LHS[i] * TestData_RHS[i];
result &= x.x == (ulong)(TestData_LHS[i].x * TestData_RHS[i].x) &
x.y == (ulong)(TestData_LHS[i].y * TestData_RHS[i].y) &
x.z == (ulong)(TestData_LHS[i].z * TestData_RHS[i].z);
}
Assert.AreEqual(true, result);
}
public static void Subtract()
{
bool result = true;
for (int i = 0; i < NUM_TESTS; i++)
{
ulong3 x = TestData_LHS[i] - TestData_RHS[i];
result &= x.x == (ulong)(TestData_LHS[i].x - TestData_RHS[i].x) &
x.y == (ulong)(TestData_LHS[i].y - TestData_RHS[i].y) &
x.z == (ulong)(TestData_LHS[i].z - TestData_RHS[i].z);
}
Assert.AreEqual(true, result);
}
public static long3 compareto(ulong3 x, ulong3 y)
{
if (Avx2.IsAvx2Supported)
{
long3 xGreatery = Operator.greater_mask_ulong(x, y);
long3 yGreaterx = Operator.greater_mask_ulong(y, x);
return((0 - xGreatery) + yGreaterx);
}
else
{
return(new long3(compareto(x.xy, y.xy),
compareto(x.z, y.z)));
}
}
public ulong3 NextULong3(ulong3 min, ulong3 max)
{
Assert.IsNotSmaller(max.x, min.x);
Assert.IsNotSmaller(max.y, min.y);
Assert.IsNotSmaller(max.z, min.z);
max -= min;
ulong3 result = ulong3.zero;
Common.umul128(NextState(), max.x, out result.x);
Common.umul128(NextState(), max.y, out result.y);
Common.umul128(NextState(), max.z, out result.z);
return(min + result);
}
public static void NOT()
{
bool result = true;
for (int i = 0; i < NUM_TESTS; i++)
{
ulong3 x = ~TestData_LHS[i];
result &= x.x == (ulong)(~TestData_LHS[i].x) &
x.y == (ulong)(~TestData_LHS[i].y) &
x.z == (ulong)(~TestData_LHS[i].z);
}
Assert.AreEqual(true, result);
}
public static void ulong3()
{
for (int i = 0; i < ULong3.TestData_LHS.Length; i++)
{
for (int j = 1; j < 3; j++)
{
ulong3 rol = maxmath.vrol(ULong3.TestData_LHS[i], j);
for (int k = 0; k < 3; k++)
{
Assert.AreEqual(rol[k], ULong3.TestData_LHS[i][((3 - j) + k) % 3]);
}
}
}
}
public static void Remainder()
{
bool result = true;
for (int i = 0; i < NUM_TESTS; i++)
{
ulong3 x = TestData_LHS[i] % TestData_RHS[i];
result &= x.x == (ulong)(TestData_LHS[i].x % TestData_RHS[i].x) &
x.y == (ulong)(TestData_LHS[i].y % TestData_RHS[i].y) &
x.z == (ulong)(TestData_LHS[i].z % TestData_RHS[i].z);
}
Assert.AreEqual(true, result);
}
public static void Cast_ToULong()
{
bool result = true;
for (int i = 0; i < NUM_TESTS; i++)
{
ulong3 x = TestData_LHS[i];
result &= x.x == (ulong)TestData_LHS[i].x &
x.y == (ulong)TestData_LHS[i].y &
x.z == (ulong)TestData_LHS[i].z;
}
Assert.AreEqual(true, result);
}
public static void ulong3()
{
for (int i = 0; i < ULong3.TestData_LHS.Length; i++)
{
for (int j = 1; j < 3; j++)
{
ulong3 shl = maxmath.vshl(ULong3.TestData_LHS[i], j);
for (int k = 0; k < 3; k++)
{
Assert.IsTrue(shl[k] == ((k - j < 0) ? 0 : ULong3.TestData_LHS[i][k - j]));
}
}
}
}
public static extern CUResult cuMemcpyDtoH_v2(ref ulong3 dstHost, CUdeviceptr srcDevice, SizeT ByteCount);
