X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fanalysis%2Fscoremodels%2FScoreMatrix.java;h=aa841ace85ddcc45cea2c9598a0188e9d405618d;hb=cd669a0e8c7b91b379bca8fe6e702cf0fcbd1ce0;hp=b904432d6652d41c15f802f13aed860ac0dd1c49;hpb=adca107ff292173bc844ad4a5c6c7eba958ad24a;p=jalview.git

diff --git a/src/jalview/analysis/scoremodels/ScoreMatrix.java b/src/jalview/analysis/scoremodels/ScoreMatrix.java
index b904432..aa841ac 100644
--- a/src/jalview/analysis/scoremodels/ScoreMatrix.java
+++ b/src/jalview/analysis/scoremodels/ScoreMatrix.java
@@ -20,9 +20,10 @@
  */
 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;
@@ -32,16 +33,20 @@ import java.util.Arrays;
 
 /**
  * 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;
+
   /*
-   * this fields records which gap character (if any) is used in the alphabet;
-   * space, dash or dot are recognised as gap symbols
+   * 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)
+   * (though a case could be made for using the minimum diagonal value)
    */
-  private char gapCharacter = '0';
+  private static final int UNKNOWN_IDENTITY_SCORE = 1;
 
   /*
    * Jalview 2.10.1 treated gaps as X (peptide) or N (nucleotide)
@@ -90,6 +95,12 @@ public class ScoreMatrix implements SimilarityScoreModelI,
    */
   private boolean peptide;
 
+  private float minValue;
+
+  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
@@ -104,6 +115,26 @@ public class ScoreMatrix implements SimilarityScoreModelI,
    */
   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(
@@ -120,10 +151,15 @@ public class ScoreMatrix implements SimilarityScoreModelI,
 
     this.matrix = values;
     this.name = theName;
+    this.description = theDescription;
     this.symbols = alphabet;
 
     symbolIndex = buildSymbolIndex(alphabet);
 
+    findMinMax();
+
+    symmetric = checkSymmetry();
+
     /*
      * crude heuristic for now...
      */
@@ -131,6 +167,52 @@ public class ScoreMatrix implements SimilarityScoreModelI,
   }
 
   /**
+   * 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()
+  {
+    float min = Float.MAX_VALUE;
+    float max = -Float.MAX_VALUE;
+    if (matrix != null)
+    {
+      for (float[] row : matrix)
+      {
+        if (row != null)
+        {
+          for (float f : row)
+          {
+            min = Math.min(min, f);
+            max = Math.max(max, f);
+          }
+        }
+      }
+    }
+    minValue = min;
+    maxValue = max;
+  }
+
+  /**
    * Returns an array A where A[i] is the position in the alphabet array of the
    * character whose value is i. For example if the alphabet is { 'A', 'D', 'X'
    * } then A['D'] = A[68] = 1.
@@ -154,11 +236,6 @@ public class ScoreMatrix implements SimilarityScoreModelI,
     short pos = 0;
     for (char c : alphabet)
     {
-      if (Comparison.isGap(c))
-      {
-        gapCharacter = c;
-      }
-
       if (c <= MAX_ASCII)
       {
         index[c] = pos;
@@ -245,33 +322,21 @@ public class ScoreMatrix implements SimilarityScoreModelI,
   }
 
   /**
-   * 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, or zero if c or d is
-   * an unscored or unexpected character
+   * 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.
    */
   @Override
   public float getPairwiseScore(char c, char d)
   {
     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;
     }
 
@@ -281,7 +346,14 @@ public class ScoreMatrix implements SimilarityScoreModelI,
     {
       return matrix[cIndex][dIndex];
     }
-    return 0;
+
+    /*
+     * one or both symbols not found in the matrix
+     * currently scoring as 1 (for identity) or the minimum
+     * matrix score value (otherwise)
+     * (a case could be made for using minimum row/column value instead)
+     */
+    return c == d ? UNKNOWN_IDENTITY_SCORE : getMinimumScore();
   }
 
   /**
@@ -318,7 +390,6 @@ public class ScoreMatrix implements SimilarityScoreModelI,
     else
     {
       sb.append("ScoreMatrix ").append(getName()).append("\n");
-      sb.append(symbols).append("\n");
     }
     for (char sym : symbols)
     {
@@ -388,13 +459,14 @@ public class ScoreMatrix implements SimilarityScoreModelI,
    * <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')
-            : Comparison.GAP_DASH;
+            : GAP_CHARACTER;
     String[] seqs = seqstrings.getSequenceStrings(gapChar);
     return findSimilarities(seqs, options);
   }
@@ -407,16 +479,20 @@ public class ScoreMatrix implements SimilarityScoreModelI,
    * @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);
@@ -453,8 +529,8 @@ public class ScoreMatrix implements SimilarityScoreModelI,
         }
       }
 
-      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);
 
@@ -524,13 +600,29 @@ public class ScoreMatrix implements SimilarityScoreModelI,
    * 
    * @return
    */
-  public String getSymbols()
+  String getSymbols()
   {
     return new String(symbols);
   }
 
-  public void setDescription(String desc)
+  public float getMinimumScore()
+  {
+    return minValue;
+  }
+
+  public float getMaximumScore()
+  {
+    return maxValue;
+  }
+
+  @Override
+  public ScoreModelI getInstance(AlignmentViewPanel avp)
+  {
+    return this;
+  }
+
+  public boolean isSymmetric()
   {
-    description = desc;
+    return symmetric;
   }
 }