src/jalview/schemes/ScoreMatrix.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
   3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
   4  *
   5  * This file is part of Jalview.
   6  *
   7  * Jalview is free software: you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation, either version 3
  10  * of the License, or (at your option) any later version.
  11  *
  12  * Jalview is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty
  14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE.  See the GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  19  * The Jalview Authors are detailed in the 'AUTHORS' file.
  20  */
  21 package jalview.schemes;
  22
  23 import jalview.analysis.scoremodels.PairwiseSeqScoreModel;
  24 import jalview.math.Matrix;
  25 import jalview.math.MatrixI;
  26
  27 public class ScoreMatrix extends PairwiseSeqScoreModel
  28 {
  29   String name;
  30
  31   @Override
  32   public String getName()
  33   {
  34     return name;
  35   }
  36
  37   /**
  38    * reference to integer score matrix
  39    */
  40   int[][] matrix;
  41
  42   /**
  43    * 0 for Protein Score matrix. 1 for dna score matrix
  44    */
  45   int type;
  46
  47   /**
  48    *
  49    * @param name
  50    *          Unique, human readable name for the matrix
  51    * @param matrix
  52    *          Pairwise scores indexed according to appropriate symbol alphabet
  53    * @param type
  54    *          0 for Protein, 1 for NA
  55    */
  56   ScoreMatrix(String name, int[][] matrix, int type)
  57   {
  58     this.matrix = matrix;
  59     this.type = type;
  60     this.name = name;
  61   }
  62
  63   @Override
  64   public boolean isDNA()
  65   {
  66     return type == 1;
  67   }
  68
  69   @Override
  70   public boolean isProtein()
  71   {
  72     return type == 0;
  73   }
  74
  75   @Override
  76   public int[][] getMatrix()
  77   {
  78     return matrix;
  79   }
  80
  81   /**
  82    * Answers the score for substituting first char in A1 with first char in A2
  83    *
  84    * @param A1
  85    * @param A2
  86    * @return
  87    */
  88   public int getPairwiseScore(String A1, String A2)
  89   {
  90     return getPairwiseScore(A1.charAt(0), A2.charAt(0));
  91   }
  92
  93   @Override
  94   public int getPairwiseScore(char c, char d)
  95   {
  96     int score = 0;
  97
  98     try
  99     {
 100       int a = (type == 0) ? ResidueProperties.aaIndex[c]
 101               : ResidueProperties.nucleotideIndex[c];
 102       int b = (type == 0) ? ResidueProperties.aaIndex[d]
 103               : ResidueProperties.nucleotideIndex[d];
 104       score = matrix[a][b];
 105     } catch (Exception e)
 106     {
 107       // System.out.println("Unknown residue in " + A1 + " " + A2);
 108     }
 109
 110     return score;
 111   }
 112
 113   /**
 114    * pretty print the matrix
 115    */
 116   @Override
 117   public String toString()
 118   {
 119     return outputMatrix(false);
 120   }
 121
 122   public String outputMatrix(boolean html)
 123   {
 124     StringBuffer sb = new StringBuffer();
 125     int[] symbols = (type == 0) ? ResidueProperties.aaIndex
 126             : ResidueProperties.nucleotideIndex;
 127     int symMax = (type == 0) ? ResidueProperties.maxProteinIndex
 128             : ResidueProperties.maxNucleotideIndex;
 129     boolean header = true;
 130     if (html)
 131     {
 132       sb.append("<table border=\"1\">");
 133     }
 134     for (char sym = 'A'; sym <= 'Z'; sym++)
 135     {
 136       if (symbols[sym] >= 0 && symbols[sym] < symMax)
 137       {
 138         if (header)
 139         {
 140           sb.append(html ? "<tr><td></td>" : "");
 141           for (char sym2 = 'A'; sym2 <= 'Z'; sym2++)
 142           {
 143             if (symbols[sym2] >= 0 && symbols[sym2] < symMax)
 144             {
 145               sb.append((html ? "<td>&nbsp;" : "\t") + sym2
 146                       + (html ? "&nbsp;</td>" : ""));
 147             }
 148           }
 149           header = false;
 150           sb.append(html ? "</tr>\n" : "\n");
 151         }
 152         if (html)
 153         {
 154           sb.append("<tr>");
 155         }
 156         sb.append((html ? "<td>" : "") + sym + (html ? "</td>" : ""));
 157         for (char sym2 = 'A'; sym2 <= 'Z'; sym2++)
 158         {
 159           if (symbols[sym2] >= 0 && symbols[sym2] < symMax)
 160           {
 161             sb.append((html ? "<td>" : "\t")
 162                     + matrix[symbols[sym]][symbols[sym2]]
 163                     + (html ? "</td>" : ""));
 164           }
 165         }
 166         sb.append(html ? "</tr>\n" : "\n");
 167       }
 168     }
 169     if (html)
 170     {
 171       sb.append("</table>");
 172     }
 173     return sb.toString();
 174   }
 175
 176   /**
 177    * Computes an NxN matrix where N is the number of sequences, and entry [i, j]
 178    * is sequence[i] pairwise multiplied with sequence[j], as a sum of scores
 179    * computed using the current score matrix. For example
 180    * <ul>
 181    * <li>Sequences:</li>
 182    * <li>FKL</li>
 183    * <li>R-D</li>
 184    * <li>QIA</li>
 185    * <li>GWC</li>
 186    * <li>Score matrix is BLOSUM62</li>
 187    * <li>Gaps treated same as X (unknown)</li>
 188    * <li>product [0, 0] = F.F + K.K + L.L = 6 + 5 + 4 = 15</li>
 189    * <li>product [1, 1] = R.R + -.- + D.D = 5 + -1 + 6 = 10</li>
 190    * <li>product [2, 2] = Q.Q + I.I + A.A = 5 + 4 + 4 = 13</li>
 191    * <li>product [3, 3] = G.G + W.W + C.C = 6 + 11 + 9 = 26</li>
 192    * <li>product[0, 1] = F.R + K.- + L.D = -3 + -1 + -3 = -8
 193    * <li>and so on</li>
 194    * </ul>
 195    */
 196   public MatrixI computePairwiseScores(String[] seqs)
 197   {
 198     double[][] values = new double[seqs.length][];
 199     for (int row = 0; row < seqs.length; row++)
 200     {
 201       values[row] = new double[seqs.length];
 202       for (int col = 0; col < seqs.length; col++)
 203       {
 204         int total = 0;
 205         int width = Math.min(seqs[row].length(), seqs[col].length());
 206         for (int i = 0; i < width; i++)
 207         {
 208           char c1 = seqs[row].charAt(i);
 209           char c2 = seqs[col].charAt(i);
 210           int score = getPairwiseScore(c1, c2);
 211           total += score;
 212         }
 213         values[row][col] = total;
 214       }
 215     }
 216     return new Matrix(values);
 217   }
 218 }