Merge branch 'releases/Release_2_10_0_Branch'

[jalview.git] / src / jalview / util / Comparison.java

diff --git a/src/jalview/util/Comparison.java b/src/jalview/util/Comparison.java
index e224b71..d210795 100644 (file)
--- a/src/jalview/util/Comparison.java
+++ b/src/jalview/util/Comparison.java
@@ -1,6 +1,6 @@
 /*
- * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
- * Copyright (C) $$Year-Rel$$ The Jalview Authors
+ * Jalview - A Sequence Alignment Editor and Viewer (Version 2.9.0b2)
+ * Copyright (C) 2015 The Jalview Authors
  * 
  * This file is part of Jalview.
  * 
@@ -22,6 +22,9 @@ package jalview.util;
 
 import jalview.datamodel.SequenceI;
 
+import java.util.ArrayList;
+import java.util.List;
+
 /**
  * Assorted methods for analysing or comparing sequences.
  */
@@ -37,8 +40,8 @@ public class Comparison
 
   private static final char GAP_DASH = '-';
 
-  public static final String GapChars = new String(new char[]
-  { GAP_SPACE, GAP_DOT, GAP_DASH });
+  public static final String GapChars = new String(new char[] { GAP_SPACE,
+      GAP_DOT, GAP_DASH });
 
   /**
    * DOCUMENT ME!
@@ -246,9 +249,21 @@ public class Comparison
   }
 
   /**
+   * Overloaded method signature to test whether a single sequence is nucleotide
+   * (that is, more than 85% CGTA)
+   * 
+   * @param seq
+   * @return
+   */
+  public static final boolean isNucleotide(SequenceI seq)
+  {
+    return isNucleotide(new SequenceI[] { seq });
+  }
+
+  /**
    * Answers true if more than 85% of the sequence residues (ignoring gaps) are
    * A, G, C, T or U, else false. This is just a heuristic guess and may give a
-   * wrong answer (as AGCT are also animo acid codes).
+   * wrong answer (as AGCT are also amino acid codes).
    * 
    * @param seqs
    * @return
@@ -259,22 +274,49 @@ public class Comparison
     {
       return false;
     }
-    int ntCount = 0;
-    int aaCount = 0;
-    for (SequenceI seq : seqs)
+    char[][] letters = new char[seqs.length][];
+    for (int i = 0; i < seqs.length; i++)
     {
-      for (char c : seq.getSequence())
+      if (seqs[i] != null)
       {
-        if ('a' <= c && c <= 'z')
+        char[] sequence = seqs[i].getSequence();
+        if (sequence != null)
         {
-          c -= TO_UPPER_CASE;
+          letters[i] = sequence;
         }
+      }
+    }
 
-        if (c == 'A' || c == 'G' || c == 'C' || c == 'T' || c == 'U')
+    return areNucleotide(letters);
+  }
+
+  /**
+   * Answers true if more than 85% of the sequence residues (ignoring gaps) are
+   * A, G, C, T or U, else false. This is just a heuristic guess and may give a
+   * wrong answer (as AGCT are also amino acid codes).
+   * 
+   * @param letters
+   * @return
+   */
+  static final boolean areNucleotide(char[][] letters)
+  {
+    int ntCount = 0;
+    int aaCount = 0;
+    for (char[] seq : letters)
+    {
+      if (seq == null)
+      {
+        continue;
+      }
+      // TODO could possibly make an informed guess just from the first sequence
+      // to save a lengthy calculation
+      for (char c : seq)
+      {
+        if (isNucleotide(c))
         {
           ntCount++;
         }
-        else if (!Comparison.isGap(c))
+        else if (!isGap(c))
         {
           aaCount++;
         }
@@ -295,4 +337,82 @@ public class Comparison
     }
 
   }
+
+  /**
+   * Answers true if the character is one of aAcCgGtTuU
+   * 
+   * @param c
+   * @return
+   */
+  public static boolean isNucleotide(char c)
+  {
+    if ('a' <= c && c <= 'z')
+    {
+      c -= TO_UPPER_CASE;
+    }
+
+    switch (c)
+    {
+    case 'A':
+    case 'C':
+    case 'G':
+    case 'T':
+    case 'U':
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Answers true if every character in the string is one of aAcCgGtTuU, or
+   * (optionally) a gap character (dot, dash, space), else false
+   * 
+   * @param s
+   * @param allowGaps
+   * @return
+   */
+  public static boolean isNucleotideSequence(String s, boolean allowGaps)
+  {
+    if (s == null)
+    {
+      return false;
+    }
+    for (int i = 0; i < s.length(); i++)
+    {
+      char c = s.charAt(i);
+      if (!isNucleotide(c))
+      {
+        if (!allowGaps || !isGap(c))
+        {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+
+  /**
+   * Convenience overload of isNucleotide
+   * 
+   * @param seqs
+   * @return
+   */
+  public static boolean isNucleotide(SequenceI[][] seqs)
+  {
+    if (seqs == null)
+    {
+      return false;
+    }
+    List<SequenceI> flattened = new ArrayList<SequenceI>();
+    for (SequenceI[] ss : seqs)
+    {
+      for (SequenceI s : ss)
+      {
+        flattened.add(s);
+      }
+    }
+    final SequenceI[] oneDArray = flattened.toArray(new SequenceI[flattened
+            .size()]);
+    return isNucleotide(oneDArray);
+  }
 }