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);