X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fanalysis%2Fscoremodels%2FScoreMatrix.java;h=41d73838b98e6b83c690c7d0d009816d40d1d5b9;hb=baad2f0ba2b171dd3d52c17afa46ef800334ea5e;hp=f0115bfca2874ae34f8a9d2c18623802c98838e1;hpb=c6e8e8ccd10f21698226ae37196cd9680e6804a0;p=jalview.git diff --git a/src/jalview/analysis/scoremodels/ScoreMatrix.java b/src/jalview/analysis/scoremodels/ScoreMatrix.java index f0115bf..41d7383 100644 --- a/src/jalview/analysis/scoremodels/ScoreMatrix.java +++ b/src/jalview/analysis/scoremodels/ScoreMatrix.java @@ -20,23 +20,28 @@ */ package jalview.analysis.scoremodels; -import jalview.api.analysis.ScoreModelI; +import jalview.api.analysis.PairwiseScoreModelI; +import jalview.api.analysis.SimilarityParamsI; +import jalview.api.analysis.SimilarityScoreModelI; +import jalview.datamodel.AlignmentView; +import jalview.math.Matrix; +import jalview.math.MatrixI; +import jalview.util.Comparison; -import java.io.BufferedReader; -import java.io.IOException; -import java.io.InputStream; -import java.io.InputStreamReader; import java.util.Arrays; -import java.util.StringTokenizer; -public class ScoreMatrix extends PairwiseSeqScoreModel implements - ScoreModelI +public class ScoreMatrix implements SimilarityScoreModelI, + PairwiseScoreModelI { - public static final short UNMAPPED = (short) -1; - - private static final String DELIMITERS = " ,\t"; + /* + * Jalview 2.10.1 treated gaps as X (peptide) or N (nucleotide) + * for pairwise scoring; 2.10.2 uses gap score (last column) in + * score matrix (JAL-2397) + * Set this flag to true (via Groovy) for 2.10.1 behaviour + */ + private static boolean scoreGapAsAny = false; - private static final String COMMENT_CHAR = "#"; + public static final short UNMAPPED = (short) -1; private static final String BAD_ASCII_ERROR = "Unexpected character %s in getPairwiseScore"; @@ -70,7 +75,9 @@ public class ScoreMatrix extends PairwiseSeqScoreModel implements private boolean peptide; /** - * Constructor + * Constructor given a name, symbol alphabet, and matrix of scores for pairs + * of symbols. The matrix should be square and of the same size as the + * alphabet, for example 20x20 for a 20 symbol alphabet. * * @param name * Unique, human readable name for the matrix @@ -81,6 +88,20 @@ public class ScoreMatrix extends PairwiseSeqScoreModel implements */ public ScoreMatrix(String name, char[] alphabet, float[][] matrix) { + if (alphabet.length != matrix.length) + { + throw new IllegalArgumentException( + "score matrix size must match alphabet size"); + } + for (float[] row : matrix) + { + if (row.length != alphabet.length) + { + throw new IllegalArgumentException( + "score matrix size must be square"); + } + } + this.matrix = matrix; this.name = name; this.symbols = alphabet; @@ -153,10 +174,44 @@ public class ScoreMatrix extends PairwiseSeqScoreModel implements return peptide; } - @Override + /** + * Returns a copy of the score matrix as used in getPairwiseScore. If using + * this matrix directly, callers must also call + * getMatrixIndex in order to get the matrix index for each + * character (symbol). + * + * @return + * @see #getMatrixIndex(char) + */ public float[][] getMatrix() { - return matrix; + float[][] v = new float[matrix.length][matrix.length]; + for (int i = 0; i < matrix.length; i++) + { + v[i] = Arrays.copyOf(matrix[i], matrix[i].length); + } + return v; + } + + /** + * Answers the matrix index for a given character, or -1 if unmapped in the + * matrix. Use this method only if using getMatrix in order to + * compute scores directly (without symbol lookup) for efficiency. + * + * @param c + * @return + * @see #getMatrix() + */ + public int getMatrixIndex(char c) + { + if (c < symbolIndex.length) + { + return symbolIndex[c]; + } + else + { + return UNMAPPED; + } } /** @@ -166,12 +221,12 @@ public class ScoreMatrix extends PairwiseSeqScoreModel implements @Override public float getPairwiseScore(char c, char d) { - if (c > MAX_ASCII) + if (c >= symbolIndex.length) { System.err.println(String.format(BAD_ASCII_ERROR, c)); return 0; } - if (d > MAX_ASCII) + if (d >= symbolIndex.length) { System.err.println(String.format(BAD_ASCII_ERROR, d)); return 0; @@ -196,7 +251,12 @@ public class ScoreMatrix extends PairwiseSeqScoreModel implements } /** - * Print the score matrix, optionally formatted as html, with the alphabet symbols as column headings and at the start of each row + * Print the score matrix, optionally formatted as html, with the alphabet + * symbols as column headings and at the start of each row. + *

+ * The non-html format should give an output which can be parsed as a score + * matrix file + * * @param html * @return */ @@ -212,6 +272,11 @@ public class ScoreMatrix extends PairwiseSeqScoreModel implements sb.append(""); sb.append(html ? "" : ""); } + else + { + sb.append("ScoreMatrix ").append(getName()).append("\n"); + sb.append(symbols).append("\n"); + } for (char sym : symbols) { if (html) @@ -251,138 +316,172 @@ public class ScoreMatrix extends PairwiseSeqScoreModel implements } /** - * Parse a score matrix from the given input stream and returns a ScoreMatrix - * object. If parsing fails, error messages are written to syserr and null is - * returned. It is the caller's responsibility to close the input stream. + * Answers the number of symbols coded for (also equal to the number of rows + * and columns of the score matrix) * - * @param is * @return */ - public static ScoreMatrix parse(InputStream is) + public int getSize() { - ScoreMatrix sm = null; - BufferedReader br = new BufferedReader(new InputStreamReader(is)); - int lineNo = 0; - String name = null; - String alphabet = null; - float[][] scores = null; - int size = 0; - int row = 0; - - try - { - String data; + return symbols.length; + } - while ((data = br.readLine()) != null) + /** + * Computes an NxN matrix where N is the number of sequences, and entry [i, j] + * is sequence[i] pairwise multiplied with sequence[j], as a sum of scores + * computed using the current score matrix. For example + * + */ + @Override + public MatrixI findSimilarities(AlignmentView seqstrings, + SimilarityParamsI options) + { + char gapChar = scoreGapAsAny ? (seqstrings.isNa() ? 'N' : 'X') : ' '; + String[] seqs = seqstrings.getSequenceStrings(gapChar); + return findSimilarities(seqs, options); + } + + /** + * Computes pairwise similarities of a set of sequences using the given + * parameters + * + * @param seqs + * @param params + * @return + */ + protected MatrixI findSimilarities(String[] seqs, SimilarityParamsI params) + { + double[][] values = new double[seqs.length][]; + for (int row = 0; row < seqs.length; row++) + { + values[row] = new double[seqs.length]; + for (int col = 0; col < seqs.length; col++) { - lineNo++; - data = data.trim(); - if (data.startsWith(COMMENT_CHAR)) - { - continue; - } - if (data.toLowerCase().startsWith("scorematrix")) - { - /* - * Parse name from ScoreMatrix - */ - if (name != null) - { - System.err - .println("Warning: 'ScoreMatrix' repeated in file at line " - + lineNo); - } - StringTokenizer nameLine = new StringTokenizer(data, DELIMITERS); - if (nameLine.countTokens() != 2) - { - System.err - .println("Format error: expected 'ScoreMatrix ', found '" - + data + "' at line " + lineNo); - return null; - } - nameLine.nextToken(); - name = nameLine.nextToken(); - continue; - } - else if (name == null) - { - System.err - .println("Format error: 'ScoreMatrix ' should be the first non-comment line"); - return null; - } + double total = computeSimilarity(seqs[row], seqs[col], params); + values[row][col] = total; + } + } + return new Matrix(values); + } + /** + * Calculates the pairwise similarity of two strings using the given + * calculation parameters + * + * @param seq1 + * @param seq2 + * @param params + * @return + */ + protected double computeSimilarity(String seq1, String seq2, + SimilarityParamsI params) + { + int len1 = seq1.length(); + int len2 = seq2.length(); + double total = 0; + + int width = Math.max(len1, len2); + for (int i = 0; i < width; i++) + { + if (i >= len1 || i >= len2) + { /* - * next line after ScoreMatrix should be the alphabet of scored symbols + * off the end of one sequence; stop if we are only matching + * on the shorter sequence length, else treat as trailing gap */ - if (alphabet == null) + if (params.denominateByShortestLength()) { - alphabet = data; - size = alphabet.length(); - scores = new float[size][]; - continue; + break; } + } + // Change GAP_SPACE to GAP_DASH if we adopt - for gap in matrices + char c1 = i >= len1 ? Comparison.GAP_SPACE : seq1.charAt(i); + char c2 = i >= len2 ? Comparison.GAP_SPACE : seq2.charAt(i); + boolean gap1 = Comparison.isGap(c1); + boolean gap2 = Comparison.isGap(c2); + if (gap1 && gap2) + { /* - * too much information? + * gap-gap: include if options say so, else ignore */ - if (row >= size && data.length() > 0) { - System.err - .println("Unexpected extra input line in score model file " - + data); - return null; + if (!params.includeGappedColumns()) + { + continue; } - + } + else if (gap1 || gap2) + { /* - * subsequent lines should be the symbol scores + * gap-residue: score if options say so */ - StringTokenizer scoreLine = new StringTokenizer(data, DELIMITERS); - if (scoreLine.countTokens() != size) + if (!params.includesGaps()) { - System.err.println(String.format( - "Expected %d tokens at line %d but found %d", size, - lineNo, scoreLine.countTokens())); - return null; - } - scores[row] = new float[size]; - int col = 0; - String value = null; - while (scoreLine.hasMoreTokens()) { - try { - value = scoreLine.nextToken(); - scores[row][col] = Float.valueOf(value); - col++; - } catch (NumberFormatException e) - { - System.err.println(String.format( - "Invalid score value %s at line %d column %d", value, - lineNo, col)); - return null; - } + continue; } - row++; } - } catch (IOException e) + float score = getPairwiseScore(c1, c2); + total += score; + } + return total; + } + + /** + * Answers a hashcode computed from the symbol alphabet and the matrix score + * values + */ + @Override + public int hashCode() + { + int hs = Arrays.hashCode(symbols); + for (float[] row : matrix) { - System.err.println("Error reading score matrix file: " - + e.getMessage() + " at line " + lineNo); + hs = hs * 31 + Arrays.hashCode(row); } + return hs; + } - /* - * out of data - check we found enough - */ - if (row < size) + /** + * Answers true if the argument is a ScoreMatrix with the same symbol alphabet + * and score values, else false + */ + @Override + public boolean equals(Object obj) + { + if (!(obj instanceof ScoreMatrix)) + { + return false; + } + ScoreMatrix sm = (ScoreMatrix) obj; + if (Arrays.equals(symbols, sm.symbols) + && Arrays.deepEquals(matrix, sm.matrix)) { - System.err - .println(String - .format("Expected %d rows of score data in score matrix but only found %d", - size, row)); - return null; + return true; } + return false; + } - /* - * If we get here, then name, alphabet and scores have been parsed successfully - */ - sm = new ScoreMatrix(name, alphabet.toCharArray(), scores); - return sm; + /** + * Returns the alphabet the matrix scores for, as a string of characters + * + * @return + */ + public String getSymbols() + { + return new String(symbols); } }