lca work

diff --git a/forester/java/src/org/forester/archaeopteryx/NodePanel.java b/forester/java/src/org/forester/archaeopteryx/NodePanel.java
index 01577d8..bb050a5 100644 (file)
--- a/forester/java/src/org/forester/archaeopteryx/NodePanel.java
+++ b/forester/java/src/org/forester/archaeopteryx/NodePanel.java
@@ -265,8 +265,8 @@ class NodePanel extends JPanel implements TreeSelectionListener {
             }
         }
         if ( !phylogeny_node.isRoot() ) {
-            addSubelement( category, "Depth", String.valueOf( PhylogenyMethods.calculateDepth( phylogeny_node ) ) );
-            final double d = PhylogenyMethods.calculateDistanceToRoot( phylogeny_node );
+            addSubelement( category, "Depth", String.valueOf( phylogeny_node.calculateDepth()  ) );
+            final double d = phylogeny_node.calculateDistanceToRoot();
             if ( d > 0 ) {
                 addSubelement( category, "Distance to root", String.valueOf( ForesterUtil.FORMATTER_6.format( d ) ) );
             }

diff --git a/forester/java/src/org/forester/archaeopteryx/TreePanel.java b/forester/java/src/org/forester/archaeopteryx/TreePanel.java
index 0a3cf22..db6b22e 100644 (file)
--- a/forester/java/src/org/forester/archaeopteryx/TreePanel.java
+++ b/forester/java/src/org/forester/archaeopteryx/TreePanel.java
@@ -2747,7 +2747,7 @@ public final class TreePanel extends JPanel implements ActionListener, MouseWhee
             }
             double r = 0;
             if ( !n.isRoot() ) {
-                r = 1 - ( ( ( double ) _circ_max_depth - PhylogenyMethods.calculateDepth( n ) ) / _circ_max_depth );
+                r = 1 - ( ( ( double ) _circ_max_depth -  n.calculateDepth() ) / _circ_max_depth );
             }
             final double theta = sum / descs.size();
             n.setXcoord( ( float ) ( center_x + r * radius * Math.cos( theta ) ) );
@@ -2776,7 +2776,7 @@ public final class TreePanel extends JPanel implements ActionListener, MouseWhee
             }
             float r = 0;
             if ( !n.isRoot() ) {
-                r = 1 - ( ( ( float ) _circ_max_depth - PhylogenyMethods.calculateDepth( n ) ) / _circ_max_depth );
+                r = 1 - ( ( ( float ) _circ_max_depth - n.calculateDepth()  ) / _circ_max_depth );
             }
             final double theta = _urt_nodeid_angle_map.get( n.getId() );
             n.setXSecondary( ( float ) ( center_x + radius * r * Math.cos( theta ) ) );

diff --git a/forester/java/src/org/forester/pccx/ModelingUtils.java b/forester/java/src/org/forester/pccx/ModelingUtils.java
index 8d10e01..929f2e1 100644 (file)
--- a/forester/java/src/org/forester/pccx/ModelingUtils.java
+++ b/forester/java/src/org/forester/pccx/ModelingUtils.java
@@ -39,7 +39,7 @@ import org.forester.phylogeny.iterators.PhylogenyNodeIterator;
 public final class ModelingUtils {
 
     static double calculateBranchLengthSum( final PhylogenyNode n1, final PhylogenyNode n2 ) {
-        final PhylogenyNode lca = PhylogenyMethods.obtainLCA( n1, n2 );
+        final PhylogenyNode lca = PhylogenyMethods.calculateLCA( n1, n2 );
         return ModelingUtils.calculateBranchLengthSumHelper( n1, lca )
                 + ModelingUtils.calculateBranchLengthSumHelper( n2, lca );
     }
@@ -57,7 +57,7 @@ public final class ModelingUtils {
     }
 
     static int calculateBranchSum( final PhylogenyNode n1, final PhylogenyNode n2 ) {
-        final PhylogenyNode lca = PhylogenyMethods.obtainLCA( n1, n2 );
+        final PhylogenyNode lca = PhylogenyMethods.calculateLCA( n1, n2 );
         return ModelingUtils.calculateBranchSumHelper( n1, lca ) + ModelingUtils.calculateBranchSumHelper( n2, lca );
     }
 

diff --git a/forester/java/src/org/forester/phylogeny/PhylogenyMethods.java b/forester/java/src/org/forester/phylogeny/PhylogenyMethods.java
index 48fb802..052b23f 100644 (file)
--- a/forester/java/src/org/forester/phylogeny/PhylogenyMethods.java
+++ b/forester/java/src/org/forester/phylogeny/PhylogenyMethods.java
@@ -79,7 +79,7 @@ public class PhylogenyMethods {
      * @return distance between node1 and node2
      */
     public double calculateDistance( final PhylogenyNode node1, final PhylogenyNode node2 ) {
-        final PhylogenyNode lca = obtainLCA( node1, node2 );
+        final PhylogenyNode lca =calculateLCA( node1, node2 );
         final PhylogenyNode n1 = node1;
         final PhylogenyNode n2 = node2;
         return ( PhylogenyMethods.getDistance( n1, lca ) + PhylogenyMethods.getDistance( n2, lca ) );
@@ -115,7 +115,7 @@ public class PhylogenyMethods {
     }
 
     final public static Event getEventAtLCA( final PhylogenyNode n1, final PhylogenyNode n2 ) {
-        return obtainLCA( n1, n2 ).getNodeData().getEvent();
+        return calculateLCA( n1, n2 ).getNodeData().getEvent();
     }
 
     @Override
@@ -157,22 +157,35 @@ public class PhylogenyMethods {
      * @param node2
      * @return LCA of node1 and node2
      */
-    public final static PhylogenyNode obtainLCA( final PhylogenyNode node1, final PhylogenyNode node2 ) {
-        final HashSet<Integer> ids_set = new HashSet<Integer>();
-        PhylogenyNode n1 = node1;
-        PhylogenyNode n2 = node2;
-        ids_set.add( n1.getId() );
-        while ( !n1.isRoot() ) {
-            n1 = n1.getParent();
-            ids_set.add( n1.getId() );
+    public final static PhylogenyNode calculateLCA( PhylogenyNode node1, PhylogenyNode node2 ) {
+        if ( node1 == node2 ) {
+            return node1;
         }
-        while ( !ids_set.contains( n2.getId() ) && !n2.isRoot() ) {
-            n2 = n2.getParent();
+        if (( node1.getParent() == node2.getParent() ) /*&& node1.getParent() != null */ ) {
+            return node1.getParent();
         }
-        if ( !ids_set.contains( n2.getId() ) ) {
-            throw new IllegalArgumentException( "attempt to get LCA of two nodes which do not share a common root" );
+        int depth1 = node1.calculateDepth() ;
+        int depth2 = node2.calculateDepth() ;
+        while ( ( depth1 > -1 ) && ( depth2 > -1 ) ) {
+            if ( depth1 > depth2 ) {
+                node1 = node1.getParent();
+                depth1--;
+            }
+            else if ( depth2 > depth1 ) {
+                node2 = node2.getParent();
+                depth2--;
+            }
+            else {
+                if ( node1 == node2 ) {
+                    return node1;
+                }
+                node1 = node1.getParent();
+                node2 = node2.getParent();
+                depth1--;
+                depth2--;
+            }
         }
-        return n2;
+        throw new IllegalArgumentException( "illegal attempt to calculate LCA of two nodes which do not share a common root" );
     }
 
     /**
@@ -202,7 +215,7 @@ public class PhylogenyMethods {
     }
 
     public static boolean isAreOrthologous( final PhylogenyNode node1, final PhylogenyNode node2 ) {
-        return !obtainLCA( node1, node2 ).isDuplication();
+        return !calculateLCA( node1, node2 ).isDuplication();
     }
 
     public final static Phylogeny[] readPhylogenies( final PhylogenyParser parser, final File file ) throws IOException {
@@ -551,28 +564,6 @@ public class PhylogenyMethods {
         }
     }
 
-    public static int calculateDepth( final PhylogenyNode node ) {
-        PhylogenyNode n = node;
-        int steps = 0;
-        while ( !n.isRoot() ) {
-            steps++;
-            n = n.getParent();
-        }
-        return steps;
-    }
-
-    public static double calculateDistanceToRoot( final PhylogenyNode node ) {
-        PhylogenyNode n = node;
-        double d = 0.0;
-        while ( !n.isRoot() ) {
-            if ( n.getDistanceToParent() > 0.0 ) {
-                d += n.getDistanceToParent();
-            }
-            n = n.getParent();
-        }
-        return d;
-    }
-
     public static short calculateMaxBranchesToLeaf( final PhylogenyNode node ) {
         if ( node.isExternal() ) {
             return 0;
@@ -600,7 +591,7 @@ public class PhylogenyMethods {
         int max = 0;
         for( final PhylogenyNodeIterator iter = phy.iteratorExternalForward(); iter.hasNext(); ) {
             final PhylogenyNode node = iter.next();
-            final int steps = calculateDepth( node );
+            final int steps = node.calculateDepth();
             if ( steps > max ) {
                 max = steps;
             }
@@ -612,7 +603,7 @@ public class PhylogenyMethods {
         double max = 0.0;
         for( final PhylogenyNodeIterator iter = phy.iteratorExternalForward(); iter.hasNext(); ) {
             final PhylogenyNode node = iter.next();
-            final double d = calculateDistanceToRoot( node );
+            final double d = node.calculateDistanceToRoot();
             if ( d > max ) {
                 max = d;
             }
@@ -783,18 +774,17 @@ public class PhylogenyMethods {
 
     public static void deleteExternalNodesNegativeSelection( final String[] node_names_to_delete, final Phylogeny p )
             throws IllegalArgumentException {
-        for( int i = 0; i < node_names_to_delete.length; ++i ) {
-            if ( ForesterUtil.isEmpty( node_names_to_delete[ i ] ) ) {
+        for( final String element : node_names_to_delete ) {
+            if ( ForesterUtil.isEmpty( element ) ) {
                 continue;
             }
             List<PhylogenyNode> nodes = null;
-            nodes = p.getNodes( node_names_to_delete[ i ] );
+            nodes = p.getNodes( element );
             final Iterator<PhylogenyNode> it = nodes.iterator();
             while ( it.hasNext() ) {
                 final PhylogenyNode n = it.next();
                 if ( !n.isExternal() ) {
-                    throw new IllegalArgumentException( "attempt to delete non-external node \""
-                            + node_names_to_delete[ i ] + "\"" );
+                    throw new IllegalArgumentException( "attempt to delete non-external node \"" + element + "\"" );
                 }
                 p.deleteSubtree( n, true );
             }

diff --git a/forester/java/src/org/forester/phylogeny/PhylogenyNode.java b/forester/java/src/org/forester/phylogeny/PhylogenyNode.java
index 318a83c..df13f64 100644 (file)
--- a/forester/java/src/org/forester/phylogeny/PhylogenyNode.java
+++ b/forester/java/src/org/forester/phylogeny/PhylogenyNode.java
@@ -735,6 +735,30 @@ public final class PhylogenyNode implements PhylogenyNodeI, Comparable<Phylogeny
         return true;
     }
 
+    public final int calculateDepth() {
+        PhylogenyNode n = this;
+        int steps = 0;
+        while ( n._parent != null ) {
+            steps++;
+            n = n._parent;
+        }
+        return steps;
+    }
+    
+    public final double calculateDistanceToRoot() {
+        PhylogenyNode n = this;
+        double d = 0.0;
+        while ( n._parent != null ) {
+            if ( n._distance_parent > 0.0 ) {
+                d += n._distance_parent;
+            }
+            n = n._parent;
+        }
+        return d;
+    }
+
+    
+    
     /**
      * Checks whether this PhylogenyNode is a root.
      * 

diff --git a/forester/java/src/org/forester/sdi/RIOn.java b/forester/java/src/org/forester/sdi/RIOn.java
index e7b7c89..058e10f 100644 (file)
--- a/forester/java/src/org/forester/sdi/RIOn.java
+++ b/forester/java/src/org/forester/sdi/RIOn.java
@@ -64,7 +64,7 @@ public class RIOn {
                 if ( i != j ) {
                     final PhylogenyNode node_i = external_nodes.get( i );
                     final PhylogenyNode node_j = external_nodes.get( j );
-                    final PhylogenyNode lca = PhylogenyMethods.obtainLCA( node_i, node_j );
+                    final PhylogenyNode lca = PhylogenyMethods.calculateLCA( node_i, node_j );
                     final Event event = lca.getNodeData().getEvent();
                     final String node_i_name = node_i.getNodeData().getSequence().getName();
                     final String node_j_name = node_j.getNodeData().getSequence().getName();

diff --git a/forester/java/src/org/forester/sdi/TestGSDI.java b/forester/java/src/org/forester/sdi/TestGSDI.java
index 045eebb..2be6dee 100644 (file)
--- a/forester/java/src/org/forester/sdi/TestGSDI.java
+++ b/forester/java/src/org/forester/sdi/TestGSDI.java
@@ -50,7 +50,7 @@ public final class TestGSDI {
     }
 
     private final static Event getEvent( final Phylogeny p, final String n1, final String n2 ) {
-        return PhylogenyMethods.obtainLCA( p.getNode( n1 ), p.getNode( n2 ) ).getNodeData().getEvent();
+        return PhylogenyMethods.calculateLCA( p.getNode( n1 ), p.getNode( n2 ) ).getNodeData().getEvent();
     }
 
     public static boolean test() {
@@ -128,17 +128,17 @@ public final class TestGSDI {
             if ( sdi1.getDuplicationsSum() != 1 ) {
                 return false;
             }
-            if ( !pm.obtainLCA( g1.getNode( "B" ), g1.getNode( "A1" ) ).getNodeData().getEvent().isSpeciation() ) {
+            if ( !pm.calculateLCA( g1.getNode( "B" ), g1.getNode( "A1" ) ).getNodeData().getEvent().isSpeciation() ) {
                 return false;
             }
-            if ( !pm.obtainLCA( g1.getNode( "C" ), g1.getNode( "A1" ) ).getNodeData().getEvent()
+            if ( !pm.calculateLCA( g1.getNode( "C" ), g1.getNode( "A1" ) ).getNodeData().getEvent()
                     .isSpeciationOrDuplication() ) {
                 return false;
             }
-            if ( !( pm.obtainLCA( g1.getNode( "A2" ), g1.getNode( "A1" ) ).getNodeData().getEvent().isDuplication() ) ) {
+            if ( !( pm.calculateLCA( g1.getNode( "A2" ), g1.getNode( "A1" ) ).getNodeData().getEvent().isDuplication() ) ) {
                 return false;
             }
-            if ( !pm.obtainLCA( g1.getNode( "D" ), g1.getNode( "A1" ) ).getNodeData().getEvent().isSpeciation() ) {
+            if ( !pm.calculateLCA( g1.getNode( "D" ), g1.getNode( "A1" ) ).getNodeData().getEvent().isSpeciation() ) {
                 return false;
             }
             final Phylogeny g2 = TestGSDI
@@ -147,17 +147,17 @@ public final class TestGSDI {
             if ( sdi2.getDuplicationsSum() != 0 ) {
                 return false;
             }
-            if ( !pm.obtainLCA( g2.getNode( "A1" ), g2.getNode( "A2" ) ).getNodeData().getEvent().isSpeciation() ) {
+            if ( !pm.calculateLCA( g2.getNode( "A1" ), g2.getNode( "A2" ) ).getNodeData().getEvent().isSpeciation() ) {
                 return false;
             }
-            if ( !pm.obtainLCA( g2.getNode( "A1" ), g2.getNode( "B" ) ).getNodeData().getEvent().isSpeciation() ) {
+            if ( !pm.calculateLCA( g2.getNode( "A1" ), g2.getNode( "B" ) ).getNodeData().getEvent().isSpeciation() ) {
                 return false;
             }
-            if ( !pm.obtainLCA( g2.getNode( "A1" ), g2.getNode( "C" ) ).getNodeData().getEvent()
+            if ( !pm.calculateLCA( g2.getNode( "A1" ), g2.getNode( "C" ) ).getNodeData().getEvent()
                     .isSpeciationOrDuplication() ) {
                 return false;
             }
-            if ( !pm.obtainLCA( g2.getNode( "A1" ), g2.getNode( "D" ) ).getNodeData().getEvent().isSpeciation() ) {
+            if ( !pm.calculateLCA( g2.getNode( "A1" ), g2.getNode( "D" ) ).getNodeData().getEvent().isSpeciation() ) {
                 return false;
             }
             final Phylogeny g3 = TestGSDI
@@ -166,17 +166,17 @@ public final class TestGSDI {
             if ( sdi3.getDuplicationsSum() != 0 ) {
                 return false;
             }
-            if ( !pm.obtainLCA( g3.getNode( "A1" ), g3.getNode( "A2" ) ).getNodeData().getEvent().isSpeciation() ) {
+            if ( !pm.calculateLCA( g3.getNode( "A1" ), g3.getNode( "A2" ) ).getNodeData().getEvent().isSpeciation() ) {
                 return false;
             }
-            if ( !pm.obtainLCA( g3.getNode( "A1" ), g3.getNode( "C" ) ).getNodeData().getEvent().isSpeciation() ) {
+            if ( !pm.calculateLCA( g3.getNode( "A1" ), g3.getNode( "C" ) ).getNodeData().getEvent().isSpeciation() ) {
                 return false;
             }
-            if ( !pm.obtainLCA( g3.getNode( "A1" ), g3.getNode( "B" ) ).getNodeData().getEvent()
+            if ( !pm.calculateLCA( g3.getNode( "A1" ), g3.getNode( "B" ) ).getNodeData().getEvent()
                     .isSpeciationOrDuplication() ) {
                 return false;
             }
-            if ( !pm.obtainLCA( g3.getNode( "A1" ), g3.getNode( "D" ) ).getNodeData().getEvent().isSpeciation() ) {
+            if ( !pm.calculateLCA( g3.getNode( "A1" ), g3.getNode( "D" ) ).getNodeData().getEvent().isSpeciation() ) {
                 return false;
             }
             final Phylogeny g4 = TestGSDI
@@ -185,13 +185,13 @@ public final class TestGSDI {
             if ( sdi4.getDuplicationsSum() != 1 ) {
                 return false;
             }
-            if ( !pm.obtainLCA( g4.getNode( "B" ), g4.getNode( "C1" ) ).getNodeData().getEvent().isSpeciation() ) {
+            if ( !pm.calculateLCA( g4.getNode( "B" ), g4.getNode( "C1" ) ).getNodeData().getEvent().isSpeciation() ) {
                 return false;
             }
-            if ( !pm.obtainLCA( g4.getNode( "B" ), g4.getNode( "C2" ) ).getNodeData().getEvent().isDuplication() ) {
+            if ( !pm.calculateLCA( g4.getNode( "B" ), g4.getNode( "C2" ) ).getNodeData().getEvent().isDuplication() ) {
                 return false;
             }
-            if ( !pm.obtainLCA( g4.getNode( "B" ), g4.getNode( "D" ) ).getNodeData().getEvent().isSpeciation() ) {
+            if ( !pm.calculateLCA( g4.getNode( "B" ), g4.getNode( "D" ) ).getNodeData().getEvent().isSpeciation() ) {
                 return false;
             }
             final Phylogeny g5 = TestGSDI
@@ -200,19 +200,19 @@ public final class TestGSDI {
             if ( sdi5.getDuplicationsSum() != 3 ) {
                 return false;
             }
-            if ( !pm.obtainLCA( g5.getNode( "D1" ), g5.getNode( "A1" ) ).getNodeData().getEvent().isSpeciation() ) {
+            if ( !pm.calculateLCA( g5.getNode( "D1" ), g5.getNode( "A1" ) ).getNodeData().getEvent().isSpeciation() ) {
                 return false;
             }
-            if ( !pm.obtainLCA( g5.getNode( "D1" ), g5.getNode( "B" ) ).getNodeData().getEvent().isDuplication() ) {
+            if ( !pm.calculateLCA( g5.getNode( "D1" ), g5.getNode( "B" ) ).getNodeData().getEvent().isDuplication() ) {
                 return false;
             }
-            if ( !pm.obtainLCA( g5.getNode( "D1" ), g5.getNode( "D2" ) ).getNodeData().getEvent().isDuplication() ) {
+            if ( !pm.calculateLCA( g5.getNode( "D1" ), g5.getNode( "D2" ) ).getNodeData().getEvent().isDuplication() ) {
                 return false;
             }
-            if ( !pm.obtainLCA( g5.getNode( "D2" ), g5.getNode( "D3" ) ).getNodeData().getEvent().isDuplication() ) {
+            if ( !pm.calculateLCA( g5.getNode( "D2" ), g5.getNode( "D3" ) ).getNodeData().getEvent().isDuplication() ) {
                 return false;
             }
-            if ( !pm.obtainLCA( g5.getNode( "C" ), g5.getNode( "D3" ) ).getNodeData().getEvent().isSpeciation() ) {
+            if ( !pm.calculateLCA( g5.getNode( "C" ), g5.getNode( "D3" ) ).getNodeData().getEvent().isSpeciation() ) {
                 return false;
             }
             final Phylogeny species7 = TestGSDI.createPhylogeny( "(((((((([&&NHX:S=a1],[&&NHX:S=a2]),"
@@ -265,7 +265,7 @@ public final class TestGSDI {
             if ( sdi2_0.getSpeciationsSum() != 1 ) {
                 return false;
             }
-            if ( !pm.obtainLCA( g2_0.getNode( "m1" ), g2_0.getNode( "m3" ) ).getNodeData().getEvent().isSpeciation() ) {
+            if ( !pm.calculateLCA( g2_0.getNode( "m1" ), g2_0.getNode( "m3" ) ).getNodeData().getEvent().isSpeciation() ) {
                 return false;
             }
             final Phylogeny g2_1 = TestGSDI.createPhylogeny( "(e2[&&NHX:S=e2],h2[&&NHX:S=h2])" );
@@ -279,7 +279,7 @@ public final class TestGSDI {
             if ( sdi2_1.getSpeciationsSum() != 1 ) {
                 return false;
             }
-            if ( !pm.obtainLCA( g2_1.getNode( "e2" ), g2_1.getNode( "h2" ) ).getNodeData().getEvent().isSpeciation() ) {
+            if ( !pm.calculateLCA( g2_1.getNode( "e2" ), g2_1.getNode( "h2" ) ).getNodeData().getEvent().isSpeciation() ) {
                 return false;
             }
             final Phylogeny g2_2 = TestGSDI.createPhylogeny( "(e2[&&NHX:S=e2],p4[&&NHX:S=p4])" );
@@ -293,7 +293,7 @@ public final class TestGSDI {
             if ( sdi2_2.getSpeciationsSum() != 1 ) {
                 return false;
             }
-            if ( !pm.obtainLCA( g2_2.getNode( "e2" ), g2_2.getNode( "p4" ) ).getNodeData().getEvent().isSpeciation() ) {
+            if ( !pm.calculateLCA( g2_2.getNode( "e2" ), g2_2.getNode( "p4" ) ).getNodeData().getEvent().isSpeciation() ) {
                 return false;
             }
             final Phylogeny g2_3 = TestGSDI.createPhylogeny( "(e2a[&&NHX:S=e2],e2b[&&NHX:S=e2])" );
@@ -307,7 +307,7 @@ public final class TestGSDI {
             if ( sdi2_3.getSpeciationsSum() != 0 ) {
                 return false;
             }
-            if ( !pm.obtainLCA( g2_3.getNode( "e2a" ), g2_3.getNode( "e2b" ) ).getNodeData().getEvent().isDuplication() ) {
+            if ( !pm.calculateLCA( g2_3.getNode( "e2a" ), g2_3.getNode( "e2b" ) ).getNodeData().getEvent().isDuplication() ) {
                 return false;
             }
             final Phylogeny g2_4 = TestGSDI.createPhylogeny( "((j1[&&NHX:S=j1],j4[&&NHX:S=j4]),i3[&&NHX:S=i3])" );
@@ -321,10 +321,10 @@ public final class TestGSDI {
             if ( sdi2_4.getSpeciationsSum() != 2 ) {
                 return false;
             }
-            if ( !pm.obtainLCA( g2_4.getNode( "j1" ), g2_4.getNode( "j4" ) ).getNodeData().getEvent().isSpeciation() ) {
+            if ( !pm.calculateLCA( g2_4.getNode( "j1" ), g2_4.getNode( "j4" ) ).getNodeData().getEvent().isSpeciation() ) {
                 return false;
             }
-            if ( !pm.obtainLCA( g2_4.getNode( "j1" ), g2_4.getNode( "i3" ) ).getNodeData().getEvent().isSpeciation() ) {
+            if ( !pm.calculateLCA( g2_4.getNode( "j1" ), g2_4.getNode( "i3" ) ).getNodeData().getEvent().isSpeciation() ) {
                 return false;
             }
             final Phylogeny g2_5 = TestGSDI.createPhylogeny( "((j1[&&NHX:S=j1],j4[&&NHX:S=j4]),f3[&&NHX:S=f3])" );
@@ -338,10 +338,10 @@ public final class TestGSDI {
             if ( sdi2_5.getSpeciationsSum() != 2 ) {
                 return false;
             }
-            if ( !pm.obtainLCA( g2_5.getNode( "j1" ), g2_5.getNode( "j4" ) ).getNodeData().getEvent().isSpeciation() ) {
+            if ( !pm.calculateLCA( g2_5.getNode( "j1" ), g2_5.getNode( "j4" ) ).getNodeData().getEvent().isSpeciation() ) {
                 return false;
             }
-            if ( !pm.obtainLCA( g2_5.getNode( "j1" ), g2_5.getNode( "f3" ) ).getNodeData().getEvent().isSpeciation() ) {
+            if ( !pm.calculateLCA( g2_5.getNode( "j1" ), g2_5.getNode( "f3" ) ).getNodeData().getEvent().isSpeciation() ) {
                 return false;
             }
             final Phylogeny g2_6 = TestGSDI.createPhylogeny( "((j3[&&NHX:S=j3],i4[&&NHX:S=i4]),f3[&&NHX:S=f3])" );
@@ -355,10 +355,10 @@ public final class TestGSDI {
             if ( sdi2_6.getSpeciationsSum() != 2 ) {
                 return false;
             }
-            if ( !pm.obtainLCA( g2_6.getNode( "j3" ), g2_6.getNode( "i4" ) ).getNodeData().getEvent().isSpeciation() ) {
+            if ( !pm.calculateLCA( g2_6.getNode( "j3" ), g2_6.getNode( "i4" ) ).getNodeData().getEvent().isSpeciation() ) {
                 return false;
             }
-            if ( !pm.obtainLCA( g2_6.getNode( "j3" ), g2_6.getNode( "f3" ) ).getNodeData().getEvent().isSpeciation() ) {
+            if ( !pm.calculateLCA( g2_6.getNode( "j3" ), g2_6.getNode( "f3" ) ).getNodeData().getEvent().isSpeciation() ) {
                 return false;
             }
             final Phylogeny g2_7 = TestGSDI.createPhylogeny( "((j1[&&NHX:S=j1],k1[&&NHX:S=k1]),i1[&&NHX:S=i1])" );
@@ -372,10 +372,10 @@ public final class TestGSDI {
             if ( sdi2_7.getSpeciationsSum() != 1 ) {
                 return false;
             }
-            if ( !pm.obtainLCA( g2_7.getNode( "j1" ), g2_7.getNode( "k1" ) ).getNodeData().getEvent().isSpeciation() ) {
+            if ( !pm.calculateLCA( g2_7.getNode( "j1" ), g2_7.getNode( "k1" ) ).getNodeData().getEvent().isSpeciation() ) {
                 return false;
             }
-            if ( !pm.obtainLCA( g2_7.getNode( "j1" ), g2_7.getNode( "i1" ) ).getNodeData().getEvent()
+            if ( !pm.calculateLCA( g2_7.getNode( "j1" ), g2_7.getNode( "i1" ) ).getNodeData().getEvent()
                     .isSpeciationOrDuplication() ) {
                 return false;
             }
@@ -390,11 +390,11 @@ public final class TestGSDI {
             if ( sdi2_8.getSpeciationsSum() != 1 ) {
                 return false;
             }
-            if ( !pm.obtainLCA( g2_8.getNode( "j1" ), g2_8.getNode( "k1" ) ).getNodeData().getEvent()
+            if ( !pm.calculateLCA( g2_8.getNode( "j1" ), g2_8.getNode( "k1" ) ).getNodeData().getEvent()
                     .isSpeciationOrDuplication() ) {
                 return false;
             }
-            if ( !pm.obtainLCA( g2_8.getNode( "k1" ), g2_8.getNode( "i1" ) ).getNodeData().getEvent().isSpeciation() ) {
+            if ( !pm.calculateLCA( g2_8.getNode( "k1" ), g2_8.getNode( "i1" ) ).getNodeData().getEvent().isSpeciation() ) {
                 return false;
             }
             final Phylogeny g2_9 = TestGSDI.createPhylogeny( "((j1[&&NHX:S=j1],k4[&&NHX:S=k4]),f2[&&NHX:S=f2])" );

diff --git a/forester/java/src/org/forester/surfacing/SurfacingUtil.java b/forester/java/src/org/forester/surfacing/SurfacingUtil.java
index 8daa322..b7590aa 100644 (file)
--- a/forester/java/src/org/forester/surfacing/SurfacingUtil.java
+++ b/forester/java/src/org/forester/surfacing/SurfacingUtil.java
@@ -374,7 +374,7 @@ public final class SurfacingUtil {
                 }
                 for( int i = 0; i < nodes.size() - 1; ++i ) {
                     for( int j = i + 1; j < nodes.size(); ++j ) {
-                        final PhylogenyNode lca = PhylogenyMethods.obtainLCA( nodes.get( i ), nodes.get( j ) );
+                        final PhylogenyNode lca = PhylogenyMethods.calculateLCA( nodes.get( i ), nodes.get( j ) );
                         String rank = "unknown";
                         if ( lca.getNodeData().isHasTaxonomy()
                                 && !ForesterUtil.isEmpty( lca.getNodeData().getTaxonomy().getRank() ) ) {

diff --git a/forester/java/src/org/forester/test/Test.java b/forester/java/src/org/forester/test/Test.java
index 7c554d4..1808421 100644 (file)
--- a/forester/java/src/org/forester/test/Test.java
+++ b/forester/java/src/org/forester/test/Test.java
@@ -136,7 +136,7 @@ public final class Test {
 
     private final static Event getEvent( final Phylogeny p, final String n1, final String n2 ) {
         final PhylogenyMethods pm = PhylogenyMethods.getInstance();
-        return pm.obtainLCA( p.getNode( n1 ), p.getNode( n2 ) ).getNodeData().getEvent();
+        return pm.calculateLCA( p.getNode( n1 ), p.getNode( n2 ) ).getNodeData().getEvent();
     }
 
     public static boolean isEqual( final double a, final double b ) {
@@ -3211,199 +3211,199 @@ public final class Test {
             final PhylogenyFactory factory = ParserBasedPhylogenyFactory.getInstance();
             final Phylogeny p1 = factory.create( "((((((A,B)ab,C)abc,D)abcd,E)abcde,F)abcdef,(G,H)gh)abcdefgh",
                                                  new NHXParser() )[ 0 ];
-            final PhylogenyNode A = PhylogenyMethods.obtainLCA( p1.getNode( "A" ), p1.getNode( "A" ) );
+            final PhylogenyNode A = PhylogenyMethods.calculateLCA( p1.getNode( "A" ), p1.getNode( "A" ) );
             if ( !A.getName().equals( "A" ) ) {
                 return false;
             }
-            final PhylogenyNode gh = PhylogenyMethods.obtainLCA( p1.getNode( "gh" ), p1.getNode( "gh" ) );
+            final PhylogenyNode gh = PhylogenyMethods.calculateLCA( p1.getNode( "gh" ), p1.getNode( "gh" ) );
             if ( !gh.getName().equals( "gh" ) ) {
                 return false;
             }
-            final PhylogenyNode ab = PhylogenyMethods.obtainLCA( p1.getNode( "A" ), p1.getNode( "B" ) );
+            final PhylogenyNode ab = PhylogenyMethods.calculateLCA( p1.getNode( "A" ), p1.getNode( "B" ) );
             if ( !ab.getName().equals( "ab" ) ) {
                 return false;
             }
-            final PhylogenyNode ab2 = PhylogenyMethods.obtainLCA( p1.getNode( "B" ), p1.getNode( "A" ) );
+            final PhylogenyNode ab2 = PhylogenyMethods.calculateLCA( p1.getNode( "B" ), p1.getNode( "A" ) );
             if ( !ab2.getName().equals( "ab" ) ) {
                 return false;
             }
-            final PhylogenyNode gh2 = PhylogenyMethods.obtainLCA( p1.getNode( "H" ), p1.getNode( "G" ) );
+            final PhylogenyNode gh2 = PhylogenyMethods.calculateLCA( p1.getNode( "H" ), p1.getNode( "G" ) );
             if ( !gh2.getName().equals( "gh" ) ) {
                 return false;
             }
-            final PhylogenyNode gh3 = PhylogenyMethods.obtainLCA( p1.getNode( "G" ), p1.getNode( "H" ) );
+            final PhylogenyNode gh3 = PhylogenyMethods.calculateLCA( p1.getNode( "G" ), p1.getNode( "H" ) );
             if ( !gh3.getName().equals( "gh" ) ) {
                 return false;
             }
-            final PhylogenyNode abc = PhylogenyMethods.obtainLCA( p1.getNode( "C" ), p1.getNode( "A" ) );
+            final PhylogenyNode abc = PhylogenyMethods.calculateLCA( p1.getNode( "C" ), p1.getNode( "A" ) );
             if ( !abc.getName().equals( "abc" ) ) {
                 return false;
             }
-            final PhylogenyNode abc2 = PhylogenyMethods.obtainLCA( p1.getNode( "A" ), p1.getNode( "C" ) );
+            final PhylogenyNode abc2 = PhylogenyMethods.calculateLCA( p1.getNode( "A" ), p1.getNode( "C" ) );
             if ( !abc2.getName().equals( "abc" ) ) {
                 return false;
             }
-            final PhylogenyNode abcd = PhylogenyMethods.obtainLCA( p1.getNode( "A" ), p1.getNode( "D" ) );
+            final PhylogenyNode abcd = PhylogenyMethods.calculateLCA( p1.getNode( "A" ), p1.getNode( "D" ) );
             if ( !abcd.getName().equals( "abcd" ) ) {
                 return false;
             }
-            final PhylogenyNode abcd2 = PhylogenyMethods.obtainLCA( p1.getNode( "D" ), p1.getNode( "A" ) );
+            final PhylogenyNode abcd2 = PhylogenyMethods.calculateLCA( p1.getNode( "D" ), p1.getNode( "A" ) );
             if ( !abcd2.getName().equals( "abcd" ) ) {
                 return false;
             }
-            final PhylogenyNode abcdef = PhylogenyMethods.obtainLCA( p1.getNode( "A" ), p1.getNode( "F" ) );
+            final PhylogenyNode abcdef = PhylogenyMethods.calculateLCA( p1.getNode( "A" ), p1.getNode( "F" ) );
             if ( !abcdef.getName().equals( "abcdef" ) ) {
                 return false;
             }
-            final PhylogenyNode abcdef2 = PhylogenyMethods.obtainLCA( p1.getNode( "F" ), p1.getNode( "A" ) );
+            final PhylogenyNode abcdef2 = PhylogenyMethods.calculateLCA( p1.getNode( "F" ), p1.getNode( "A" ) );
             if ( !abcdef2.getName().equals( "abcdef" ) ) {
                 return false;
             }
-            final PhylogenyNode abcdef3 = PhylogenyMethods.obtainLCA( p1.getNode( "ab" ), p1.getNode( "F" ) );
+            final PhylogenyNode abcdef3 = PhylogenyMethods.calculateLCA( p1.getNode( "ab" ), p1.getNode( "F" ) );
             if ( !abcdef3.getName().equals( "abcdef" ) ) {
                 return false;
             }
-            final PhylogenyNode abcdef4 = PhylogenyMethods.obtainLCA( p1.getNode( "F" ), p1.getNode( "ab" ) );
+            final PhylogenyNode abcdef4 = PhylogenyMethods.calculateLCA( p1.getNode( "F" ), p1.getNode( "ab" ) );
             if ( !abcdef4.getName().equals( "abcdef" ) ) {
                 return false;
             }
-            final PhylogenyNode abcde = PhylogenyMethods.obtainLCA( p1.getNode( "A" ), p1.getNode( "E" ) );
+            final PhylogenyNode abcde = PhylogenyMethods.calculateLCA( p1.getNode( "A" ), p1.getNode( "E" ) );
             if ( !abcde.getName().equals( "abcde" ) ) {
                 return false;
             }
-            final PhylogenyNode abcde2 = PhylogenyMethods.obtainLCA( p1.getNode( "E" ), p1.getNode( "A" ) );
+            final PhylogenyNode abcde2 = PhylogenyMethods.calculateLCA( p1.getNode( "E" ), p1.getNode( "A" ) );
             if ( !abcde2.getName().equals( "abcde" ) ) {
                 return false;
             }
-            final PhylogenyNode r = PhylogenyMethods.obtainLCA( p1.getNode( "abcdefgh" ), p1.getNode( "abcdefgh" ) );
+            final PhylogenyNode r = PhylogenyMethods.calculateLCA( p1.getNode( "abcdefgh" ), p1.getNode( "abcdefgh" ) );
             if ( !r.getName().equals( "abcdefgh" ) ) {
                 return false;
             }
-            final PhylogenyNode r2 = PhylogenyMethods.obtainLCA( p1.getNode( "A" ), p1.getNode( "H" ) );
+            final PhylogenyNode r2 = PhylogenyMethods.calculateLCA( p1.getNode( "A" ), p1.getNode( "H" ) );
             if ( !r2.getName().equals( "abcdefgh" ) ) {
                 return false;
             }
-            final PhylogenyNode r3 = PhylogenyMethods.obtainLCA( p1.getNode( "H" ), p1.getNode( "A" ) );
+            final PhylogenyNode r3 = PhylogenyMethods.calculateLCA( p1.getNode( "H" ), p1.getNode( "A" ) );
             if ( !r3.getName().equals( "abcdefgh" ) ) {
                 return false;
             }
-            final PhylogenyNode abcde3 = PhylogenyMethods.obtainLCA( p1.getNode( "E" ), p1.getNode( "abcde" ) );
+            final PhylogenyNode abcde3 = PhylogenyMethods.calculateLCA( p1.getNode( "E" ), p1.getNode( "abcde" ) );
             if ( !abcde3.getName().equals( "abcde" ) ) {
                 return false;
             }
-            final PhylogenyNode abcde4 = PhylogenyMethods.obtainLCA( p1.getNode( "abcde" ), p1.getNode( "E" ) );
+            final PhylogenyNode abcde4 = PhylogenyMethods.calculateLCA( p1.getNode( "abcde" ), p1.getNode( "E" ) );
             if ( !abcde4.getName().equals( "abcde" ) ) {
                 return false;
             }
-            final PhylogenyNode ab3 = PhylogenyMethods.obtainLCA( p1.getNode( "ab" ), p1.getNode( "B" ) );
+            final PhylogenyNode ab3 = PhylogenyMethods.calculateLCA( p1.getNode( "ab" ), p1.getNode( "B" ) );
             if ( !ab3.getName().equals( "ab" ) ) {
                 return false;
             }
-            final PhylogenyNode ab4 = PhylogenyMethods.obtainLCA( p1.getNode( "B" ), p1.getNode( "ab" ) );
+            final PhylogenyNode ab4 = PhylogenyMethods.calculateLCA( p1.getNode( "B" ), p1.getNode( "ab" ) );
             if ( !ab4.getName().equals( "ab" ) ) {
                 return false;
             }
             final Phylogeny p2 = factory.create( "(a,b,(((c,d)cd,e)cde,f)cdef)r", new NHXParser() )[ 0 ];
-            final PhylogenyNode cd = PhylogenyMethods.obtainLCA( p2.getNode( "c" ), p2.getNode( "d" ) );
+            final PhylogenyNode cd = PhylogenyMethods.calculateLCA( p2.getNode( "c" ), p2.getNode( "d" ) );
             if ( !cd.getName().equals( "cd" ) ) {
                 return false;
             }
-            final PhylogenyNode cd2 = PhylogenyMethods.obtainLCA( p2.getNode( "d" ), p2.getNode( "c" ) );
+            final PhylogenyNode cd2 = PhylogenyMethods.calculateLCA( p2.getNode( "d" ), p2.getNode( "c" ) );
             if ( !cd2.getName().equals( "cd" ) ) {
                 return false;
             }
-            final PhylogenyNode cde = PhylogenyMethods.obtainLCA( p2.getNode( "c" ), p2.getNode( "e" ) );
+            final PhylogenyNode cde = PhylogenyMethods.calculateLCA( p2.getNode( "c" ), p2.getNode( "e" ) );
             if ( !cde.getName().equals( "cde" ) ) {
                 return false;
             }
-            final PhylogenyNode cde2 = PhylogenyMethods.obtainLCA( p2.getNode( "e" ), p2.getNode( "c" ) );
+            final PhylogenyNode cde2 = PhylogenyMethods.calculateLCA( p2.getNode( "e" ), p2.getNode( "c" ) );
             if ( !cde2.getName().equals( "cde" ) ) {
                 return false;
             }
-            final PhylogenyNode cdef = PhylogenyMethods.obtainLCA( p2.getNode( "c" ), p2.getNode( "f" ) );
+            final PhylogenyNode cdef = PhylogenyMethods.calculateLCA( p2.getNode( "c" ), p2.getNode( "f" ) );
             if ( !cdef.getName().equals( "cdef" ) ) {
                 return false;
             }
-            final PhylogenyNode cdef2 = PhylogenyMethods.obtainLCA( p2.getNode( "d" ), p2.getNode( "f" ) );
+            final PhylogenyNode cdef2 = PhylogenyMethods.calculateLCA( p2.getNode( "d" ), p2.getNode( "f" ) );
             if ( !cdef2.getName().equals( "cdef" ) ) {
                 return false;
             }
-            final PhylogenyNode cdef3 = PhylogenyMethods.obtainLCA( p2.getNode( "f" ), p2.getNode( "d" ) );
+            final PhylogenyNode cdef3 = PhylogenyMethods.calculateLCA( p2.getNode( "f" ), p2.getNode( "d" ) );
             if ( !cdef3.getName().equals( "cdef" ) ) {
                 return false;
             }
-            final PhylogenyNode rt = PhylogenyMethods.obtainLCA( p2.getNode( "c" ), p2.getNode( "a" ) );
+            final PhylogenyNode rt = PhylogenyMethods.calculateLCA( p2.getNode( "c" ), p2.getNode( "a" ) );
             if ( !rt.getName().equals( "r" ) ) {
                 return false;
             }
             final Phylogeny p3 = factory
                     .create( "((((a,(b,c)bc)abc,(d,e)de)abcde,f)abcdef,(((g,h)gh,(i,j)ij)ghij,k)ghijk,l)",
                              new NHXParser() )[ 0 ];
-            final PhylogenyNode bc_3 = PhylogenyMethods.obtainLCA( p3.getNode( "b" ), p3.getNode( "c" ) );
+            final PhylogenyNode bc_3 = PhylogenyMethods.calculateLCA( p3.getNode( "b" ), p3.getNode( "c" ) );
             if ( !bc_3.getName().equals( "bc" ) ) {
                 return false;
             }
-            final PhylogenyNode ac_3 = PhylogenyMethods.obtainLCA( p3.getNode( "a" ), p3.getNode( "c" ) );
+            final PhylogenyNode ac_3 = PhylogenyMethods.calculateLCA( p3.getNode( "a" ), p3.getNode( "c" ) );
             if ( !ac_3.getName().equals( "abc" ) ) {
                 return false;
             }
-            final PhylogenyNode ad_3 = PhylogenyMethods.obtainLCA( p3.getNode( "a" ), p3.getNode( "d" ) );
+            final PhylogenyNode ad_3 = PhylogenyMethods.calculateLCA( p3.getNode( "a" ), p3.getNode( "d" ) );
             if ( !ad_3.getName().equals( "abcde" ) ) {
                 return false;
             }
-            final PhylogenyNode af_3 = PhylogenyMethods.obtainLCA( p3.getNode( "a" ), p3.getNode( "f" ) );
+            final PhylogenyNode af_3 = PhylogenyMethods.calculateLCA( p3.getNode( "a" ), p3.getNode( "f" ) );
             if ( !af_3.getName().equals( "abcdef" ) ) {
                 return false;
             }
-            final PhylogenyNode ag_3 = PhylogenyMethods.obtainLCA( p3.getNode( "a" ), p3.getNode( "g" ) );
+            final PhylogenyNode ag_3 = PhylogenyMethods.calculateLCA( p3.getNode( "a" ), p3.getNode( "g" ) );
             if ( !ag_3.getName().equals( "" ) ) {
                 return false;
             }
             if ( !ag_3.isRoot() ) {
                 return false;
             }
-            final PhylogenyNode al_3 = PhylogenyMethods.obtainLCA( p3.getNode( "a" ), p3.getNode( "l" ) );
+            final PhylogenyNode al_3 = PhylogenyMethods.calculateLCA( p3.getNode( "a" ), p3.getNode( "l" ) );
             if ( !al_3.getName().equals( "" ) ) {
                 return false;
             }
             if ( !al_3.isRoot() ) {
                 return false;
             }
-            final PhylogenyNode kl_3 = PhylogenyMethods.obtainLCA( p3.getNode( "k" ), p3.getNode( "l" ) );
+            final PhylogenyNode kl_3 = PhylogenyMethods.calculateLCA( p3.getNode( "k" ), p3.getNode( "l" ) );
             if ( !kl_3.getName().equals( "" ) ) {
                 return false;
             }
             if ( !kl_3.isRoot() ) {
                 return false;
             }
-            final PhylogenyNode fl_3 = PhylogenyMethods.obtainLCA( p3.getNode( "f" ), p3.getNode( "l" ) );
+            final PhylogenyNode fl_3 = PhylogenyMethods.calculateLCA( p3.getNode( "f" ), p3.getNode( "l" ) );
             if ( !fl_3.getName().equals( "" ) ) {
                 return false;
             }
             if ( !fl_3.isRoot() ) {
                 return false;
             }
-            final PhylogenyNode gk_3 = PhylogenyMethods.obtainLCA( p3.getNode( "g" ), p3.getNode( "k" ) );
+            final PhylogenyNode gk_3 = PhylogenyMethods.calculateLCA( p3.getNode( "g" ), p3.getNode( "k" ) );
             if ( !gk_3.getName().equals( "ghijk" ) ) {
                 return false;
             }
             final Phylogeny p4 = factory.create( "(a,b,c)r", new NHXParser() )[ 0 ];
-            final PhylogenyNode r_4 = PhylogenyMethods.obtainLCA( p4.getNode( "b" ), p4.getNode( "c" ) );
+            final PhylogenyNode r_4 = PhylogenyMethods.calculateLCA( p4.getNode( "b" ), p4.getNode( "c" ) );
             if ( !r_4.getName().equals( "r" ) ) {
                 return false;
             }
             final Phylogeny p5 = factory.create( "((a,b),c,d)root", new NHXParser() )[ 0 ];
-            final PhylogenyNode r_5 = PhylogenyMethods.obtainLCA( p5.getNode( "a" ), p5.getNode( "c" ) );
+            final PhylogenyNode r_5 = PhylogenyMethods.calculateLCA( p5.getNode( "a" ), p5.getNode( "c" ) );
             if ( !r_5.getName().equals( "root" ) ) {
                 return false;
             }
             final Phylogeny p6 = factory.create( "((a,b),c,d)rot", new NHXParser() )[ 0 ];
-            final PhylogenyNode r_6 = PhylogenyMethods.obtainLCA( p6.getNode( "c" ), p6.getNode( "a" ) );
+            final PhylogenyNode r_6 = PhylogenyMethods.calculateLCA( p6.getNode( "c" ), p6.getNode( "a" ) );
             if ( !r_6.getName().equals( "rot" ) ) {
                 return false;
             }
             final Phylogeny p7 = factory.create( "(((a,b)x,c)x,d,e)rott", new NHXParser() )[ 0 ];
-            final PhylogenyNode r_7 = PhylogenyMethods.obtainLCA( p7.getNode( "a" ), p7.getNode( "e" ) );
+            final PhylogenyNode r_7 = PhylogenyMethods.calculateLCA( p7.getNode( "a" ), p7.getNode( "e" ) );
             if ( !r_7.getName().equals( "rott" ) ) {
                 return false;
             }