181 lines
7 KiB
Python
181 lines
7 KiB
Python
#!/usr/bin/env python3
|
|
"""Compare complete tuples to an independent Python Java-arithmetic oracle."""
|
|
import argparse
|
|
import json
|
|
from pathlib import Path
|
|
import subprocess
|
|
import unittest
|
|
|
|
ROOT = Path(__file__).resolve().parent
|
|
GPU = False
|
|
A = 0x5DEECE66D
|
|
MASK = (1 << 48) - 1
|
|
XOR = 987234911
|
|
|
|
|
|
def i32(v):
|
|
v &= (1 << 32) - 1
|
|
return v - (1 << 32) if v >> 31 else v
|
|
|
|
|
|
def term(x, z):
|
|
return i32(x*x*4987142) + i32(x*5947611) + i32(z*z)*4392871 + i32(z*389711)
|
|
|
|
|
|
def first(seed, x, z):
|
|
state = ((seed + term(x, z)) ^ XOR ^ A) & MASK
|
|
return (state*A + 11) & MASK
|
|
|
|
|
|
def slime(seed, x, z):
|
|
state = first(seed, x, z)
|
|
while True:
|
|
q = state >> 17
|
|
if q < 2147483640:
|
|
return q % 10 == 0
|
|
state = (state*A + 11) & MASK
|
|
|
|
|
|
def oracle(seed, seeds, x0, z0, width, height, n):
|
|
return [[s, x, z] for s in range(seed, seed+seeds)
|
|
for x in range(x0, x0+width) for z in range(z0, z0+height)
|
|
if all(slime(s, x+dx, z+dz) for dx in range(n) for dz in range(n))]
|
|
|
|
|
|
def execute(binary, args, json_output=True):
|
|
result = subprocess.run([str(ROOT/'bin'/binary), *map(str, args)],
|
|
capture_output=True, text=True, timeout=60, check=True)
|
|
return json.loads(result.stdout) if json_output else result.stdout
|
|
|
|
|
|
def cli(case):
|
|
seed, seeds, x, z, width, height, n = case
|
|
return ['--seed', seed, '--seeds', seeds, '--x0', x, '--z0', z,
|
|
'--width', width, '--height', height, '-n', n, '--repeats', 1]
|
|
|
|
|
|
class Steps(unittest.TestCase):
|
|
def compare(self, case):
|
|
expected = oracle(*case)
|
|
self.assertEqual(execute('01_cpu', cli(case))['hits'], expected)
|
|
if GPU:
|
|
result = execute('cuda_steps', cli(case))
|
|
self.assertTrue(result['comparison_equal'])
|
|
self.assertEqual(result['hits'], expected)
|
|
|
|
def test_nonzero_seed_and_nonblock_dimensions(self):
|
|
self.compare((1337, 7, -23, 17, 19, 21, 1))
|
|
|
|
def test_negative_and_overflow_coordinates(self):
|
|
self.compare((98765, 3, -1875000, 1874995, 17, 19, 2))
|
|
|
|
def test_int32_edges(self):
|
|
self.compare((42, 2, -2147483648, 2147483600, 17, 17, 2))
|
|
|
|
def test_known_hit_and_partial_tiles(self):
|
|
case = (61692151016558, 3, 51050, 419107, 37, 35, 5)
|
|
self.compare(case)
|
|
self.assertIn([61692151016558, 51069, 419124], oracle(*case))
|
|
|
|
def test_all_pattern_sizes(self):
|
|
for n in range(1, 9):
|
|
with self.subTest(n=n):
|
|
self.compare((61692151016558, 2, 51069, 419124, 3, 3, n))
|
|
|
|
def test_high16_equivalence_and_seed48_wrap(self):
|
|
base = (61692151016558, 2, 51060, 419115, 17, 19, 5)
|
|
high = (base[0]+(34567 << 48), *base[1:])
|
|
self.compare(high)
|
|
# Compare normalized seed labels, not raw world seed IDs.
|
|
normalized = [[s & MASK, x, z] for s, x, z in oracle(*high)]
|
|
self.assertEqual(normalized, oracle(*base))
|
|
self.compare((MASK-2, 7, -7, 5, 17, 19, 1))
|
|
|
|
def test_rejection_tail(self):
|
|
# Engineer each of Java's eight rejected first outputs and a successful redraw.
|
|
inv = pow(A, -1, 1 << 48)
|
|
for q in range(2147483640, 2147483648):
|
|
for suffix in range(10000):
|
|
v = (q << 17) | suffix
|
|
u = ((v-11)*inv) & MASK
|
|
seed = ((u ^ (XOR ^ A))-term(-31, 29)) & MASK
|
|
if slime(seed, -31, 29):
|
|
break
|
|
else:
|
|
self.fail('could not construct successful redraw')
|
|
self.assertEqual(first(seed, -31, 29) >> 17, q)
|
|
self.compare((seed, 1, -31, 29, 1, 1, 1))
|
|
|
|
def test_invalid_ranges_and_truncation(self):
|
|
invalid = [
|
|
['--width', 0], ['--repeats', 0], ['--seeds', 0],
|
|
['--seed', (1 << 64)-1, '--seeds', 2],
|
|
['--x0', 2147483647, '--width', 2],
|
|
['--seed', 0, '--seeds', 5, '-n', 1, '--capacity', 1],
|
|
]
|
|
for binary in ['01_cpu'] + (['cuda_steps'] if GPU else []):
|
|
for args in invalid:
|
|
p = subprocess.run([str(ROOT/'bin'/binary), *map(str, args)],
|
|
capture_output=True, text=True, timeout=60)
|
|
self.assertNotEqual(p.returncode, 0, (binary, args))
|
|
|
|
def test_upper13_against_enumeration(self):
|
|
if not GPU:
|
|
self.skipTest('requires --gpu')
|
|
result = execute('08_upper_compare', ['--planes', 3, '--repeats', 1])
|
|
expected = []
|
|
for lower in range(16420645998, 16420645998+3):
|
|
for m in range(8192):
|
|
seed = lower+(m << 35)
|
|
if all((first(seed, 51069+dx, 419124+dz) >> 17) % 10 == 0
|
|
for dx in range(5) for dz in range(5)):
|
|
self.assertTrue(all(slime(seed, 51069+dx, 419124+dz)
|
|
for dx in range(5) for dz in range(5)))
|
|
expected.append([lower, seed])
|
|
self.assertTrue(result['comparison_equal'])
|
|
self.assertEqual(result['solutions'], expected)
|
|
self.assertEqual(len(expected), 12)
|
|
|
|
def test_complete_fixed_position_pipeline(self):
|
|
if not GPU:
|
|
self.skipTest('requires --gpu')
|
|
args = ['--x', 51069, '--z', 419124, '-n', 5, '--max-results', 1000]
|
|
cpu = execute('08_seed_cpu', ['search', *args, '-p', 16], False)
|
|
gpu = execute('08_seed_cuda', [*args, '--threads', 256], False)
|
|
seeds = lambda text: sorted(int(line) for line in text.splitlines() if line.isdigit())
|
|
self.assertEqual(seeds(cpu), seeds(gpu))
|
|
self.assertEqual(len(seeds(cpu)), 24)
|
|
self.assertIn(61692151016558, seeds(cpu))
|
|
for s in seeds(cpu):
|
|
self.assertTrue(all(slime(s, 51069+dx, 419124+dz)
|
|
for dx in range(5) for dz in range(5)))
|
|
|
|
def test_residue_expansion_against_direct_window(self):
|
|
if not GPU:
|
|
self.skipTest('requires --gpu')
|
|
case = (61692151016558, 1, 51050, 419107, 37, 35, 5)
|
|
output = execute('07_residue', ['--seed', case[0], '--x0', case[2],
|
|
'--x1', case[2]+case[4]-1, '--z0', case[3],
|
|
'--z1', case[3]+case[5]-1, '-n', 5], False)
|
|
hits = [[case[0], *map(int, line.split()[1:])] for line in output.splitlines()
|
|
if line.startswith('hit ')]
|
|
self.assertEqual(hits, oracle(*case))
|
|
|
|
def test_outer_tall_rectangle_fallback(self):
|
|
if not GPU:
|
|
self.skipTest('requires --gpu')
|
|
# More than 65535 tiles on Z: exercise the safe linear-grid fallback.
|
|
args = cli((61692151016558, 1, 51069, 0, 1, 1048561, 5))
|
|
cpu = execute('01_cpu', args)
|
|
gpu = execute('cuda_steps', [*args, '--modes', '3,4'])
|
|
self.assertEqual(cpu['hits'], gpu['hits'])
|
|
self.assertIn([61692151016558, 51069, 419124], cpu['hits'])
|
|
|
|
|
|
|
|
if __name__ == '__main__':
|
|
parser = argparse.ArgumentParser()
|
|
parser.add_argument('--gpu', action='store_true')
|
|
args, rest = parser.parse_known_args()
|
|
GPU = args.gpu
|
|
unittest.main(argv=[__file__, *rest], verbosity=2)
|