def annealing_cut_accept_backwards(partition):
boundaries1 = {x[0] for x in partition["cut_edges"]}.union({x[1] for x in partition["cut_edges"]})
boundaries2 = {x[0] for x in partition.parent["cut_edges"]}.union({x[1] for x in partition.parent["cut_edges"]})
t = partition["step_num"]
#if t <100000:
# beta = 0
#elif t<400000:
# beta = (t-100000)/100000 #was 50000)/50000
#else:
# beta = 3
base = .1
beta = 5
bound = 1
if partition.parent is not None:
bound = (base**(beta*(-len(partition["cut_edges"])+len(partition.parent["cut_edges"]))))*(len(boundaries1)/len(boundaries2))
#if not popbound(partition):
# bound = 0
if not single_flip_contiguous(partition):
bound = 0
#bound = min(1, (how_many_seats_value(partition, col1="G17RATG",
#col2="G17DATG")/how_many_seats_value(partition.parent, col1="G17RATG",
#col2="G17DATG"))**2 ) #for some states/elections probably want to add 1 to denominator so you don't divide by zero
return random.random() < bound
def test_contiguous_with_contiguity_flips_is_true(
contiguous_partition_with_flips):
contiguous_partition, test_flips = contiguous_partition_with_flips
contiguous_partition2 = contiguous_partition.flip(test_flips)
assert contiguous(contiguous_partition2)
assert single_flip_contiguous(contiguous_partition2)
assert contiguous_bfs(contiguous_partition2)
def uniform_accept(partition):
bound = 0
if single_flip_contiguous(partition) and boundary_condition(partition):
bound = 1
return random.random() < bound
def test_discontiguous_with_single_flip_contiguous_flips_is_false(
discontiguous_partition_with_flips
):
part, test_flips = discontiguous_partition_with_flips
discontiguous_partition2 = part.flip(test_flips)
assert not single_flip_contiguous(discontiguous_partition2)
def test_discontiguous_with_single_flip_contiguous_no_flips_is_false(
discontiguous_partition
):
assert not single_flip_contiguous(discontiguous_partition)
def test_contiguous_with_contiguity_no_flips_is_true(contiguous_partition):
assert contiguous(contiguous_partition)
assert single_flip_contiguous(contiguous_partition)
assert contiguous_bfs(contiguous_partition)
def test_discontiguous_with_contiguity_flips_is_false():
discontiguous_partition = MockDiscontiguousPartition()
discontiguous_partition.flips = discontiguous_partition.test_flips
assert not contiguous(discontiguous_partition)
assert not single_flip_contiguous(discontiguous_partition)
assert not fast_connected(discontiguous_partition)
def test_contiguous_with_contiguity_flips_is_true():
contiguous_partition = MockContiguousPartition()
contiguous_partition.flips = contiguous_partition.test_flips
assert contiguous(contiguous_partition)
assert single_flip_contiguous(contiguous_partition)
assert fast_connected(contiguous_partition)
def test_discontiguous_with_single_flip_contiguous_flips_is_false(
discontiguous_partition):
discontiguous_partition2 = discontiguous_partition.flip(
discontiguous_partition.test_flips)
assert not single_flip_contiguous(discontiguous_partition2)
def test_contiguous_with_contiguity_flips_is_true(contiguous_partition):
contiguous_partition2 = contiguous_partition.merge(
contiguous_partition.test_flips)
assert contiguous(contiguous_partition2)
assert single_flip_contiguous(contiguous_partition2)
assert contiguous_bfs(contiguous_partition2)
