def test_to_hessenberg_some_forbidden(n_eqs, n_vars, seed):
rng = Random(seed)
g, eqs = create_rnd_bipartite(n_eqs, n_vars, seed, rng)
edges = g.edges(eqs)
log('Edges:', edges)
forbidden = set(rng.choice(edges) for _ in range(len(edges)//2) )
log('Forbidden:', list(forbidden))
to_hessenberg_form(g, eqs, forbidden)
def test_weighted_bipart(n_eqs, n_vars, seed):
log('---------------------------------------------------------------------')
bip = raw_rnd_bipartite(n_eqs, n_vars, seed)
assert is_bipartite_node_set(bip, range(n_eqs))
#
rng = Random(seed)
cols_rowwise = [ list(bip[i]) for i in range(n_eqs) ]
vals_rowwise = [ rnd_weights(rng, len(cols)) for cols in cols_rowwise ]
row_weights = [ sum(vals, 0.0) for vals in vals_rowwise ]
#
g, eqs, mapping, _ = to_bipart_w_weights(cols_rowwise, vals_rowwise)
rowp, colp, _, sinks, row_matches, _ = to_hessenberg_form(g, eqs)
#
rowp = [ mapping[r] for r in rowp ]
sinks = [ mapping[r] for r in sinks ]
row_matches = [ mapping[r] for r in row_matches ]
#
log('bip rowp:', rowp)
log('eqs =', n_eqs, ' vars =', n_vars, ' edges =', bip.number_of_edges())
#
check_nonincreasing_envelope(bip, rowp, colp)
check_nondecreasing_row_weights(bip, rowp, colp, row_weights)
log('---------------------------------------------------------------------')
def test_to_hessenberg_all_forbidden_diagonal(n, seed):
rng = Random(seed)
g, eqs = create_diagonal_matrix(n, rng)
rowp = to_hessenberg_form(g, eqs, set(g.edges_iter(eqs)))[0]
assert rowp == sorted(rowp)
def test_to_hessenberg_none_forbidden_diagonal(n, seed):
rng = Random(seed)
g, eqs = create_diagonal_matrix(n, rng)
rowp = to_hessenberg_form(g, eqs)[0]
assert rowp == sorted(rowp)
def test_to_hessenberg_all_forbidden(n_eqs, n_vars, seed):
rng = Random(seed)
g, eqs = create_rnd_bipartite(n_eqs, n_vars, seed, rng)
to_hessenberg_form(g, eqs, set(g.edges_iter(eqs)))
def test_to_hessenberg_none_forbidden(n_eqs, n_vars, seed):
rng = Random(seed)
g, eqs = create_rnd_bipartite(n_eqs, n_vars, seed, rng)
to_hessenberg_form(g, eqs)