*/
package jalview.analysis.scoremodels;
+import jalview.api.AlignmentViewPanel;
import jalview.api.analysis.PairwiseScoreModelI;
+import jalview.api.analysis.ScoreModelI;
import jalview.api.analysis.SimilarityParamsI;
-import jalview.api.analysis.SimilarityScoreModelI;
import jalview.datamodel.AlignmentView;
import jalview.math.Matrix;
import jalview.math.MatrixI;
/**
* A class that models a substitution score matrix for any given alphabet of
- * symbols
+ * symbols. Instances of this class are immutable and thread-safe, so the same
+ * object is returned from calls to getInstance().
*/
-public class ScoreMatrix implements SimilarityScoreModelI,
- PairwiseScoreModelI
+public class ScoreMatrix extends SimilarityScoreModel
+ implements PairwiseScoreModelI
{
+ private static final char GAP_CHARACTER = Comparison.GAP_DASH;
+
/*
* an arbitrary score to assign for identity of an unknown symbol
* (this is the value on the diagonal in the * column of the NCBI matrix)
private static final int UNKNOWN_IDENTITY_SCORE = 1;
/*
- * 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)
private float maxValue;
+ private boolean symmetric;
+
/**
* 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
*/
public ScoreMatrix(String theName, char[] alphabet, float[][] values)
{
+ this(theName, null, alphabet, values);
+ }
+
+ /**
+ * Constructor given a name, description, 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 theName
+ * Unique, human readable name for the matrix
+ * @param theDescription
+ * descriptive display name suitable for use in menus
+ * @param alphabet
+ * the symbols to which scores apply
+ * @param values
+ * Pairwise scores indexed according to the symbol alphabet
+ */
+ public ScoreMatrix(String theName, String theDescription, char[] alphabet,
+ float[][] values)
+ {
if (alphabet.length != values.length)
{
throw new IllegalArgumentException(
this.matrix = values;
this.name = theName;
+ this.description = theDescription;
this.symbols = alphabet;
symbolIndex = buildSymbolIndex(alphabet);
findMinMax();
+ symmetric = checkSymmetry();
+
/*
* crude heuristic for now...
*/
}
/**
+ * Answers true if the matrix is symmetric, else false. Usually, substitution
+ * matrices are symmetric, which allows calculations to be short cut.
+ *
+ * @return
+ */
+ private boolean checkSymmetry()
+ {
+ for (int i = 0; i < matrix.length; i++)
+ {
+ for (int j = i; j < matrix.length; j++)
+ {
+ if (matrix[i][j] != matrix[j][i])
+ {
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+
+ /**
* Record the minimum and maximum score values
*/
protected void findMinMax()
short pos = 0;
for (char c : alphabet)
{
- if (Comparison.isGap(c))
- {
- gapCharacter = c;
- }
-
if (c <= MAX_ASCII)
{
index[c] = pos;
}
/**
- * Answers the matrix index for the gap character, or -1 if unmapped in the
- * matrix. Use this method only if using <code>getMatrix</code> 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. If either c or d is
* an unexpected character, returns 1 for identity (c == d), else the minimum
* score value in the matrix.
{
if (c >= symbolIndex.length)
{
- System.err.println(String.format(BAD_ASCII_ERROR, c));
+ jalview.bin.Console.errPrintln(String.format(BAD_ASCII_ERROR, c));
return 0;
}
if (d >= symbolIndex.length)
{
- System.err.println(String.format(BAD_ASCII_ERROR, d));
+ jalview.bin.Console.errPrintln(String.format(BAD_ASCII_ERROR, d));
return 0;
}
* <li>product[0, 1] = F.R + K.- + L.D = -3 + -1 + -3 = -8
* <li>and so on</li>
* </ul>
+ * This method is thread-safe.
*/
@Override
public MatrixI findSimilarities(AlignmentView seqstrings,
SimilarityParamsI options)
{
char gapChar = scoreGapAsAny ? (seqstrings.isNa() ? 'N' : 'X')
- : gapCharacter;
+ : GAP_CHARACTER;
String[] seqs = seqstrings.getSequenceStrings(gapChar);
return findSimilarities(seqs, options);
}
* @param params
* @return
*/
- protected MatrixI findSimilarities(String[] seqs, SimilarityParamsI params)
+ protected MatrixI findSimilarities(String[] seqs,
+ SimilarityParamsI params)
{
- double[][] values = new double[seqs.length][];
+ double[][] values = new double[seqs.length][seqs.length];
for (int row = 0; row < seqs.length; row++)
{
- values[row] = new double[seqs.length];
- for (int col = 0; col < seqs.length; col++)
+ for (int col = symmetric ? row : 0; col < seqs.length; col++)
{
double total = computeSimilarity(seqs[row], seqs[col], params);
values[row][col] = total;
+ if (symmetric)
+ {
+ values[col][row] = total;
+ }
}
}
return new Matrix(values);
}
}
- char c1 = i >= len1 ? gapCharacter : seq1.charAt(i);
- char c2 = i >= len2 ? gapCharacter : seq2.charAt(i);
+ char c1 = i >= len1 ? GAP_CHARACTER : seq1.charAt(i);
+ char c2 = i >= len2 ? GAP_CHARACTER : seq2.charAt(i);
boolean gap1 = Comparison.isGap(c1);
boolean gap2 = Comparison.isGap(c2);
return new String(symbols);
}
- public void setDescription(String desc)
- {
- description = desc;
- }
-
public float getMinimumScore()
{
return minValue;
{
return maxValue;
}
+
+ @Override
+ public ScoreModelI getInstance(AlignmentViewPanel avp)
+ {
+ return this;
+ }
+
+ public boolean isSymmetric()
+ {
+ return symmetric;
+ }
}
git://source.jalview.org / jalview.git / blobdiff