JAL-2069 typo
[jalview.git] / src / jalview / analysis / SecStrConsensus.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.analysis;
22
23 import java.util.ArrayList;
24 import java.util.Hashtable;
25
26 public class SecStrConsensus
27 {
28
29   /**
30    * Internal class to represent a simple base-pair.
31    * 
32    * @author Yawn [JBPNote: ^^ is that Anne Menard or Ya(w)nn Ponty, I wonder !
33    *         ]
34    */
35   public static class SimpleBP
36   {
37     int bp5;
38
39     int bp3;
40
41     public SimpleBP()
42     {
43
44     }
45
46     public SimpleBP(int i5, int i3)
47     {
48       bp5 = i5;
49       bp3 = i3;
50     }
51
52     public void setBP5(int i5)
53     {
54       bp5 = i5;
55     }
56
57     public void setBP3(int i3)
58     {
59       bp3 = i3;
60     }
61
62     public int getBP5()
63     {
64       return bp5;
65     }
66
67     public int getBP3()
68     {
69       return bp3;
70     }
71
72     public String toString()
73     {
74       return "(" + bp5 + "," + bp3 + ")";
75     }
76
77   }
78
79   public static int[] extractConsensus(ArrayList<ArrayList<SimpleBP>> bps)
80   {
81     // We do not currently know the length of the alignment
82     // => Estimate it as the biggest index of a base-pair plus one.
83     int maxlength = 0;
84     for (ArrayList<SimpleBP> strs : bps)
85     {
86       for (SimpleBP bp : strs)
87       {
88
89         maxlength = Math.max(1 + Math.max(bp.bp5, bp.bp3), maxlength);
90
91       }
92     }
93     // Now we have a good estimate for length, allocate and initialize data
94     // to be fed to the dynamic programming procedure.
95     ArrayList<Hashtable<Integer, Double>> seq = new ArrayList<Hashtable<Integer, Double>>();
96     for (int i = 0; i < maxlength; i++)
97     {
98       seq.add(new Hashtable<Integer, Double>());
99     }
100     for (ArrayList<SimpleBP> strs : bps)
101     {
102       for (SimpleBP bp : strs)
103       {
104         int i = bp.bp5;
105         int j = bp.bp3;
106         Hashtable<Integer, Double> h = seq.get(i);
107         if (!h.containsKey(j))
108         {
109           h.put(j, 0.0);
110         }
111         h.put(j, h.get(j) + 1.);
112       }
113     }
114     // At this point, seq contains, at each position i, a hashtable which
115     // associates,
116     // to each possible end j, the number of time a base-pair (i,j) occurs in
117     // the alignment
118
119     // We can now run the dynamic programming procedure on this data
120     double[][] mat = fillMatrix(seq);
121     ArrayList<SimpleBP> res = backtrack(mat, seq);
122
123     // Convert it to an array, ie finalres[i] = j >= 0 iff a base-pair (i,j) is
124     // present
125     // in the consensus, or -1 otherwise
126     int[] finalres = new int[seq.size()];
127     for (int i = 0; i < seq.size(); i++)
128     {
129       finalres[i] = -1;
130     }
131     for (SimpleBP bp : res)
132     {
133       finalres[bp.bp5] = bp.bp3;
134       finalres[bp.bp3] = bp.bp5;
135     }
136
137     return finalres;
138   }
139
140   private static boolean canBasePair(
141           ArrayList<Hashtable<Integer, Double>> seq, int i, int k)
142   {
143     return seq.get(i).containsKey(k);
144   }
145
146   // Returns the score of a potential base-pair, ie the number of structures in
147   // which it is found.
148   private static double basePairScore(
149           ArrayList<Hashtable<Integer, Double>> seq, int i, int k)
150   {
151     return seq.get(i).get(k);
152   }
153
154   private static double[][] fillMatrix(
155           ArrayList<Hashtable<Integer, Double>> seq)
156   {
157     int n = seq.size();
158     double[][] tab = new double[n][n];
159     for (int m = 1; m <= n; m++)
160     {
161       for (int i = 0; i < n - m + 1; i++)
162       {
163         int j = i + m - 1;
164         tab[i][j] = 0;
165         if (i < j)
166         {
167           tab[i][j] = Math.max(tab[i][j], tab[i + 1][j]);
168           for (int k = i + 1; k <= j; k++)
169           {
170             if (canBasePair(seq, i, k))
171             {
172               double fact1 = 0;
173               if (k > i + 1)
174               {
175                 fact1 = tab[i + 1][k - 1];
176               }
177               double fact2 = 0;
178               if (k < j)
179               {
180                 fact2 = tab[k + 1][j];
181               }
182               tab[i][j] = Math.max(tab[i][j],
183                       basePairScore(seq, i, k) + fact1 + fact2);
184             }
185           }
186         }
187       }
188     }
189     return tab;
190   }
191
192   private static ArrayList<SimpleBP> backtrack(double[][] tab,
193           ArrayList<Hashtable<Integer, Double>> seq)
194   {
195     return backtrack(tab, seq, 0, seq.size() - 1);
196   }
197
198   private static ArrayList<SimpleBP> backtrack(double[][] tab,
199           ArrayList<Hashtable<Integer, Double>> seq, int i, int j)
200   {
201     ArrayList<SimpleBP> result = new ArrayList<SimpleBP>();
202     if (i < j)
203     {
204       ArrayList<Integer> indices = new ArrayList<Integer>();
205       indices.add(-1);
206       for (int k = i + 1; k <= j; k++)
207       {
208         indices.add(k);
209       }
210       for (int k : indices)
211       {
212         if (k == -1)
213         {
214           if (tab[i][j] == tab[i + 1][j])
215           {
216             result = backtrack(tab, seq, i + 1, j);
217           }
218         }
219         else
220         {
221           if (canBasePair(seq, i, k))
222           {
223             double fact1 = 0;
224             if (k > i + 1)
225             {
226               fact1 = tab[i + 1][k - 1];
227             }
228             double fact2 = 0;
229             if (k < j)
230             {
231               fact2 = tab[k + 1][j];
232             }
233             if (tab[i][j] == basePairScore(seq, i, k) + fact1 + fact2)
234             {
235               result = backtrack(tab, seq, i + 1, k - 1);
236               result.addAll(backtrack(tab, seq, k + 1, j));
237               result.add(new SimpleBP(i, k));
238             }
239           }
240         }
241       }
242     }
243     else if (i == j)
244     {
245
246     }
247     else
248     {
249
250     }
251     return result;
252   }
253
254 }