def T_to_newick(T):
"""
Get a newick string from an unweighted topology.
@param T: topology
@return: newick string
"""
return R_to_newick(Ftree.T_to_R_canonical(T))
def equal_arc_layout(T, B):
"""
@param T: tree topology
@param B: branch lengths
@return: a map from vertex to location
"""
# arbitrarily root the tree
R = Ftree.T_to_R_canonical(T)
r = Ftree.R_to_root(R)
# map vertices to subtree tip count
v_to_sinks = Ftree.R_to_v_to_sinks(R)
v_to_count = {}
for v in Ftree.R_to_postorder(R):
sinks = v_to_sinks.get(v, [])
if sinks:
v_to_count[v] = sum(v_to_count[sink] for sink in sinks)
else:
v_to_count[v] = 1
# create the equal arc angles
v_to_theta = {}
_force_equal_arcs(
v_to_sinks, v_to_count, v_to_theta,
r, -math.pi, math.pi)
# convert angles to coordinates
v_to_source = Ftree.R_to_v_to_source(R)
v_to_location = {}
_update_locations(
R, B,
v_to_source, v_to_sinks, v_to_theta, v_to_location,
r, (0, 0), 0)
return v_to_location
def equal_daylight_layout(T, B, iteration_count):
"""
@param T: topology
@param B: branch lengths
"""
R = Ftree.T_to_R_canonical(T)
r = Ftree.R_to_root(R)
# create the initial equal arc layout
v_to_location = equal_arc_layout(T, B)
# use sax-like events to create a parallel tree in the C extension
v_to_sinks = Ftree.R_to_v_to_sinks(R)
v_to_dtree_id = {}
dtree = day.Day()
count = _build_dtree(
dtree, r, v_to_sinks, v_to_location, v_to_dtree_id, 0)
# repeatedly reroot and equalize
v_to_neighbors = Ftree.T_to_v_to_neighbors(T)
for i in range(iteration_count):
for v in Ftree.T_to_inside_out(T):
neighbor_count = len(v_to_neighbors[v])
if neighbor_count > 2:
dtree.select_node(v_to_dtree_id[v])
dtree.reroot()
dtree.equalize()
# extract the x and y coordinates from the dtree
v_to_location = {}
for v, dtree_id in v_to_dtree_id.items():
dtree.select_node(dtree_id)
x = dtree.get_x()
y = dtree.get_y()
v_to_location[v] = (x, y)
return v_to_location
def TB_to_newick(T, B):
"""
Get a newick string from a weighted topology.
@param T: topology
@param B: branch lengths
@return: newick string
"""
return RB_to_newick(Ftree.T_to_R_canonical(T), B)
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()
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()
