def analyze_matrix(M, block_size):
"""
Get results for g(f(M)) and f(g(M)).
Each block is square with block_size rows.
@param M: a matrix
@param block_size: the number of rows in blocks of the partitioned matrix
@return: a string of results
"""
# define the response
out = StringIO()
# get the new matrix using the first composition of functions
M_11 = SchurAlgebra.mmerge(M, set(range(2 * block_size)))
M_12 = SchurAlgebra.mschur(
M_11, set(1 + block_size + k for k in range(block_size)))
print >> out, M_12
# get the new matrix using the second composition of functions
M_21 = SchurAlgebra.mschur(
M, set(3 * block_size + k for k in range(block_size)))
M_22 = SchurAlgebra.mmerge(M_21, set(range(2 * block_size)))
print >> out, M_22
if np.allclose(M_12, M_22):
print >> out, 'the matrices are similar'
else:
print >> out, 'the matrices are different'
return out.getvalue().strip()
def analyze_matrix(M, block_size):
"""
Get results for g(f(M)) and f(g(M)).
Each block is square with block_size rows.
@param M: a matrix
@param block_size: the number of rows in blocks of the partitioned matrix
@return: a string of results
"""
# define the response
out = StringIO()
# get the new matrix using the first composition of functions
M_11 = SchurAlgebra.mmerge(M, set(range(2*block_size)))
M_12 = SchurAlgebra.mschur(
M_11, set(1 + block_size + k for k in range(block_size)))
print >> out, M_12
# get the new matrix using the second composition of functions
M_21 = SchurAlgebra.mschur(
M, set(3*block_size + k for k in range(block_size)))
M_22 = SchurAlgebra.mmerge(M_21, set(range(2*block_size)))
print >> out, M_22
if np.allclose(M_12, M_22):
print >> out, 'the matrices are similar'
else:
print >> out, 'the matrices are different'
return out.getvalue().strip()
def get_response_content(fs):
# build the newick tree from the string
tree = NewickIO.parse(fs.tree_string, FelTree.NewickTree)
nvertices = len(list(tree.preorder()))
nleaves = len(list(tree.gen_tips()))
# get ordered ids with the leaves first
ordered_ids = get_ordered_ids(tree)
# get the adjacency matrix and the augmented adjacency matrix
A = np.array(tree.get_affinity_matrix(ordered_ids))
A_aug = get_augmented_adjacency(A, nleaves, fs.ndups, fs.strength)
# get the laplacian matrices
L = Euclid.adjacency_to_laplacian(A)
L_aug = Euclid.adjacency_to_laplacian(A_aug)
# get the schur complement
R = SchurAlgebra.mschur(L, set(range(nleaves, nvertices)))
R_pinv = np.linalg.pinv(R)
vals, vecs = EigUtil.eigh(R_pinv)
# get the scaled Fiedler vector for the Schur complement
w, v = EigUtil.principal_eigh(R_pinv)
fiedler = v * math.sqrt(w)
# get the eigendecomposition of the augmented Laplacian
L_aug_pinv = np.linalg.pinv(L_aug)
vals_aug, vecs_aug = EigUtil.eigh(L_aug_pinv)
# get the scaled Fiedler vector for the augmented Laplacian
w_aug, v_aug = EigUtil.principal_eigh(L_aug_pinv)
fiedler_aug = v_aug * math.sqrt(w_aug)
# report the results
np.set_printoptions(linewidth=300)
out = StringIO()
print >> out, 'Laplacian matrix:'
print >> out, L
print >> out
print >> out, 'Schur complement of Laplacian matrix:'
print >> out, R
print >> out
print >> out, 'scaled Fiedler vector of Schur complement:'
print >> out, fiedler
print >> out
print >> out, 'eigenvalues of pinv of Schur complement:'
print >> out, vals
print >> out
print >> out, 'corresponding eigenvectors of pinv of Schur complement:'
print >> out, np.array(vecs).T
print >> out
print >> out
print >> out, 'augmented Laplacian matrix:'
print >> out, L_aug
print >> out
print >> out, 'scaled Fiedler vector of augmented Laplacian:'
print >> out, fiedler_aug
print >> out
print >> out, 'eigenvalues of pinv of augmented Laplacian:'
print >> out, vals_aug
print >> out
print >> out, 'rows are eigenvectors of pinv of augmented Laplacian:'
print >> out, np.array(vecs_aug)
return out.getvalue()
def get_response_content(fs):
# build the newick tree from the string
tree = NewickIO.parse(fs.tree_string, FelTree.NewickTree)
nvertices = len(list(tree.preorder()))
nleaves = len(list(tree.gen_tips()))
# get ordered ids with the leaves first
ordered_ids = get_ordered_ids(tree)
# get the adjacency matrix and the augmented adjacency matrix
A = np.array(tree.get_affinity_matrix(ordered_ids))
A_aug = get_augmented_adjacency(A, nleaves, fs.ndups, fs.strength)
# get the laplacian matrices
L = Euclid.adjacency_to_laplacian(A)
L_aug = Euclid.adjacency_to_laplacian(A_aug)
# get the schur complement
R = SchurAlgebra.mschur(L, set(range(nleaves, nvertices)))
R_pinv = np.linalg.pinv(R)
vals, vecs = EigUtil.eigh(R_pinv)
# get the scaled Fiedler vector for the Schur complement
w, v = EigUtil.principal_eigh(R_pinv)
fiedler = v * math.sqrt(w)
# get the eigendecomposition of the augmented Laplacian
L_aug_pinv = np.linalg.pinv(L_aug)
vals_aug, vecs_aug = EigUtil.eigh(L_aug_pinv)
# get the scaled Fiedler vector for the augmented Laplacian
w_aug, v_aug = EigUtil.principal_eigh(L_aug_pinv)
fiedler_aug = v_aug * math.sqrt(w_aug)
# report the results
np.set_printoptions(linewidth=300)
out = StringIO()
print >> out, 'Laplacian matrix:'
print >> out, L
print >> out
print >> out, 'Schur complement of Laplacian matrix:'
print >> out, R
print >> out
print >> out, 'scaled Fiedler vector of Schur complement:'
print >> out, fiedler
print >> out
print >> out, 'eigenvalues of pinv of Schur complement:'
print >> out, vals
print >> out
print >> out, 'corresponding eigenvectors of pinv of Schur complement:'
print >> out, np.array(vecs).T
print >> out
print >> out
print >> out, 'augmented Laplacian matrix:'
print >> out, L_aug
print >> out
print >> out, 'scaled Fiedler vector of augmented Laplacian:'
print >> out, fiedler_aug
print >> out
print >> out, 'eigenvalues of pinv of augmented Laplacian:'
print >> out, vals_aug
print >> out
print >> out, 'rows are eigenvectors of pinv of augmented Laplacian:'
print >> out, np.array(vecs_aug)
return out.getvalue()
def get_splits(initial_distance_matrix,
split_function,
update_function,
on_label_split=None):
"""
This is the most external of the functions in this module.
Get the set of splits implied by the tree that would be reconstructed.
@param initial_distance_matrix: a distance matrix
@param split_function: takes a distance matrix and returns an index split
@param update_function: takes a distance matrix and an index subset and returns a distance matrix
@param on_label_split: notifies the caller of the label split induced by an index split
@return: a set of splits
"""
n = len(initial_distance_matrix)
# keep a stack of (label_set_per_vertex, distance_matrix) pairs
initial_state = ([set([i]) for i in range(n)], initial_distance_matrix)
stack = [initial_state]
# process the stack in a depth first manner, building the split set
label_split_set = set()
while stack:
label_sets, D = stack.pop()
# if the matrix is small then we are done
if len(D) < 4:
continue
# split the indices using the specified function
try:
index_split = split_function(D)
# convert the index split to a label split
label_split = index_split_to_label_split(index_split, label_sets)
# notify the caller if a callback is requested
if on_label_split:
on_label_split(label_split)
# add the split to the master set of label splits
label_split_set.add(label_split)
# for large matrices create the new label sets and the new conformant distance matrices
a, b = index_split
for index_selection, index_complement in ((a, b), (b, a)):
if len(index_complement) > 2:
next_label_sets = SchurAlgebra.vmerge(
label_sets, index_selection)
next_D = update_function(D, index_selection)
next_state = (next_label_sets, next_D)
stack.append(next_state)
except DegenerateSplitException, e:
# we cannot recover from a degenerate split unless there are more than four indices
if len(D) <= 4:
continue
# with more than four indices we can fall back to partial splits
index_set = set([e.index])
# get the next label sets
next_label_sets = SchurAlgebra.vdelete(label_sets, index_set)
# get the next conformant distance matrix by schur complementing out the offending index
L = Euclid.edm_to_laplacian(D)
L_small = SchurAlgebra.mschur(L, index_set)
next_D = Euclid.laplacian_to_edm(L_small)
next_state = (next_label_sets, next_D)
stack.append(next_state)
def get_response_content(fs):
# build the newick tree from the string
tree = NewickIO.parse(fs.tree_string, FelTree.NewickTree)
nvertices = len(list(tree.preorder()))
nleaves = len(list(tree.gen_tips()))
# get ordered ids with the leaves first
ordered_ids = get_ordered_ids(tree)
# get the distance matrix and the augmented distance matrix
D = np.array(tree.get_partial_distance_matrix(ordered_ids))
D_aug = get_augmented_distance(D, nleaves, fs.ndups)
# get the laplacian matrix
L = Euclid.edm_to_laplacian(D)
# get the schur complement
R = SchurAlgebra.mschur(L, set(range(nleaves, nvertices)))
R_pinv = np.linalg.pinv(R)
vals, vecs = EigUtil.eigh(R_pinv)
# get the scaled Fiedler vector for the Schur complement
w, v = EigUtil.principal_eigh(R_pinv)
fiedler = v * math.sqrt(w)
# get the eigendecomposition of the centered augmented distance matrix
L_aug_pinv = Euclid.edm_to_dccov(D_aug)
vals_aug, vecs_aug = EigUtil.eigh(L_aug_pinv)
# get the scaled Fiedler vector for the augmented Laplacian
w_aug, v_aug = EigUtil.principal_eigh(L_aug_pinv)
fiedler_aug = v_aug * math.sqrt(w_aug)
# report the results
np.set_printoptions(linewidth=300, threshold=10000)
out = StringIO()
print >> out, "Laplacian matrix:"
print >> out, L
print >> out
print >> out, "Schur complement of Laplacian matrix:"
print >> out, R
print >> out
print >> out, "scaled Fiedler vector of Schur complement:"
print >> out, fiedler
print >> out
print >> out, "eigenvalues of pinv of Schur complement:"
print >> out, vals
print >> out
print >> out, "corresponding eigenvectors of pinv of Schur complement:"
print >> out, np.array(vecs).T
print >> out
print >> out
print >> out, "augmented distance matrix:"
print >> out, D_aug
print >> out
print >> out, "scaled Fiedler vector of augmented Laplacian limit:"
print >> out, fiedler_aug
print >> out
print >> out, "eigenvalues of pinv of augmented Laplacian limit:"
print >> out, vals_aug
print >> out
print >> out, "rows are eigenvectors of pinv of augmented Laplacian limit:"
print >> out, np.array(vecs_aug)
return out.getvalue()
def get_response_content(fs):
# build the newick tree from the string
tree = NewickIO.parse(fs.tree_string, FelTree.NewickTree)
nvertices = len(list(tree.preorder()))
nleaves = len(list(tree.gen_tips()))
# get ordered ids with the leaves first
ordered_ids = get_ordered_ids(tree)
# get the adjacency matrix and the augmented adjacency matrix
A = np.array(tree.get_affinity_matrix(ordered_ids))
A_aug = get_augmented_adjacency(A, nleaves, fs.strength)
# get the laplacian matrices
L = Euclid.adjacency_to_laplacian(A)
L_aug = Euclid.adjacency_to_laplacian(A_aug)
# get the schur complements
R = SchurAlgebra.mschur(L, set(range(nleaves, nvertices)))
R_aug = SchurAlgebra.mschur(L_aug, set(range(nleaves, nvertices)))
# get the scaled Fiedler vectors
w, v = EigUtil.principal_eigh(np.linalg.pinv(R))
fiedler = v * math.sqrt(w)
w_aug, v_aug = EigUtil.principal_eigh(np.linalg.pinv(R_aug))
fiedler_aug = v_aug * math.sqrt(w_aug)
# report the results
np.set_printoptions(linewidth=200)
out = StringIO()
print >> out, 'Laplacian matrix:'
print >> out, L
print >> out
print >> out, 'Schur complement of Laplacian matrix:'
print >> out, R
print >> out
print >> out, 'scaled Fiedler vector:'
print >> out, fiedler
print >> out
print >> out, 'augmented Laplacian matrix:'
print >> out, L_aug
print >> out
print >> out, 'Schur complement of augmented Laplacian matrix:'
print >> out, R_aug
print >> out
print >> out, 'scaled Fiedler vector of augmented matrix:'
print >> out, fiedler_aug
print >> out
return out.getvalue()
def get_response_content(fs):
# build the newick tree from the string
tree = NewickIO.parse(fs.tree_string, FelTree.NewickTree)
nvertices = len(list(tree.preorder()))
nleaves = len(list(tree.gen_tips()))
# get ordered ids with the leaves first
ordered_ids = get_ordered_ids(tree)
# get the adjacency matrix and the augmented adjacency matrix
A = np.array(tree.get_affinity_matrix(ordered_ids))
A_aug = get_augmented_adjacency(A, nleaves, fs.strength)
# get the laplacian matrices
L = Euclid.adjacency_to_laplacian(A)
L_aug = Euclid.adjacency_to_laplacian(A_aug)
# get the schur complements
R = SchurAlgebra.mschur(L, set(range(nleaves, nvertices)))
R_aug = SchurAlgebra.mschur(L_aug, set(range(nleaves, nvertices)))
# get the scaled Fiedler vectors
w, v = EigUtil.principal_eigh(np.linalg.pinv(R))
fiedler = v * math.sqrt(w)
w_aug, v_aug = EigUtil.principal_eigh(np.linalg.pinv(R_aug))
fiedler_aug = v_aug * math.sqrt(w_aug)
# report the results
np.set_printoptions(linewidth=200)
out = StringIO()
print >> out, "Laplacian matrix:"
print >> out, L
print >> out
print >> out, "Schur complement of Laplacian matrix:"
print >> out, R
print >> out
print >> out, "scaled Fiedler vector:"
print >> out, fiedler
print >> out
print >> out, "augmented Laplacian matrix:"
print >> out, L_aug
print >> out
print >> out, "Schur complement of augmented Laplacian matrix:"
print >> out, R_aug
print >> out
print >> out, "scaled Fiedler vector of augmented matrix:"
print >> out, fiedler_aug
print >> out
return out.getvalue()
def get_response_content(fs):
# read the matrix
L = fs.laplacian
# read the ordered labels
ordered_labels = Util.get_stripped_lines(StringIO(fs.labels))
if not ordered_labels:
raise HandlingError('no ordered taxa were provided')
if len(ordered_labels) != len(set(ordered_labels)):
raise HandlingError('the ordered taxa should be unique')
# get the label selection and its complement
min_selected_labels = 2
min_unselected_labels = 1
selected_labels = set(Util.get_stripped_lines(StringIO(fs.selection)))
if len(selected_labels) < min_selected_labels:
raise HandlingError(
'at least %d taxa should be selected to be grouped' %
min_selected_labels)
# get the set of labels in the complement
unselected_labels = set(ordered_labels) - selected_labels
if len(unselected_labels) < min_unselected_labels:
raise HandlingError(
'at least %d taxa should remain outside the selected group' %
min_unselected_labels)
# assert that no bizarre labels were selected
weird_labels = selected_labels - set(ordered_labels)
if weird_labels:
raise HandlingError('some selected taxa are invalid: ' +
str(weird_labels))
# assert that the size of the distance matrix is compatible with the number of ordered labels
if len(L) != len(ordered_labels):
raise HandlingError(
'the number of listed taxa does not match the number of rows in the distance matrix'
)
# get the set of selected indices and its complement
n = len(L)
index_selection = set(i for i, label in enumerate(ordered_labels)
if label in selected_labels)
index_complement = set(range(n)) - index_selection
# begin the response
out = StringIO()
# calculate the new laplacian matrix
L_small = SchurAlgebra.mschur(L, index_selection)
D_small = Euclid.laplacian_to_edm(L_small)
# print the matrices and the labels of its rows
print >> out, 'new laplacian matrix:'
print >> out, MatrixUtil.m_to_string(L_small)
print >> out
print >> out, 'new distance matrix:'
print >> out, MatrixUtil.m_to_string(D_small)
print >> out
print >> out, 'new taxon labels:'
for index in sorted(index_complement):
print >> out, ordered_labels[index]
# write the response
return out.getvalue()
def get_splits(initial_distance_matrix, split_function, update_function, on_label_split=None):
"""
This is the most external of the functions in this module.
Get the set of splits implied by the tree that would be reconstructed.
@param initial_distance_matrix: a distance matrix
@param split_function: takes a distance matrix and returns an index split
@param update_function: takes a distance matrix and an index subset and returns a distance matrix
@param on_label_split: notifies the caller of the label split induced by an index split
@return: a set of splits
"""
n = len(initial_distance_matrix)
# keep a stack of (label_set_per_vertex, distance_matrix) pairs
initial_state = ([set([i]) for i in range(n)], initial_distance_matrix)
stack = [initial_state]
# process the stack in a depth first manner, building the split set
label_split_set = set()
while stack:
label_sets, D = stack.pop()
# if the matrix is small then we are done
if len(D) < 4:
continue
# split the indices using the specified function
try:
index_split = split_function(D)
# convert the index split to a label split
label_split = index_split_to_label_split(index_split, label_sets)
# notify the caller if a callback is requested
if on_label_split:
on_label_split(label_split)
# add the split to the master set of label splits
label_split_set.add(label_split)
# for large matrices create the new label sets and the new conformant distance matrices
a, b = index_split
for index_selection, index_complement in ((a, b), (b, a)):
if len(index_complement) > 2:
next_label_sets = SchurAlgebra.vmerge(label_sets, index_selection)
next_D = update_function(D, index_selection)
next_state = (next_label_sets, next_D)
stack.append(next_state)
except DegenerateSplitException, e:
# we cannot recover from a degenerate split unless there are more than four indices
if len(D) <= 4:
continue
# with more than four indices we can fall back to partial splits
index_set = set([e.index])
# get the next label sets
next_label_sets = SchurAlgebra.vdelete(label_sets, index_set)
# get the next conformant distance matrix by schur complementing out the offending index
L = Euclid.edm_to_laplacian(D)
L_small = SchurAlgebra.mschur(L, index_set)
next_D = Euclid.laplacian_to_edm(L_small)
next_state = (next_label_sets, next_D)
stack.append(next_state)
def test_commutativity(self):
"""
Schur complementation and merging can be done in either order.
"""
reciprocal_adjacency_big = np.array([
[0, 0, 0, 0, 0, 0, 0, 2, 0, 0],
[0, 0, 0, 0, 0, 0, 2, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 9, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 3, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 2],
[0, 2, 9, 0, 0, 0, 0, 4, 0, 0],
[2, 0, 0, 0, 0, 0, 4, 0, 0, 1],
[0, 0, 0, 1, 3, 0, 0, 0, 0, 7],
[0, 0, 0, 0, 0, 2, 0, 1, 7, 0]], dtype=float)
A_big = self.nonzero_reciprocal(reciprocal_adjacency_big)
L_big = adjacency_to_laplacian(A_big)
# define the pruned branch length
p = 101.0 / 39.0
reciprocal_adjacency_small = np.array([
[0, 0, 0, 0, 0, 2],
[0, 0, 0, 0, 2, 0],
[0, 0, 0, 0, 9, 0],
[0, 0, 0, 0, 0, p],
[0, 2, 9, 0, 0, 4],
[2, 0, 0, p, 4, 0]])
A_small = self.nonzero_reciprocal(reciprocal_adjacency_small)
L_small = adjacency_to_laplacian(A_small)
# get the small matrix in terms of the big matrix by schur complementation followed by merging
reconstructed_small_a = SchurAlgebra.mmerge(SchurAlgebra.mschur(L_big, set([8, 9])), set([3, 4, 5]))
self.assertTrue(np.allclose(L_small, reconstructed_small_a))
# get the small matrix in terms of the big matrix by merging followed by schur complementation
reconstructed_small_b = SchurAlgebra.mschur(SchurAlgebra.mmerge(L_big, set([3, 4, 5])), set([6, 7]))
self.assertTrue(np.allclose(L_small, reconstructed_small_b))
# get the laplacian associated with a 4x4 distance matrix in multiple ways
first_result = SchurAlgebra.mmerge(SchurAlgebra.mschur(L_big, set([6, 7, 8, 9])), set([3, 4, 5]))
second_result = SchurAlgebra.mschur(L_small, set([4, 5]))
self.assertTrue(np.allclose(first_result, second_result))
def get_response_content(fs):
# read the matrix
L = fs.laplacian
# read the ordered labels
ordered_labels = Util.get_stripped_lines(StringIO(fs.labels))
if not ordered_labels:
raise HandlingError('no ordered taxa were provided')
if len(ordered_labels) != len(set(ordered_labels)):
raise HandlingError('the ordered taxa should be unique')
# get the label selection and its complement
min_selected_labels = 2
min_unselected_labels = 1
selected_labels = set(Util.get_stripped_lines(StringIO(fs.selection)))
if len(selected_labels) < min_selected_labels:
raise HandlingError('at least %d taxa should be selected to be grouped' % min_selected_labels)
# get the set of labels in the complement
unselected_labels = set(ordered_labels) - selected_labels
if len(unselected_labels) < min_unselected_labels:
raise HandlingError('at least %d taxa should remain outside the selected group' % min_unselected_labels)
# assert that no bizarre labels were selected
weird_labels = selected_labels - set(ordered_labels)
if weird_labels:
raise HandlingError('some selected taxa are invalid: ' + str(weird_labels))
# assert that the size of the distance matrix is compatible with the number of ordered labels
if len(L) != len(ordered_labels):
raise HandlingError('the number of listed taxa does not match the number of rows in the distance matrix')
# get the set of selected indices and its complement
n = len(L)
index_selection = set(i for i, label in enumerate(ordered_labels) if label in selected_labels)
index_complement = set(range(n)) - index_selection
# begin the response
out = StringIO()
# calculate the new laplacian matrix
L_small = SchurAlgebra.mschur(L, index_selection)
D_small = Euclid.laplacian_to_edm(L_small)
# print the matrices and the labels of its rows
print >> out, 'new laplacian matrix:'
print >> out, MatrixUtil.m_to_string(L_small)
print >> out
print >> out, 'new distance matrix:'
print >> out, MatrixUtil.m_to_string(D_small)
print >> out
print >> out, 'new taxon labels:'
for index in sorted(index_complement):
print >> out, ordered_labels[index]
# write the response
return out.getvalue()
def get_response_content(fs):
# use a default border; actually this is ignored
border_info = BorderInfo(10, 10)
# Collect the image format information.
axis_info = AxisInfo(fs.flip_x, fs.flip_y, fs.show_x, fs.show_y)
# read the points and edges
points, edges = read_points_and_edges(fs.graph_data)
# define edge weights
if fs.weighted:
np_points = [np.array(p) for p in points]
dists = [np.linalg.norm(np_points[j] - np_points[i]) for i, j in edges]
weights = [1.0 / d for d in dists]
else:
weights = [1.0 for e in edges]
# create the full laplacian
L = edges_to_laplacian(edges, weights)
if fs.schur:
# remove internal nodes by schur complementation
index_to_degree = edges_to_node_degrees(edges)
internal_indices = set(i
for i, d in enumerate(index_to_degree) if d > 1)
L_schur = SchurAlgebra.mschur(L, internal_indices)
L_final = L_schur
else:
L_final = L
# define the point colors using the graph Fiedler loadings
G = np.linalg.pinv(L_final)
X = Euclid.dccov_to_points(G)
points = [(p[0], p[1]) for p in X]
xs, ys = zip(*points)
colors = valuations_to_colors(xs)
# draw the image
ext = Form.g_imageformat_to_ext[fs.imageformat]
image_info = ImageInfo(fs.width, fs.height,
fs.black, fs.show_labels,
axis_info, border_info, ext)
return get_image_string(xs, ys, colors, edges, image_info, fs.scale)
