X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fanalysis%2FNJTree.java;h=4ee0be936ef6ced3a6c46c8d3c820636e045ac2e;hb=b4228f9114855211ecb84c2670777e00947e8548;hp=144ec2c6ea14328cb69c066c38a6d06b9663f2ee;hpb=59d682209891099d46b960509907c79e3fb276fe;p=jalview.git

diff --git a/src/jalview/analysis/NJTree.java b/src/jalview/analysis/NJTree.java
index 144ec2c..4ee0be9 100644
--- a/src/jalview/analysis/NJTree.java
+++ b/src/jalview/analysis/NJTree.java
@@ -1,28 +1,44 @@
 /*
- * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8)
- * Copyright (C) 2012 J Procter, AM Waterhouse, LM Lui, J Engelhardt, G Barton, M Clamp, S Searle
+ * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
+ * Copyright (C) $$Year-Rel$$ The Jalview Authors
  * 
  * This file is part of Jalview.
  * 
  * Jalview is free software: you can redistribute it and/or
  * modify it under the terms of the GNU General Public License 
- * as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
+ * as published by the Free Software Foundation, either version 3
+ * of the License, or (at your option) any later version.
  *  
  * Jalview is distributed in the hope that it will be useful, but 
  * WITHOUT ANY WARRANTY; without even the implied warranty 
  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
  * PURPOSE.  See the GNU General Public License for more details.
  * 
- * You should have received a copy of the GNU General Public License along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU General Public License
+ * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
+ * The Jalview Authors are detailed in the 'AUTHORS' file.
  */
 package jalview.analysis;
 
-import java.util.*;
-
-import jalview.datamodel.*;
-import jalview.io.*;
-import jalview.schemes.*;
-import jalview.util.*;
+import jalview.analysis.scoremodels.ScoreModels;
+import jalview.analysis.scoremodels.SimilarityParams;
+import jalview.api.analysis.DistanceScoreModelI;
+import jalview.api.analysis.ScoreModelI;
+import jalview.api.analysis.SimilarityScoreModelI;
+import jalview.datamodel.AlignmentView;
+import jalview.datamodel.BinaryNode;
+import jalview.datamodel.CigarArray;
+import jalview.datamodel.NodeTransformI;
+import jalview.datamodel.SeqCigar;
+import jalview.datamodel.Sequence;
+import jalview.datamodel.SequenceI;
+import jalview.datamodel.SequenceNode;
+import jalview.io.NewickFile;
+import jalview.math.MatrixI;
+
+import java.util.Enumeration;
+import java.util.List;
+import java.util.Vector;
 
 /**
  * DOCUMENT ME!
@@ -32,7 +48,16 @@ import jalview.util.*;
  */
 public class NJTree
 {
-  Vector cluster;
+  /*
+   * 'methods'
+   */
+  public static final String AVERAGE_DISTANCE = "AV";
+
+  public static final String NEIGHBOUR_JOINING = "NJ";
+
+  public static final String FROM_FILE = "FromFile";
+
+  Vector<Cluster> cluster;
 
   SequenceI[] sequence;
 
@@ -46,29 +71,29 @@ public class NJTree
 
   int noClus;
 
-  float[][] distance;
+  MatrixI distance;
 
   int mini;
 
   int minj;
 
-  float ri;
+  double ri;
 
-  float rj;
+  double rj;
 
-  Vector groups = new Vector();
+  Vector<SequenceNode> groups = new Vector<SequenceNode>();
 
   SequenceNode maxdist;
 
   SequenceNode top;
 
-  float maxDistValue;
+  double maxDistValue;
 
-  float maxheight;
+  double maxheight;
 
   int ycount;
 
-  Vector node;
+  Vector<SequenceNode> node;
 
   String type;
 
@@ -76,8 +101,6 @@ public class NJTree
 
   Object found = null;
 
-  Object leaves = null;
-
   boolean hasDistances = true; // normal case for jalview trees
 
   boolean hasBootstrap = false; // normal case for jalview trees
@@ -139,8 +162,7 @@ public class NJTree
 
     SequenceIdMatcher algnIds = new SequenceIdMatcher(seqs);
 
-    Vector leaves = new Vector();
-    findLeaves(top, leaves);
+    Vector<SequenceNode> leaves = findLeaves(top);
 
     int i = 0;
     int namesleft = seqs.length;
@@ -148,11 +170,11 @@ public class NJTree
     SequenceNode j;
     SequenceI nam;
     String realnam;
-    Vector one2many = new Vector();
+    Vector<SequenceI> one2many = new Vector<SequenceI>();
     int countOne2Many = 0;
     while (i < leaves.size())
     {
-      j = (SequenceNode) leaves.elementAt(i++);
+      j = leaves.elementAt(i++);
       realnam = j.getName();
       nam = null;
 
@@ -196,25 +218,29 @@ public class NJTree
    * 
    * @param sequence
    *          DOCUMENT ME!
-   * @param type
+   * @param treeType
    *          DOCUMENT ME!
-   * @param pwtype
+   * @param modelType
    *          DOCUMENT ME!
    * @param start
    *          DOCUMENT ME!
    * @param end
    *          DOCUMENT ME!
    */
-  public NJTree(SequenceI[] sequence, AlignmentView seqData, String type,
-          String pwtype, int start, int end)
+  public NJTree(SequenceI[] sqs, AlignmentView seqView, String treeType,
+          String modelType, ScoreModelI sm, int start, int end)
   {
-    this.sequence = sequence;
-    this.node = new Vector();
-    this.type = type;
-    this.pwtype = pwtype;
-    if (seqData != null)
+    this.sequence = sqs;
+    this.node = new Vector<SequenceNode>();
+    if (!(treeType.equals(NEIGHBOUR_JOINING)))
     {
-      this.seqData = seqData;
+      treeType = AVERAGE_DISTANCE;
+    }
+    this.type = treeType;
+    this.pwtype = modelType;
+    if (seqView != null)
+    {
+      this.seqData = seqView;
     }
     else
     {
@@ -227,17 +253,12 @@ public class NJTree
       sdata.addOperation(CigarArray.M, end - start + 1);
       this.seqData = new AlignmentView(sdata, start);
     }
-    // System.err.println("Made seqData");// dbg
-    if (!(type.equals("NJ")))
-    {
-      type = "AV";
-    }
 
-    if (!(pwtype.equals("PID")))
+    if (sm == null && !(modelType.equals("PID")))
     {
-      if (ResidueProperties.getScoreMatrix(pwtype) == null)
+      if (ScoreModels.getInstance().forName(modelType) == null)
       {
-        pwtype = "BLOSUM62";
+        modelType = "BLOSUM62";
       }
     }
 
@@ -253,17 +274,28 @@ public class NJTree
 
     noseqs = i++;
 
-    distance = findDistances(this.seqData
-            .getSequenceStrings(Comparison.GapChars.charAt(0)));
-    // System.err.println("Made distances");// dbg
+    // TODO pass choice of params from GUI in constructo
+    if (sm instanceof DistanceScoreModelI)
+    {
+      distance = ((DistanceScoreModelI) sm).findDistances(seqData,
+              SimilarityParams.Jalview);
+    }
+    else if (sm instanceof SimilarityScoreModelI)
+    {
+      /*
+       * compute similarity and invert it to give a distance measure
+       */
+      MatrixI result = ((SimilarityScoreModelI) sm).findSimilarities(
+              seqData, SimilarityParams.Jalview);
+      result.reverseRange(true);
+      distance = result;
+    }
+
     makeLeaves();
-    // System.err.println("Made leaves");// dbg
 
     noClus = cluster.size();
 
     cluster();
-    // System.err.println("Made clusters");// dbg
-
   }
 
   /**
@@ -271,12 +303,13 @@ public class NJTree
    * 
    * @return Newick File with all tree data available
    */
+  @Override
   public String toString()
   {
     jalview.io.NewickFile fout = new jalview.io.NewickFile(getTopNode());
 
-    return fout.print(isHasBootstrap(), isHasDistances(),
-            isHasRootDistance()); // output all data available for tree
+    return fout.print(hasBootstrap(), hasDistances(),
+            hasRootDistance()); // output all data available for tree
   }
 
   /**
@@ -286,10 +319,9 @@ public class NJTree
    * @param list
    *          Sequence set to be associated with tree nodes
    */
-  public void UpdatePlaceHolders(List<SequenceI> list)
+  public void updatePlaceHolders(List<SequenceI> list)
   {
-    Vector leaves = new Vector();
-    findLeaves(top, leaves);
+    Vector<SequenceNode> leaves = findLeaves(top);
 
     int sz = leaves.size();
     SequenceIdMatcher seqmatcher = null;
@@ -297,7 +329,7 @@ public class NJTree
 
     while (i < sz)
     {
-      SequenceNode leaf = (SequenceNode) leaves.elementAt(i++);
+      SequenceNode leaf = leaves.elementAt(i++);
 
       if (list.contains(leaf.element()))
       {
@@ -312,7 +344,7 @@ public class NJTree
 
           for (int j = 0; j < seqs.length; j++)
           {
-            seqs[j] = (SequenceI) list.get(j);
+            seqs[j] = list.get(j);
           }
 
           seqmatcher = new SequenceIdMatcher(seqs);
@@ -358,12 +390,12 @@ public class NJTree
     {
 
       @Override
-      public void transform(BinaryNode node)
+      public void transform(BinaryNode nd)
       {
-        Object el = node.element();
+        Object el = nd.element();
         if (el != null && el instanceof SequenceI)
         {
-          node.setName(((SequenceI) el).getName());
+          nd.setName(((SequenceI) el).getName());
         }
       }
     });
@@ -372,11 +404,11 @@ public class NJTree
   /**
    * DOCUMENT ME!
    */
-  public void cluster()
+  void cluster()
   {
     while (noClus > 2)
     {
-      if (type.equals("NJ"))
+      if (type.equals(NEIGHBOUR_JOINING))
       {
         findMinNJDistance();
       }
@@ -417,7 +449,7 @@ public class NJTree
     }
 
     joinClusters(one, two);
-    top = (SequenceNode) (node.elementAt(one));
+    top = (node.elementAt(one));
 
     reCount(top);
     findHeight(top);
@@ -434,23 +466,23 @@ public class NJTree
    * 
    * @return DOCUMENT ME!
    */
-  public Cluster joinClusters(int i, int j)
+  Cluster joinClusters(int i, int j)
   {
-    float dist = distance[i][j];
+    double dist = distance.getValue(i, j);
 
-    int noi = ((Cluster) cluster.elementAt(i)).value.length;
-    int noj = ((Cluster) cluster.elementAt(j)).value.length;
+    int noi = cluster.elementAt(i).value.length;
+    int noj = cluster.elementAt(j).value.length;
 
     int[] value = new int[noi + noj];
 
     for (int ii = 0; ii < noi; ii++)
     {
-      value[ii] = ((Cluster) cluster.elementAt(i)).value[ii];
+      value[ii] = cluster.elementAt(i).value[ii];
     }
 
     for (int ii = noi; ii < (noi + noj); ii++)
     {
-      value[ii] = ((Cluster) cluster.elementAt(j)).value[ii - noi];
+      value[ii] = cluster.elementAt(j).value[ii - noi];
     }
 
     Cluster c = new Cluster(value);
@@ -458,7 +490,7 @@ public class NJTree
     ri = findr(i, j);
     rj = findr(j, i);
 
-    if (type.equals("NJ"))
+    if (type.equals(NEIGHBOUR_JOINING))
     {
       findClusterNJDistance(i, j);
     }
@@ -469,13 +501,13 @@ public class NJTree
 
     SequenceNode sn = new SequenceNode();
 
-    sn.setLeft((SequenceNode) (node.elementAt(i)));
-    sn.setRight((SequenceNode) (node.elementAt(j)));
+    sn.setLeft((node.elementAt(i)));
+    sn.setRight((node.elementAt(j)));
 
-    SequenceNode tmpi = (SequenceNode) (node.elementAt(i));
-    SequenceNode tmpj = (SequenceNode) (node.elementAt(j));
+    SequenceNode tmpi = (node.elementAt(i));
+    SequenceNode tmpj = (node.elementAt(j));
 
-    if (type.equals("NJ"))
+    if (type.equals(NEIGHBOUR_JOINING))
     {
       findNewNJDistances(tmpi, tmpj, dist);
     }
@@ -502,8 +534,8 @@ public class NJTree
    * @param dist
    *          DOCUMENT ME!
    */
-  public void findNewNJDistances(SequenceNode tmpi, SequenceNode tmpj,
-          float dist)
+  void findNewNJDistances(SequenceNode tmpi, SequenceNode tmpj,
+          double dist)
   {
 
     tmpi.dist = ((dist + ri) - rj) / 2;
@@ -530,11 +562,11 @@ public class NJTree
    * @param dist
    *          DOCUMENT ME!
    */
-  public void findNewDistances(SequenceNode tmpi, SequenceNode tmpj,
-          float dist)
+  void findNewDistances(SequenceNode tmpi, SequenceNode tmpj,
+          double dist)
   {
-    float ih = 0;
-    float jh = 0;
+    double ih = 0;
+    double jh = 0;
 
     SequenceNode sni = tmpi;
     SequenceNode snj = tmpj;
@@ -563,19 +595,22 @@ public class NJTree
    * @param j
    *          DOCUMENT ME!
    */
-  public void findClusterDistance(int i, int j)
+  void findClusterDistance(int i, int j)
   {
-    int noi = ((Cluster) cluster.elementAt(i)).value.length;
-    int noj = ((Cluster) cluster.elementAt(j)).value.length;
+    int noi = cluster.elementAt(i).value.length;
+    int noj = cluster.elementAt(j).value.length;
 
     // New distances from cluster to others
-    float[] newdist = new float[noseqs];
+    double[] newdist = new double[noseqs];
 
     for (int l = 0; l < noseqs; l++)
     {
       if ((l != i) && (l != j))
       {
-        newdist[l] = ((distance[i][l] * noi) + (distance[j][l] * noj))
+        // newdist[l] = ((distance[i][l] * noi) + (distance[j][l] * noj))
+        // / (noi + noj);
+        newdist[l] = ((distance.getValue(i, l) * noi) + (distance.getValue(
+                j, l) * noj))
                 / (noi + noj);
       }
       else
@@ -586,8 +621,10 @@ public class NJTree
 
     for (int ii = 0; ii < noseqs; ii++)
     {
-      distance[i][ii] = newdist[ii];
-      distance[ii][i] = newdist[ii];
+      // distance[i][ii] = newdist[ii];
+      // distance[ii][i] = newdist[ii];
+      distance.setValue(i, ii, newdist[ii]);
+      distance.setValue(ii, i, newdist[ii]);
     }
   }
 
@@ -599,17 +636,20 @@ public class NJTree
    * @param j
    *          DOCUMENT ME!
    */
-  public void findClusterNJDistance(int i, int j)
+  void findClusterNJDistance(int i, int j)
   {
 
     // New distances from cluster to others
-    float[] newdist = new float[noseqs];
+    double[] newdist = new double[noseqs];
 
     for (int l = 0; l < noseqs; l++)
     {
       if ((l != i) && (l != j))
       {
-        newdist[l] = ((distance[i][l] + distance[j][l]) - distance[i][j]) / 2;
+        // newdist[l] = ((distance[i][l] + distance[j][l]) - distance[i][j]) /
+        // 2;
+        newdist[l] = (distance.getValue(i, l) + distance.getValue(j, l) - distance
+                .getValue(i, j)) / 2;
       }
       else
       {
@@ -619,8 +659,10 @@ public class NJTree
 
     for (int ii = 0; ii < noseqs; ii++)
     {
-      distance[i][ii] = newdist[ii];
-      distance[ii][i] = newdist[ii];
+      // distance[i][ii] = newdist[ii];
+      // distance[ii][i] = newdist[ii];
+      distance.setValue(i, ii, newdist[ii]);
+      distance.setValue(ii, i, newdist[ii]);
     }
   }
 
@@ -634,15 +676,16 @@ public class NJTree
    * 
    * @return DOCUMENT ME!
    */
-  public float findr(int i, int j)
+  double findr(int i, int j)
   {
-    float tmp = 1;
+    double tmp = 1;
 
     for (int k = 0; k < noseqs; k++)
     {
       if ((k != i) && (k != j) && (done[k] != 1))
       {
-        tmp = tmp + distance[i][k];
+        // tmp = tmp + distance[i][k];
+        tmp = tmp + distance.getValue(i, k);
       }
     }
 
@@ -659,9 +702,9 @@ public class NJTree
    * 
    * @return DOCUMENT ME!
    */
-  public float findMinNJDistance()
+  double findMinNJDistance()
   {
-    float min = 100000;
+    double min = Double.MAX_VALUE;
 
     for (int i = 0; i < (noseqs - 1); i++)
     {
@@ -669,7 +712,9 @@ public class NJTree
       {
         if ((done[i] != 1) && (done[j] != 1))
         {
-          float tmp = distance[i][j] - (findr(i, j) + findr(j, i));
+          // float tmp = distance[i][j] - (findr(i, j) + findr(j, i));
+          double tmp = distance.getValue(i, j)
+                  - (findr(i, j) + findr(j, i));
 
           if (tmp < min)
           {
@@ -690,9 +735,9 @@ public class NJTree
    * 
    * @return DOCUMENT ME!
    */
-  public float findMinDistance()
+  double findMinDistance()
   {
-    float min = 100000;
+    double min = Double.MAX_VALUE;
 
     for (int i = 0; i < (noseqs - 1); i++)
     {
@@ -700,12 +745,14 @@ public class NJTree
       {
         if ((done[i] != 1) && (done[j] != 1))
         {
-          if (distance[i][j] < min)
+          // if (distance[i][j] < min)
+          if (distance.getValue(i, j) < min)
           {
             mini = i;
             minj = j;
 
-            min = distance[i][j];
+            // min = distance[i][j];
+            min = distance.getValue(i, j);
           }
         }
       }
@@ -716,107 +763,10 @@ public class NJTree
 
   /**
    * DOCUMENT ME!
-   * 
-   * @return DOCUMENT ME!
-   */
-  public float[][] findDistances(String[] sequenceString)
-  {
-    float[][] distance = new float[noseqs][noseqs];
-
-    if (pwtype.equals("PID"))
-    {
-      for (int i = 0; i < (noseqs - 1); i++)
-      {
-        for (int j = i; j < noseqs; j++)
-        {
-          if (j == i)
-          {
-            distance[i][i] = 0;
-          }
-          else
-          {
-            distance[i][j] = 100 - Comparison.PID(sequenceString[i],
-                    sequenceString[j]);
-
-            distance[j][i] = distance[i][j];
-          }
-        }
-      }
-    }
-    else
-    {
-      // Pairwise substitution score (with no gap penalties)
-      ScoreMatrix pwmatrix = ResidueProperties.getScoreMatrix(pwtype);
-      if (pwmatrix == null)
-      {
-        pwmatrix = ResidueProperties.getScoreMatrix("BLOSUM62");
-      }
-      int maxscore = 0;
-      int end = sequenceString[0].length();
-      for (int i = 0; i < (noseqs - 1); i++)
-      {
-        for (int j = i; j < noseqs; j++)
-        {
-          int score = 0;
-
-          for (int k = 0; k < end; k++)
-          {
-            try
-            {
-              score += pwmatrix.getPairwiseScore(
-                      sequenceString[i].charAt(k),
-                      sequenceString[j].charAt(k));
-            } catch (Exception ex)
-            {
-              System.err.println("err creating BLOSUM62 tree");
-              ex.printStackTrace();
-            }
-          }
-
-          distance[i][j] = (float) score;
-
-          if (score > maxscore)
-          {
-            maxscore = score;
-          }
-        }
-      }
-
-      for (int i = 0; i < (noseqs - 1); i++)
-      {
-        for (int j = i; j < noseqs; j++)
-        {
-          distance[i][j] = (float) maxscore - distance[i][j];
-          distance[j][i] = distance[i][j];
-        }
-      }
-
-    }
-    return distance;
-
-    // else
-    /*
-     * else if (pwtype.equals("SW")) { float max = -1;
-     * 
-     * for (int i = 0; i < (noseqs - 1); i++) { for (int j = i; j < noseqs; j++)
-     * { AlignSeq as = new AlignSeq(sequence[i], sequence[j], "pep");
-     * as.calcScoreMatrix(); as.traceAlignment(); as.printAlignment(System.out);
-     * distance[i][j] = (float) as.maxscore;
-     * 
-     * if (max < distance[i][j]) { max = distance[i][j]; } } }
-     * 
-     * for (int i = 0; i < (noseqs - 1); i++) { for (int j = i; j < noseqs; j++)
-     * { distance[i][j] = max - distance[i][j]; distance[j][i] = distance[i][j];
-     * } } }/
-     */
-  }
-
-  /**
-   * DOCUMENT ME!
    */
-  public void makeLeaves()
+  void makeLeaves()
   {
-    cluster = new Vector();
+    cluster = new Vector<Cluster>();
 
     for (int i = 0; i < noseqs; i++)
     {
@@ -835,26 +785,42 @@ public class NJTree
   }
 
   /**
+   * Search for leaf nodes below (or at) the given node
+   * 
+   * @param nd
+   *          root node to search from
+   * 
+   * @return
+   */
+  public Vector<SequenceNode> findLeaves(SequenceNode nd)
+  {
+    Vector<SequenceNode> leaves = new Vector<SequenceNode>();
+    findLeaves(nd, leaves);
+    return leaves;
+  }
+
+  /**
    * Search for leaf nodes.
    * 
-   * @param node
+   * @param nd
    *          root node to search from
    * @param leaves
    *          Vector of leaves to add leaf node objects too.
    * 
    * @return Vector of leaf nodes on binary tree
    */
-  public Vector findLeaves(SequenceNode node, Vector leaves)
+  Vector<SequenceNode> findLeaves(SequenceNode nd,
+          Vector<SequenceNode> leaves)
   {
-    if (node == null)
+    if (nd == null)
     {
       return leaves;
     }
 
-    if ((node.left() == null) && (node.right() == null)) // Interior node
+    if ((nd.left() == null) && (nd.right() == null)) // Interior node
     // detection
     {
-      leaves.addElement(node);
+      leaves.addElement(nd);
 
       return leaves;
     }
@@ -864,110 +830,67 @@ public class NJTree
        * TODO: Identify internal nodes... if (node.isSequenceLabel()) {
        * leaves.addElement(node); }
        */
-      findLeaves((SequenceNode) node.left(), leaves);
-      findLeaves((SequenceNode) node.right(), leaves);
+      findLeaves((SequenceNode) nd.left(), leaves);
+      findLeaves((SequenceNode) nd.right(), leaves);
     }
 
     return leaves;
   }
 
   /**
-   * Find the leaf node with a particular ycount
-   * 
-   * @param node
-   *          initial point on tree to search from
-   * @param count
-   *          value to search for
-   * 
-   * @return null or the node with ycound=count
-   */
-  public Object findLeaf(SequenceNode node, int count)
-  {
-    found = _findLeaf(node, count);
-
-    return found;
-  }
-
-  /*
-   * #see findLeaf(SequenceNode node, count)
-   */
-  public Object _findLeaf(SequenceNode node, int count)
-  {
-    if (node == null)
-    {
-      return null;
-    }
-
-    if (node.ycount == count)
-    {
-      found = node.element();
-
-      return found;
-    }
-    else
-    {
-      _findLeaf((SequenceNode) node.left(), count);
-      _findLeaf((SequenceNode) node.right(), count);
-    }
-
-    return found;
-  }
-
-  /**
    * printNode is mainly for debugging purposes.
    * 
-   * @param node
+   * @param nd
    *          SequenceNode
    */
-  public void printNode(SequenceNode node)
+  void printNode(SequenceNode nd)
   {
-    if (node == null)
+    if (nd == null)
     {
       return;
     }
 
-    if ((node.left() == null) && (node.right() == null))
+    if ((nd.left() == null) && (nd.right() == null))
     {
-      System.out
-              .println("Leaf = " + ((SequenceI) node.element()).getName());
-      System.out.println("Dist " + ((SequenceNode) node).dist);
-      System.out.println("Boot " + node.getBootstrap());
+      System.out.println("Leaf = " + ((SequenceI) nd.element()).getName());
+      System.out.println("Dist " + nd.dist);
+      System.out.println("Boot " + nd.getBootstrap());
     }
     else
     {
-      System.out.println("Dist " + ((SequenceNode) node).dist);
-      printNode((SequenceNode) node.left());
-      printNode((SequenceNode) node.right());
+      System.out.println("Dist " + nd.dist);
+      printNode((SequenceNode) nd.left());
+      printNode((SequenceNode) nd.right());
     }
   }
 
   /**
    * DOCUMENT ME!
    * 
-   * @param node
+   * @param nd
    *          DOCUMENT ME!
    */
-  public void findMaxDist(SequenceNode node)
+  void findMaxDist(SequenceNode nd)
   {
-    if (node == null)
+    if (nd == null)
     {
       return;
     }
 
-    if ((node.left() == null) && (node.right() == null))
+    if ((nd.left() == null) && (nd.right() == null))
     {
-      float dist = ((SequenceNode) node).dist;
+      double dist = nd.dist;
 
       if (dist > maxDistValue)
       {
-        maxdist = (SequenceNode) node;
+        maxdist = nd;
         maxDistValue = dist;
       }
     }
     else
     {
-      findMaxDist((SequenceNode) node.left());
-      findMaxDist((SequenceNode) node.right());
+      findMaxDist((SequenceNode) nd.left());
+      findMaxDist((SequenceNode) nd.right());
     }
   }
 
@@ -976,7 +899,7 @@ public class NJTree
    * 
    * @return DOCUMENT ME!
    */
-  public Vector getGroups()
+  public Vector<SequenceNode> getGroups()
   {
     return groups;
   }
@@ -986,7 +909,7 @@ public class NJTree
    * 
    * @return DOCUMENT ME!
    */
-  public float getMaxHeight()
+  public double getMaxHeight()
   {
     return maxheight;
   }
@@ -994,51 +917,51 @@ public class NJTree
   /**
    * DOCUMENT ME!
    * 
-   * @param node
+   * @param nd
    *          DOCUMENT ME!
    * @param threshold
    *          DOCUMENT ME!
    */
-  public void groupNodes(SequenceNode node, float threshold)
+  public void groupNodes(SequenceNode nd, float threshold)
   {
-    if (node == null)
+    if (nd == null)
     {
       return;
     }
 
-    if ((node.height / maxheight) > threshold)
+    if ((nd.height / maxheight) > threshold)
     {
-      groups.addElement(node);
+      groups.addElement(nd);
     }
     else
     {
-      groupNodes((SequenceNode) node.left(), threshold);
-      groupNodes((SequenceNode) node.right(), threshold);
+      groupNodes((SequenceNode) nd.left(), threshold);
+      groupNodes((SequenceNode) nd.right(), threshold);
     }
   }
 
   /**
    * DOCUMENT ME!
    * 
-   * @param node
+   * @param nd
    *          DOCUMENT ME!
    * 
    * @return DOCUMENT ME!
    */
-  public float findHeight(SequenceNode node)
+  public double findHeight(SequenceNode nd)
   {
-    if (node == null)
+    if (nd == null)
     {
       return maxheight;
     }
 
-    if ((node.left() == null) && (node.right() == null))
+    if ((nd.left() == null) && (nd.right() == null))
     {
-      node.height = ((SequenceNode) node.parent()).height + node.dist;
+      nd.height = ((SequenceNode) nd.parent()).height + nd.dist;
 
-      if (node.height > maxheight)
+      if (nd.height > maxheight)
       {
-        return node.height;
+        return nd.height;
       }
       else
       {
@@ -1047,18 +970,18 @@ public class NJTree
     }
     else
     {
-      if (node.parent() != null)
+      if (nd.parent() != null)
       {
-        node.height = ((SequenceNode) node.parent()).height + node.dist;
+        nd.height = ((SequenceNode) nd.parent()).height + nd.dist;
       }
       else
       {
         maxheight = 0;
-        node.height = (float) 0.0;
+        nd.height = (float) 0.0;
       }
 
-      maxheight = findHeight((SequenceNode) (node.left()));
-      maxheight = findHeight((SequenceNode) (node.right()));
+      maxheight = findHeight((SequenceNode) (nd.left()));
+      maxheight = findHeight((SequenceNode) (nd.right()));
     }
 
     return maxheight;
@@ -1069,13 +992,14 @@ public class NJTree
    * 
    * @return DOCUMENT ME!
    */
-  public SequenceNode reRoot()
+  SequenceNode reRoot()
   {
+    // TODO not used - remove?
     if (maxdist != null)
     {
       ycount = 0;
 
-      float tmpdist = maxdist.dist;
+      double tmpdist = maxdist.dist;
 
       // New top
       SequenceNode sn = new SequenceNode();
@@ -1141,44 +1065,42 @@ public class NJTree
   /**
    * DOCUMENT ME!
    * 
-   * @param node
+   * @param nd
    *          DOCUMENT ME!
    */
-  public void printN(SequenceNode node)
+  void printN(SequenceNode nd)
   {
-    if (node == null)
+    if (nd == null)
     {
       return;
     }
 
-    if ((node.left() != null) && (node.right() != null))
+    if ((nd.left() != null) && (nd.right() != null))
     {
-      printN((SequenceNode) node.left());
-      printN((SequenceNode) node.right());
+      printN((SequenceNode) nd.left());
+      printN((SequenceNode) nd.right());
     }
     else
     {
-      System.out.println(" name = "
-              + ((SequenceI) node.element()).getName());
+      System.out.println(" name = " + ((SequenceI) nd.element()).getName());
     }
 
-    System.out.println(" dist = " + ((SequenceNode) node).dist + " "
-            + ((SequenceNode) node).count + " "
-            + ((SequenceNode) node).height);
+    System.out.println(" dist = " + nd.dist + " " + nd.count + " "
+            + nd.height);
   }
 
   /**
    * DOCUMENT ME!
    * 
-   * @param node
+   * @param nd
    *          DOCUMENT ME!
    */
-  public void reCount(SequenceNode node)
+  public void reCount(SequenceNode nd)
   {
     ycount = 0;
     _lycount = 0;
     // _lylimit = this.node.size();
-    _reCount(node);
+    _reCount(nd);
   }
 
   private long _lycount = 0, _lylimit = 0;
@@ -1186,37 +1108,37 @@ public class NJTree
   /**
    * DOCUMENT ME!
    * 
-   * @param node
+   * @param nd
    *          DOCUMENT ME!
    */
-  public void _reCount(SequenceNode node)
+  void _reCount(SequenceNode nd)
   {
     // if (_lycount<_lylimit)
     // {
     // System.err.println("Warning: depth of _recount greater than number of nodes.");
     // }
-    if (node == null)
+    if (nd == null)
     {
       return;
     }
     _lycount++;
 
-    if ((node.left() != null) && (node.right() != null))
+    if ((nd.left() != null) && (nd.right() != null))
     {
 
-      _reCount((SequenceNode) node.left());
-      _reCount((SequenceNode) node.right());
+      _reCount((SequenceNode) nd.left());
+      _reCount((SequenceNode) nd.right());
 
-      SequenceNode l = (SequenceNode) node.left();
-      SequenceNode r = (SequenceNode) node.right();
+      SequenceNode l = (SequenceNode) nd.left();
+      SequenceNode r = (SequenceNode) nd.right();
 
-      ((SequenceNode) node).count = l.count + r.count;
-      ((SequenceNode) node).ycount = (l.ycount + r.ycount) / 2;
+      nd.count = l.count + r.count;
+      nd.ycount = (l.ycount + r.ycount) / 2;
     }
     else
     {
-      ((SequenceNode) node).count = 1;
-      ((SequenceNode) node).ycount = ycount++;
+      nd.count = 1;
+      nd.ycount = ycount++;
     }
     _lycount--;
   }
@@ -1224,80 +1146,80 @@ public class NJTree
   /**
    * DOCUMENT ME!
    * 
-   * @param node
+   * @param nd
    *          DOCUMENT ME!
    */
-  public void swapNodes(SequenceNode node)
+  public void swapNodes(SequenceNode nd)
   {
-    if (node == null)
+    if (nd == null)
     {
       return;
     }
 
-    SequenceNode tmp = (SequenceNode) node.left();
+    SequenceNode tmp = (SequenceNode) nd.left();
 
-    node.setLeft(node.right());
-    node.setRight(tmp);
+    nd.setLeft(nd.right());
+    nd.setRight(tmp);
   }
 
   /**
    * DOCUMENT ME!
    * 
-   * @param node
+   * @param nd
    *          DOCUMENT ME!
    * @param dir
    *          DOCUMENT ME!
    */
-  public void changeDirection(SequenceNode node, SequenceNode dir)
+  void changeDirection(SequenceNode nd, SequenceNode dir)
   {
-    if (node == null)
+    if (nd == null)
     {
       return;
     }
 
-    if (node.parent() != top)
+    if (nd.parent() != top)
     {
-      changeDirection((SequenceNode) node.parent(), node);
+      changeDirection((SequenceNode) nd.parent(), nd);
 
-      SequenceNode tmp = (SequenceNode) node.parent();
+      SequenceNode tmp = (SequenceNode) nd.parent();
 
-      if (dir == node.left())
+      if (dir == nd.left())
       {
-        node.setParent(dir);
-        node.setLeft(tmp);
+        nd.setParent(dir);
+        nd.setLeft(tmp);
       }
-      else if (dir == node.right())
+      else if (dir == nd.right())
       {
-        node.setParent(dir);
-        node.setRight(tmp);
+        nd.setParent(dir);
+        nd.setRight(tmp);
       }
     }
     else
     {
-      if (dir == node.left())
+      if (dir == nd.left())
       {
-        node.setParent(node.left());
+        nd.setParent(nd.left());
 
-        if (top.left() == node)
+        if (top.left() == nd)
         {
-          node.setRight(top.right());
+          nd.setRight(top.right());
         }
         else
         {
-          node.setRight(top.left());
+          nd.setRight(top.left());
         }
       }
       else
       {
-        node.setParent(node.right());
+        nd.setParent(nd.right());
 
-        if (top.left() == node)
+        if (top.left() == nd)
         {
-          node.setLeft(top.right());
+          nd.setLeft(top.right());
         }
         else
         {
-          node.setLeft(top.left());
+          nd.setLeft(top.left());
         }
       }
     }
@@ -1327,7 +1249,7 @@ public class NJTree
    * 
    * @return true if tree has real distances
    */
-  public boolean isHasDistances()
+  public boolean hasDistances()
   {
     return hasDistances;
   }
@@ -1336,12 +1258,12 @@ public class NJTree
    * 
    * @return true if tree has real bootstrap values
    */
-  public boolean isHasBootstrap()
+  public boolean hasBootstrap()
   {
     return hasBootstrap;
   }
 
-  public boolean isHasRootDistance()
+  public boolean hasRootDistance()
   {
     return hasRootDistance;
   }
@@ -1353,9 +1275,12 @@ public class NJTree
    */
   public void applyToNodes(NodeTransformI nodeTransformI)
   {
-    for (Enumeration nodes = node.elements(); nodes.hasMoreElements(); nodeTransformI
-            .transform((BinaryNode) nodes.nextElement()))
+    for (Enumeration<SequenceNode> nodes = node.elements(); nodes
+            .hasMoreElements(); nodeTransformI.transform(nodes
+            .nextElement()))
+    {
       ;
+    }
   }
 }
 
@@ -1365,6 +1290,7 @@ public class NJTree
  * @author $author$
  * @version $Revision$
  */
+// TODO what does this class have that int[] doesn't have already?
 class Cluster
 {
   int[] value;