X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fanalysis%2Fscoremodels%2FScoreMatrix.java;h=f7da9f3f8845db6fc737532a85f34aaa68299621;hb=81f1e29b00bc98403d45d2258da71ac19c425c57;hp=eb94817f4d441f322bc7df25145a78a2a41eacfe;hpb=7c5c70f4bbe69a722dd6e8bd269d7d01e1089034;p=jalview.git diff --git a/src/jalview/analysis/scoremodels/ScoreMatrix.java b/src/jalview/analysis/scoremodels/ScoreMatrix.java index eb94817..f7da9f3 100644 --- a/src/jalview/analysis/scoremodels/ScoreMatrix.java +++ b/src/jalview/analysis/scoremodels/ScoreMatrix.java @@ -20,10 +20,37 @@ */ package jalview.analysis.scoremodels; +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.util.Arrays; -public class ScoreMatrix implements PairwiseScoreModelI +/** + * A class that models a substitution score matrix for any given alphabet of + * symbols + */ +public class ScoreMatrix implements SimilarityScoreModelI, + PairwiseScoreModelI { + /* + * this fields records which gap character (if any) is used in the alphabet; + * space, dash or dot are recognised as gap symbols + */ + private char gapCharacter = '0'; + + /* + * 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; + public static final short UNMAPPED = (short) -1; private static final String BAD_ASCII_ERROR = "Unexpected character %s in getPairwiseScore"; @@ -32,10 +59,16 @@ public class ScoreMatrix implements PairwiseScoreModelI /* * the name of the model as shown in menus + * each score model in use should have a unique name */ private String name; /* + * a description for the model as shown in tooltips + */ + private String description; + + /* * the characters that the model provides scores for */ private char[] symbols; @@ -62,21 +95,21 @@ public class ScoreMatrix implements PairwiseScoreModelI * 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 + * @param theName * Unique, human readable name for the matrix * @param alphabet * the symbols to which scores apply - * @param matrix + * @param values * Pairwise scores indexed according to the symbol alphabet */ - public ScoreMatrix(String name, char[] alphabet, float[][] matrix) + public ScoreMatrix(String theName, char[] alphabet, float[][] values) { - if (alphabet.length != matrix.length) + if (alphabet.length != values.length) { throw new IllegalArgumentException( "score matrix size must match alphabet size"); } - for (float[] row : matrix) + for (float[] row : values) { if (row.length != alphabet.length) { @@ -85,8 +118,8 @@ public class ScoreMatrix implements PairwiseScoreModelI } } - this.matrix = matrix; - this.name = name; + this.matrix = values; + this.name = theName; this.symbols = alphabet; symbolIndex = buildSymbolIndex(alphabet); @@ -107,17 +140,25 @@ public class ScoreMatrix implements PairwiseScoreModelI * Mappings are added automatically for lower case symbols (for non case * sensitive scoring), unless they are explicitly present in the alphabet (are * scored separately in the score matrix). + *

+ * the gap character (space, dash or dot) included in the alphabet (if any) is + * recorded in a field * * @param alphabet * @return */ - static short[] buildSymbolIndex(char[] alphabet) + short[] buildSymbolIndex(char[] alphabet) { short[] index = new short[MAX_ASCII + 1]; Arrays.fill(index, UNMAPPED); short pos = 0; for (char c : alphabet) { + if (Comparison.isGap(c)) + { + gapCharacter = c; + } + if (c <= MAX_ASCII) { index[c] = pos; @@ -146,6 +187,12 @@ public class ScoreMatrix implements PairwiseScoreModelI } @Override + public String getDescription() + { + return description; + } + + @Override public boolean isDNA() { return !peptide; @@ -158,16 +205,22 @@ public class ScoreMatrix implements PairwiseScoreModelI } /** - * Returns 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). + * 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; } /** @@ -192,6 +245,19 @@ public class ScoreMatrix implements PairwiseScoreModelI } /** + * Answers the matrix index for the gap 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. + * + * @return + * @see #getMatrix() + */ + public int getGapIndex() + { + return getMatrixIndex(gapCharacter); + } + + /** * Returns the pairwise score for substituting c with d, or zero if c or d is * an unscored or unexpected character */ @@ -228,7 +294,12 @@ public class ScoreMatrix implements PairwiseScoreModelI } /** - * 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 */ @@ -244,6 +315,11 @@ public class ScoreMatrix implements PairwiseScoreModelI sb.append(""); sb.append(html ? "" : ""); } + else + { + sb.append("ScoreMatrix ").append(getName()).append("\n"); + sb.append(symbols).append("\n"); + } for (char sym : symbols) { if (html) @@ -292,4 +368,169 @@ public class ScoreMatrix implements PairwiseScoreModelI { return symbols.length; } + + /** + * 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') + : gapCharacter; + 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++) + { + 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) + { + /* + * off the end of one sequence; stop if we are only matching + * on the shorter sequence length, else treat as trailing gap + */ + if (params.denominateByShortestLength()) + { + break; + } + } + + char c1 = i >= len1 ? gapCharacter : seq1.charAt(i); + char c2 = i >= len2 ? gapCharacter : seq2.charAt(i); + boolean gap1 = Comparison.isGap(c1); + boolean gap2 = Comparison.isGap(c2); + + if (gap1 && gap2) + { + /* + * gap-gap: include if options say so, else ignore + */ + if (!params.includeGappedColumns()) + { + continue; + } + } + else if (gap1 || gap2) + { + /* + * gap-residue: score if options say so + */ + if (!params.includeGaps()) + { + continue; + } + } + 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) + { + hs = hs * 31 + Arrays.hashCode(row); + } + return hs; + } + + /** + * 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)) + { + return true; + } + return false; + } + + /** + * Returns the alphabet the matrix scores for, as a string of characters + * + * @return + */ + public String getSymbols() + { + return new String(symbols); + } + + public void setDescription(String desc) + { + description = desc; + } }