X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Futil%2FComparison.java;h=286bfb257332dac8e1f2481947c616cd6d4a99e6;hb=4728b1bd60655ad9f269438e505e70f23c9c83f3;hp=8902e2ce4433aa173361d2c36711af0afc0383c7;hpb=edf2c4eda8ef83c1c86aacd7395d51fc59b89ea1;p=jalview.git diff --git a/src/jalview/util/Comparison.java b/src/jalview/util/Comparison.java index 8902e2c..286bfb2 100644 --- a/src/jalview/util/Comparison.java +++ b/src/jalview/util/Comparison.java @@ -34,14 +34,15 @@ public class Comparison private static final int TO_UPPER_CASE = 'a' - 'A'; - private static final char GAP_SPACE = ' '; + public static final char GAP_SPACE = ' '; - private static final char GAP_DOT = '.'; + public static final char GAP_DOT = '.'; - private static final char GAP_DASH = '-'; + public 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! @@ -71,7 +72,8 @@ public class Comparison * int * @return float */ - public static float compare(SequenceI ii, SequenceI jj, int start, int end) + public static float compare(SequenceI ii, SequenceI jj, int start, + int end) { String si = ii.getSequenceAsString(); String sj = jj.getSequenceAsString(); @@ -97,8 +99,8 @@ public class Comparison { for (int j = 0; j < jlen; j++) { - if (si.substring(start + j, start + j + 1).equals( - sj.substring(start + j, start + j + 1))) + if (si.substring(start + j, start + j + 1) + .equals(sj.substring(start + j, start + j + 1))) { match++; } @@ -112,8 +114,8 @@ public class Comparison { for (int j = 0; j < jlen; j++) { - if (si.substring(start + j, start + j + 1).equals( - sj.substring(start + j, start + j + 1))) + if (si.substring(start + j, start + j + 1) + .equals(sj.substring(start + j, start + j + 1))) { match++; } @@ -135,7 +137,9 @@ public class Comparison * @param s2 * SequenceI * @return float + * @deprecated use PIDModel.computePID() */ + @Deprecated public final static float PID(String seq1, String seq2) { return PID(seq1, seq2, 0, seq1.length()); @@ -144,7 +148,12 @@ public class Comparison static final int caseShift = 'a' - 'A'; // Another pid with region specification - public final static float PID(String seq1, String seq2, int start, int end) + /** + * @deprecated use PIDModel.computePID() + */ + @Deprecated + public final static float PID(String seq1, String seq2, int start, + int end) { return PID(seq1, seq2, start, end, true, false); } @@ -165,7 +174,9 @@ public class Comparison * @param ungappedOnly * - if true - only count PID over ungapped columns * @return + * @deprecated use PIDModel.computePID() */ + @Deprecated public final static float PID(String seq1, String seq2, int start, int end, boolean wcGaps, boolean ungappedOnly) { @@ -249,33 +260,46 @@ public class Comparison } /** - * 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). + * Overloaded method signature to test whether a single sequence is nucleotide + * (that is, more than 85% CGTA) * - * @param seqs + * @param seq * @return */ - public static final boolean isNucleotide(SequenceI[] seqs) + public static final boolean isNucleotide(SequenceI seq) { - if (seqs == null) + if (seq==null) { return false; } - char[][] letters = new char[seqs.length][]; - for (int i = 0; i < seqs.length; i++) + long ntCount = 0; + long aaCount = 0; + + int len = seq.getLength(); + for (int i = 0; i < len; i++) { - if (seqs[i] != null) + char c = seq.getCharAt(i); + if (isNucleotide(c)) { - char[] sequence = seqs[i].getSequence(); - if (sequence != null) - { - letters[i] = sequence; - } + ntCount++; + } + else if (!isGap(c)) + { + aaCount++; } } - - return areNucleotide(letters); + /* + * Check for nucleotide count > 85% of total count (in a form that evades + * int / float conversion or divide by zero). + */ + if (ntCount * 100 > EIGHTY_FIVE * (ntCount + aaCount)) + { + return true; + } + else + { + return false; + } } /** @@ -283,52 +307,85 @@ public class Comparison * 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 + * @param seqs * @return */ - public static final boolean areNucleotide(char[][] letters) + public static final boolean isNucleotide(SequenceI[] seqs) { - int ntCount = 0; - int aaCount = 0; - for (char[] seq : letters) + if (seqs == null) + { + return false; + } + // true if we have seen a nucleotide sequence + boolean na=false; + for (SequenceI seq : seqs) { if (seq == null) { continue; } + na=true; // TODO could possibly make an informed guess just from the first sequence // to save a lengthy calculation - for (char c : seq) - { - if ('a' <= c && c <= 'z') - { - c -= TO_UPPER_CASE; - } - - if (c == 'A' || c == 'G' || c == 'C' || c == 'T' || c == 'U') - { - ntCount++; - } - else if (!Comparison.isGap(c)) - { - aaCount++; - } + if (seq.isProtein()) { + // if even one looks like protein, the alignment is protein + return false; } } + return na; + } - /* - * Check for nucleotide count > 85% of total count (in a form that evades - * int / float conversion or divide by zero). - */ - if (ntCount * 100 > EIGHTY_FIVE * (ntCount + aaCount)) + /** + * 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; } - else + 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; } /** @@ -351,8 +408,33 @@ public class Comparison flattened.add(s); } } - final SequenceI[] oneDArray = flattened.toArray(new SequenceI[flattened - .size()]); + final SequenceI[] oneDArray = flattened + .toArray(new SequenceI[flattened.size()]); return isNucleotide(oneDArray); } + + /** + * Compares two residues either case sensitively or case insensitively + * depending on the caseSensitive flag + * + * @param c1 + * first char + * @param c2 + * second char to compare with + * @param caseSensitive + * if true comparison will be case sensitive otherwise its not + * @return + */ + public static boolean isSameResidue(char c1, char c2, + boolean caseSensitive) + { + if (caseSensitive) + { + return (c1 == c2); + } + else + { + return Character.toUpperCase(c1) == Character.toUpperCase(c2); + } + } }