Class: Bio::Tree

Inherits:
Object show all
Defined in:
lib/bio/tree.rb,
lib/bio/db/newick.rb

Overview

This is the class for phylogenetic tree. It stores a phylogenetic tree.

Internally, it is based on Bio::Pathway class. However, users cannot handle Bio::Pathway object directly.

This is alpha version. Incompatible changes may be made frequently.

Defined Under Namespace

Classes: Edge, NoPathError, Node

Constant Summary collapse

DEFAULT_OPTIONS =

default options

{ :indent => '  ' }

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(tree = nil) ⇒ Tree

Creates a new phylogenetic tree. When no arguments are given, it creates a new empty tree. When a Tree object is given, it copies the tree. Note that the new tree shares Node and Edge objects with the given tree.



257
258
259
260
261
262
263
 
# File 'lib/bio/tree.rb', line 257

def initialize(tree = nil)
  # creates an undirected adjacency list graph
  @pathway = Bio::Pathway.new([], true)
  @root = nil
  @options = {}
  self.concat(tree) if tree
end

Instance Attribute Details

#options ⇒ Object

tree options; mainly used for tree output



270
271
272
 
# File 'lib/bio/tree.rb', line 270

def options
  @options
end

#root ⇒ Object

root node of this tree (even if unrooted tree, it is used by some methods)



267
268
269
 
# File 'lib/bio/tree.rb', line 267

def root
  @root
end

Instance Method Details

#add_edge(source, target, edge = Edge.new) ⇒ Object

Adds a new edge to the tree. Returns the newly added edge. If the edge already exists, it is overwritten with new one.



366
367
368
369
 
# File 'lib/bio/tree.rb', line 366

def add_edge(source, target, edge = Edge.new)
  @pathway.append(Bio::Relation.new(source, target, edge))
  edge
end

#add_node(node) ⇒ Object

Adds a node to the tree. Returns self. If the node already exists, it does nothing.



387
388
389
390
 
# File 'lib/bio/tree.rb', line 387

def add_node(node)
  @pathway.graph[node] ||= {}
  self
end

#adjacency_matrix(nodes = nil, default_value = nil, diagonal_value = nil) ⇒ Object

Shows the adjacency matrix representation of the tree. It shows matrix only for given nodes. If nodes is nil or is ommitted, it acts the same as tree.adjacency_matrix(tree.nodes). If a block is given, for each edge, it yields source, target, and edge, and uses the returned value of the block. Without blocks, it uses edge. Returns a matrix object.



758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
 
# File 'lib/bio/tree.rb', line 758

def adjacency_matrix(nodes = nil,
                     default_value = nil,
                     diagonal_value = nil) #:yields: source, target, edge
  nodes ||= self.nodes
  size = nodes.size
  hash = {}
  nodes.each_with_index { |x, i| hash[x] = i }
  # prepares an matrix
  matrix = Array.new(size, nil)
  matrix.collect! { |x| Array.new(size, default_value) }
  (0...size).each { |i| matrix[i][i] = diagonal_value }
  # fills the matrix from each edge
  self.each_edge do |source, target, edge|
    i_source = hash[source]
    i_target = hash[target]
    if i_source and i_target then
      val = block_given? ? (yield source, target, edge) : edge
      matrix[i_source][i_target] = val
      matrix[i_target][i_source] = val
    end
  end
  Matrix.rows(matrix, false)
end

#adjacent_nodes(node) ⇒ Object

Returns an array of adjacent nodes of the given node.



317
318
319
320
 
# File 'lib/bio/tree.rb', line 317

def adjacent_nodes(node)
  h = @pathway.graph[node]
  h ? h.keys : []
end

#ancestors(node, root = nil) ⇒ Object

Gets all ancestral nodes of the node. If root isn’t specified or root is nil, @root is used. Returns an array of Nodes. The result is unspecified for cyclic trees.



693
694
695
696
 
# File 'lib/bio/tree.rb', line 693

def ancestors(node, root = nil)
  root ||= @root
  (self.path(root, node) - [ node ]).reverse
end

#children(node, root = nil) ⇒ Object

Gets the adjacent children nodes of the node. If root isn’t specified or root is nil, @root is used. Returns an array of Nodes. The result is unspecified for cyclic trees.



636
637
638
639
640
641
642
 
# File 'lib/bio/tree.rb', line 636

def children(node, root = nil)
  root ||= @root
  path = self.path(root, node)
  result = self.adjacent_nodes(node)
  result -= path
  result
end

#clear ⇒ Object

Clears all nodes and edges. Returns self. Note that options and root are also cleared.



275
276
277
278
 
# File 'lib/bio/tree.rb', line 275

def clear
  initialize
  self
end

#clear_node(node) ⇒ Object

Removes all edges connected with the node. Returns self. If the node does not exist, raises IndexError.



401
402
403
404
405
406
407
408
409
410
411
412
413
 
# File 'lib/bio/tree.rb', line 401

def clear_node(node)
  unless self.include?(node)
    raise IndexError, 'the node does not exist'
  end
  @pathway.relations.delete_if do |rel|
    rel.node.include?(node)
  end
  @pathway.graph[node].each_key do |k|
    @pathway.graph[k].delete(node)
  end
  @pathway.graph[node].clear
  self
end

#collect_edge! ⇒ Object

Replaces each edge by each block’s return value. Returns self.



505
506
507
508
509
510
511
512
 
# File 'lib/bio/tree.rb', line 505

def collect_edge! #:yields: source, target, edge
  @pathway.relations.each do |rel|
    newedge = yield rel.node[0], rel.node[1], rel.relation
    rel.relation = newedge
    @pathway.append(rel, false)
  end
  self
end

#collect_node! ⇒ Object

Replaces each node by each block’s return value. Returns self.



485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
 
# File 'lib/bio/tree.rb', line 485

def collect_node! #:yields: node
  tr = {}
  self.each_node do |node|
    tr[node] = yield node
  end
  # replaces nodes in @pathway.relations
  @pathway.relations.each do |rel|
    rel.node.collect! { |node| tr[node] }
  end
  # re-generates @pathway from relations
  @pathway.to_list
  # adds orphan nodes
  tr.each_value do |newnode|
    @pathway.graph[newnode] ||= {}
  end
  self
end

#concat(other) ⇒ Object

Concatenates the other tree. If the same edge exists, the edge in other is used. Returns self. The result is unspecified if other isn’t a Tree object. Note that the Node and Edge objects in the other tree are shared in the concatinated tree.



572
573
574
575
576
577
578
579
580
581
 
# File 'lib/bio/tree.rb', line 572

def concat(other)
  #raise TypeError unless other.kind_of?(self.class)
  other.each_node do |node|
    self.add_node(node)
  end
  other.each_edge do |node1, node2, edge|
    self.add_edge(node1, node2, edge)
  end
  self
end

#descendents(node, root = nil) ⇒ Object

Gets all descendent nodes of the node. If root isn’t specified or root is nil, @root is used. Returns an array of Nodes. The result is unspecified for cyclic trees.



648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
 
# File 'lib/bio/tree.rb', line 648

def descendents(node, root = nil)
  root ||= @root
  distance, route = @pathway.breadth_first_search(root)
  d = distance[node]
  result = []
  distance.each do |key, val|
    if val > d then
      x = key
      while x = route[x]
        if x == node then
          result << key
          break
        end
        break if distance[x] <= d
      end
    end
  end
  result
end

#distance(node1, node2) ⇒ Object

Returns distance between node1 and node2. It would raise error if the edges didn’t contain distance values. The result is unspecified for cyclic trees.



615
616
617
618
619
620
621
 
# File 'lib/bio/tree.rb', line 615

def distance(node1, node2)
  distance = 0
  self.each_edge_in_path(node1, node2) do |source, target, edge|
    distance += get_edge_distance(edge)
  end
  distance
end

#distance_matrix(nodes = nil) ⇒ Object

Calculates distance matrix of given nodes. If nodes is nil, or is ommited, it acts the same as tree.distance_matrix(tree.leaves). Returns a matrix object. The result is unspecified for cyclic trees. Note 1: The diagonal values of the matrix are 0. Note 2: If the distance cannot be calculated, nil will be set.



729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
 
# File 'lib/bio/tree.rb', line 729

def distance_matrix(nodes = nil)
  nodes ||= self.leaves
  matrix = []
  nodes.each_index do |i|
    row = []
    nodes.each_index do |j|
      if i == j then
        distance = 0
      elsif r = matrix[j] and val = r[i] then
        distance = val
      else
        distance = (self.distance(nodes[i], nodes[j]) rescue nil)
      end
      row << distance
    end
    matrix << row
  end
  Matrix.rows(matrix, false)
end

#each_edge ⇒ Object

Iterates over each edges of this tree.



297
298
299
300
301
302
 
# File 'lib/bio/tree.rb', line 297

def each_edge #:yields: source, target, edge
  @pathway.relations.each do |rel|
    yield rel.node[0], rel.node[1], rel.relation
  end
  self
end

#each_edge_in_path(node1, node2) ⇒ Object

Iterates over each edge from node1 to node2. The result is unspecified for cyclic trees.



601
602
603
604
605
606
607
608
609
610
 
# File 'lib/bio/tree.rb', line 601

def each_edge_in_path(node1, node2)
  path = self.path(node1, node2)
  source = path.shift
  path.each do |target|
    edge = self.get_edge(source, target)
    yield source, target, edge
    source = target
  end
  self
end

#each_node(&x) ⇒ Object

Iterates over each node of this tree.



291
292
293
294
 
# File 'lib/bio/tree.rb', line 291

def each_node(&x) #:yields: node
  @pathway.graph.each_key(&x)
  self
end

#each_out_edge(source) ⇒ Object

Iterates over each connected edges of the given node. Returns self.

The reason why the method name is “each_out_edge” is that it comes from the Boost Graph Library.



341
342
343
344
345
 
# File 'lib/bio/tree.rb', line 341

def each_out_edge(source) #:yields: source, target, edge
  h = @pathway.graph[source]
  h.each { |key, val| yield source, key, val } if h
  self
end

#edges ⇒ Object

Returns all edges an array of [ node0, node1, edge ]



305
306
307
308
309
 
# File 'lib/bio/tree.rb', line 305

def edges
  @pathway.relations.collect do |rel|
    [ rel.node[0], rel.node[1], rel.relation ]
  end
end

#get_edge(source, target) ⇒ Object

Returns an edge from source to target. If source and target are not adjacent nodes, returns nil.



358
359
360
361
 
# File 'lib/bio/tree.rb', line 358

def get_edge(source, target)
  h = @pathway.graph[source]
  h ? h[target] : nil
end

#get_edge_distance(edge) ⇒ Object

Gets distance value from the given edge. Returns float or any other numeric value or nil.



101
102
103
104
105
106
107
108
 
# File 'lib/bio/tree.rb', line 101

def get_edge_distance(edge)
  begin
    dist = edge.distance
  rescue NoMethodError
    dist = edge
  end
  dist
end

#get_edge_distance_string(edge) ⇒ Object

Gets distance string from the given edge. Returns a string or nil.



112
113
114
115
116
117
118
119
 
# File 'lib/bio/tree.rb', line 112

def get_edge_distance_string(edge)
  begin
    dist = edge.distance_string
  rescue NoMethodError
    dist = (edge ? edge.to_s : nil)
  end
  dist
end

#get_edge_merged(edge1, edge2) ⇒ Object

Returns edge1 + edge2



122
123
124
125
126
127
128
129
130
131
132
133
134
 
# File 'lib/bio/tree.rb', line 122

def get_edge_merged(edge1, edge2)
  dist1 = get_edge_distance(edge1)
  dist2 = get_edge_distance(edge2)
  if dist1 and dist2 then
    Edge.new(dist1 + dist2)
  elsif dist1 then
    Edge.new(dist1)
  elsif dist2 then
    Edge.new(dist2)
  else
    Edge.new
  end
end

#get_node_bootstrap(node) ⇒ Object 



236
237
238
239
240
241
242
 
# File 'lib/bio/tree.rb', line 236

def get_node_bootstrap(node)
  begin
    node.bootstrap
  rescue NoMethodError
    nil
  end
end

#get_node_bootstrap_string(node) ⇒ Object 



244
245
246
247
248
249
250
 
# File 'lib/bio/tree.rb', line 244

def get_node_bootstrap_string(node)
  begin
    node.bootstrap_string
  rescue NoMethodError
    nil
  end
end

#get_node_by_name(str) ⇒ Object

Finds a node in the tree by given name and returns the node. If the node does not found, returns nil. If multiple nodes with the same name exist, the result would be one of those (unspecified).



375
376
377
378
379
380
381
382
 
# File 'lib/bio/tree.rb', line 375

def get_node_by_name(str)
  self.each_node do |node|
    if get_node_name(node) == str
      return node
    end
  end
  nil
end

#get_node_name(node) ⇒ Object

Gets node name



228
229
230
231
232
233
234
 
# File 'lib/bio/tree.rb', line 228

def get_node_name(node)
  begin
    node.name
  rescue NoMethodError
    node.to_s
  end
end

#include?(node) ⇒ Boolean

If the node exists, returns true. Otherwise, returns false.

Returns:

  • (Boolean) 


394
395
396
 
# File 'lib/bio/tree.rb', line 394

def include?(node)
  @pathway.graph[node] ? true : false
end

#insert_node(node1, node2, new_node, new_distance = nil) ⇒ Object

Insert a new node between adjacent nodes node1 and node2. The old edge between node1 and node2 are changed to the edge between new_node and node2. The edge between node1 and new_node is newly created.

If new_distance is specified, the distance between node1 and new_node is set to new_distance, and distance between new_node and node2 is set to tree.get_edge(node1, node2).distance - new_distance.

Returns self. If node1 and node2 are not adjacent, raises IndexError.

If new_node already exists in the tree, the tree would become circular. In addition, if the edge between new_node and node1 (or node2) already exists, it will be erased.



825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
 
# File 'lib/bio/tree.rb', line 825

def insert_node(node1, node2, new_node, new_distance = nil)
  unless edge = self.get_edge(node1, node2) then
    raise IndexError, 'nodes not found or two nodes are not adjacent'
  end
  new_edge = Edge.new(new_distance)
  self.remove_edge(node1, node2)
  self.add_edge(node1, new_node, new_edge)
  if new_distance and old_distance = get_edge_distance(edge) then
    old_distance -= new_distance
    begin
      edge.distance = old_distance
    rescue NoMethodError
      edge = old_distance
    end
  end
  self.add_edge(new_node, node2, edge)
  self
end

#leaves(node = nil, root = nil) ⇒ Object

If node is nil, returns an array of all leaves (nodes connected with one edge). Otherwise, gets all descendent leaf nodes of the node. If root isn’t specified or root is nil, @root is used. Returns an array of Nodes. The result is unspecified for cyclic trees.



674
675
676
677
678
679
680
681
682
683
684
685
686
687
 
# File 'lib/bio/tree.rb', line 674

def leaves(node = nil, root = nil)
  unless node then
    nodes = []
    self.each_node do |x|
      nodes << x if self.out_degree(x) == 1
    end
    return nodes
  else
    root ||= @root
    self.descendents(node, root).find_all do |x|
      self.adjacent_nodes(x).size == 1
    end
  end
end

#lowest_common_ancestor(node1, node2, root = nil) ⇒ Object

Gets the lowest common ancestor of the two nodes. If root isn’t specified or root is nil, @root is used. Returns a Node object or nil. The result is unspecified for cyclic trees.



702
703
704
705
706
707
708
709
710
 
# File 'lib/bio/tree.rb', line 702

def lowest_common_ancestor(node1, node2, root = nil)
  root ||= @root
  distance, route = @pathway.breadth_first_search(root)
  x = node1; r1 = []
  begin; r1 << x; end while x = route[x]
  x = node2; r2 = []
  begin; r2 << x; end while x = route[x]
  return (r1 & r2).first
end

#nodes ⇒ Object

Returns all nodes as an array.



281
282
283
 
# File 'lib/bio/tree.rb', line 281

def nodes
  @pathway.graph.keys
end

#number_of_edges ⇒ Object

Returns number of edges in the tree.



312
313
314
 
# File 'lib/bio/tree.rb', line 312

def number_of_edges
  @pathway.relations.size
end

#number_of_nodes ⇒ Object

Number of nodes.



286
287
288
 
# File 'lib/bio/tree.rb', line 286

def number_of_nodes
  @pathway.nodes
end

#out_degree(source) ⇒ Object

Returns number of edges in the given node.

The reason why the method name is “out_degree” is that it comes from the Boost Graph Library.



351
352
353
354
 
# File 'lib/bio/tree.rb', line 351

def out_degree(source)
  h = @pathway.graph[source]
  h ? h.size : 0
end

#out_edges(source) ⇒ Object

Returns all connected edges with adjacent nodes. Returns an array of the array [ source, target, edge ].

The reason why the method name is “out_edges” is that it comes from the Boost Graph Library.



327
328
329
330
331
332
333
334
 
# File 'lib/bio/tree.rb', line 327

def out_edges(source)
  h = @pathway.graph[source]
  if h
    h.collect { |key, val| [ source, key, val ] }
  else
    []
  end
end

#output(format, *arg, &block) ⇒ Object

Returns formatted text (or something) of the tree Currently supported format is: :newick, :nhx



235
236
237
238
239
240
241
242
243
244
245
246
 
# File 'lib/bio/db/newick.rb', line 235

def output(format, *arg, &block)
  case format
  when :newick
    output_newick(*arg, &block)
  when :nhx
    output_nhx(*arg, &block)
  when :phylip_distance_matrix
    output_phylip_distance_matrix(*arg, &block)
  else
    raise 'Unknown format'
  end
end

#output_newick(options = {}, &block) ⇒ Object Also known as: newick

Returns a newick formatted string. If block is given, the order of the node is sorted (as the same manner as Enumerable#sort).

Available options:

:indent

indent string; set false to disable (default: ‘ ’)

:bootstrap_style

:disabled disables bootstrap representations. :traditional for traditional style. :molphy for Molphy style (default).



203
204
205
206
207
208
209
210
 
# File 'lib/bio/db/newick.rb', line 203

def output_newick(options = {}, &block) #:yields: node1, node2
  root = @root
  root ||= self.nodes.first
  return '();' unless root
  __to_newick([], root, 0, :__to_newick_format_leaf, options, &block) +
    __to_newick_format_leaf(root, Edge.new, options) +
    ";\n"
end

#output_nhx(options = {}, &block) ⇒ Object

Returns a NHX (New Hampshire eXtended) formatted string. If block is given, the order of the node is sorted (as the same manner as Enumerable#sort).

Available options:

:indent

indent string; set false to disable (default: ‘ ’)



223
224
225
226
227
228
229
230
231
 
# File 'lib/bio/db/newick.rb', line 223

def output_nhx(options = {}, &block) #:yields: node1, node2
  root = @root
  root ||= self.nodes.first
  return '();' unless root
  __to_newick([], root, 0,
              :__to_newick_format_leaf_NHX, options, &block) +
    __to_newick_format_leaf_NHX(root, Edge.new, options) +
    ";\n"
end

#output_phylip_distance_matrix(nodes = nil, options = {}) ⇒ Object

Generates phylip-style distance matrix as a string. if nodes is not given, all leaves in the tree are used. If the names of some of the given (or default) nodes are not defined or are empty, the names are automatically generated.



256
257
258
259
260
261
262
263
264
265
 
# File 'lib/bio/db/newick.rb', line 256

def output_phylip_distance_matrix(nodes = nil, options = {})
  nodes = self.leaves unless nodes
  names = nodes.collect do |x|
    y = get_node_name(x)
    y = sprintf("%x", x.__id__.abs) if y.empty?
    y
  end
  m = self.distance_matrix(nodes)
  Bio::Phylip::DistanceMatrix.generate(m, names, options)
end

#parent(node, root = nil) ⇒ Object

Gets the parent node of the node. If root isn’t specified or root is nil, @root is used. Returns an Node object or nil. The result is unspecified for cyclic trees.



627
628
629
630
 
# File 'lib/bio/tree.rb', line 627

def parent(node, root = nil)
  root ||= @root
  self.path(root, node)[-2]
end

#path(node1, node2) ⇒ Object

Gets path from node1 to node2. Retruns an array of nodes, including node1 and node2. If node1 and/or node2 do not exist, IndexError is raised. If node1 and node2 are not connected, NoPathError is raised. The result is unspecified for cyclic trees.

Raises:

  • (IndexError) 


588
589
590
591
592
593
594
595
596
597
 
# File 'lib/bio/tree.rb', line 588

def path(node1, node2)
  raise IndexError, 'node1 not found' unless @pathway.graph[node1]
  raise IndexError, 'node2 not found' unless @pathway.graph[node2]
  return [ node1 ] if node1 == node2
  step, path = @pathway.bfs_shortest_path(node1, node2)
  unless path[0] == node1 and path[-1] == node2 then
    raise NoPathError, 'node1 and node2 are not connected'
  end
  path
end

#remove_edge(source, target) ⇒ Object

Removes an edge between source and target. Returns self. If the edge does not exist, raises IndexError.

If two or more edges exists between source and target, all of them are removed. +++



446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
 
# File 'lib/bio/tree.rb', line 446

def remove_edge(source, target)
  unless self.get_edge(source, target) then
    raise IndexError, 'edge not found'
  end
  fwd = [ source, target ]
  rev = [ target, source ]
  @pathway.relations.delete_if do |rel|
    rel.node == fwd or rel.node == rev
  end
  h = @pathway.graph[source]
  h.delete(target) if h
  h = @pathway.graph[target]
  h.delete(source) if h
  self
end

#remove_edge_if ⇒ Object

Removes each edge if the block returns not nil. Returns self.



464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
 
# File 'lib/bio/tree.rb', line 464

def remove_edge_if #:yields: source, target, edge
  removed_rel = []
  @pathway.relations.delete_if do |rel|
    if yield rel.node[0], rel.node[1], edge then
      removed_rel << rel
      true
    end
  end
  removed_rel.each do |rel|
    source = rel[0]
    target = rel[1]
    h = @pathway.graph[source]
    h.delete(target) if h
    h = @pathway.graph[target]
    h.delete(source) if h
  end
  self
end

#remove_node(node) ⇒ Object

Removes the given node from the tree. All edges connected with the node are also removed. Returns self. If the node does not exist, raises IndexError.



419
420
421
422
423
 
# File 'lib/bio/tree.rb', line 419

def remove_node(node)
  self.clear_node(node)
  @pathway.graph.delete(node)
  self
end

#remove_node_if ⇒ Object

Removes each node if the block returns not nil. All edges connected with the removed nodes are also removed. Returns self.



428
429
430
431
432
433
434
435
436
437
 
# File 'lib/bio/tree.rb', line 428

def remove_node_if
  all = self.nodes
  all.each do |node|
    if yield node then
      self.clear_node(node)
      @pathway.graph.delete(node)
    end
  end
  self
end

#remove_nonsense_nodes ⇒ Object

Removes all nodes that are not branches nor leaves. That is, removes nodes connected with exactly two edges. For each removed node, two adjacent edges are merged and a new edge are created. Returns removed nodes. Note that orphan nodes are still kept unchanged.



788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
 
# File 'lib/bio/tree.rb', line 788

def remove_nonsense_nodes
  hash = {}
  self.each_node do |node|
    hash[node] = true if @pathway.graph[node].size == 2
  end
  hash.each_key do |node|
    adjs = @pathway.graph[node].keys
    edges = @pathway.graph[node].values
    new_edge = get_edge_merged(edges[0], edges[1])
    @pathway.graph[adjs[0]].delete(node)
    @pathway.graph[adjs[1]].delete(node)
    @pathway.graph.delete(node)
    @pathway.append(Bio::Relation.new(adjs[0], adjs[1], new_edge))
  end
  #@pathway.to_relations
  @pathway.relations.reject! do |rel|
    hash[rel.node[0]] or hash[rel.node[1]]
  end
  return hash.keys
end

#subtree(nodes) ⇒ Object

Gets the sub-tree consisted of given nodes. nodes must be an array of nodes. Nodes that do not exist in the original tree are ignored. Returns a Tree object. Note that the sub-tree shares Node and Edge objects with the original tree.



520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
 
# File 'lib/bio/tree.rb', line 520

def subtree(nodes)
  nodes = nodes.find_all do |x|
    @pathway.graph[x]
  end
  return self.class.new if nodes.empty?
  # creates subtree
  new_tree = self.class.new
  nodes.each do |x|
    new_tree.add_node(x)
  end
  self.each_edge do |node1, node2, edge|
    if new_tree.include?(node1) and new_tree.include?(node2) then
      new_tree.add_edge(node1, node2, edge)
    end
  end
  return new_tree
end

#subtree_with_all_paths(nodes) ⇒ Object

Gets the sub-tree consisted of given nodes and all internal nodes connected between given nodes. nodes must be an array of nodes. Nodes that do not exist in the original tree are ignored. Returns a Tree object. The result is unspecified for cyclic trees. Note that the sub-tree shares Node and Edge objects with the original tree.



546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
 
# File 'lib/bio/tree.rb', line 546

def subtree_with_all_paths(nodes)
  hash = {}
  nodes.each { |x| hash[x] = true }
  nodes.each_index do |i|
    node1 = nodes[i]
    (0...i).each do |j|
      node2 = nodes[j]
      unless node1 == node2 then
        begin
          path = self.path(node1, node2)
        rescue IndexError, NoPathError
          path = []
        end
        path.each { |x| hash[x] = true }
      end
    end
  end
  self.subtree(hash.keys)
end

#total_distance ⇒ Object

Returns total distance of all edges. It would raise error if some edges didn’t contain distance values.



714
715
716
717
718
719
720
 
# File 'lib/bio/tree.rb', line 714

def total_distance
  distance = 0
  self.each_edge do |source, target, edge|
    distance += get_edge_distance(edge)
  end
  distance
end