Пример #1
0
def get_response_content(fs):
    # read the trees
    T_true, B_true, N_true = FtreeIO.newick_to_TBN(fs.true_tree)
    T_test, B_test, N_test = FtreeIO.newick_to_TBN(fs.test_tree)
    # we are concerned about the names of the leaves of the two trees
    true_leaves = Ftree.T_to_leaves(T_true)
    test_leaves = Ftree.T_to_leaves(T_test)
    true_leaf_to_n = dict((v, N_true[v]) for v in true_leaves)
    test_leaf_to_n = dict((v, N_test[v]) for v in test_leaves)
    # check that all leaves are named
    if len(true_leaves) != len(true_leaf_to_n):
        raise ValueError(
                'all leaves in the leaf MDS tree should be named')
    if len(test_leaves) != len(test_leaf_to_n):
        raise ValueError(
                'all leaves in the harmonic extension tree should be named')
    # check that within each tree all leaves are uniquely named
    if len(set(true_leaf_to_n.values())) != len(true_leaves):
        raise ValueError(
                'all leaf names in the leaf MDS tree should be unique')
    if len(set(test_leaf_to_n.values())) != len(test_leaves):
        raise ValueError(
                'all leaf names in the harmonic extension tree '
                'should be unique')
    # check that the leaf name sets are the same
    if set(true_leaf_to_n.values()) != set(test_leaf_to_n.values()):
        raise ValueError(
                'the two trees should have corresponding leaf names')
    # invert the leaf name maps
    true_n_to_leaf = dict((n, v) for v, n in true_leaf_to_n.items())
    test_n_to_leaf = dict((n, v) for v, n in test_leaf_to_n.items())
    # get correspondingly ordered leaf sequences
    leaf_names = true_leaf_to_n.values()
    true_leaves_reordered = [true_n_to_leaf[n] for n in leaf_names]
    test_leaves_reordered = [test_n_to_leaf[n] for n in leaf_names]
    # get the Schur complement matrix for the leaves
    L_schur_true = Ftree.TB_to_L_schur(T_true, B_true, true_leaves_reordered)
    # get the MDS points
    w, V = scipy.linalg.eigh(L_schur_true, eigvals=(1, 2))
    X = np.dot(V, np.diag(np.reciprocal(np.sqrt(w))))
    # get the linear operator that defines the harmonic extension
    test_internal = Ftree.T_to_internal_vertices(T_test)
    L22 = Ftree.TB_to_L_block(T_test, B_test,
            test_internal, test_internal)
    L21 = Ftree.TB_to_L_block(T_test, B_test,
            test_internal, test_leaves_reordered)
    M = -np.dot(np.linalg.pinv(L22), L21)
    # get the harmonic extension
    X_extension = np.dot(M, X)
    X_extended = np.vstack([X, X_extension])
    # draw the image
    v_to_index = Ftree.invseq(test_leaves_reordered + test_internal)
    physical_size = (640, 480)
    ext = Form.g_imageformat_to_ext[fs.imageformat]
    return get_animation_frame(ext, physical_size, fs.scale,
            v_to_index, T_test, X_extended)
Пример #2
0
def get_response_content(fs):
    """
    @param fs: a FieldStorage object containing the cgi arguments
    @return: the response
    """
    # get a properly formatted newick tree with branch lengths
    T, B, N = FtreeIO.newick_to_TBN(fs.tree)
    # get the vertex valuations
    reflect = False
    all_valuations = TB_to_harmonic_valuations(T, B, reflect)
    fiedler_valuations = all_valuations[1]
    # do the layout
    v_to_location = FtreeAux.equal_daylight_layout(T, B, 3)
    # get the vertex list and the initial vertex locations
    vertices = Ftree.T_to_leaves(T) + Ftree.T_to_internal_vertices(T)
    X_in = np.array([tuple(v_to_location[v]) for v in vertices])
    # fit the tree to the physical size
    physical_size = (fs.width, fs.height)
    theta = layout.get_best_angle(X_in, physical_size)
    X = layout.rotate_2d_centroid(X_in, theta)
    sz = layout.get_axis_aligned_size(X)
    sf = layout.get_scaling_factor(sz, physical_size)
    X *= sf
    # get the map from id to location for the final tree layout
    v_to_location = dict((v, tuple(r)) for v, r in zip(vertices, X))
    # draw the image
    context = TikzContext()
    draw_plain_branches_ftree(T, B, context, v_to_location)
    draw_ticks_ftree(T, B, context, fiedler_valuations, v_to_location)
    draw_labels_ftree(T, N, context, v_to_location)
    context.finish()
    # get the response
    tikzpicture = context.get_text()
    return tikz.get_response(tikzpicture, fs.tikzformat)
Пример #3
0
def get_response_content(fs):
    """
    @param fs: a FieldStorage object containing the cgi arguments
    @return: the response
    """
    # get a properly formatted newick tree with branch lengths
    T, B, N = FtreeIO.newick_to_TBN(fs.tree)
    # get the vertex valuations
    all_valuations = TB_to_harmonic_valuations(T, B)
    valuations = all_valuations[fs.first_index:]
    nfigures = (fs.last_index - fs.first_index) + 1
    # do the layout
    if fs.equal_arc_layout:
        v_to_location = FtreeAux.equal_arc_layout(T, B)
    elif fs.equal_daylight_layout:
        v_to_location = FtreeAux.equal_daylight_layout(T, B, 3)
    # draw the image
    physical_size = (fs.width, fs.height)
    tikzpicture = DrawEigenLacing.get_forest_image_ftree(
            T, B, N, v_to_location,
            physical_size, valuations, nfigures, fs.inner_margin,
            fs.reflect_trees, fs.show_vertex_labels, fs.show_subfigure_labels)
    packages = []
    preamble = '\\usetikzlibrary{snakes}'
    return tikz.get_figure_response(
            tikzpicture, fs.tikzformat, g_figure_caption, g_figure_label,
            packages, preamble)
Пример #4
0
def get_response_content(fs):
    """
    @param fs: a FieldStorage object containing the cgi arguments
    @return: the response
    """
    # get a properly formatted newick tree with branch lengths
    T, B, N = FtreeIO.newick_to_TBN(fs.tree)
    # get the vertex valuations
    reflect = False
    all_valuations = TB_to_harmonic_valuations(T, B, reflect)
    fiedler_valuations = all_valuations[1]
    # do the layout
    v_to_location = FtreeAux.equal_daylight_layout(T, B, 3)
    # get the vertex list and the initial vertex locations
    vertices = Ftree.T_to_leaves(T) + Ftree.T_to_internal_vertices(T)
    X_in = np.array([tuple(v_to_location[v]) for v in vertices])
    # fit the tree to the physical size
    physical_size = (fs.width, fs.height)
    theta = layout.get_best_angle(X_in, physical_size)
    X = layout.rotate_2d_centroid(X_in, theta)
    sz = layout.get_axis_aligned_size(X)
    sf = layout.get_scaling_factor(sz, physical_size)
    X *= sf
    # get the map from id to location for the final tree layout
    v_to_location = dict((v, tuple(r)) for v, r in zip(vertices, X))
    # draw the image
    context = TikzContext()
    draw_plain_branches_ftree(T, B, context, v_to_location)
    draw_ticks_ftree(T, B, context, fiedler_valuations, v_to_location)
    draw_labels_ftree(T, N, context, v_to_location)
    context.finish()
    # get the response
    tikzpicture = context.get_text()
    return tikz.get_response(tikzpicture, fs.tikzformat)
Пример #5
0
def get_tikz_lines(newick, eigenvector_index, yaw, pitch):
    """
    @param eigenvector_index: 1 is Fiedler
    """
    tree = Newick.parse(newick, SpatialTree.SpatialTree) 
    # change the node names and get the new tree string
    for node in tree.preorder():
        node.name = 'n' + str(id(node))
    newick = NewickIO.get_newick_string(tree)
    # do the layout
    layout = FastDaylightLayout.StraightBranchLayout() 
    layout.do_layout(tree) 
    tree.fit((g_xy_scale, g_xy_scale))
    name_to_location = dict((
        x.name, tree._layout_to_display(x.location)) for x in tree.preorder())
    T, B, N = FtreeIO.newick_to_TBN(newick)
    # get some vertices
    leaves = Ftree.T_to_leaves(T)
    internal = Ftree.T_to_internal_vertices(T)
    vertices = leaves + internal
    # get the locations
    v_to_location = dict((v, name_to_location[N[v]]) for v in vertices)
    # get the valuations
    w, V = Ftree.TB_to_harmonic_extension(T, B, leaves, internal)
    index_to_val = V[:, eigenvector_index-1]
    v_to_val = dict(
            (vertices[i], g_z_scale*val) for i, val in enumerate(index_to_val))
    # get the coordinates
    v_to_xyz = get_v_to_xyz(yaw, v_to_location, v_to_val)
    # add intersection vertices
    add_intersection_vertices(T, B, v_to_xyz)
    intersection_vertices = sorted(v for v in v_to_xyz if v not in vertices)
    # get lines of the tikz file
    return xyz_to_tikz_lines(T, B, pitch, v_to_xyz,
            leaves, internal, intersection_vertices)
Пример #6
0
def get_tikz_lines(newick, eigenvector_index, yaw, pitch):
    """
    @param eigenvector_index: 1 is Fiedler
    """
    tree = Newick.parse(newick, SpatialTree.SpatialTree)
    # change the node names and get the new tree string
    for node in tree.preorder():
        node.name = 'n' + str(id(node))
    newick = NewickIO.get_newick_string(tree)
    # do the layout
    layout = FastDaylightLayout.StraightBranchLayout()
    layout.do_layout(tree)
    tree.fit((g_xy_scale, g_xy_scale))
    name_to_location = dict(
        (x.name, tree._layout_to_display(x.location)) for x in tree.preorder())
    T, B, N = FtreeIO.newick_to_TBN(newick)
    # get some vertices
    leaves = Ftree.T_to_leaves(T)
    internal = Ftree.T_to_internal_vertices(T)
    vertices = leaves + internal
    # get the locations
    v_to_location = dict((v, name_to_location[N[v]]) for v in vertices)
    # get the valuations
    w, V = Ftree.TB_to_harmonic_extension(T, B, leaves, internal)
    index_to_val = V[:, eigenvector_index - 1]
    v_to_val = dict(
        (vertices[i], g_z_scale * val) for i, val in enumerate(index_to_val))
    # get the coordinates
    v_to_xyz = get_v_to_xyz(yaw, v_to_location, v_to_val)
    # add intersection vertices
    add_intersection_vertices(T, B, v_to_xyz)
    intersection_vertices = sorted(v for v in v_to_xyz if v not in vertices)
    # get lines of the tikz file
    return xyz_to_tikz_lines(T, B, pitch, v_to_xyz, leaves, internal,
                             intersection_vertices)
Пример #7
0
def get_response_content(fs):
    # read the trees
    T_true, B_true, N_true = FtreeIO.newick_to_TBN(fs.true_tree)
    T_test, B_test, N_test = FtreeIO.newick_to_TBN(fs.test_tree)
    # we are concerned about the names of the leaves of the two trees
    true_leaves = Ftree.T_to_leaves(T_true)
    test_leaves = Ftree.T_to_leaves(T_test)
    true_leaf_to_n = dict((v, N_true[v]) for v in true_leaves)
    test_leaf_to_n = dict((v, N_test[v]) for v in test_leaves)
    # check that all leaves are named
    if len(true_leaves) != len(true_leaf_to_n):
        raise ValueError("all leaves in the leaf MDS tree should be named")
    if len(test_leaves) != len(test_leaf_to_n):
        raise ValueError("all leaves in the harmonic extension tree should be named")
    # check that within each tree all leaves are uniquely named
    if len(set(true_leaf_to_n.values())) != len(true_leaves):
        raise ValueError("all leaf names in the leaf MDS tree should be unique")
    if len(set(test_leaf_to_n.values())) != len(test_leaves):
        raise ValueError("all leaf names in the harmonic extension tree " "should be unique")
    # check that the leaf name sets are the same
    if set(true_leaf_to_n.values()) != set(test_leaf_to_n.values()):
        raise ValueError("the two trees should have corresponding leaf names")
    # invert the leaf name maps
    true_n_to_leaf = dict((n, v) for v, n in true_leaf_to_n.items())
    test_n_to_leaf = dict((n, v) for v, n in test_leaf_to_n.items())
    # get correspondingly ordered leaf sequences
    leaf_names = true_leaf_to_n.values()
    true_leaves_reordered = [true_n_to_leaf[n] for n in leaf_names]
    test_leaves_reordered = [test_n_to_leaf[n] for n in leaf_names]
    # get the Schur complement matrix for the leaves
    L_schur_true = Ftree.TB_to_L_schur(T_true, B_true, true_leaves_reordered)
    # get the MDS points
    w, V = scipy.linalg.eigh(L_schur_true, eigvals=(1, 2))
    X = np.dot(V, np.diag(np.reciprocal(np.sqrt(w))))
    # get the linear operator that defines the harmonic extension
    test_internal = Ftree.T_to_internal_vertices(T_test)
    L22 = Ftree.TB_to_L_block(T_test, B_test, test_internal, test_internal)
    L21 = Ftree.TB_to_L_block(T_test, B_test, test_internal, test_leaves_reordered)
    M = -np.dot(np.linalg.pinv(L22), L21)
    # get the harmonic extension
    X_extension = np.dot(M, X)
    X_extended = np.vstack([X, X_extension])
    # draw the image
    v_to_index = Ftree.invseq(test_leaves_reordered + test_internal)
    physical_size = (640, 480)
    ext = Form.g_imageformat_to_ext[fs.imageformat]
    return get_animation_frame(ext, physical_size, fs.scale, v_to_index, T_test, X_extended)
Пример #8
0
 def __init__(self):
     self.tree_string = Newick.daylight_example_tree 
     T, B, N = FtreeIO.newick_to_TBN(self.tree_string)
     self.T = T
     self.B = B
     self.v_to_name = N
     self.v_to_point = self._get_v_to_point()
     self.v_to_layout_point = self._get_v_to_layout_point()
     self.shape = self.get_shape()
Пример #9
0
 def __init__(self):
     self.tree_string = Newick.daylight_example_tree
     T, B, N = FtreeIO.newick_to_TBN(self.tree_string)
     self.T = T
     self.B = B
     self.v_to_name = N
     self.v_to_point = self._get_v_to_point()
     self.v_to_layout_point = self._get_v_to_layout_point()
     self.shape = self.get_shape()
Пример #10
0
def get_response_content(fs):
    # read the tree
    T, B, N = FtreeIO.newick_to_TBN(fs.tree)
    leaves = Ftree.T_to_leaves(T)
    internal = Ftree.T_to_internal_vertices(T)
    # get the distinguished vertex of articulation
    r = get_unique_vertex(N, fs.vertex)
    if r not in internal:
        raise ValueError(
                'the distinguished vertex should have degree at least two')
    # Partition the leaves with respect to the given root.
    # Each set of leaves will eventually define a connected component.
    R = Ftree.T_to_R_specific(T, r)
    v_to_sinks = Ftree.R_to_v_to_sinks(R)
    # break some edges
    R_pruned = set(R)
    neighbors = Ftree.T_to_v_to_neighbors(T)[r]
    for adj in neighbors:
        R_pruned.remove((r, adj))
    T_pruned = Ftree.R_to_T(R_pruned)
    # get the leaf partition
    ordered_leaves = []
    leaf_lists = []
    for adj in neighbors:
        R_subtree = Ftree.T_to_R_specific(T_pruned, adj)
        C = sorted(b for a, b in R_subtree if b not in v_to_sinks)
        ordered_leaves.extend(C)
        leaf_lists.append(C)
    # define the vertices to keep and those to remove
    keepers = ordered_leaves + [r]
    # get the schur complement
    L_schur = Ftree.TB_to_L_schur(T, B, keepers)
    # get principal submatrices of the schur complement
    principal_matrices = []
    accum = 0
    for component_leaves in leaf_lists:
        n = len(component_leaves)
        M = L_schur[accum:accum+n, accum:accum+n]
        principal_matrices.append(M)
        accum += n
    # write the report
    out = StringIO()
    print >> out, 'algebraic connectivity:'
    print >> out, get_algebraic_connectivity(T, B, leaves)
    print >> out
    print >> out
    print >> out, 'perron values:'
    print >> out
    for M, leaf_list in zip(principal_matrices, leaf_lists):
        value = scipy.linalg.eigh(M, eigvals_only=True)[0]
        name_list = [N[v] for v in leaf_list]
        print >> out, name_list
        print >> out, value
        print >> out
    return out.getvalue()
Пример #11
0
def get_response_content(fs):
    # read the tree
    T, B, N = FtreeIO.newick_to_TBN(fs.tree)
    leaves = Ftree.T_to_leaves(T)
    internal = Ftree.T_to_internal_vertices(T)
    # get the valuations with harmonic extensions
    w, V = Ftree.TB_to_harmonic_extension(T, B, leaves, internal)
    # get the Fiedler valuations with harmonic extensions
    h = V[:, 0]
    # check for vertices with small valuations
    eps = 1e-8
    if any(abs(x) < x for x in h):
        raise ValueError('the tree has no clear harmonic Fiedler point')
    # find the edge contining the harmonic Fiedler point
    v_to_val = dict((v, h[i]) for i, v in enumerate(leaves + internal))
    d_edges = [(a, b) for a, b in T if v_to_val[a] * v_to_val[b] < 0]
    if len(d_edges) != 1:
        raise ValueError('expected the point to fall clearly on a single edge')
    d_edge = d_edges[0]
    a, b = d_edge
    # find the proportion along the directed edge
    t = v_to_val[a] / (v_to_val[a] - v_to_val[b])
    # find the distance from the new root to each endpoint vertices
    u_edge = frozenset(d_edge)
    d = B[u_edge]
    da = t * d
    db = (1 - t) * d
    # create the new tree
    r = max(Ftree.T_to_order(T)) + 1
    N[r] = fs.root_name
    T.remove(u_edge)
    del B[u_edge]
    ea = frozenset((r, a))
    eb = frozenset((r, b))
    T.add(ea)
    T.add(eb)
    B[ea] = da
    B[eb] = db
    # add a new leaf with arbitrary branch length
    leaf = r + 1
    N[leaf] = fs.leaf_name
    u_edge = frozenset((r, leaf))
    T.add(u_edge)
    B[u_edge] = 1.0
    # get the best branch length to cause eigenvalue multiplicity
    blen = scipy.optimize.golden(get_gap, (T, B, u_edge),
                                 full_output=False,
                                 tol=1e-12)
    B[u_edge] = blen
    # return the string representation of the new tree
    R = Ftree.T_to_R_specific(T, r)
    return FtreeIO.RBN_to_newick(R, B, N)
Пример #12
0
def get_response_content(fs):
    # read the ordered leaf names for the distance matrix
    D_names = Util.get_stripped_lines(fs.names.splitlines())
    # read the tree
    T_test, B_test, N_test = FtreeIO.newick_to_TBN(fs.test_tree)
    # we are concerned about the names of the leaves of the two trees
    test_leaves = Ftree.T_to_leaves(T_test)
    test_leaf_to_n = dict((v, N_test[v]) for v in test_leaves)
    # check that all leaves are named
    if len(D_names) != len(fs.D):
        raise HandlingError(
                'the number of ordered leaf names '
                'should be the same as the number of rows '
                'in the distance matrix')
    if len(test_leaves) != len(test_leaf_to_n):
        raise ValueError(
                'all leaves in the harmonic extension tree '
                'should be named')
    # check that leaves are uniquely named
    if len(set(D_names)) != len(D_names):
        raise ValueError(
                'all ordered leaf names in the distance matrix '
                'should be unique')
    # check that the leaf name sets are the same
    if set(D_names) != set(test_leaf_to_n.values()):
        raise ValueError(
                'the set of leaf names on the tree '
                'should be the same as '
                'the set of leaf names for the distance matrix')
    # invert the leaf name map
    test_n_to_leaf = dict((n, v) for v, n in test_leaf_to_n.items())
    # get correspondingly ordered leaf sequences
    test_leaves_reordered = [test_n_to_leaf[n] for n in D_names]
    # get the MDS points
    X = MDS_v4(fs.D)
    # get the linear operator that defines the harmonic extension
    test_internal = Ftree.T_to_internal_vertices(T_test)
    L22 = Ftree.TB_to_L_block(T_test, B_test,
            test_internal, test_internal)
    L21 = Ftree.TB_to_L_block(T_test, B_test,
            test_internal, test_leaves_reordered)
    M = -np.dot(np.linalg.pinv(L22), L21)
    # get the harmonic extension
    X_extension = np.dot(M, X)
    X_extended = np.vstack([X, X_extension])
    # draw the image
    v_to_index = Ftree.invseq(test_leaves_reordered + test_internal)
    physical_size = (640, 480)
    ext = Form.g_imageformat_to_ext[fs.imageformat]
    return get_animation_frame(ext, physical_size, fs.scale,
            v_to_index, T_test, X_extended)
Пример #13
0
def get_response_content(fs):
    # read the tree
    T, B, N = FtreeIO.newick_to_TBN(fs.tree)
    leaves = Ftree.T_to_leaves(T)
    internal = Ftree.T_to_internal_vertices(T)
    # get the valuations with harmonic extensions
    w, V = Ftree.TB_to_harmonic_extension(T, B, leaves, internal)
    # get the Fiedler valuations with harmonic extensions
    h = V[:,0]
    # check for vertices with small valuations
    eps = 1e-8
    if any(abs(x)<x for x in h):
        raise ValueError('the tree has no clear harmonic Fiedler point')
    # find the edge contining the harmonic Fiedler point
    v_to_val = dict((v, h[i]) for i, v in enumerate(leaves + internal))
    d_edges = [(a,b) for a, b in T if v_to_val[a]*v_to_val[b] < 0]
    if len(d_edges) != 1:
        raise ValueError('expected the point to fall clearly on a single edge')
    d_edge = d_edges[0]
    a, b = d_edge
    # find the proportion along the directed edge
    t = v_to_val[a] / (v_to_val[a] - v_to_val[b])
    # find the distance from the new root to each endpoint vertices
    u_edge = frozenset(d_edge)
    d = B[u_edge]
    da = t*d
    db = (1-t)*d
    # create the new tree
    r = max(Ftree.T_to_order(T)) + 1
    N[r] = fs.root_name
    T.remove(u_edge)
    del B[u_edge]
    ea = frozenset((r, a))
    eb = frozenset((r, b))
    T.add(ea)
    T.add(eb)
    B[ea] = da
    B[eb] = db
    # add a new leaf with arbitrary branch length
    leaf = r + 1
    N[leaf] = fs.leaf_name
    u_edge = frozenset((r, leaf))
    T.add(u_edge)
    B[u_edge] = 1.0
    # get the best branch length to cause eigenvalue multiplicity
    blen = scipy.optimize.golden(
            get_gap, (T, B, u_edge), full_output=False, tol=1e-12)
    B[u_edge] = blen
    # return the string representation of the new tree
    R = Ftree.T_to_R_specific(T, r)
    return FtreeIO.RBN_to_newick(R, B, N)
Пример #14
0
def get_response_content(fs):
    """
    @param fs: a FieldStorage object containing the cgi arguments
    @return: the response
    """
    T, B, N = FtreeIO.newick_to_TBN(fs.tree_string)
    # sanitize taxon labels if requested
    if fs.sanitization:
        for v in N:
            N[v] = latexutil.sanitize(N[v])
    # scale branch lengths so the diameter is 1
    diameter = np.max(Ftree.TB_to_D(T, B, Ftree.T_to_leaves(T)))
    # scale the branch lengths
    for u_edge in T:
        B[u_edge] /= diameter
    info = FigureInfo(T, B, N, fs.label_mode)
    # get the texts
    tikz_bodies = [
            info.get_tikz_tree(fs.tree_layout),
            info.get_tikz_MDS_full(),
            info.get_tikz_MDS_partial(),
            info.get_tikz_MDS_harmonic(),
            ]
    tikz_pictures = []
    for b in tikz_bodies:
        tikzpicture = tikz.get_picture(b, 'auto', scale=fs.scaling_factor)
        tikz_pictures.append(tikzpicture)
    figure_body = '\n'.join([
        '\\subfloat[]{',
        tikz_pictures[0],
        '}',
        '\\subfloat[]{',
        tikz_pictures[1],
        '} \\\\',
        '\\subfloat[]{',
        tikz_pictures[2],
        '}',
        '\\subfloat[]{',
        tikz_pictures[3],
        '}',
        ])
    packages = ['tikz', 'subfig']
    preamble = ''
    figure_caption = None
    figure_label = None
    return latexutil.get_centered_figure_response(
            figure_body, fs.latexformat, figure_caption, figure_label,
            packages, preamble)
Пример #15
0
def get_response_content(fs):
    # read the tree
    T, B, N = FtreeIO.newick_to_TBN(fs.tree)
    leaves = Ftree.T_to_leaves(T)
    internal = Ftree.T_to_internal_vertices(T)
    # root arbitrarily
    R = Ftree.T_to_R_canonical(T)
    # init some sampling parameters
    nsamples = 1000
    npillars = 10
    # Init the accumulators.
    # Accumulate the sum of squares of differences
    # and the sum of differences.
    # The differences are from the leaf mean.
    dsum = defaultdict(float)
    dsumsq = defaultdict(float)
    # Repeatedly sample using Brownian motion on the tree.
    for i in range(nsamples):
        # Sample using Brownian motion at vertices on the tree.
        v_to_sample = sample_brownian_motion(R, B)
        # Compute the mean at the leaves.
        mu = sum(v_to_sample[v] for v in leaves) / len(leaves)
        # Accumulate difference moments at vertices of the tree.
        for v, x in v_to_sample.items():
            dsum[(v, -1, -1)] += x-mu
            dsumsq[(v, -1, -1)] += (x-mu)**2
        # Sample using Brownian bridge on edges.
        for d_edge in R:
            u_edge = frozenset(d_edge)
            va, vb = d_edge
            a = v_to_sample[va]
            b = v_to_sample[vb]
            samples = bridge(a, b, npillars, B[u_edge])
            for i, x in enumerate(samples):
                dsum[(va, vb, i)] += x-mu
                dsumsq[(va, vb, i)] += (x-mu)**2
    quad = min((val, va, vb, i) for (va, vb, i), val in dsumsq.items())
    val, va, vb, i = quad
    # write the report
    out = StringIO()
    if i < 0:
        print >> out, 'min sum of squares was at vertex', N[va]
    else:
        print >> out, 'min sum of squares was at edge',
        print >> out, N[va], '--[', i, ']-->', N[vb]
    print >> out
    print >> out, 'the min sum of squares value was', val
    return out.getvalue()
Пример #16
0
def get_response_content(fs):
    # read the tree
    T, B, N = FtreeIO.newick_to_TBN(fs.tree)
    leaves = Ftree.T_to_leaves(T)
    internal = Ftree.T_to_internal_vertices(T)
    # root arbitrarily
    R = Ftree.T_to_R_canonical(T)
    # init some sampling parameters
    nsamples = 1000
    npillars = 10
    # Init the accumulators.
    # Accumulate the sum of squares of differences
    # and the sum of differences.
    # The differences are from the leaf mean.
    dsum = defaultdict(float)
    dsumsq = defaultdict(float)
    # Repeatedly sample using Brownian motion on the tree.
    for i in range(nsamples):
        # Sample using Brownian motion at vertices on the tree.
        v_to_sample = sample_brownian_motion(R, B)
        # Compute the mean at the leaves.
        mu = sum(v_to_sample[v] for v in leaves) / len(leaves)
        # Accumulate difference moments at vertices of the tree.
        for v, x in v_to_sample.items():
            dsum[(v, -1, -1)] += x - mu
            dsumsq[(v, -1, -1)] += (x - mu)**2
        # Sample using Brownian bridge on edges.
        for d_edge in R:
            u_edge = frozenset(d_edge)
            va, vb = d_edge
            a = v_to_sample[va]
            b = v_to_sample[vb]
            samples = bridge(a, b, npillars, B[u_edge])
            for i, x in enumerate(samples):
                dsum[(va, vb, i)] += x - mu
                dsumsq[(va, vb, i)] += (x - mu)**2
    quad = min((val, va, vb, i) for (va, vb, i), val in dsumsq.items())
    val, va, vb, i = quad
    # write the report
    out = StringIO()
    if i < 0:
        print >> out, 'min sum of squares was at vertex', N[va]
    else:
        print >> out, 'min sum of squares was at edge',
        print >> out, N[va], '--[', i, ']-->', N[vb]
    print >> out
    print >> out, 'the min sum of squares value was', val
    return out.getvalue()
Пример #17
0
def get_response_content(fs):
    # read the ordered leaf names for the distance matrix
    D_names = Util.get_stripped_lines(fs.names.splitlines())
    # read the tree
    T_test, B_test, N_test = FtreeIO.newick_to_TBN(fs.test_tree)
    # we are concerned about the names of the leaves of the two trees
    test_leaves = Ftree.T_to_leaves(T_test)
    test_leaf_to_n = dict((v, N_test[v]) for v in test_leaves)
    # check that all leaves are named
    if len(D_names) != len(fs.D):
        raise HandlingError('the number of ordered leaf names '
                            'should be the same as the number of rows '
                            'in the distance matrix')
    if len(test_leaves) != len(test_leaf_to_n):
        raise ValueError('all leaves in the harmonic extension tree '
                         'should be named')
    # check that leaves are uniquely named
    if len(set(D_names)) != len(D_names):
        raise ValueError('all ordered leaf names in the distance matrix '
                         'should be unique')
    # check that the leaf name sets are the same
    if set(D_names) != set(test_leaf_to_n.values()):
        raise ValueError('the set of leaf names on the tree '
                         'should be the same as '
                         'the set of leaf names for the distance matrix')
    # invert the leaf name map
    test_n_to_leaf = dict((n, v) for v, n in test_leaf_to_n.items())
    # get correspondingly ordered leaf sequences
    test_leaves_reordered = [test_n_to_leaf[n] for n in D_names]
    # get the MDS points
    X = MDS_v4(fs.D)
    # get the linear operator that defines the harmonic extension
    test_internal = Ftree.T_to_internal_vertices(T_test)
    L22 = Ftree.TB_to_L_block(T_test, B_test, test_internal, test_internal)
    L21 = Ftree.TB_to_L_block(T_test, B_test, test_internal,
                              test_leaves_reordered)
    M = -np.dot(np.linalg.pinv(L22), L21)
    # get the harmonic extension
    X_extension = np.dot(M, X)
    X_extended = np.vstack([X, X_extension])
    # draw the image
    v_to_index = Ftree.invseq(test_leaves_reordered + test_internal)
    physical_size = (640, 480)
    ext = Form.g_imageformat_to_ext[fs.imageformat]
    return get_animation_frame(ext, physical_size, fs.scale, v_to_index,
                               T_test, X_extended)
Пример #18
0
def get_tikz_lines(fs):
    """
    @param fs: user input
    @return: a sequence of tikz lines
    """
    newick = fs.tree_string
    # hardcode the axes
    x_index = 0
    y_index = 1
    # get the tree with ordered vertices
    #T, B = FtreeIO.newick_to_TB(newick, int)
    T, B, N = FtreeIO.newick_to_TBN(newick)
    leaves = Ftree.T_to_leaves(T)
    internal = Ftree.T_to_internal_vertices(T)
    vertices = leaves + internal
    # get the harmonic extension points
    w, v = Ftree.TB_to_harmonic_extension(T, B, leaves, internal)
    # possibly scale using the eigenvalues
    if fs.scale_using_eigenvalues:
        X_full = np.dot(v, np.diag(np.reciprocal(np.sqrt(w))))
    else:
        X_full = v
    # scale using the scaling factor
    X_full *= fs.scaling_factor
    # get the first two axes
    X = np.vstack([X_full[:,x_index], X_full[:,y_index]]).T
    # get the tikz lines
    axis_lines = [
            '% draw the axes',
            '\\node (axisleft) at (0, -5) {};',
            '\\node (axisright) at (0, 5) {};',
            '\\node (axistop) at (5, 0) {};',
            '\\node (axisbottom) at (-5, 0) {};',
            '\\path (axisleft) edge[draw,color=lightgray] node {} (axisright);',
            '\\path (axistop) edge[draw,color=lightgray] node {} (axisbottom);']
    node_lines = []
    for v, (x,y) in zip(vertices, X.tolist()):
        line = get_vertex_line(v, x, y)
        node_lines.append(line)
    edge_lines = []
    for va, vb in T:
        line = get_edge_line(va, vb)
        edge_lines.append(line)
    return axis_lines + node_lines + edge_lines
Пример #19
0
def get_tikz_lines(newick):
    tree = Newick.parse(newick, SpatialTree.SpatialTree)
    # layout = FastDaylightLayout.StraightBranchLayout()
    # layout.set_iteration_count(20)
    # layout.do_layout(tree)
    EqualArcLayout.do_layout(tree)
    tree.fit((2.0, 2.0))
    name_to_location = dict((x.name, tree._layout_to_display(x.location)) for x in tree.preorder())
    T, B, N = FtreeIO.newick_to_TBN(newick)
    node_lines = []
    for v, depth in Ftree.T_to_v_to_centrality(T).items():
        x, y = name_to_location[N[v]]
        line = get_vertex_line(v, depth, x, y)
        node_lines.append(line)
    edge_lines = []
    for va, vb in T:
        line = get_edge_line(va, vb)
        edge_lines.append(line)
    return node_lines + edge_lines
Пример #20
0
def get_tikz_lines(newick):
    tree = Newick.parse(newick, SpatialTree.SpatialTree)
    #layout = FastDaylightLayout.StraightBranchLayout()
    #layout.set_iteration_count(20)
    #layout.do_layout(tree)
    EqualArcLayout.do_layout(tree)
    tree.fit((2.0, 2.0))
    name_to_location = dict(
        (x.name, tree._layout_to_display(x.location)) for x in tree.preorder())
    T, B, N = FtreeIO.newick_to_TBN(newick)
    node_lines = []
    for v, depth in Ftree.T_to_v_to_centrality(T).items():
        x, y = name_to_location[N[v]]
        line = get_vertex_line(v, depth, x, y)
        node_lines.append(line)
    edge_lines = []
    for va, vb in T:
        line = get_edge_line(va, vb)
        edge_lines.append(line)
    return node_lines + edge_lines
Пример #21
0
def get_response_content(fs):
    # read the tree
    T, B, N = FtreeIO.newick_to_TBN(fs.tree)
    leaves = Ftree.T_to_leaves(T)
    internal = Ftree.T_to_internal_vertices(T)
    # get the valuations with harmonic extensions
    w, V = Ftree.TB_to_harmonic_extension(T, B, leaves, internal)
    # get the Fiedler valuations with harmonic extensions
    h = V[:,0]
    # check for vertices with small valuations
    eps = 1e-8
    if any(abs(x)<x for x in h):
        raise ValueError('the tree has no clear harmonic Fiedler point')
    # find the edge contining the harmonic Fiedler point
    v_to_val = dict((v, h[i]) for i, v in enumerate(leaves + internal))
    d_edges = [(a,b) for a, b in T if v_to_val[a]*v_to_val[b] < 0]
    if len(d_edges) != 1:
        raise ValueError('expected the point to fall clearly on a single edge')
    d_edge = d_edges[0]
    a, b = d_edge
    # find the proportion along the directed edge
    t = v_to_val[a] / (v_to_val[a] - v_to_val[b])
    # find the distance from the new root to each endpoint vertices
    u_edge = frozenset(d_edge)
    d = B[u_edge]
    da = t*d
    db = (1-t)*d
    # create the new tree
    r = max(Ftree.T_to_order(T)) + 1
    T.remove(u_edge)
    del B[u_edge]
    ea = frozenset((r, a))
    eb = frozenset((r, b))
    T.add(ea)
    T.add(eb)
    B[ea] = da
    B[eb] = db
    R = Ftree.T_to_R_specific(T, r)
    # return the string representation of the new tree
    return FtreeIO.RBN_to_newick(R, B, N)
Пример #22
0
def get_response_content(fs):
    # read the tree
    T, B, N = FtreeIO.newick_to_TBN(fs.tree)
    leaves = Ftree.T_to_leaves(T)
    internal = Ftree.T_to_internal_vertices(T)
    # root arbitrarily
    R = Ftree.T_to_R_canonical(T)
    # init some sampling parameters
    npillars = 9
    # init some helper variables
    nleaves = len(leaves)
    r = get_new_vertex(T)
    vertices = internal + [r] + leaves
    combo = np.array([0] * len(internal) + [1] + [-1.0 / nleaves] * nleaves)
    # Map edge position triple to the quadratic form value.
    qform = {}
    for d_edge in R:
        a, b = d_edge
        u_edge = frozenset(d_edge)
        distance = B[u_edge]
        for i in range(npillars):
            # get the proportion of the distance along the branch
            t = (i + 1) / float(npillars + 1)
            T_new, B_new = add_vertex(T, B, d_edge, r, t)
            # create the new centered covariance matrix
            L = Ftree.TB_to_L_principal(T_new, B_new, vertices)
            S = np.linalg.pinv(L)
            qform[(a, b, t * distance)] = quadratic_form(S, combo)
            #shortcombo = np.array([1] + [-1.0/nleaves]*nleaves)
            #shortvert = [r] + leaves
            #L_schur = Ftree.TB_to_L_schur(T_new, B_new, shortvert)
            #S = np.linalg.pinv(L_schur)
            #qform[(a, b, t*distance)] = quadratic_form(S, shortcombo)
    wat = sorted((val, va, vb, d) for (va, vb, d), val in qform.items())
    # write the report
    out = StringIO()
    for val, va, vb, d in wat:
        print >> out, N[va], '--[', d, ']-->', N[vb], ':', val
        print >> out
    return out.getvalue()
Пример #23
0
def get_response_content(fs):
    # read the tree
    T, B, N = FtreeIO.newick_to_TBN(fs.tree)
    leaves = Ftree.T_to_leaves(T)
    internal = Ftree.T_to_internal_vertices(T)
    # get the valuations with harmonic extensions
    w, V = Ftree.TB_to_harmonic_extension(T, B, leaves, internal)
    # get the Fiedler valuations with harmonic extensions
    h = V[:, 0]
    # check for vertices with small valuations
    eps = 1e-8
    if any(abs(x) < x for x in h):
        raise ValueError('the tree has no clear harmonic Fiedler point')
    # find the edge contining the harmonic Fiedler point
    v_to_val = dict((v, h[i]) for i, v in enumerate(leaves + internal))
    d_edges = [(a, b) for a, b in T if v_to_val[a] * v_to_val[b] < 0]
    if len(d_edges) != 1:
        raise ValueError('expected the point to fall clearly on a single edge')
    d_edge = d_edges[0]
    a, b = d_edge
    # find the proportion along the directed edge
    t = v_to_val[a] / (v_to_val[a] - v_to_val[b])
    # find the distance from the new root to each endpoint vertices
    u_edge = frozenset(d_edge)
    d = B[u_edge]
    da = t * d
    db = (1 - t) * d
    # create the new tree
    r = max(Ftree.T_to_order(T)) + 1
    T.remove(u_edge)
    del B[u_edge]
    ea = frozenset((r, a))
    eb = frozenset((r, b))
    T.add(ea)
    T.add(eb)
    B[ea] = da
    B[eb] = db
    R = Ftree.T_to_R_specific(T, r)
    # return the string representation of the new tree
    return FtreeIO.RBN_to_newick(R, B, N)
Пример #24
0
def get_response_content(fs):
    """
    @param fs: a FieldStorage object containing the cgi arguments
    @return: the response
    """
    T, B, N = FtreeIO.newick_to_TBN(fs.tree_string)
    leaves = Ftree.T_to_leaves(T)
    internal = Ftree.T_to_internal_vertices(T)
    vertices = leaves + internal
    # compute the 2D MDS of the full tree
    MDS_full = get_full_distance_MDS(T, B, vertices)
    # compute the harmonic extension of 2D MDS of the leaves
    MDS_harmonic = get_harmonically_extended_MDS(T, B, leaves, internal)
    # get the Fiedler MDS leaf partition for full 2D MDS
    v_to_value = dict(zip(vertices, MDS_full[:,0]))
    neg_leaves = frozenset([v for v in leaves if v_to_value[v] < 0])
    pos_leaves = frozenset([v for v in leaves if v_to_value[v] >= 0])
    full_mds_fiedler_partition = [neg_leaves, pos_leaves]
    # get the Fiedler MDS leaf partition for harmonic 2D MDS
    v_to_value = dict(zip(vertices, MDS_harmonic[:,0]))
    neg_leaves = frozenset([v for v in leaves if v_to_value[v] < 0])
    pos_leaves = frozenset([v for v in leaves if v_to_value[v] >= 0])
    harmonic_mds_fiedler_partition = [neg_leaves, pos_leaves]
    # get the Fiedler plus one MDS leaf partition for full 2D MDS
    v_to_value = dict(zip(vertices, MDS_full[:,1]))
    full_mds_fp1_partition = get_fp1_ordered_leaf_partition(T, v_to_value)
    # get the Fiedler plus one MDS leaf partition for harmonic 2D MDS
    v_to_value = dict(zip(vertices, MDS_harmonic[:,1]))
    harmonic_mds_fp1_partition = get_fp1_ordered_leaf_partition(T, v_to_value)
    # write the output
    out = StringIO()
    print >> out, get_2D_report(
            N, set(leaves), 'Full distance 2D MDS',
            full_mds_fiedler_partition, full_mds_fp1_partition)
    print >> out
    print >> out, get_2D_report(
            N, set(leaves), 'Harmonically extended 2D MDS',
            harmonic_mds_fiedler_partition, harmonic_mds_fp1_partition)
    return out.getvalue()
Пример #25
0
def get_tikz_lines(fs):
    """
    @param fs: user input
    @return: a sequence of tikz lines
    """
    newick = fs.tree_string
    T, B, N = FtreeIO.newick_to_TBN(newick)
    # get the tree with ordered vertices
    leaves = Ftree.T_to_leaves(T)
    internal = Ftree.T_to_internal_vertices(T)
    vertices = leaves + internal
    # get the tikz lines
    axis_lines = [
            '% draw the axes',
            '\\node (axisleft) at (0, -6) {};',
            '\\node (axisright) at (0, 6) {};',
            '\\node (axistop) at (6, 0) {};',
            '\\node (axisbottom) at (-6, 0) {};',
            '\\path (axisleft) edge[draw,color=lightgray] node {} (axisright);',
            '\\path (axistop) edge[draw,color=lightgray] node {} (axisbottom);']
    # set up the figure info
    info = FigureInfo(T, B)
    # define the points caused by MDS of distance matrices with errors
    point_lines = []
    for v_to_point in info.gen_point_samples(fs.nsamples, fs.stddev):
        for x, y in v_to_point.values():
            line = get_point_line(fs.scaling_factor*x, fs.scaling_factor*y)
            point_lines.append(line)
    # get the tikz corresponding to the tree drawn inside the MDS plot
    node_lines = []
    for v, (x,y) in info.get_v_to_point().items():
        line = get_vertex_line(v, fs.scaling_factor*x, fs.scaling_factor*y)
        node_lines.append(line)
    edge_lines = []
    for va, vb in T:
        line = get_edge_line(va, vb)
        edge_lines.append(line)
    # return the tikz
    return axis_lines + point_lines + node_lines + edge_lines
Пример #26
0
def get_response_content(fs):
    """
    @param fs: a FieldStorage object containing the cgi arguments
    @return: the response
    """
    T, B, N = FtreeIO.newick_to_TBN(fs.tree_string)
    leaves = Ftree.T_to_leaves(T)
    internal = Ftree.T_to_internal_vertices(T)
    vertices = leaves + internal
    # compute the 2D MDS of the full tree
    MDS_full = get_full_distance_MDS(T, B, vertices)
    # compute the harmonic extension of 2D MDS of the leaves
    MDS_harmonic = get_harmonically_extended_MDS(T, B, leaves, internal)
    # get the Fiedler MDS leaf partition for full 2D MDS
    v_to_value = dict(zip(vertices, MDS_full[:, 0]))
    neg_leaves = frozenset([v for v in leaves if v_to_value[v] < 0])
    pos_leaves = frozenset([v for v in leaves if v_to_value[v] >= 0])
    full_mds_fiedler_partition = [neg_leaves, pos_leaves]
    # get the Fiedler MDS leaf partition for harmonic 2D MDS
    v_to_value = dict(zip(vertices, MDS_harmonic[:, 0]))
    neg_leaves = frozenset([v for v in leaves if v_to_value[v] < 0])
    pos_leaves = frozenset([v for v in leaves if v_to_value[v] >= 0])
    harmonic_mds_fiedler_partition = [neg_leaves, pos_leaves]
    # get the Fiedler plus one MDS leaf partition for full 2D MDS
    v_to_value = dict(zip(vertices, MDS_full[:, 1]))
    full_mds_fp1_partition = get_fp1_ordered_leaf_partition(T, v_to_value)
    # get the Fiedler plus one MDS leaf partition for harmonic 2D MDS
    v_to_value = dict(zip(vertices, MDS_harmonic[:, 1]))
    harmonic_mds_fp1_partition = get_fp1_ordered_leaf_partition(T, v_to_value)
    # write the output
    out = StringIO()
    print >> out, get_2D_report(N, set(leaves), 'Full distance 2D MDS',
                                full_mds_fiedler_partition,
                                full_mds_fp1_partition)
    print >> out
    print >> out, get_2D_report(N, set(leaves), 'Harmonically extended 2D MDS',
                                harmonic_mds_fiedler_partition,
                                harmonic_mds_fp1_partition)
    return out.getvalue()
Пример #27
0
def get_tikz_lines(fs):
    """
    @param fs: user input
    @return: a sequence of tikz lines
    """
    newick = fs.tree_string
    T, B, N = FtreeIO.newick_to_TBN(newick)
    # get the tree with ordered vertices
    leaves = Ftree.T_to_leaves(T)
    internal = Ftree.T_to_internal_vertices(T)
    vertices = leaves + internal
    # get the tikz lines
    axis_lines = [
        '% draw the axes', '\\node (axisleft) at (0, -6) {};',
        '\\node (axisright) at (0, 6) {};', '\\node (axistop) at (6, 0) {};',
        '\\node (axisbottom) at (-6, 0) {};',
        '\\path (axisleft) edge[draw,color=lightgray] node {} (axisright);',
        '\\path (axistop) edge[draw,color=lightgray] node {} (axisbottom);'
    ]
    # set up the figure info
    info = FigureInfo(T, B)
    # define the points caused by MDS of distance matrices with errors
    point_lines = []
    for v_to_point in info.gen_point_samples(fs.nsamples, fs.stddev):
        for x, y in v_to_point.values():
            line = get_point_line(fs.scaling_factor * x, fs.scaling_factor * y)
            point_lines.append(line)
    # get the tikz corresponding to the tree drawn inside the MDS plot
    node_lines = []
    for v, (x, y) in info.get_v_to_point().items():
        line = get_vertex_line(v, fs.scaling_factor * x, fs.scaling_factor * y)
        node_lines.append(line)
    edge_lines = []
    for va, vb in T:
        line = get_edge_line(va, vb)
        edge_lines.append(line)
    # return the tikz
    return axis_lines + point_lines + node_lines + edge_lines
Пример #28
0
def get_response_content(fs):
    # read the user input
    weight_delta_mu = fs.weight_delta_mu
    T, B, N = FtreeIO.newick_to_TBN(fs.newick)
    # summarize the tree
    leaves = Ftree.T_to_leaves(T)
    internal = Ftree.T_to_internal_vertices(T)
    vertices = leaves + internal
    nleaves = len(leaves)
    # define the fully connected schur complement graph as a Laplacian matrix
    # init the tree reconstruction state
    v_to_name = {}
    for v in leaves:
        name = N.get(v, None)
        if name is None:
            name = 'P' + chr(ord('a') + v)
        v_to_name[v] = name
    v_to_svs = dict((v, set([0])) for v in leaves)
    sv_to_vs = {0 : set(leaves)}
    # define edge weights (used only for spectral split strategy)
    G = Ftree.TB_to_L_schur(T, B, leaves)
    # add some random amount to each edge weight
    for i in range(nleaves):
        for j in range(i):
            rate = 1 / fs.weight_delta_mu
            x = random.expovariate(rate)
            G[i, j] -= x
            G[j, i] -= x
            G[i, i] += x
            G[j, j] += x
    edge_to_weight = {}
    for index_pair in itertools.combinations(range(nleaves), 2):
        i, j = index_pair
        leaf_pair = (leaves[i], leaves[j])
        edge_to_weight[frozenset(leaf_pair)] = -G[index_pair]
    # define pairwise distances (used only for nj split strategy)
    D = Ftree.TB_to_D(T, B, leaves)
    edge_to_distance = {}
    for index_pair in itertools.combinations(range(nleaves), 2):
        i, j = index_pair
        leaf_pair = (leaves[i], leaves[j])
        edge_to_distance[frozenset(leaf_pair)] = D[index_pair]
    # pairs like (-(number of vertices in supervertex sv), supervertex sv)
    active_svs = set([0])
    # initialize the sources of unique vertex and supervertex identifiers
    v_gen = itertools.count(max(leaves)+1)
    sv_gen = itertools.count(1)
    # write the output
    out = StringIO()
    print >> out, '<html>'
    print >> out, '<body>'
    for count_pos in itertools.count(1):
        # add the graph rendering before the decomposition at this stage
        if fs.nj_split:
            edge_to_branch_weight = {}
            for k, v in edge_to_distance.items():
                edge_to_branch_weight[k] = 1 / v
        elif fs.spectral_split:
            edge_to_branch_weight = edge_to_weight
        print >> out, '<div>'
        if fs.vis_star:
            print >> out, nhj.get_svg_star_components(
                    active_svs, sv_to_vs, v_to_name, v_to_svs,
                    edge_to_branch_weight)
        elif fs.vis_complete:
            print >> out, nhj.get_svg(
                    active_svs, sv_to_vs, v_to_name, v_to_svs,
                    edge_to_branch_weight)
        print >> out, '</div>'
        # update the splits
        next_active_svs = set()
        # svs can be decomposed independently in arbitrary order
        alpha_index_gen = itertools.count()
        for sv in active_svs:
            nstates = len(sv_to_vs[sv])
            if nstates > 2:
                v_new = next(v_gen)
                sv_new_a = next(sv_gen)
                sv_new_b = next(sv_gen)
                alpha_index = next(alpha_index_gen)
                alpha = chr(ord('a') + alpha_index)
                v_to_name[v_new] = 'R%s%s' % (count_pos, alpha)
                next_active_svs.add(sv_new_a)
                next_active_svs.add(sv_new_b)
                if fs.spectral_split:
                    if len(sv_to_vs[sv]) == 3:
                        sv_new_c = next(sv_gen)
                        nhj.delta_wye_transform(
                                sv, v_to_svs, sv_to_vs, edge_to_weight,
                                v_new, sv_new_a, sv_new_b, sv_new_c)
                        next_active_svs.add(sv_new_c)
                    else:
                        nhj.harmonic_split_transform(
                                sv, v_to_svs, sv_to_vs, edge_to_weight,
                                v_new, sv_new_a, sv_new_b)
                elif fs.nj_split:
                    sv_new_big = next(sv_gen)
                    nhj.nj_split_transform(
                            sv, v_to_svs, sv_to_vs, edge_to_distance,
                            v_new, sv_new_big, sv_new_a, sv_new_b)
                    next_active_svs.add(sv_new_big)
            elif nstates == 2:
                next_active_svs.add(sv)
            else:
                raise ValueError('supervertex has too few vertices')
        # if the set of active svs has not changed then we are done
        if active_svs == next_active_svs:
            break
        else:
            active_svs = next_active_svs
    print >> out, '</html>'
    print >> out, '</body>'
    return out.getvalue()
Пример #29
0
def get_response_content(fs):
    T, B, N = FtreeIO.newick_to_TBN(fs.tree)
    leaves = Ftree.T_to_leaves(T)
    L_schur = Ftree.TB_to_L_schur(T, B, leaves)
    mu = scipy.linalg.eigh(L_schur, eigvals_only=True)[1]
    return str(mu)
Пример #30
0
def get_response_content(fs):
    T, B, N = FtreeIO.newick_to_TBN(fs.tree)
    leaves = Ftree.T_to_leaves(T)
    L_schur = Ftree.TB_to_L_schur(T, B, leaves)
    mu = scipy.linalg.eigh(L_schur, eigvals_only=True)[1]
    return str(mu)
Пример #31
0
def get_response_content(fs):
    # read the user input
    weight_delta_mu = fs.weight_delta_mu
    T, B, N = FtreeIO.newick_to_TBN(fs.newick)
    # summarize the tree
    leaves = Ftree.T_to_leaves(T)
    internal = Ftree.T_to_internal_vertices(T)
    vertices = leaves + internal
    nleaves = len(leaves)
    # define the fully connected schur complement graph as a Laplacian matrix
    # init the tree reconstruction state
    v_to_name = {}
    for v in leaves:
        name = N.get(v, None)
        if name is None:
            name = 'P' + chr(ord('a') + v)
        v_to_name[v] = name
    v_to_svs = dict((v, set([0])) for v in leaves)
    sv_to_vs = {0: set(leaves)}
    # define edge weights (used only for spectral split strategy)
    G = Ftree.TB_to_L_schur(T, B, leaves)
    # add some random amount to each edge weight
    for i in range(nleaves):
        for j in range(i):
            rate = 1 / fs.weight_delta_mu
            x = random.expovariate(rate)
            G[i, j] -= x
            G[j, i] -= x
            G[i, i] += x
            G[j, j] += x
    edge_to_weight = {}
    for index_pair in itertools.combinations(range(nleaves), 2):
        i, j = index_pair
        leaf_pair = (leaves[i], leaves[j])
        edge_to_weight[frozenset(leaf_pair)] = -G[index_pair]
    # define pairwise distances (used only for nj split strategy)
    D = Ftree.TB_to_D(T, B, leaves)
    edge_to_distance = {}
    for index_pair in itertools.combinations(range(nleaves), 2):
        i, j = index_pair
        leaf_pair = (leaves[i], leaves[j])
        edge_to_distance[frozenset(leaf_pair)] = D[index_pair]
    # pairs like (-(number of vertices in supervertex sv), supervertex sv)
    active_svs = set([0])
    # initialize the sources of unique vertex and supervertex identifiers
    v_gen = itertools.count(max(leaves) + 1)
    sv_gen = itertools.count(1)
    # write the output
    out = StringIO()
    print >> out, '<html>'
    print >> out, '<body>'
    for count_pos in itertools.count(1):
        # add the graph rendering before the decomposition at this stage
        if fs.nj_split:
            edge_to_branch_weight = {}
            for k, v in edge_to_distance.items():
                edge_to_branch_weight[k] = 1 / v
        elif fs.spectral_split:
            edge_to_branch_weight = edge_to_weight
        print >> out, '<div>'
        if fs.vis_star:
            print >> out, nhj.get_svg_star_components(active_svs, sv_to_vs,
                                                      v_to_name, v_to_svs,
                                                      edge_to_branch_weight)
        elif fs.vis_complete:
            print >> out, nhj.get_svg(active_svs, sv_to_vs, v_to_name,
                                      v_to_svs, edge_to_branch_weight)
        print >> out, '</div>'
        # update the splits
        next_active_svs = set()
        # svs can be decomposed independently in arbitrary order
        alpha_index_gen = itertools.count()
        for sv in active_svs:
            nstates = len(sv_to_vs[sv])
            if nstates > 2:
                v_new = next(v_gen)
                sv_new_a = next(sv_gen)
                sv_new_b = next(sv_gen)
                alpha_index = next(alpha_index_gen)
                alpha = chr(ord('a') + alpha_index)
                v_to_name[v_new] = 'R%s%s' % (count_pos, alpha)
                next_active_svs.add(sv_new_a)
                next_active_svs.add(sv_new_b)
                if fs.spectral_split:
                    if len(sv_to_vs[sv]) == 3:
                        sv_new_c = next(sv_gen)
                        nhj.delta_wye_transform(sv, v_to_svs, sv_to_vs,
                                                edge_to_weight, v_new,
                                                sv_new_a, sv_new_b, sv_new_c)
                        next_active_svs.add(sv_new_c)
                    else:
                        nhj.harmonic_split_transform(sv, v_to_svs, sv_to_vs,
                                                     edge_to_weight, v_new,
                                                     sv_new_a, sv_new_b)
                elif fs.nj_split:
                    sv_new_big = next(sv_gen)
                    nhj.nj_split_transform(sv, v_to_svs, sv_to_vs,
                                           edge_to_distance, v_new, sv_new_big,
                                           sv_new_a, sv_new_b)
                    next_active_svs.add(sv_new_big)
            elif nstates == 2:
                next_active_svs.add(sv)
            else:
                raise ValueError('supervertex has too few vertices')
        # if the set of active svs has not changed then we are done
        if active_svs == next_active_svs:
            break
        else:
            active_svs = next_active_svs
    print >> out, '</html>'
    print >> out, '</body>'
    return out.getvalue()