Works on strings, not seqs
[jalview.git] / src / jalview / analysis / NJTree.java
index 4aeee3d..be3b96d 100755 (executable)
+/*\r
+* Jalview - A Sequence Alignment Editor and Viewer\r
+* Copyright (C) 2005 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle\r
+*\r
+* This program is free software; you can redistribute it and/or\r
+* modify it under the terms of the GNU General Public License\r
+* as published by the Free Software Foundation; either version 2\r
+* of the License, or (at your option) any later version.\r
+*\r
+* This program is distributed in the hope that it will be useful,\r
+* but WITHOUT ANY WARRANTY; without even the implied warranty of\r
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
+* GNU General Public License for more details.\r
+*\r
+* You should have received a copy of the GNU General Public License\r
+* along with this program; if not, write to the Free Software\r
+* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA\r
+*/\r
 package jalview.analysis;\r
 \r
 import jalview.datamodel.*;\r
-import jalview.util.*;\r
-import jalview.schemes.ResidueProperties;\r
-import java.util.*;\r
-\r
-public class NJTree {\r
-\r
-  Vector cluster;\r
-  SequenceI[] sequence;\r
-\r
-  int done[];\r
-  int noseqs;\r
-  int noClus;\r
 \r
-  float distance[][];\r
+import jalview.io.NewickFile;\r
 \r
-  int mini;\r
-  int minj;\r
-  float ri;\r
-  float rj;\r
-\r
-  Vector groups = new Vector();\r
-  SequenceNode maxdist;\r
-  SequenceNode top;\r
-\r
-  float maxDistValue;\r
-  float maxheight;\r
-\r
-  int ycount;\r
+import jalview.schemes.ResidueProperties;\r
 \r
-  Vector node;\r
+import jalview.util.*;\r
 \r
-  String type;\r
-  String pwtype;\r
+import java.util.*;\r
 \r
-  Object found = null;\r
-  Object leaves = null;\r
 \r
-  int start;\r
-  int end;\r
+/**\r
+ * DOCUMENT ME!\r
+ *\r
+ * @author $author$\r
+ * @version $Revision$\r
+ */\r
+public class NJTree\r
+{\r
+    Vector cluster;\r
+    SequenceI[] sequence;\r
+\r
+    //SequenceData is a string representation of what the user\r
+    //sees. The display may contain hidden columns.\r
+    String [] sequenceString;\r
+\r
+    int[] done;\r
+    int noseqs;\r
+    int noClus;\r
+    float[][] distance;\r
+    int mini;\r
+    int minj;\r
+    float ri;\r
+    float rj;\r
+    Vector groups = new Vector();\r
+    SequenceNode maxdist;\r
+    SequenceNode top;\r
+    float maxDistValue;\r
+    float maxheight;\r
+    int ycount;\r
+    Vector node;\r
+    String type;\r
+    String pwtype;\r
+    Object found = null;\r
+    Object leaves = null;\r
+\r
+    boolean hasDistances = true; // normal case for jalview trees\r
+    boolean hasBootstrap = false; // normal case for jalview trees\r
+\r
+    private boolean hasRootDistance = true;\r
+\r
+\r
+    /**\r
+     * Creates a new NJTree object.\r
+     *\r
+     * @param seqs DOCUMENT ME!\r
+     * @param treefile DOCUMENT ME!\r
+     */\r
+    public NJTree(SequenceI[] seqs,  NewickFile treefile)\r
+    {\r
+        top = treefile.getTree();\r
+\r
+        if (sequenceString == null)\r
+        {\r
+          sequenceString = new String[sequence.length];\r
+          for (int i = 0; i < sequence.length; i++)\r
+          {\r
+            sequenceString[i] = sequence[i].getSequence();\r
+          }\r
+        }\r
 \r
-  public NJTree(SequenceNode node) {\r
-    top = node;\r
-    maxheight = findHeight(top);\r
-  }\r
 \r
-  public NJTree(SequenceI[] sequence,int start, int end) {\r
-    this(sequence,"NJ","BL",start,end);\r
-  }\r
+        hasDistances = treefile.HasDistances();\r
+        hasBootstrap = treefile.HasBootstrap();\r
+        hasRootDistance = treefile.HasRootDistance();\r
 \r
-  public NJTree(SequenceI[] sequence,String type,String pwtype,int start, int end ) {\r
+        maxheight = findHeight(top);\r
 \r
-    this.sequence = sequence;\r
-    this.node     = new Vector();\r
-    this.type     = type;\r
-    this.pwtype   = pwtype;\r
-    this.start    = start;\r
-    this.end      = end;\r
+        SequenceIdMatcher algnIds = new SequenceIdMatcher(seqs);\r
 \r
-    if (!(type.equals("NJ"))) {\r
-      type = "AV";\r
-    }\r
+        Vector leaves = new Vector();\r
+        findLeaves(top, leaves);\r
 \r
-    if (!(pwtype.equals("PID"))) {\r
-      type = "BL";\r
-    }\r
+        int i = 0;\r
+        int namesleft = seqs.length;\r
 \r
-    int i=0;\r
+        SequenceNode j;\r
+        SequenceI nam;\r
+        String realnam;\r
 \r
-    done = new int[sequence.length];\r
+        while (i < leaves.size())\r
+        {\r
+            j = (SequenceNode) leaves.elementAt(i++);\r
+            realnam = j.getName();\r
+            nam = null;\r
 \r
+            if (namesleft > -1)\r
+            {\r
+                nam = algnIds.findIdMatch(realnam);\r
+            }\r
 \r
-    while (i < sequence.length  && sequence[i] != null) {\r
-      done[i] = 0;\r
-      i++;\r
+            if (nam != null)\r
+            {\r
+                j.setElement(nam);\r
+                namesleft--;\r
+            }\r
+            else\r
+            {\r
+                j.setElement(new Sequence(realnam, "THISISAPLACEHLDER"));\r
+                j.setPlaceholder(true);\r
+            }\r
+        }\r
     }\r
 \r
-    noseqs = i++;\r
-\r
-    distance = findDistances();\r
-\r
-    makeLeaves();\r
+    /**\r
+     * Creates a new NJTree object.\r
+     *\r
+     * @param sequence DOCUMENT ME!\r
+     * @param type DOCUMENT ME!\r
+     * @param pwtype DOCUMENT ME!\r
+     * @param start DOCUMENT ME!\r
+     * @param end DOCUMENT ME!\r
+     */\r
+    public NJTree(SequenceI[] sequence,\r
+                  String [] sequenceString,\r
+                  String type,\r
+                  String pwtype,\r
+                  int start, int end)\r
+    {\r
+        this.sequence = sequence;\r
+        this.node = new Vector();\r
+        this.type = type;\r
+        this.pwtype = pwtype;\r
+\r
+        if (sequenceString == null)\r
+        {\r
+          this.sequenceString = new String[sequence.length];\r
+          for(int i=0; i<sequence.length; i++)\r
+          {\r
+            this.sequenceString[i] = sequence[i].getSequence(start, end);\r
+          }\r
+        }\r
+        else\r
+          this.sequenceString = sequenceString;\r
 \r
-    noClus = cluster.size();\r
 \r
-    cluster();\r
+        if (!(type.equals("NJ")))\r
+        {\r
+            type = "AV";\r
+        }\r
 \r
-  }\r
+        if (!(pwtype.equals("PID")))\r
+        {\r
+            type = "BL";\r
+        }\r
 \r
+        int i = 0;\r
 \r
-  public void cluster() {\r
+        done = new int[sequence.length];\r
 \r
-    while (noClus > 2) {\r
-      if (type.equals("NJ")) {\r
-        float mind = findMinNJDistance();\r
-      } else {\r
-        float mind = findMinDistance();\r
-      }\r
+        while ((i < sequence.length) && (sequence[i] != null))\r
+        {\r
+            done[i] = 0;\r
+            i++;\r
+        }\r
 \r
-      Cluster c = joinClusters(mini,minj);\r
+        noseqs = i++;\r
 \r
+        distance = findDistances();\r
 \r
-      done[minj] = 1;\r
+        makeLeaves();\r
 \r
-      cluster.setElementAt(null,minj);\r
-      cluster.setElementAt(c,mini);\r
+        noClus = cluster.size();\r
 \r
-      noClus--;\r
+        cluster();\r
     }\r
 \r
-    boolean onefound = false;\r
+    /**\r
+     * DOCUMENT ME!\r
+     *\r
+     * @return DOCUMENT ME!\r
+     */\r
+    public String toString()\r
+    {\r
+        jalview.io.NewickFile fout = new jalview.io.NewickFile(getTopNode());\r
 \r
-    int one = -1;\r
-    int two = -1;\r
+        return fout.print(false, true); // distances only\r
+    }\r
 \r
-    for (int i=0; i < noseqs; i++) {\r
-      if (done[i] != 1) {\r
-        if (onefound == false) {\r
-          two = i;\r
-          onefound = true;\r
-        } else {\r
-          one = i;\r
+    /**\r
+     *\r
+     * used when the alignment associated to a tree has changed.\r
+     *\r
+     * @param alignment Vector\r
+     */\r
+    public void UpdatePlaceHolders(Vector alignment)\r
+    {\r
+        Vector leaves = new Vector();\r
+        findLeaves(top, leaves);\r
+\r
+        int sz = leaves.size();\r
+        SequenceIdMatcher seqmatcher = null;\r
+        int i = 0;\r
+\r
+        while (i < sz)\r
+        {\r
+            SequenceNode leaf = (SequenceNode) leaves.elementAt(i++);\r
+\r
+            if (alignment.contains(leaf.element()))\r
+            {\r
+                leaf.setPlaceholder(false);\r
+            }\r
+            else\r
+            {\r
+                if (seqmatcher == null)\r
+                {\r
+                    // Only create this the first time we need it\r
+                    SequenceI[] seqs = new SequenceI[alignment.size()];\r
+\r
+                    for (int j = 0; j < seqs.length; j++)\r
+                        seqs[j] = (SequenceI) alignment.elementAt(j);\r
+\r
+                    seqmatcher = new SequenceIdMatcher(seqs);\r
+                }\r
+\r
+                SequenceI nam = seqmatcher.findIdMatch(leaf.getName());\r
+\r
+                if (nam != null)\r
+                {\r
+                    leaf.setPlaceholder(false);\r
+                    leaf.setElement(nam);\r
+                }\r
+                else\r
+                {\r
+                    leaf.setPlaceholder(true);\r
+                }\r
+            }\r
         }\r
-      }\r
     }\r
 \r
-    Cluster c = joinClusters(one,two);\r
-    top = (SequenceNode)(node.elementAt(one));\r
-\r
-    reCount(top);\r
-    findHeight(top);\r
-    findMaxDist(top);\r
-\r
-  }\r
-\r
-  public Cluster joinClusters(int i, int j) {\r
-\r
-    float dist = distance[i][j];\r
-\r
-    int noi = ((Cluster)cluster.elementAt(i)).value.length;\r
-    int noj = ((Cluster)cluster.elementAt(j)).value.length;\r
+    /**\r
+     * DOCUMENT ME!\r
+     */\r
+    public void cluster()\r
+    {\r
+        while (noClus > 2)\r
+        {\r
+            if (type.equals("NJ"))\r
+            {\r
+                findMinNJDistance();\r
+            }\r
+            else\r
+            {\r
+                findMinDistance();\r
+            }\r
+\r
+            Cluster c = joinClusters(mini, minj);\r
+\r
+            done[minj] = 1;\r
+\r
+            cluster.setElementAt(null, minj);\r
+            cluster.setElementAt(c, mini);\r
+\r
+            noClus--;\r
+        }\r
 \r
-    int[] value = new int[noi + noj];\r
+        boolean onefound = false;\r
+\r
+        int one = -1;\r
+        int two = -1;\r
+\r
+        for (int i = 0; i < noseqs; i++)\r
+        {\r
+            if (done[i] != 1)\r
+            {\r
+                if (onefound == false)\r
+                {\r
+                    two = i;\r
+                    onefound = true;\r
+                }\r
+                else\r
+                {\r
+                    one = i;\r
+                }\r
+            }\r
+        }\r
 \r
-    for (int ii = 0; ii < noi;ii++) {\r
-      value[ii] =  ((Cluster)cluster.elementAt(i)).value[ii];\r
-    }\r
+        joinClusters(one, two);\r
+        top = (SequenceNode) (node.elementAt(one));\r
 \r
-    for (int ii = noi; ii < noi+ noj;ii++) {\r
-      value[ii] =  ((Cluster)cluster.elementAt(j)).value[ii-noi];\r
+        reCount(top);\r
+        findHeight(top);\r
+        findMaxDist(top);\r
     }\r
 \r
-    Cluster c = new Cluster(value);\r
-\r
-    ri = findr(i,j);\r
-    rj = findr(j,i);\r
-\r
-    if (type.equals("NJ")) {\r
-      findClusterNJDistance(i,j);\r
-    } else {\r
-      findClusterDistance(i,j);\r
-    }\r
+    /**\r
+     * DOCUMENT ME!\r
+     *\r
+     * @param i DOCUMENT ME!\r
+     * @param j DOCUMENT ME!\r
+     *\r
+     * @return DOCUMENT ME!\r
+     */\r
+    public Cluster joinClusters(int i, int j)\r
+    {\r
+        float dist = distance[i][j];\r
+\r
+        int noi = ((Cluster) cluster.elementAt(i)).value.length;\r
+        int noj = ((Cluster) cluster.elementAt(j)).value.length;\r
+\r
+        int[] value = new int[noi + noj];\r
+\r
+        for (int ii = 0; ii < noi; ii++)\r
+        {\r
+            value[ii] = ((Cluster) cluster.elementAt(i)).value[ii];\r
+        }\r
 \r
-    SequenceNode sn = new SequenceNode();\r
+        for (int ii = noi; ii < (noi + noj); ii++)\r
+        {\r
+            value[ii] = ((Cluster) cluster.elementAt(j)).value[ii - noi];\r
+        }\r
 \r
-    sn.setLeft((SequenceNode)(node.elementAt(i)));\r
-    sn.setRight((SequenceNode)(node.elementAt(j)));\r
+        Cluster c = new Cluster(value);\r
 \r
-    SequenceNode tmpi = (SequenceNode)(node.elementAt(i));\r
-    SequenceNode tmpj = (SequenceNode)(node.elementAt(j));\r
+        ri = findr(i, j);\r
+        rj = findr(j, i);\r
 \r
-    if (type.equals("NJ")) {\r
-      findNewNJDistances(tmpi,tmpj,dist);\r
-    } else {\r
-      findNewDistances(tmpi,tmpj,dist);\r
-    }\r
+        if (type.equals("NJ"))\r
+        {\r
+            findClusterNJDistance(i, j);\r
+        }\r
+        else\r
+        {\r
+            findClusterDistance(i, j);\r
+        }\r
 \r
-    tmpi.setParent(sn);\r
-    tmpj.setParent(sn);\r
+        SequenceNode sn = new SequenceNode();\r
 \r
-    node.setElementAt(sn,i);\r
-    return c;\r
-  }\r
+        sn.setLeft((SequenceNode) (node.elementAt(i)));\r
+        sn.setRight((SequenceNode) (node.elementAt(j)));\r
 \r
-  public void findNewNJDistances(SequenceNode tmpi, SequenceNode tmpj, float dist) {\r
+        SequenceNode tmpi = (SequenceNode) (node.elementAt(i));\r
+        SequenceNode tmpj = (SequenceNode) (node.elementAt(j));\r
 \r
-    float ih = 0;\r
-    float jh = 0;\r
+        if (type.equals("NJ"))\r
+        {\r
+            findNewNJDistances(tmpi, tmpj, dist);\r
+        }\r
+        else\r
+        {\r
+            findNewDistances(tmpi, tmpj, dist);\r
+        }\r
 \r
-    SequenceNode sni = tmpi;\r
-    SequenceNode snj = tmpj;\r
+        tmpi.setParent(sn);\r
+        tmpj.setParent(sn);\r
 \r
-    tmpi.dist = (dist + ri - rj)/2;\r
-    tmpj.dist = (dist - tmpi.dist);\r
+        node.setElementAt(sn, i);\r
 \r
-    if (tmpi.dist < 0) {\r
-      tmpi.dist = 0;\r
+        return c;\r
     }\r
-    if (tmpj.dist < 0) {\r
-      tmpj.dist = 0;\r
-    }\r
-  }\r
-\r
-  public void findNewDistances(SequenceNode tmpi,SequenceNode tmpj,float dist) {\r
 \r
-    float ih = 0;\r
-    float jh = 0;\r
-\r
-    SequenceNode sni = tmpi;\r
-    SequenceNode snj = tmpj;\r
-\r
-    while (sni != null) {\r
-      ih = ih + sni.dist;\r
-      sni = (SequenceNode)sni.left();\r
-    }\r
+    /**\r
+     * DOCUMENT ME!\r
+     *\r
+     * @param tmpi DOCUMENT ME!\r
+     * @param tmpj DOCUMENT ME!\r
+     * @param dist DOCUMENT ME!\r
+     */\r
+    public void findNewNJDistances(SequenceNode tmpi, SequenceNode tmpj,\r
+        float dist)\r
+    {\r
+\r
+        tmpi.dist = ((dist + ri) - rj) / 2;\r
+        tmpj.dist = (dist - tmpi.dist);\r
+\r
+        if (tmpi.dist < 0)\r
+        {\r
+            tmpi.dist = 0;\r
+        }\r
 \r
-    while (snj != null) {\r
-      jh = jh + snj.dist;\r
-      snj = (SequenceNode)snj.left();\r
+        if (tmpj.dist < 0)\r
+        {\r
+            tmpj.dist = 0;\r
+        }\r
     }\r
 \r
-    tmpi.dist = (dist/2 - ih);\r
-    tmpj.dist = (dist/2 - jh);\r
-  }\r
-\r
-\r
+    /**\r
+     * DOCUMENT ME!\r
+     *\r
+     * @param tmpi DOCUMENT ME!\r
+     * @param tmpj DOCUMENT ME!\r
+     * @param dist DOCUMENT ME!\r
+     */\r
+    public void findNewDistances(SequenceNode tmpi, SequenceNode tmpj,\r
+        float dist)\r
+    {\r
+        float ih = 0;\r
+        float jh = 0;\r
+\r
+        SequenceNode sni = tmpi;\r
+        SequenceNode snj = tmpj;\r
+\r
+        while (sni != null)\r
+        {\r
+            ih = ih + sni.dist;\r
+            sni = (SequenceNode) sni.left();\r
+        }\r
 \r
-  public void findClusterDistance(int i, int j) {\r
+        while (snj != null)\r
+        {\r
+            jh = jh + snj.dist;\r
+            snj = (SequenceNode) snj.left();\r
+        }\r
 \r
-    int noi = ((Cluster)cluster.elementAt(i)).value.length;\r
-    int noj = ((Cluster)cluster.elementAt(j)).value.length;\r
+        tmpi.dist = ((dist / 2) - ih);\r
+        tmpj.dist = ((dist / 2) - jh);\r
+    }\r
 \r
-    // New distances from cluster to others\r
-    float[] newdist = new float[noseqs];\r
+    /**\r
+     * DOCUMENT ME!\r
+     *\r
+     * @param i DOCUMENT ME!\r
+     * @param j DOCUMENT ME!\r
+     */\r
+    public void findClusterDistance(int i, int j)\r
+    {\r
+        int noi = ((Cluster) cluster.elementAt(i)).value.length;\r
+        int noj = ((Cluster) cluster.elementAt(j)).value.length;\r
+\r
+        // New distances from cluster to others\r
+        float[] newdist = new float[noseqs];\r
+\r
+        for (int l = 0; l < noseqs; l++)\r
+        {\r
+            if ((l != i) && (l != j))\r
+            {\r
+                newdist[l] = ((distance[i][l] * noi) + (distance[j][l] * noj)) / (noi +\r
+                    noj);\r
+            }\r
+            else\r
+            {\r
+                newdist[l] = 0;\r
+            }\r
+        }\r
 \r
-    for (int l = 0; l < noseqs; l++) {\r
-      if ( l != i && l != j) {\r
-        newdist[l] = (distance[i][l] * noi + distance[j][l] * noj)/(noi + noj);\r
-      } else {\r
-        newdist[l] = 0;\r
-      }\r
+        for (int ii = 0; ii < noseqs; ii++)\r
+        {\r
+            distance[i][ii] = newdist[ii];\r
+            distance[ii][i] = newdist[ii];\r
+        }\r
     }\r
 \r
-    for (int ii=0; ii < noseqs;ii++) {\r
-      distance[i][ii] = newdist[ii];\r
-      distance[ii][i] = newdist[ii];\r
-    }\r
-  }\r
+    /**\r
+     * DOCUMENT ME!\r
+     *\r
+     * @param i DOCUMENT ME!\r
+     * @param j DOCUMENT ME!\r
+     */\r
+    public void findClusterNJDistance(int i, int j)\r
+    {\r
+\r
+        // New distances from cluster to others\r
+        float[] newdist = new float[noseqs];\r
+\r
+        for (int l = 0; l < noseqs; l++)\r
+        {\r
+            if ((l != i) && (l != j))\r
+            {\r
+                newdist[l] = ((distance[i][l] + distance[j][l]) -\r
+                    distance[i][j]) / 2;\r
+            }\r
+            else\r
+            {\r
+                newdist[l] = 0;\r
+            }\r
+        }\r
 \r
-  public void findClusterNJDistance(int i, int j) {\r
+        for (int ii = 0; ii < noseqs; ii++)\r
+        {\r
+            distance[i][ii] = newdist[ii];\r
+            distance[ii][i] = newdist[ii];\r
+        }\r
+    }\r
 \r
-    int noi = ((Cluster)cluster.elementAt(i)).value.length;\r
-    int noj = ((Cluster)cluster.elementAt(j)).value.length;\r
+    /**\r
+     * DOCUMENT ME!\r
+     *\r
+     * @param i DOCUMENT ME!\r
+     * @param j DOCUMENT ME!\r
+     *\r
+     * @return DOCUMENT ME!\r
+     */\r
+    public float findr(int i, int j)\r
+    {\r
+        float tmp = 1;\r
+\r
+        for (int k = 0; k < noseqs; k++)\r
+        {\r
+            if ((k != i) && (k != j) && (done[k] != 1))\r
+            {\r
+                tmp = tmp + distance[i][k];\r
+            }\r
+        }\r
 \r
-    // New distances from cluster to others\r
-    float[] newdist = new float[noseqs];\r
+        if (noClus > 2)\r
+        {\r
+            tmp = tmp / (noClus - 2);\r
+        }\r
 \r
-    for (int l = 0; l < noseqs; l++) {\r
-      if ( l != i && l != j) {\r
-        newdist[l] = (distance[i][l] + distance[j][l] - distance[i][j])/2;\r
-      } else {\r
-        newdist[l] = 0;\r
-      }\r
+        return tmp;\r
     }\r
 \r
-    for (int ii=0; ii < noseqs;ii++) {\r
-      distance[i][ii] = newdist[ii];\r
-      distance[ii][i] = newdist[ii];\r
+    /**\r
+     * DOCUMENT ME!\r
+     *\r
+     * @return DOCUMENT ME!\r
+     */\r
+    public float findMinNJDistance()\r
+    {\r
+        float min = 100000;\r
+\r
+        for (int i = 0; i < (noseqs - 1); i++)\r
+        {\r
+            for (int j = i + 1; j < noseqs; j++)\r
+            {\r
+                if ((done[i] != 1) && (done[j] != 1))\r
+                {\r
+                    float tmp = distance[i][j] - (findr(i, j) + findr(j, i));\r
+\r
+                    if (tmp < min)\r
+                    {\r
+                        mini = i;\r
+                        minj = j;\r
+\r
+                        min = tmp;\r
+                    }\r
+                }\r
+            }\r
+        }\r
+\r
+        return min;\r
     }\r
-  }\r
 \r
-  public float findr(int i, int j) {\r
+    /**\r
+     * DOCUMENT ME!\r
+     *\r
+     * @return DOCUMENT ME!\r
+     */\r
+    public float findMinDistance()\r
+    {\r
+        float min = 100000;\r
+\r
+        for (int i = 0; i < (noseqs - 1); i++)\r
+        {\r
+            for (int j = i + 1; j < noseqs; j++)\r
+            {\r
+                if ((done[i] != 1) && (done[j] != 1))\r
+                {\r
+                    if (distance[i][j] < min)\r
+                    {\r
+                        mini = i;\r
+                        minj = j;\r
+\r
+                        min = distance[i][j];\r
+                    }\r
+                }\r
+            }\r
+        }\r
 \r
-    float tmp = 1;\r
-    for (int k=0; k < noseqs;k++) {\r
-      if (k!= i && k!= j && done[k] != 1) {\r
-        tmp = tmp + distance[i][k];\r
-      }\r
+        return min;\r
     }\r
 \r
-    if (noClus > 2) {\r
-      tmp = tmp/(noClus - 2);\r
+    /**\r
+     * DOCUMENT ME!\r
+     *\r
+     * @return DOCUMENT ME!\r
+     */\r
+    public float[][] findDistances()\r
+    {\r
+        float[][] distance = new float[noseqs][noseqs];\r
+\r
+        if (pwtype.equals("PID"))\r
+        {\r
+            for (int i = 0; i < (noseqs - 1); i++)\r
+            {\r
+                for (int j = i; j < noseqs; j++)\r
+                {\r
+                    if (j == i)\r
+                    {\r
+                        distance[i][i] = 0;\r
+                    }\r
+                    else\r
+                    {\r
+                        distance[i][j] = 100 -\r
+                             Comparison.PID(sequenceString[i], sequenceString[j]);\r
+\r
+                        distance[j][i] = distance[i][j];\r
+                    }\r
+                }\r
+            }\r
+        }\r
+        else if (pwtype.equals("BL"))\r
+        {\r
+            int maxscore = 0;\r
+            int end = sequenceString[0].length();\r
+            for (int i = 0; i < (noseqs - 1); i++)\r
+            {\r
+                for (int j = i; j < noseqs; j++)\r
+                {\r
+                    int score = 0;\r
+\r
+                    for (int k = 0; k < end; k++)\r
+                    {\r
+                        try\r
+                        {\r
+                            score += ResidueProperties.getBLOSUM62(\r
+                              sequenceString[i].substring(k, k + 1),\r
+                              sequenceString[j].substring(k, k + 1));\r
+                        }\r
+                        catch (Exception ex)\r
+                        {\r
+                            System.err.println("err creating BLOSUM62 tree");\r
+                            ex.printStackTrace();\r
+                        }\r
+                    }\r
+\r
+                    distance[i][j] = (float) score;\r
+\r
+                    if (score > maxscore)\r
+                    {\r
+                        maxscore = score;\r
+                    }\r
+                }\r
+            }\r
+\r
+            for (int i = 0; i < (noseqs - 1); i++)\r
+            {\r
+                for (int j = i; j < noseqs; j++)\r
+                {\r
+                    distance[i][j] = (float) maxscore - distance[i][j];\r
+                    distance[j][i] = distance[i][j];\r
+                }\r
+            }\r
+        }\r
+      /*  else if (pwtype.equals("SW"))\r
+        {\r
+            float max = -1;\r
+\r
+            for (int i = 0; i < (noseqs - 1); i++)\r
+            {\r
+                for (int j = i; j < noseqs; j++)\r
+                {\r
+                    AlignSeq as = new AlignSeq(sequence[i], sequence[j], "pep");\r
+                    as.calcScoreMatrix();\r
+                    as.traceAlignment();\r
+                    as.printAlignment(System.out);\r
+                    distance[i][j] = (float) as.maxscore;\r
+\r
+                    if (max < distance[i][j])\r
+                    {\r
+                        max = distance[i][j];\r
+                    }\r
+                }\r
+            }\r
+\r
+            for (int i = 0; i < (noseqs - 1); i++)\r
+            {\r
+                for (int j = i; j < noseqs; j++)\r
+                {\r
+                    distance[i][j] = max - distance[i][j];\r
+                    distance[j][i] = distance[i][j];\r
+                }\r
+            }\r
+        }/*/\r
+\r
+        return distance;\r
     }\r
 \r
-    return tmp;\r
-  }\r
+    /**\r
+     * DOCUMENT ME!\r
+     */\r
+    public void makeLeaves()\r
+    {\r
+        cluster = new Vector();\r
 \r
-  public float findMinNJDistance() {\r
+        for (int i = 0; i < noseqs; i++)\r
+        {\r
+            SequenceNode sn = new SequenceNode();\r
 \r
-    float min = 100000;\r
+            sn.setElement(sequence[i]);\r
+            sn.setName(sequence[i].getName());\r
+            node.addElement(sn);\r
 \r
-    for (int i=0; i < noseqs-1; i++) {\r
-      for (int j=i+1;j < noseqs;j++) {\r
-        if (done[i] != 1 && done[j] != 1) {\r
-          float tmp = distance[i][j] - (findr(i,j) + findr(j,i));\r
-          if (tmp < min) {\r
+            int[] value = new int[1];\r
+            value[0] = i;\r
 \r
-            mini = i;\r
-            minj = j;\r
-\r
-            min = tmp;\r
-\r
-          }\r
+            Cluster c = new Cluster(value);\r
+            cluster.addElement(c);\r
         }\r
-      }\r
     }\r
-    return min;\r
-  }\r
-\r
-  public float findMinDistance() {\r
 \r
-    float min = 100000;\r
+    /**\r
+     * DOCUMENT ME!\r
+     *\r
+     * @param node DOCUMENT ME!\r
+     * @param leaves DOCUMENT ME!\r
+     *\r
+     * @return DOCUMENT ME!\r
+     */\r
+    public Vector findLeaves(SequenceNode node, Vector leaves)\r
+    {\r
+        if (node == null)\r
+        {\r
+            return leaves;\r
+        }\r
 \r
-    for (int i=0; i < noseqs-1;i++) {\r
-      for (int j = i+1; j < noseqs;j++) {\r
-        if (done[i] != 1 && done[j] != 1) {\r
-          if (distance[i][j] < min) {\r
-            mini = i;\r
-            minj = j;\r
+        if ((node.left() == null) && (node.right() == null))\r
+        {\r
+            leaves.addElement(node);\r
 \r
-            min = distance[i][j];\r
-          }\r
+            return leaves;\r
         }\r
-      }\r
+        else\r
+        {\r
+            findLeaves((SequenceNode) node.left(), leaves);\r
+            findLeaves((SequenceNode) node.right(), leaves);\r
+        }\r
+\r
+        return leaves;\r
+    }\r
+\r
+    /**\r
+     * DOCUMENT ME!\r
+     *\r
+     * @param node DOCUMENT ME!\r
+     * @param count DOCUMENT ME!\r
+     *\r
+     * @return DOCUMENT ME!\r
+     */\r
+    public Object findLeaf(SequenceNode node, int count)\r
+    {\r
+        found = _findLeaf(node, count);\r
+\r
+        return found;\r
     }\r
-    return min;\r
-  }\r
 \r
-  public float[][] findDistances() {\r
+    /**\r
+     * DOCUMENT ME!\r
+     *\r
+     * @param node DOCUMENT ME!\r
+     * @param count DOCUMENT ME!\r
+     *\r
+     * @return DOCUMENT ME!\r
+     */\r
+    public Object _findLeaf(SequenceNode node, int count)\r
+    {\r
+        if (node == null)\r
+        {\r
+            return null;\r
+        }\r
 \r
-    float[][] distance = new float[noseqs][noseqs];\r
+        if (node.ycount == count)\r
+        {\r
+            found = node.element();\r
 \r
-    if (pwtype.equals("PID")) {\r
-      for (int i = 0; i < noseqs-1; i++) {\r
-        for (int j = i; j < noseqs; j++) {\r
-          if (j==i) {\r
-            distance[i][i] = 0;\r
-          } else {\r
-            distance[i][j] = 100-Comparison.compare(sequence[i],sequence[j],start,end);\r
-            distance[j][i] = distance[i][j];\r
-          }\r
+            return found;\r
         }\r
-      }\r
-    } else if (pwtype.equals("BL")) {\r
-      int   maxscore = 0;\r
-\r
-      for (int i = 0; i < noseqs-1; i++) {\r
-        for (int j = i; j < noseqs; j++) {\r
-          int score = 0;\r
-          for (int k=0; k < sequence[i].getLength(); k++) {\r
-            try{\r
-              score +=\r
-                  ResidueProperties.getBLOSUM62(sequence[i].getSequence(k,\r
-                  k + 1),\r
-                                                sequence[j].getSequence(k,\r
-                  k + 1));\r
-            }catch(Exception ex){System.out.println("err creating BLOSUM62 tree");}\r
-          }\r
-          distance[i][j] = (float)score;\r
-          if (score > maxscore) {\r
-            maxscore = score;\r
-          }\r
+        else\r
+        {\r
+            _findLeaf((SequenceNode) node.left(), count);\r
+            _findLeaf((SequenceNode) node.right(), count);\r
         }\r
-      }\r
-      for (int i = 0; i < noseqs-1; i++) {\r
-        for (int j = i; j < noseqs; j++) {\r
-          distance[i][j] =  (float)maxscore - distance[i][j];\r
-          distance[j][i] = distance[i][j];\r
+\r
+        return found;\r
+    }\r
+\r
+    /**\r
+     * printNode is mainly for debugging purposes.\r
+     *\r
+     * @param node SequenceNode\r
+     */\r
+    public void printNode(SequenceNode node)\r
+    {\r
+        if (node == null)\r
+        {\r
+            return;\r
         }\r
-      }\r
-    } else if (pwtype.equals("SW")) {\r
-      float max = -1;\r
-      for (int i = 0; i < noseqs-1; i++) {\r
-        for (int j = i; j < noseqs; j++) {\r
-          AlignSeq as = new AlignSeq(sequence[i],sequence[j],"pep");\r
-          as.calcScoreMatrix();\r
-          as.traceAlignment();\r
-          as.printAlignment();\r
-          distance[i][j] = (float)as.maxscore;\r
-          if (max < distance[i][j]) {\r
-            max = distance[i][j];\r
-          }\r
+\r
+        if ((node.left() == null) && (node.right() == null))\r
+        {\r
+            System.out.println("Leaf = " +\r
+                ((SequenceI) node.element()).getName());\r
+            System.out.println("Dist " + ((SequenceNode) node).dist);\r
+            System.out.println("Boot " + node.getBootstrap());\r
         }\r
-      }\r
-      for (int i = 0; i < noseqs-1; i++) {\r
-        for (int j = i; j < noseqs; j++) {\r
-          distance[i][j] =  max - distance[i][j];\r
-          distance[j][i] = distance[i][j];\r
+        else\r
+        {\r
+            System.out.println("Dist " + ((SequenceNode) node).dist);\r
+            printNode((SequenceNode) node.left());\r
+            printNode((SequenceNode) node.right());\r
         }\r
-      }\r
     }\r
 \r
-    return distance;\r
-  }\r
-\r
-  public void makeLeaves() {\r
-    cluster = new Vector();\r
-\r
-    for (int i=0; i < noseqs; i++) {\r
-      SequenceNode sn = new SequenceNode();\r
-\r
-      sn.setElement(sequence[i]);\r
-      sn.setName(sequence[i].getName());\r
-      node.addElement(sn);\r
+    /**\r
+     * DOCUMENT ME!\r
+     *\r
+     * @param node DOCUMENT ME!\r
+     */\r
+    public void findMaxDist(SequenceNode node)\r
+    {\r
+        if (node == null)\r
+        {\r
+            return;\r
+        }\r
 \r
-      int[] value = new int[1];\r
-      value[0] = i;\r
+        if ((node.left() == null) && (node.right() == null))\r
+        {\r
+            float dist = ((SequenceNode) node).dist;\r
 \r
-      Cluster c = new Cluster(value);\r
-      cluster.addElement(c);\r
+            if (dist > maxDistValue)\r
+            {\r
+                maxdist = (SequenceNode) node;\r
+                maxDistValue = dist;\r
+            }\r
+        }\r
+        else\r
+        {\r
+            findMaxDist((SequenceNode) node.left());\r
+            findMaxDist((SequenceNode) node.right());\r
+        }\r
     }\r
-  }\r
 \r
-  public Vector findLeaves(SequenceNode node, Vector leaves) {\r
-    if (node == null) {\r
-      return leaves;\r
+    /**\r
+     * DOCUMENT ME!\r
+     *\r
+     * @return DOCUMENT ME!\r
+     */\r
+    public Vector getGroups()\r
+    {\r
+        return groups;\r
     }\r
 \r
-    if (node.left() == null && node.right() == null) {\r
-      leaves.addElement(node);\r
-      return leaves;\r
-    } else {\r
-      findLeaves((SequenceNode)node.left(),leaves);\r
-      findLeaves((SequenceNode)node.right(),leaves);\r
+    /**\r
+     * DOCUMENT ME!\r
+     *\r
+     * @return DOCUMENT ME!\r
+     */\r
+    public float getMaxHeight()\r
+    {\r
+        return maxheight;\r
     }\r
-    return leaves;\r
-  }\r
 \r
-  public Object findLeaf(SequenceNode node, int count) {\r
-    found = _findLeaf(node,count);\r
+    /**\r
+     * DOCUMENT ME!\r
+     *\r
+     * @param node DOCUMENT ME!\r
+     * @param threshold DOCUMENT ME!\r
+     */\r
+    public void groupNodes(SequenceNode node, float threshold)\r
+    {\r
+        if (node == null)\r
+        {\r
+            return;\r
+        }\r
 \r
-    return found;\r
-  }\r
-  public Object _findLeaf(SequenceNode node,int count) {\r
-    if (node == null) {\r
-      return null;\r
-    }\r
-    if (node.ycount == count) {\r
-      found = node.element();\r
-      return found;\r
-    } else {\r
-      _findLeaf((SequenceNode)node.left(),count);\r
-      _findLeaf((SequenceNode)node.right(),count);\r
+        if ((node.height / maxheight) > threshold)\r
+        {\r
+            groups.addElement(node);\r
+        }\r
+        else\r
+        {\r
+            groupNodes((SequenceNode) node.left(), threshold);\r
+            groupNodes((SequenceNode) node.right(), threshold);\r
+        }\r
     }\r
 \r
-    return found;\r
-  }\r
-\r
-  public void printNode(SequenceNode node) {\r
-    if (node == null) {\r
-      return;\r
-    }\r
-    if (node.left() == null && node.right() == null) {\r
-      System.out.println("Leaf = " + ((SequenceI)node.element()).getName());\r
-      System.out.println("Dist " + ((SequenceNode)node).dist);\r
-      System.out.println("Boot " + node.getBootstrap());\r
-    } else {\r
-      System.out.println("Dist " + ((SequenceNode)node).dist);\r
-      printNode((SequenceNode)node.left());\r
-      printNode((SequenceNode)node.right());\r
-    }\r
-  }\r
-  public void findMaxDist(SequenceNode node) {\r
-    if (node == null) {\r
-      return;\r
-    }\r
-    if (node.left() == null && node.right() == null) {\r
+    /**\r
+     * DOCUMENT ME!\r
+     *\r
+     * @param node DOCUMENT ME!\r
+     *\r
+     * @return DOCUMENT ME!\r
+     */\r
+    public float findHeight(SequenceNode node)\r
+    {\r
+        if (node == null)\r
+        {\r
+            return maxheight;\r
+        }\r
 \r
-      float dist = ((SequenceNode)node).dist;\r
-      if (dist > maxDistValue) {\r
-         maxdist      = (SequenceNode)node;\r
-         maxDistValue = dist;\r
-      }\r
-    } else {\r
-      findMaxDist((SequenceNode)node.left());\r
-      findMaxDist((SequenceNode)node.right());\r
-    }\r
-  }\r
-    public Vector getGroups() {\r
-       return groups;\r
-    }\r
-    public float getMaxHeight() {\r
-       return maxheight;\r
-    }\r
-  public void  groupNodes(SequenceNode node, float threshold) {\r
-    if (node == null) {\r
-      return;\r
-    }\r
+        if ((node.left() == null) && (node.right() == null))\r
+        {\r
+            node.height = ((SequenceNode) node.parent()).height + node.dist;\r
+\r
+            if (node.height > maxheight)\r
+            {\r
+                return node.height;\r
+            }\r
+            else\r
+            {\r
+                return maxheight;\r
+            }\r
+        }\r
+        else\r
+        {\r
+            if (node.parent() != null)\r
+            {\r
+                node.height = ((SequenceNode) node.parent()).height +\r
+                    node.dist;\r
+            }\r
+            else\r
+            {\r
+                maxheight = 0;\r
+                node.height = (float) 0.0;\r
+            }\r
+\r
+            maxheight = findHeight((SequenceNode) (node.left()));\r
+            maxheight = findHeight((SequenceNode) (node.right()));\r
+        }\r
 \r
-    if (node.height/maxheight > threshold) {\r
-      groups.addElement(node);\r
-    } else {\r
-      groupNodes((SequenceNode)node.left(),threshold);\r
-      groupNodes((SequenceNode)node.right(),threshold);\r
+        return maxheight;\r
     }\r
-  }\r
 \r
-  public float findHeight(SequenceNode node) {\r
+    /**\r
+     * DOCUMENT ME!\r
+     *\r
+     * @return DOCUMENT ME!\r
+     */\r
+    public SequenceNode reRoot()\r
+    {\r
+        if (maxdist != null)\r
+        {\r
+            ycount = 0;\r
+\r
+            float tmpdist = maxdist.dist;\r
+\r
+            // New top\r
+            SequenceNode sn = new SequenceNode();\r
+            sn.setParent(null);\r
+\r
+            // New right hand of top\r
+            SequenceNode snr = (SequenceNode) maxdist.parent();\r
+            changeDirection(snr, maxdist);\r
+            System.out.println("Printing reversed tree");\r
+            printN(snr);\r
+            snr.dist = tmpdist / 2;\r
+            maxdist.dist = tmpdist / 2;\r
+\r
+            snr.setParent(sn);\r
+            maxdist.setParent(sn);\r
+\r
+            sn.setRight(snr);\r
+            sn.setLeft(maxdist);\r
+\r
+            top = sn;\r
+\r
+            ycount = 0;\r
+            reCount(top);\r
+            findHeight(top);\r
+        }\r
 \r
-    if (node == null) {\r
-      return maxheight;\r
+        return top;\r
     }\r
 \r
-    if (node.left() == null && node.right() == null) {\r
-      node.height = ((SequenceNode)node.parent()).height + node.dist;\r
-\r
-      if (node.height > maxheight) {\r
-        return node.height;\r
-      } else {\r
-        return maxheight;\r
-      }\r
-    } else {\r
-      if (node.parent() != null) {\r
-        node.height = ((SequenceNode)node.parent()).height + node.dist;\r
-      } else {\r
-        maxheight = 0;\r
-        node.height = (float)0.0;\r
+    public String printOriginalSequenceData()\r
+    {\r
+      StringBuffer sb = new StringBuffer();\r
+      for(int i=0; i<sequenceString.length; i++)\r
+      {\r
+        sb.append(sequence[i].getName()+"\t");\r
+        sb.append(sequenceString[i]+"\n");\r
       }\r
-\r
-      maxheight = findHeight((SequenceNode)(node.left()));\r
-      maxheight = findHeight((SequenceNode)(node.right()));\r
+      return sb.toString();\r
     }\r
-    return maxheight;\r
-  }\r
-  public SequenceNode reRoot() {\r
-    if (maxdist != null) {\r
-      ycount = 0;\r
-      float tmpdist = maxdist.dist;\r
-\r
-      // New top\r
-      SequenceNode sn = new SequenceNode();\r
-      sn.setParent(null);\r
-\r
-      // New right hand of top\r
-      SequenceNode snr = (SequenceNode)maxdist.parent();\r
-      changeDirection(snr,maxdist);\r
-      System.out.println("Printing reversed tree");\r
-      printN(snr);\r
-      snr.dist = tmpdist/2;\r
-      maxdist.dist = tmpdist/2;\r
-\r
-      snr.setParent(sn);\r
-      maxdist.setParent(sn);\r
-\r
-      sn.setRight(snr);\r
-      sn.setLeft(maxdist);\r
 \r
-      top = sn;\r
-\r
-      ycount = 0;\r
-      reCount(top);\r
-      findHeight(top);\r
+    /**\r
+     * DOCUMENT ME!\r
+     *\r
+     * @param node DOCUMENT ME!\r
+     */\r
+    public void printN(SequenceNode node)\r
+    {\r
+        if (node == null)\r
+        {\r
+            return;\r
+        }\r
 \r
-    }\r
-    return top;\r
-  }\r
-  public static void printN(SequenceNode node) {\r
-    if (node == null) {\r
-      return;\r
-    }\r
+        if ((node.left() != null) && (node.right() != null))\r
+        {\r
+            printN((SequenceNode) node.left());\r
+            printN((SequenceNode) node.right());\r
+        }\r
+        else\r
+        {\r
+            System.out.println(" name = " +\r
+                ((SequenceI) node.element()).getName());\r
+        }\r
 \r
-    if (node.left() != null && node.right() != null) {\r
-      printN((SequenceNode)node.left());\r
-      printN((SequenceNode)node.right());\r
-    } else {\r
-      System.out.println(" name = " + ((SequenceI)node.element()).getName());\r
+        System.out.println(" dist = " + ((SequenceNode) node).dist + " " +\r
+            ((SequenceNode) node).count + " " + ((SequenceNode) node).height);\r
     }\r
-    System.out.println(" dist = " + ((SequenceNode)node).dist + " " + ((SequenceNode)node).count + " " + ((SequenceNode)node).height);\r
-  }\r
 \r
-    public void reCount(SequenceNode node) {\r
-       ycount = 0;\r
-       _reCount(node);\r
-    }\r
-  public void _reCount(SequenceNode node) {\r
-    if (node == null) {\r
-      return;\r
+    /**\r
+     * DOCUMENT ME!\r
+     *\r
+     * @param node DOCUMENT ME!\r
+     */\r
+    public void reCount(SequenceNode node)\r
+    {\r
+        ycount = 0;\r
+        _reCount(node);\r
     }\r
 \r
-    if (node.left() != null && node.right() != null) {\r
-      _reCount((SequenceNode)node.left());\r
-      _reCount((SequenceNode)node.right());\r
+    /**\r
+     * DOCUMENT ME!\r
+     *\r
+     * @param node DOCUMENT ME!\r
+     */\r
+    public void _reCount(SequenceNode node)\r
+    {\r
+        if (node == null)\r
+        {\r
+            return;\r
+        }\r
 \r
-      SequenceNode l = (SequenceNode)node.left();\r
-      SequenceNode r = (SequenceNode)node.right();\r
+        if ((node.left() != null) && (node.right() != null))\r
+        {\r
+            _reCount((SequenceNode) node.left());\r
+            _reCount((SequenceNode) node.right());\r
 \r
-      ((SequenceNode)node).count  = l.count + r.count;\r
-      ((SequenceNode)node).ycount = (l.ycount + r.ycount)/2;\r
+            SequenceNode l = (SequenceNode) node.left();\r
+            SequenceNode r = (SequenceNode) node.right();\r
 \r
-    } else {\r
-      ((SequenceNode)node).count = 1;\r
-      ((SequenceNode)node).ycount = ycount++;\r
+            ((SequenceNode) node).count = l.count + r.count;\r
+            ((SequenceNode) node).ycount = (l.ycount + r.ycount) / 2;\r
+        }\r
+        else\r
+        {\r
+            ((SequenceNode) node).count = 1;\r
+            ((SequenceNode) node).ycount = ycount++;\r
+        }\r
     }\r
 \r
-  }\r
-    public void swapNodes(SequenceNode node) {\r
-       if (node == null) {\r
-           return;\r
-       }\r
-       SequenceNode tmp = (SequenceNode)node.left();\r
-\r
-       node.setLeft(node.right());\r
-       node.setRight(tmp);\r
-    }\r
-  public void changeDirection(SequenceNode node, SequenceNode dir) {\r
-    if (node == null) {\r
-      return;\r
-    }\r
-    if (node.parent() != top) {\r
-      changeDirection((SequenceNode)node.parent(), node);\r
+    /**\r
+     * DOCUMENT ME!\r
+     *\r
+     * @param node DOCUMENT ME!\r
+     */\r
+    public void swapNodes(SequenceNode node)\r
+    {\r
+        if (node == null)\r
+        {\r
+            return;\r
+        }\r
 \r
-      SequenceNode tmp = (SequenceNode)node.parent();\r
+        SequenceNode tmp = (SequenceNode) node.left();\r
 \r
-      if (dir == node.left()) {\r
-        node.setParent(dir);\r
-        node.setLeft(tmp);\r
-      } else if (dir == node.right()) {\r
-        node.setParent(dir);\r
+        node.setLeft(node.right());\r
         node.setRight(tmp);\r
-      }\r
-\r
-    } else {\r
-      if (dir == node.left()) {\r
-        node.setParent(node.left());\r
+    }\r
 \r
-        if (top.left() == node) {\r
-          node.setRight(top.right());\r
-        } else {\r
-          node.setRight(top.left());\r
+    /**\r
+     * DOCUMENT ME!\r
+     *\r
+     * @param node DOCUMENT ME!\r
+     * @param dir DOCUMENT ME!\r
+     */\r
+    public void changeDirection(SequenceNode node, SequenceNode dir)\r
+    {\r
+        if (node == null)\r
+        {\r
+            return;\r
         }\r
-      } else {\r
-        node.setParent(node.right());\r
 \r
-        if (top.left() == node) {\r
-          node.setLeft(top.right());\r
-        } else {\r
-          node.setLeft(top.left());\r
+        if (node.parent() != top)\r
+        {\r
+            changeDirection((SequenceNode) node.parent(), node);\r
+\r
+            SequenceNode tmp = (SequenceNode) node.parent();\r
+\r
+            if (dir == node.left())\r
+            {\r
+                node.setParent(dir);\r
+                node.setLeft(tmp);\r
+            }\r
+            else if (dir == node.right())\r
+            {\r
+                node.setParent(dir);\r
+                node.setRight(tmp);\r
+            }\r
+        }\r
+        else\r
+        {\r
+            if (dir == node.left())\r
+            {\r
+                node.setParent(node.left());\r
+\r
+                if (top.left() == node)\r
+                {\r
+                    node.setRight(top.right());\r
+                }\r
+                else\r
+                {\r
+                    node.setRight(top.left());\r
+                }\r
+            }\r
+            else\r
+            {\r
+                node.setParent(node.right());\r
+\r
+                if (top.left() == node)\r
+                {\r
+                    node.setLeft(top.right());\r
+                }\r
+                else\r
+                {\r
+                    node.setLeft(top.left());\r
+                }\r
+            }\r
         }\r
-      }\r
     }\r
-  }\r
-    public void setMaxDist(SequenceNode node) {\r
-       this.maxdist = maxdist;\r
+\r
+\r
+    /**\r
+     * DOCUMENT ME!\r
+     *\r
+     * @return DOCUMENT ME!\r
+     */\r
+    public SequenceNode getMaxDist()\r
+    {\r
+        return maxdist;\r
     }\r
-    public SequenceNode getMaxDist() {\r
-       return maxdist;\r
+\r
+    /**\r
+     * DOCUMENT ME!\r
+     *\r
+     * @return DOCUMENT ME!\r
+     */\r
+    public SequenceNode getTopNode()\r
+    {\r
+        return top;\r
     }\r
-    public SequenceNode getTopNode() {\r
-       return top;\r
+    /**\r
+     *\r
+     * @return true if tree has real distances\r
+     */\r
+    public boolean isHasDistances() {\r
+      return hasDistances;\r
     }\r
 \r
-}\r
-\r
-\r
+    /**\r
+     *\r
+     * @return true if tree has real bootstrap values\r
+     */\r
+    public boolean isHasBootstrap() {\r
+      return hasBootstrap;\r
+    }\r
 \r
-class Cluster {\r
+  public boolean isHasRootDistance()\r
+  {\r
+    return hasRootDistance;\r
+  }\r
 \r
-  int[] value;\r
+}\r
 \r
-  public Cluster(int[] value) {\r
-    this.value = value;\r
-  }\r
 \r
+/**\r
+ * DOCUMENT ME!\r
+ *\r
+ * @author $author$\r
+ * @version $Revision$\r
+ */\r
+class Cluster\r
+{\r
+    int[] value;\r
+\r
+    /**\r
+     * Creates a new Cluster object.\r
+     *\r
+     * @param value DOCUMENT ME!\r
+     */\r
+    public Cluster(int[] value)\r
+    {\r
+        this.value = value;\r
+    }\r
 }\r
 \r