The main method takes three parameters from the command line to generate a
* sequence: type, size and file, where:
*
-
*
typeis eitherDNAfor DNA sequences or *PROTfor protein sequences. *sizeis the number os characters. *file(optional) is the name of a file (if ommited, sequence * is written to standard output). *
The main method takes three parameters from the command line to generate a
* sequence: type, size and file, where:
*
-
*
typeis eitherDNAfor DNA sequences or *PROTfor protein sequences. *sizeis the number os characters. *file(optional) is the name of a file (if ommited, sequence * is written to standard output). *
This implementation derives from the paper of M.Crochemore, G.Landau and * M.Ziv-Ukelson, A Sub-quadratic Sequence Alignment Algorithm for Unrestricted Scoring * Matrices (available here as * PDF or * Postscript).
* *For a general description of the algorithm, please refer to the specification of the * abstract {@linkplain CrochemoreLandauZivUkelson} superclass.
* *This class consist mainly of methods that:
* *This algorithm works essentially in the same way as the global alignment version. * The main differences is that an aptimal path can either be contained entirely in a * block (called C-path) or be a block-crossing path. A block-crossing path * consists of a (possibly empty) S-path (a path that starts inside a block and * ends in its output border), followed by any number of paths that cross a block from its * input border to its output border, and ending in an E-path (a path that starts * in the input border of a block and ends inside the block).
* *Therefore, it is necessary to compute extra information to keep track of these * possibilities. This is accomplished by using an instance of a {@linkplain * LocalAlignmentBlock} (which extends the {@linkplain AlignmentBlock} class) for every * block in the block table.
* * @see CrochemoreLandauZivUkelson * @see CrochemoreLandauZivUkelsonLocalAlignment * @author Sergio A. de Carvalho Jr. */ public class CrochemoreLandauZivUkelsonLocalAlignment extends CrochemoreLandauZivUkelson { /** * A constant that indicates that the best path ending at a given entry of the output * border is a block-crossing path (one that starts outside the block). */ protected static final byte TYPE_CROSSING_PATH = 0; /** * A constant that indicates that the best path ending at a given entry of the output * border is a S-path (one that starts inside the block). */ protected static final byte TYPE_S_PATH = 1; /** * A constant that indicates that the high scoring path ending in a given block is a * C-path, i.e. one that starts inside the block. */ protected static final byte TYPE_C_PATH = 2; /** * A constant that indicates that the high scoring path ending in a given block is an * E-path, i.e. one that starts at its input border. */ protected static final byte TYPE_E_PATH = 3; /** * The score of the high scoring local alignment found. */ protected int max_score; /** * The row index of a block (in the block table) where the high scoring local * alignment ends. */ protected int max_row; /** * The column index of a block (in the block table) where the high scoring local * alignment ends. */ protected int max_col; /** * The type of the high scoring local alignment found. */ protected byte max_path_type; /** * If the high scoring local alignment ends in an E-path at a block B, this field * contains the index of the entry in the input border of B that where the E-path * starts. */ protected int max_source_index; /** * Creates and computes all information of an alignment block. This method works * essentially in the same way as its global alignment counterpart. Its main job is to * compute the DIST column for the block. It then request the *computeOutputBorder method to compute the block's output border. It
* also computes all S, C and E-paths of this block. Finally, it checks if the C-path
* of this block is higher than the highest score found so far.
*
* @param factor1 factor of the first sequence
* @param factor2 factor of the second sequence
* @param row row index of the block in the block table
* @param col column index of the block in the block table
* @return the computed block
* @throws IncompatibleScoringSchemeException if the scoring scheme is not compatible
* with the sequences being aligned
*/
protected AlignmentBlock createBlock (Factor factor1, Factor factor2, int row,
int col) throws IncompatibleScoringSchemeException
{
LocalAlignmentBlock block, left_prefix, diag_prefix, top_prefix;
int size, lr, lc, max, ins_E, del_E;
int score_ins, score_sub, score_del, ins, del, sub;
lr = factor1.length();
lc = factor2.length();
size = lr + lc + 1;
block = new LocalAlignmentBlock (factor1, factor2, size);
// retrieve pointers to prefixes
left_prefix = (LocalAlignmentBlock) getLeftPrefix (block);
diag_prefix = (LocalAlignmentBlock) getDiagonalPrefix (block);
top_prefix = (LocalAlignmentBlock) getTopPrefix (block);
// compute scores
score_ins = scoreInsertion (factor2.getNewChar());
score_sub = scoreSubstitution (factor1.getNewChar(), factor2.getNewChar());
score_del = scoreDeletion (factor1.getNewChar());
// compute block's data
for (int i = 0; i < size; i++)
{
ins = sub = del = ins_E = del_E = Integer.MIN_VALUE;
if (i < size - 1)
{
ins = left_prefix.dist_column[i] + score_ins;
ins_E = left_prefix.E_path_score[i];
}
if ((i > 0) && (i < size - 1))
{
sub = diag_prefix.dist_column[i - 1] + score_sub;
}
if (i > 0)
{
del = top_prefix.dist_column[i - 1] + score_del;
del_E = top_prefix.E_path_score[i - 1];
}
block.dist_column[i] = max = max (ins, sub, del);
if (max == ins)
block.direction[i] = LEFT_DIRECTION;
else if (max == sub)
block.direction[i] = DIAGONAL_DIRECTION;
else
block.direction[i] = TOP_DIRECTION;
block.E_path_score[i] = max = max (ins_E, block.dist_column[i], del_E);
if (max == ins_E)
{
block.E_path_ancestor[i] = left_prefix.E_path_ancestor[i];
block.E_path_ancestor_index[i] = left_prefix.E_path_ancestor_index[i];
}
else if (max == block.dist_column[i])
{
block.E_path_ancestor[i] = block;
block.E_path_ancestor_index[i] = i;
}
else
{
block.E_path_ancestor[i] = top_prefix.E_path_ancestor[i - 1];
block.E_path_ancestor_index[i] = top_prefix.E_path_ancestor_index[i - 1];
}
if (i < lc)
{
block.S_path_score[i] = left_prefix.S_path_score[i];
}
else if (i == lc)
{
ins = left_prefix.S_path_score[i-1] + score_ins;
sub = diag_prefix.S_path_score[i-1] + score_sub;
del = top_prefix.S_path_score[i] + score_del;
block.S_path_score[i] = max = max (0, ins, sub, del);
if (max == ins)
block.S_direction = LEFT_DIRECTION;
else if (max == sub)
block.S_direction = DIAGONAL_DIRECTION;
else if (max == del)
block.S_direction = TOP_DIRECTION;
else
block.S_direction = STOP_DIRECTION;
}
else
{
block.S_path_score[i] = top_prefix.S_path_score[i - 1];
}
}
computeOutputBorder (block, row, col, size, lc, lr);
ins = left_prefix.C;
del = top_prefix.C;
block.C = max = max (ins, block.S_path_score[lc], del);
if (block.C > max_score)
{
// assert block.C == block.S_path_score[lc]; => always true
max_score = block.C;
max_row = row;
max_col = col;
max_path_type = TYPE_C_PATH;
}
return block;
}
/**
* Creates the root block. This is a special case of the createBlock
* method. No information is actually computed.
*
* @param factor1 factor of the first sequence
* @param factor2 factor of the second sequence
* @return the root block
*/
protected AlignmentBlock createRootBlock (Factor factor1, Factor factor2)
{
// resets the variables that keep track
// of the high scoring alignment
max_row = max_col = max_score = 0;
max_path_type = TYPE_C_PATH;
return new LocalAlignmentBlock (factor1, factor2);
}
/**
* Creates and computes all information of an alignment block of the first column of
* the block table. This is a special case of the createBlock method.
*
* @param factor1 factor of the first sequence
* @param factor2 factor of the second sequence
* @param col column index of the block in the block table
* @return the computed block
* @throws IncompatibleScoringSchemeException if the scoring scheme is not compatible
* with the sequences being aligned
* @see #createBlock createBlock
*/
protected AlignmentBlock createFirstRowBlock (Factor factor1, Factor factor2, int col)
throws IncompatibleScoringSchemeException
{
LocalAlignmentBlock block, left_prefix;
int size, lr, lc, score_ins;
lr = 0; // factor1.length();
lc = factor2.length();
size = lr + lc + 1;
block = new LocalAlignmentBlock (factor1, factor2, size);
// retrieve a pointer to left prefix
left_prefix = (LocalAlignmentBlock) getLeftPrefix (block);
// compute insertion's score
score_ins = scoreInsertion (factor2.getNewChar());
// compute block's data
for (int i = 0; i < lc; i++)
{
block.dist_column[i] = left_prefix.dist_column[i] + score_ins;
block.direction[i] = LEFT_DIRECTION;
block.S_path_score[i] = left_prefix.S_path_score[i];
block.E_path_score[i] = left_prefix.E_path_score[i];
block.E_path_ancestor[i] = left_prefix.E_path_ancestor[i];
block.E_path_ancestor_index[i] = left_prefix.E_path_ancestor_index[i];
if (block.dist_column[i] > block.E_path_score[i])
{
block.E_path_score[i] = block.dist_column[i];
block.E_path_ancestor[i] = block;
block.E_path_ancestor_index[i] = i;
}
}
// last position
block.E_path_score[lc] = block.dist_column[lc] = 0;
block.direction[lc] = STOP_DIRECTION;
block.E_path_ancestor[lc] = block;
block.E_path_ancestor_index[lc] = lc;
block.S_direction = LEFT_DIRECTION;
block.S_path_score[lc] = left_prefix.S_path_score[lc - 1] + score_ins;
if (block.S_path_score[lc] <= 0)
{
block.S_path_score[lc] = 0;
block.S_direction = STOP_DIRECTION;
}
computeOutputBorder (block, 0, col, size, lc, lr);
block.C = max (left_prefix.C, block.S_path_score[lc]);
if (block.C > max_score)
{
max_score = block.C;
max_row = 0;
max_col = col;
max_path_type = TYPE_C_PATH;
}
return block;
}
/**
* Creates and computes all information of an alignment block of the first column of
* the block table. This is a special case of the createBlock method.
*
* @param factor1 factor of the first sequence
* @param factor2 factor of the second sequence
* @param row row index of the block in the block table
* @return the computed block
* @throws IncompatibleScoringSchemeException if the scoring scheme is not compatible
* with the sequences being aligned
* @see #createBlock createBlock
*/
protected AlignmentBlock createFirstColumnBlock (Factor factor1, Factor factor2,
int row) throws IncompatibleScoringSchemeException
{
LocalAlignmentBlock block, top_prefix;
int size, lr, lc, score_del;
lr = factor1.length();
lc = 0; // factor2.length();
size = lr + lc + 1;
block = new LocalAlignmentBlock (factor1, factor2, size);
// retrieve a pointer to top prefix
top_prefix = (LocalAlignmentBlock) getTopPrefix (block);
// compute deletion's score
score_del = scoreDeletion (factor1.getNewChar());
// first position
block.E_path_score[0] = block.dist_column[0] = 0;
block.direction[0] = STOP_DIRECTION;
block.E_path_ancestor[0] = block;
block.E_path_ancestor_index[0] = 0;
block.S_direction = TOP_DIRECTION;
block.S_path_score[0] = top_prefix.S_path_score[0] + score_del;
if (block.S_path_score[0] <= 0)
{
block.S_path_score[0] = 0;
block.S_direction = STOP_DIRECTION;
}
// compute block's data
for (int i = 1; i < size; i++)
{
block.dist_column[i] = top_prefix.dist_column[i - 1] + score_del;
block.direction[i] = TOP_DIRECTION;
block.S_path_score[i] = top_prefix.S_path_score[i - 1];
block.E_path_score[i] = top_prefix.E_path_score[i - 1];
block.E_path_ancestor[i] = top_prefix.E_path_ancestor[i - 1];
block.E_path_ancestor_index[i] = top_prefix.E_path_ancestor_index[i - 1];
if (block.dist_column[i] > block.E_path_score[i])
{
block.E_path_score[i] = block.dist_column[i];
block.E_path_ancestor[i] = block;
block.E_path_ancestor_index[i] = i;
}
}
computeOutputBorder (block, row, 0, size, lc, lr);
block.C = max (block.S_path_score[lc], top_prefix.C);
if (block.C > max_score)
{
max_score = block.C;
max_row = row;
max_col = 0;
max_path_type = TYPE_C_PATH;
}
return block;
}
/**
* Computes the output border of a block. This method works essentially in the same
* way as its global alignment counterpart:
*
* However, it also check if there is a better path starting inside the block (an
* S path) and oupdate the output border accordingly. It also checks if this block has
* any path of score higher than the maximum score found so far.
*
* @param block the block for which the output border is to be computed
* @param row row index of the block in the block table
* @param col column index of the block in the block table
* @param dim dimension of the output border
* @param lc number of columns of the block
* @param lr number of row of the block
*/
protected void computeOutputBorder (LocalAlignmentBlock block, int row, int col, int
dim, int lc, int lr)
{
int[] input = assembleInputBorder (dim, row, col, lr);
int[][] dist = assembleDistMatrix (block, dim, row, col, lc); // (AlignmentBlock)
// build an interface to the OUT matrix
out_matrix.setData (dist, input, dim, lc);
// compute source_path using SMAWK
smawk.computeColumnMaxima(out_matrix, block.source_path);
// update output border
for (int i = 0; i < dim; i++)
{
block.path_type[i] = TYPE_CROSSING_PATH;
block.output_border[i] = out_matrix.valueAt(block.source_path[i], i);
// check if there is a better path starting inside the block
// (if there is a path of equal score, preference is given
// to the S-path because it ends sooner)
if (block.S_path_score[i] >= block.output_border[i])
{
block.output_border[i] = block.S_path_score[i];
block.path_type[i] = TYPE_S_PATH;
}
// check if this block contains a score higher
// than the best path found so far
if (input[i] + block.E_path_score[i] > max_score)
{
max_score = input[i] + block.E_path_score[i];
max_row = row;
max_col = col;
max_source_index = i;
max_path_type = TYPE_E_PATH;
}
}
}
/**
* Builds an optimal local alignment between the loaded sequences after the block
* table has been computed by tracing a path back in the block table.
*
* @return an optimal global alignment
* @throws IncompatibleScoringSchemeException If the scoring scheme is not compatible
* with the loaded sequences.
* @see CrochemoreLandauZivUkelson#traverseBlock
*/
protected PairwiseAlignment buildOptimalAlignment ()
throws IncompatibleScoringSchemeException
{
LocalAlignmentBlock block;
StringBuffer gapped_seq1, tag_line, gapped_seq2;
gapped_seq1 = new StringBuffer();
tag_line = new StringBuffer();
gapped_seq2 = new StringBuffer();
block = (LocalAlignmentBlock) block_table[max_row][max_col];
if (max_path_type == TYPE_C_PATH)
{
// a C-path is essentially an S-path
traverseS_Path (block, gapped_seq1, tag_line, gapped_seq2);
}
else
{
traverseBlockCrossingPath (block, gapped_seq1, tag_line, gapped_seq2);
}
return new PairwiseAlignment (gapped_seq1.toString(), tag_line.toString(),
gapped_seq2.toString(), locateScore());
}
/**
* Traverses a series of block crossing paths to retrieve an optimal alignment. A
* block-crossing path consists of a (possibly empty) S-path (a path that
* starts inside a block and ends in its output border), followed by any number of
* paths that cross a block from its input border to its output border, and ending in
* an E-path (a path that starts in the input border of a block and ends inside
* the block).
*
* @param block the block to be traversed
* @param gapped_seq1 the StringBuffer to where the gapped sequence 1 is written to
* @param tag_line the StringBuffer to where the tag_line is written to
* @param gapped_seq2 the StringBuffer to where the gapped sequence 2 is written to
* @throws IncompatibleScoringSchemeException If the scoring scheme is not compatible
* with the loaded sequences.
*/
protected void traverseBlockCrossingPath (LocalAlignmentBlock block,
StringBuffer gapped_seq1, StringBuffer tag_line, StringBuffer gapped_seq2)
throws IncompatibleScoringSchemeException
{
LocalAlignmentBlock ancestor;
int source, dest, ancestor_source;
int row, col;
row = max_row;
col = max_col;
// recover the E-path
source = max_source_index;
ancestor = block.E_path_ancestor[source];
ancestor_source = block.E_path_ancestor_index[source];
traverseBlock (ancestor, ancestor_source, gapped_seq1, tag_line, gapped_seq2);
// now recover crossing paths
while (true)
{
if (row == 0)
{
col = col - 1;
dest = block_table[row][col].factor2.length();
}
else if (col == 0)
{
row = row - 1;
dest = 0;
}
else
{
if (source < block.factor1.length())
{
col = col - 1;
dest = block_table[row][col].factor2.length() + source;
}
else if (source == block.factor1.length())
{
row = row - 1; col = col - 1;
dest = block_table[row][col].factor2.length();
}
else
{
row = row - 1;
dest = source - block.factor1.length();
}
}
// check if has reached the root block
if (!(row > 0 || col > 0)) break;
block = (LocalAlignmentBlock) block_table[row][col];
if (block.path_type[dest] == TYPE_S_PATH)
{
// last part, an S-path, and we're done
ancestor = (LocalAlignmentBlock) block.ancestor[dest];
traverseS_Path (ancestor, gapped_seq1, tag_line, gapped_seq2);
break;
}
source = block.source_path[dest];
ancestor = (LocalAlignmentBlock) block.ancestor[dest];
ancestor_source = source;
if (dest > block.factor2.length())
ancestor_source -= (block.factor1.length() - ancestor.factor1.length());
traverseBlock (ancestor, ancestor_source, gapped_seq1, tag_line, gapped_seq2);
}
}
/**
* Traverses an S-path of a block to retrieve a part of an optimal alignment from the
* new vertex of a block to entry in its input border. This method is essentially
* similar to the traverseBlock. The only difference is that it uses
* the information of the S_direction field of the
* LocalAlignmentBlock class.
*
* @param block the block to be traversed
* @param gapped_seq1 the StringBuffer to where the gapped sequence 1 is written to
* @param tag_line the StringBuffer to where the tag_line is written to
* @param gapped_seq2 the StringBuffer to where the gapped sequence 2 is written to
* @throws IncompatibleScoringSchemeException If the scoring scheme is not compatible
* with the loaded sequences.
*/
protected void traverseS_Path (LocalAlignmentBlock block, StringBuffer gapped_seq1,
StringBuffer tag_line, StringBuffer gapped_seq2)
throws IncompatibleScoringSchemeException
{
char char1, char2;
while (block.S_direction != STOP_DIRECTION)
{
char1 = block.factor1.getNewChar();
char2 = block.factor2.getNewChar();
switch (block.S_direction)
{
case LEFT_DIRECTION:
gapped_seq1.insert (0, GAP_CHARACTER);
tag_line.insert (0, GAP_TAG);
gapped_seq2.insert (0, char2);
block = (LocalAlignmentBlock) getLeftPrefix (block);
break;
case DIAGONAL_DIRECTION:
gapped_seq1.insert (0, char1);
if (char1 == char2)
if (useMatchTag())
tag_line.insert (0, MATCH_TAG);
else
tag_line.insert (0, char1);
else if (scoreSubstitution(char1, char2) > 0)
tag_line.insert (0, APPROXIMATE_MATCH_TAG);
else
tag_line.insert (0, MISMATCH_TAG);
gapped_seq2.insert(0, char2);
block = (LocalAlignmentBlock) getDiagonalPrefix (block);
break;
case TOP_DIRECTION:
gapped_seq1.insert (0, char1);
tag_line.insert (0, GAP_TAG);
gapped_seq2.insert (0, GAP_CHARACTER);
block = (LocalAlignmentBlock) getTopPrefix (block);
break;
}
}
}
/**
* Returns the score of the high scoring local alignment in the block table.
*
* @return the score of the highest scoring local alignment
*/
protected int locateScore ()
{
return max_score;
}
}
neobio-0.0.20030929/src/neobio/alignment/PairwiseAlignment.java 0000644 0002656 0002032 00000016766 07717074370 023220 0 ustar tillea admin /*
* PairwiseAlignment.java
*
* Copyright 2003 Sergio Anibal de Carvalho Junior
*
* This file is part of NeoBio.
*
* NeoBio is free software; you can redistribute it and/or modify it under the terms of
* the GNU General Public License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with NeoBio;
* if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307, USA.
*
* Proper attribution of the author as the source of the software would be appreciated.
*
* Sergio Anibal de Carvalho Junior mailto:sergioanibaljr@users.sourceforge.net
* Department of Computer Science http://www.dcs.kcl.ac.uk
* King's College London, UK http://www.kcl.ac.uk
*
* Please visit http://neobio.sourceforge.net
*
* This project was supervised by Professor Maxime Crochemore.
*
*/
package neobio.alignment;
import java.io.Serializable;
/**
* This class is the product of a pairwise alignment, generated by one subclasses of
* {@linkplain PairwiseAlignmentAlgorithm}. It contains the two sequences strings with
* gaps, a score tag line, and a score value. It is typically displayed in three rows as
* in the following example of an alignment between parts of two protein sequences:
*
*
* MDEIHQLEDMFTVDSETLRKVVKHFILPHD-----MRTTKHQEELWSFIAELDSLKDFMVEQE // sequence 1
* M +I E +FTV +ETL+ V KHFILP D MRTT++ +ELW FIA DSLK F+ EQ // score tag line
* MQQIENFEKIFTVPTETLQAVTKHFILP-DATETLMRTTQNPDELWEFIA--DSLKAFIDEQF // sequence 2
*
Each column has one character of each sequence and a score tag. The same character * is displayed in all three rows when a column has an exact match (character of sequences * 1 and 2 are equal). When a mismatch occurs (substitution of different characters), the * score tag is left blank. A '+' in the score line signals a partial match (a * substitution of similar characters). The difference between a partial match and a * mismatch is that the score of a partial match is positive whereas the score of a * mismatch is zero or negative (each case is determined by the scoring scheme).
* *Gaps are usually represented by dashes ('-') and have a blank score tag. Insertions * have dashes in sequence 1 and the inserted character in sequence 2. Deletions, by * contrast, have the deleted character in sequence 1 and dashes in sequence 2.
* *Each column carries a score value for the corresponding operation (as defined by the * scoring scheme). The overall score of a pairwise alignment is the sum of all columns * scores values.
* *When the scoring schemes does not support partial matches, a match is usually * signaled by a '|' character.
* *
Note that these special characters are defined by the
* PairwiseAlignmentAlgorithm class. Consult that class specification for the
* actual configuration. For instance, an alignment between two DNA fragmens may look like
* this:
* A--C--TAAAAAGCA--TT-AATAATAAA-A
* | | |||| ||| || ||||| ||| |
* AAGCCCTAAACCGCAAGTTTAATAA-AAATA
*
This class is serializable, so it can be saved to a file (or any other output). It
* overrides the default equals method of the Object class to
* allow a proper comparsion of alignments produced by different algorithms or even
* different runs of the same algorithm. However, it does not override the
* hashCode method as it is generally the case to maintain the contract for
* the hashCode method (which states that equal objects must have equal hash
* codes). Hence, as it is, its use in a hash table is not supported.
PairwiseAlignment instance with the specified gapped
* sequences, score tag line and score value.
*
* @param gapped_seq1 the first gapped sequence
* @param score_tag_line the score tag line
* @param gapped_seq2 the second gapped sequence
* @param score the overall score value for this alignment
*/
public PairwiseAlignment (String gapped_seq1, String score_tag_line,
String gapped_seq2, int score)
{
this.gapped_seq1 = gapped_seq1;
this.score_tag_line = score_tag_line;
this.gapped_seq2 = gapped_seq2;
this.score = score;
}
/**
* Returns the first gapped sequence.
*
* @return first gapped sequence
*/
public String getGappedSequence1 ()
{
return gapped_seq1;
}
/**
* Returns the score tag line.
*
* @return score tag line
*/
public String getScoreTagLine ()
{
return score_tag_line;
}
/**
* Returns the second gapped sequence.
*
* @return second gapped sequence
*/
public String getGappedSequence2 ()
{
return gapped_seq2;
}
/**
* Returns the score for this alignment.
*
* @return overall score for this alignment
*/
public int getScore ()
{
return score;
}
/**
* Returns a four-line String representation of this alignment in the following
* order: first gapped sequence, score tag line, second gapped sequence and the
* score value.
*
* @return a String representation of this scoring matrix
*/
public String toString ()
{
return gapped_seq1 + "\n" + score_tag_line + "\n"
+ gapped_seq2 + "\nScore: " + score;
}
/**
* Compares this object to the specified object. The result is true if
* and only if the argument is not null and is an
* PairwiseAlignment object that contains the same values as this object,
* i.e. the same gapped sequences, the same score tag line and the same score.
*
* @param obj the object to compare with
* @return true if objects are the same, false otherwise
*/
public boolean equals (Object obj)
{
if (!(obj instanceof PairwiseAlignment))
return false;
PairwiseAlignment another_pa = (PairwiseAlignment) obj;
if (this.score != another_pa.score)
return false;
if (!this.gapped_seq1.equals(another_pa.gapped_seq1))
return false;
if (!this.score_tag_line.equals(another_pa.score_tag_line))
return false;
if (!this.gapped_seq2.equals(another_pa.gapped_seq2))
return false;
return true;
}
}
neobio-0.0.20030929/src/neobio/alignment/AlignmentBlock.java 0000644 0002656 0002032 00000010067 07725254634 022455 0 ustar tillea admin /*
* AlignmentBlock.java
*
* Copyright 2003 Sergio Anibal de Carvalho Junior
*
* This file is part of NeoBio.
*
* NeoBio is free software; you can redistribute it and/or modify it under the terms of
* the GNU General Public License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with NeoBio;
* if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307, USA.
*
* Proper attribution of the author as the source of the software would be appreciated.
*
* Sergio Anibal de Carvalho Junior mailto:sergioanibaljr@users.sourceforge.net
* Department of Computer Science http://www.dcs.kcl.ac.uk
* King's College London, UK http://www.kcl.ac.uk
*
* Please visit http://neobio.sourceforge.net
*
* This project was supervised by Professor Maxime Crochemore.
*
*/
package neobio.alignment;
/**
* This class is used by the {@linkplain CrochemoreLandauZivUkelson} algorithm to store
* the information of an alignment block. All fields are public (but final) in order to
* simplify the access to the data.
*
* For more information on how this class is used, please refer to the specification
* of the CrochemoreLandauZivUkelson class and it subclasses.
source_path and
* ancestor arrays. Moreover, its dist_column and
* output_border arrays are set to zero, and the direction
* array is set to contain an STOP_DIRECTION.
*
* @param factor1 factor of the first sequence being aligned
* @param factor2 factor of the second sequence being aligned
*/
public AlignmentBlock (Factor factor1, Factor factor2)
{
this.factor1 = factor1;
this.factor2 = factor2;
dist_column = output_border = new int[] {0};
direction = new byte [] {0}; // STOP_DIRECTION
source_path = null;
ancestor = null;
}
/**
* Creates a new alignment block, with all arrays created with the specified size.
*
* @param factor1 factor of the first sequence being aligned
* @param factor2 factor of the second sequence being aligned
* @param size size of the arrays to be created
*/
public AlignmentBlock (Factor factor1, Factor factor2, int size)
{
this.factor1 = factor1;
this.factor2 = factor2;
dist_column = new int[size];
output_border = new int[size];
direction = new byte[size];
source_path = new int[size];
ancestor = new AlignmentBlock[size];
}
}
neobio-0.0.20030929/src/neobio/alignment/FactorSequence.java 0000644 0002656 0002032 00000021721 07717074374 022474 0 ustar tillea admin /*
* FactorSequence.java
*
* Copyright 2003 Sergio Anibal de Carvalho Junior
*
* This file is part of NeoBio.
*
* NeoBio is free software; you can redistribute it and/or modify it under the terms of
* the GNU General Public License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with NeoBio;
* if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307, USA.
*
* Proper attribution of the author as the source of the software would be appreciated.
*
* Sergio Anibal de Carvalho Junior mailto:sergioanibaljr@users.sourceforge.net
* Department of Computer Science http://www.dcs.kcl.ac.uk
* King's College London, UK http://www.kcl.ac.uk
*
* Please visit http://neobio.sourceforge.net
*
* This project was supervised by Professor Maxime Crochemore.
*
*/
package neobio.alignment;
import java.io.Reader;
import java.io.BufferedReader;
import java.io.IOException;
/**
* This class builds a list of factors of a character sequence as induced by its
* Lempel-Ziv (LZ78) factorisation. Each factor is enconded as the longest factor
* previously seen plus one character.
*
* The input can come from any source, provided it is encapsulated in a proper
* Reader instance. The stream is expected to be ready (i.e. the next
* read operation must return the first character of the sequence) and it is
* not closed when its end is reached, so the client is allowed to reset it and maybe use
* it for another purpose.
Sequences can contain letters only although lines started with the
* COMMENT_CHAR character ('>') are regarded as comments and are completely
* skipped. White spaces (including tabs, line feeds and carriage returns) are also
* ignored throughout.
This class uses a {@linkplain Trie} to keep track of a list of factors. Each node of * the trie contains a {@linkplain Factor} of the text. As the sequence is read from the * input, the trie is traversed as far as possible. When a leaf node is reached (which * means that the longest prefix of the input has been found), two tasks are * accomplished:
* *-
*
- a new
Factoris created with the character at the current position of * the input and the leaf node's factor; * - a new node is added to the trie with the character at the current position of the * input; *
Each factor also receives a serial number according to the order they are found and * a pointer to the next factor (in that order) for fast access. This pointer, together * with the factor's ancestor pointer forms a doubly-linked list of factors. The original * text can then be reconstructed simply by following the linked list and writing out its * factors.
* *As an example, the sequence ACTAAACCGCATTAATAATAAAA is parsed into the
* following 12 factors:
* 0 ( , ) = empty
* 1 (0,A) = A
* 2 (0,C) = C
* 3 (0,T) = T
* 4 (1,A) = AA
* 5 (1,C) = AC
* 6 (2,G) = CG
* 7 (2,A) = CA
* 8 (3,T) = TT
* 9 (4,T) = AAT
* 10 (9,A) = AATA
* 11 (4,A) = AAA
*
* serial # (prefix, new char) = factor text
*
This class is used by {@linkplain CrochemoreLandauZivUkelson} algorithm to speed up * the classic dynamic programming approach to sequence alignment.
* * @author Sergio A. de Carvalho Jr. * @see Factor * @see Trie * @see CrochemoreLandauZivUkelson */ public class FactorSequence { /** * The character used to start a comment line in a sequence file. When this character * is found, the rest of the line is ignored. */ protected static final char COMMENT_CHAR = '>'; /** * A pointer to the root factor, the one that starts the list of factors. */ protected Factor root_factor; /** * The numbers of character represented by this sequence. */ protected int num_chars; /** * The numbers of factors generated by the LZ78 parsing of the sequence. */ protected int num_factors; /** * Creates a new instance of aFactorSequence, loading the sequence data
* from the Reader input stream. A doubly-linked list of factors is built
* according to its LZ78 factorisation.
*
* @param reader source of characters for this sequence
* @throws IOException if an I/O exception occurs when reading the input
* @throws InvalidSequenceException if the input does not contain a valid sequence
*/
public FactorSequence (Reader reader)
throws IOException, InvalidSequenceException
{
BufferedReader input = new BufferedReader(reader);
Trie root_node, current_node, new_node = null;
Factor current_factor, last_factor, new_factor;
int ch;
char c;
// create root factor and the root node of the trie
root_factor = new Factor ();
root_node = new Trie (root_factor);
num_factors = 1;
num_chars = 0;
current_node = root_node;
last_factor = root_factor;
// read characters from the input
while ((ch = input.read()) != -1)
{
c = (char) ch;
if (c == COMMENT_CHAR)
// it's a comment line: skip it!
input.readLine();
// accept letters only
else if (Character.isLetter(c))
{
num_chars++;
// walk down the trie as far as possible
new_node = current_node.spellDown(c);
if (new_node != null)
{
current_node = new_node;
}
else
{
// the longest factor of the input has been found,
// now create a new factor from the current node's factor
current_factor = (Factor) current_node.getData();
new_factor = new Factor (current_factor, num_factors, c);
// add the new character to the trie as well
current_node.add (new_factor, c);
// set up a pointer from the last factor to the new one
last_factor.setNext (new_factor);
last_factor = new_factor;
// restart at the root of the trie
current_node = root_node;
num_factors++;
}
}
// anything else, except whitespaces, will throw an exception
else if (!Character.isWhitespace(c))
throw new InvalidSequenceException
("Sequences can contain letters only.");
}
// if new_node is not null, the last factor is actually
// not a new factor but a factor already created
if (new_node != null)
{
// no new node is created, just point the last_factor to an
// existing one that represents the last characters of the text
last_factor.setNext((Factor) new_node.getData());
num_factors++;
}
// check if read anything useful!
if (num_factors <= 1)
throw new InvalidSequenceException ("Empty sequence.");
}
/**
* Returns the root factor, the one that starts the list of factors.
*
* @return root factor
*/
public Factor getRootFactor ()
{
return root_factor;
}
/**
* Returns the number of factors produced by the LZ78 parsing of the text.
*
* @return number of factors
*/
public int numFactors()
{
return num_factors;
}
/**
* Returns the number of characters of the original sequence.
*
* @return number of characters of the original sequence
*/
public int numChars ()
{
return num_chars;
}
/**
* Reconstructs the sequence from the list of factors induced by the LZ78 parsing of
* the text.
*
* @return the original sequence
*/
public String toString ()
{
StringBuffer buf = new StringBuffer();
Factor node;
node = root_factor.getNext();
for (int i = 1; i < numFactors(); i++)
{
buf.append(node);
node = node.getNext();
}
return buf.toString();
}
/**
* Returns a string representation of the actual list of factors produced by the LZ78
* parsing of the text. Each factor is printed out in a separate line, in the order
* they appear in the text, with its serial number, its ancestor's serial number, its
* new character, length and a string representation of the factor itself.
*
* @return a string representation of the list of factors
*/
public String printFactors ()
{
StringBuffer buf = new StringBuffer();
Factor factor;
factor = root_factor.getNext();
for (int i = 1; i < numFactors(); i++)
{
buf.append (factor.getSerialNumber() + "\t<");
buf.append (factor.getAncestor().getSerialNumber() + " ,\t");
buf.append (factor.getNewChar() + ">\t");
buf.append (factor.length() + "\t" + factor + "\n");
factor = factor.getNext();
}
buf.append(numFactors() + " factors\n");
return buf.toString();
}
}
neobio-0.0.20030929/src/neobio/alignment/PairwiseAlignmentAlgorithm.java 0000644 0002656 0002032 00000041112 07717234200 025034 0 ustar tillea admin /*
* PairwiseAlignmentAlgorithm.java
*
* Copyright 2003 Sergio Anibal de Carvalho Junior
*
* This file is part of NeoBio.
*
* NeoBio is free software; you can redistribute it and/or modify it under the terms of
* the GNU General Public License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with NeoBio;
* if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307, USA.
*
* Proper attribution of the author as the source of the software would be appreciated.
*
* Sergio Anibal de Carvalho Junior mailto:sergioanibaljr@users.sourceforge.net
* Department of Computer Science http://www.dcs.kcl.ac.uk
* King's College London, UK http://www.kcl.ac.uk
*
* Please visit http://neobio.sourceforge.net
*
* This project was supervised by Professor Maxime Crochemore.
*
*/
package neobio.alignment;
import java.io.Reader;
import java.io.IOException;
/**
* This abstract class is the superclass of all classes implementing pairwise sequence
* alignment algorithms. Subclasses are required to provide methods to build a high
* scoring alignment between two sequences and compute its score with a given scoring
* scheme.
*
* Clients are required to set a scoring scheme and load two sequences before * requesting an alignment or the computation of its score. They typically make the * following sequence of method calls:
* *
* // prepare
* PairwiseAlignmentAlgorithm algorithm = new SomePairwiseAlignmentAlgorith ();
* algorithm.setScoringScheme (some_scoring_scheme);
* algorithm.loadSequences (sequence1, sequence2);
*
* // now compute the alignment
* PairwiseAlignment alignment = algorithm.getPairwiseAlignment();
* int score = algorithm.getScore();
*
use_match_tag flag.
*
* @see #use_match_tag
* @see #useMatchTag
*/
protected static final char MATCH_TAG = '|';
/**
* Tag character that signals an approximate match in the score tag line of an
* alignment.
*/
protected static final char APPROXIMATE_MATCH_TAG = '+';
/**
* Character that signals a mismatch in the score tag line of an alignment.
*/
protected static final char MISMATCH_TAG = ' ';
/**
* Character that signals a gap in the score tag line of an alignment.
*/
protected static final char GAP_TAG = ' ';
/**
* Character that signals a gap in sequence.
*/
protected static final char GAP_CHARACTER = '-';
/**
* Indicates if the MATCH_TAG tag should be used or not. If it is
* true, the alignment algorithm should write the MATCH_TAG
* tag in the score tag line of the alignment whenever a match occurs between
* characters of the two sequences. If it is false the matching character
* should be written instead. This flag is updated whenever a scoring scheme is set to
* this PairwiseAlignmentAlgorithm by the setScoringScheme
* method.
*
* @see #MATCH_TAG
* @see #useMatchTag
* @see #setScoringScheme
*/
protected boolean use_match_tag;
/**
* The scoring scheme used to compute a pairwise sequence alignment. It must be set
* before performing the alignment, and if a new scoring scheme is set, any alignment
* or score already computed is lost.
*/
protected ScoringScheme scoring;
/**
* Stores the product of the last pairwise alignment performed. It contains a string
* representation of a highest scoring alignment between the two sequences and its
* score. It is set after a successful execution of the
* computePairwiseAlignment method that subclasses must implement. It is
* set to null if new sequences are loaded or a new scoring scheme is set.
*/
protected PairwiseAlignment alignment;
/**
* This field stores just the score of the last pairwise alignment performed (if the
* score_computed flag is set to true). It is useful when just the score
* is needed (and not the alignment itselft). Its value is set after a successful
* execution of both computePairwiseAlignment or
* computeScore methods that subclasses must implement. If new sequences
* are loaded or a new scoring scheme is set, the score_computed flag is
* set to false, and this field's value becomes undefined.
*/
protected int score;
/**
* Flags whether the score of the alignment between the last two loaded sequences has
* already been computed. It is set to true after a successful execution of both
* computePairwiseAlignment or computeScore methods that
* subclasses must implement. It is set to falsef if new sequences are loaded or a new
* scoring scheme is set.
*/
protected boolean score_computed = false;
/**
* Flags whether sequences have been loaded. It is set to true after subclasses
* successfully load two sequences.
*/
protected boolean sequences_loaded = false;
/**
* Sets the scoring scheme to be used for the next alignments. Any alignment or score
* already computed is lost. If the scoring scheme supports partial matches, this
* PairwiseAlignmentAlgorithm is set not to use the
* MATCH_TAG tag because in this case the score tag line be confusing.
* If the scoring scheme does not support partial matches, then the use of the
* MATCH_TAG tag is enabled.
*
* @param scoring Scoring scheme to be used
* @see #MATCH_TAG
* @see ScoringScheme#isPartialMatchSupported
*/
public void setScoringScheme (ScoringScheme scoring)
{
if (scoring == null)
throw new IllegalArgumentException ("Null scoring scheme object.");
this.scoring = scoring;
// if the scoring scheme supports partial matches,
// disable the use of the MATCH_TAG character
if (scoring.isPartialMatchSupported())
this.use_match_tag = false;
else
this.use_match_tag = true;
// when a new scoring scheme is set,
// the alignment needs to be recomputed
this.alignment = null;
this.score_computed = false;
}
/**
* Tells wether the MATCH_TAG tag should be used or not. If it returns
* true, the alignment algorithm should write the MATCH_TAG
* tag in the score tag line of the alignment produced whenever a match occurs between
* characters of the two sequences. If it returns false the matching
* character should be written instead. The value returned is conditioned by the
* use_match_tag flag, which is updated whenever a scoring scheme is set
* to this PairwiseAlignmentAlgorithm by the
* setScoringScheme method.
*
* @return trueMATCH_TAG tag should be used,
* false otherwise
* @see #MATCH_TAG
* @see #use_match_tag
* @see #setScoringScheme
*/
protected boolean useMatchTag ()
{
return use_match_tag;
}
/**
* Request subclasses to load the sequences according to their own needs. Any
* alignment and score already computed is lost. If no exception is raised, the loaded
* flag is set to true. Subclasses typically store the sequences in instances of an
* appropiate class and each can have its own contract, so check each algorithm to see
* what kind of sequences it produces. Input can come from any source provided they
* are encapsulated with a proper Reader. They must be ready to be read, i.e. the next
* read operation must return the sequence's first character.
*
* @param input1 First sequence
* @param input2 Second sequence
* @throws IOException If an I/O error occurs when reading the sequences
* @throws InvalidSequenceException If the sequences are not valid
*/
public void loadSequences (Reader input1, Reader input2)
throws IOException, InvalidSequenceException
{
// when new sequences are loaded, the
// alignment and score needs to be recomputed
this.alignment = null;
this.score_computed = false;
// make sure that if an exception is raised
// the sequences_loaded flag is false
this.sequences_loaded = false;
// request subclasses to load sequences
loadSequencesInternal (input1, input2);
// if no exception is raised,
// set the loaded flag to true
this.sequences_loaded = true;
}
/**
* Frees pointer to loaded sequences and computed alignments (if any) so that their
* data can be garbage collected.
*/
public void unloadSequences ()
{
// allow any alignment already computed
// to be garbage collected
this.alignment = null;
this.score_computed = false;
// request subclasses to unload sequences
unloadSequencesInternal ();
this.sequences_loaded = false;
}
/**
* Return the last pairwise alignment computed (if any) or request subclasses to
* compute one and return the result by calling the
* computePairwiseAlignment method. The sequences must already be loaded
* and a scoring scheme must already be set.
*
* @return a pairwise alignment between the loaded sequences
* @throws IncompatibleScoringSchemeException If the scoring scheme
* is not compatible with the loaded sequences
* @see #computePairwiseAlignment
*/
public PairwiseAlignment getPairwiseAlignment ()
throws IncompatibleScoringSchemeException
{
if (!sequences_loaded)
throw new IllegalStateException ("Sequences have not been loaded.");
if (scoring == null)
throw new IllegalStateException ("Scoring scheme has not been set.");
if (this.alignment == null)
{
// make sure the scoring scheme won't be changed
// in the middle of the alignment computation
synchronized (scoring)
{
// compute the alignment if it hasn't been computed yet
this.alignment = computePairwiseAlignment();
}
// store the score as well
this.score = this.alignment.getScore();
this.score_computed = true;
}
return this.alignment;
}
/**
* Returns the score of the last alignment computed (if any) or request subclasses to
* compute one and return the result by calling the computeScore method.
* The sequences must already be loaded and a scoring scheme must already be set.
*
* @return the score of the alignment between the loaded sequences
* @throws IncompatibleScoringSchemeException If the scoring scheme
* is not compatible with the loaded sequences
* @see #computeScore
*/
public int getScore () throws IncompatibleScoringSchemeException
{
if (!sequences_loaded)
throw new IllegalStateException ("Sequences have not been loaded.");
if (scoring == null)
throw new IllegalStateException ("Scoring scheme has not been set.");
if (!score_computed)
{
// make sure the scoring scheme won't be changed
// in the middle of the alignment computation
synchronized (scoring)
{
// compute the alignment's score if it hasn't been computed yet
this.score = computeScore();
}
this.score_computed = true;
}
return this.score;
}
/**
* Subclasses must implement this method to load sequences according to their own
* needs and throw an exception in case of any failure. If no exception is raised, the
* loaded flag is set to true by the public method and the sequences are believed to
* be loaded (so an alignment or score can be requested).
*
* @param input1 First sequence
* @param input2 Second sequence
* @throws IOException If an I/O error occurs when reading the sequences
* @throws InvalidSequenceException If the sequences are not valid
* @see #loadSequences
* @see CharSequence
* @see FactorSequence
*/
protected abstract void loadSequencesInternal (Reader input1, Reader input2)
throws IOException, InvalidSequenceException;
/**
* Subclasses must implement this method to unload sequences according to their own
* storage, freeing pointers to sequences and any intermediate data so that they can
* be garbage collected. This methid is called by the public
* unloadSequences method.
*
* @see #unloadSequences
*/
protected abstract void unloadSequencesInternal ();
/**
* Subclasses must implement this method to compute an alignment between the loaded
* sequences using the scoring scheme previously set. This methid is called by the
* getPairwiseAlignment method when needed.
*
* @return a pairwise alignment between the loaded sequences
* @throws IncompatibleScoringSchemeException If the scoring scheme
* is not compatible with the loaded sequences
* @see #getPairwiseAlignment
*/
protected abstract PairwiseAlignment computePairwiseAlignment ()
throws IncompatibleScoringSchemeException;
/**
* Subclasses must implement this method to compute the score of the alignment between
* the loaded sequences using the scoring scheme previously set. This methid is called
* by the getScore method when needed.
*
* @return the score of the alignment between the loaded sequences
* @throws IncompatibleScoringSchemeException If the scoring scheme
* is not compatible with the loaded sequences
* @see #getScore
*/
protected abstract int computeScore () throws IncompatibleScoringSchemeException;
/**
* Helper method to invoke the scoreSubstitution method of the scoring
* scheme set to this algorithm.
*
* @param a first character
* @param b second character
* @return score of substitution of a for b
* @throws IncompatibleScoringSchemeException if the scoring scheme is not compatible
* with the sequences being aligned
* @see ScoringScheme#scoreSubstitution
*/
protected final int scoreSubstitution (char a, char b)
throws IncompatibleScoringSchemeException
{
return scoring.scoreSubstitution (a, b);
}
/**
* Helper method to invoke the scoreInsertion method of the scoring
* scheme set to this algorithm.
*
* @param a the character to be inserted
* @return score of insertion of a
* @throws IncompatibleScoringSchemeException if the scoring scheme is not compatible
* with the sequences being aligned
* @see ScoringScheme#scoreInsertion
*/
protected final int scoreInsertion (char a) throws IncompatibleScoringSchemeException
{
return scoring.scoreInsertion (a);
}
/**
* Helper method to invoke the scoreDeletion method of the scoring scheme
* set to this algorithm.
*
* @param a the character to be deleted
* @return score of deletion of a
* @throws IncompatibleScoringSchemeException if the scoring scheme is not compatible
* with the sequences being aligned
* @see ScoringScheme#scoreDeletion
*/
protected final int scoreDeletion (char a) throws IncompatibleScoringSchemeException
{
return scoring.scoreDeletion (a);
}
/**
* Helper method to compute the the greater of two values.
*
* @param v1 first value
* @param v2 second value
* @return the larger of v1 and v2
*/
protected final int max (int v1, int v2)
{
return (v1 >= v2) ? v1 : v2;
}
/**
* Helper method to compute the the greater of three values.
*
* @param v1 first value
* @param v2 second value
* @param v3 third value
* @return the larger of v1, v2 and v3
*/
protected final int max (int v1, int v2, int v3)
{
return (v1 >= v2) ? ((v1 >= v3)? v1 : v3) : ((v2 >= v3)? v2 : v3);
}
/**
* Helper method to compute the the greater of four values.
*
* @param v1 first value
* @param v2 second value
* @param v3 third value
* @param v4 fourth value
* @return the larger of v1, v2 v3 and
* v4
*/
protected final int max (int v1, int v2, int v3, int v4)
{
int m1 = ((v1 >= v2) ? v1 : v2);
int m2 = ((v3 >= v4) ? v3 : v4);
return (m1 >= m2) ? m1 : m2;
}
}
neobio-0.0.20030929/src/neobio/alignment/InvalidSequenceException.java 0000644 0002656 0002032 00000005034 07717074366 024523 0 ustar tillea admin /*
* InvalidSequenceException.java
*
* Copyright 2003 Sergio Anibal de Carvalho Junior
*
* This file is part of NeoBio.
*
* NeoBio is free software; you can redistribute it and/or modify it under the terms of
* the GNU General Public License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with NeoBio;
* if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307, USA.
*
* Proper attribution of the author as the source of the software would be appreciated.
*
* Sergio Anibal de Carvalho Junior mailto:sergioanibaljr@users.sourceforge.net
* Department of Computer Science http://www.dcs.kcl.ac.uk
* King's College London, UK http://www.kcl.ac.uk
*
* Please visit http://neobio.sourceforge.net
*
* This project was supervised by Professor Maxime Crochemore.
*
*/
package neobio.alignment;
/**
* Signals that the sequence does not comply with the specification (see
* {@linkplain CharSequence} or {@linkplain FactorSequence} for details).
*
* @author Sergio A. de Carvalho Jr.
* @see CharSequence
* @see FactorSequence
*/
public class InvalidSequenceException extends Exception
{
/**
* Constructs an InvalidSequenceException with null as its
* error detail message.
*/
public InvalidSequenceException ()
{
super();
}
/**
* Constructs an InvalidSequenceException with the specified
* detail message.
*
* @param message an error message
*/
public InvalidSequenceException (String message)
{
super(message);
}
/**
* Constructs an InvalidSequenceException with the specified
* cause (and a detail message that typically contains the class and detail message
* of cause).
*
* @param cause a cause
*/
public InvalidSequenceException (Throwable cause)
{
super(cause);
}
/**
* Constructs an InvalidSequenceException with the specified
* detail message and cause.
*
* @param message an error message
* @param cause a cause
*/
public InvalidSequenceException (String message, Throwable cause)
{
super(message, cause);
}
}
neobio-0.0.20030929/src/neobio/alignment/CharSequence.java 0000644 0002656 0002032 00000012033 07717074372 022125 0 ustar tillea admin /*
* CharSequence.java
*
* Copyright 2003 Sergio Anibal de Carvalho Junior
*
* This file is part of NeoBio.
*
* NeoBio is free software; you can redistribute it and/or modify it under the terms of
* the GNU General Public License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with NeoBio;
* if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307, USA.
*
* Proper attribution of the author as the source of the software would be appreciated.
*
* Sergio Anibal de Carvalho Junior mailto:sergioanibaljr@users.sourceforge.net
* Department of Computer Science http://www.dcs.kcl.ac.uk
* King's College London, UK http://www.kcl.ac.uk
*
* Please visit http://neobio.sourceforge.net
*
* This project was supervised by Professor Maxime Crochemore.
*
*/
package neobio.alignment;
import java.io.Reader;
import java.io.BufferedReader;
import java.io.IOException;
/**
* This class implements a sequence of characters stored as an array that provides random
* access to any position in constant time.
*
* The input can come from any source, provided it is encapsulated in a proper
* Reader instance. The stream is expected to be ready (i.e. the next
* read operation must return the first character of the sequence) and it is
* not closed when its end is reached, so the client is allowed to reset it and maybe use
* it for another purpose.
Sequences can contain letters only although lines started with the
* COMMENT_CHAR character ('>') are regarded as comments and are completely
* skipped. White spaces (including tabs, line feeds and carriage returns) are also
* ignored throughout.
This class is used by two sequence alignment algorithms: {@linkplain SmithWaterman} * and {@linkplain NeedlemanWunsch}.
* * @author Sergio A. de Carvalho Jr. * @see SmithWaterman * @see NeedlemanWunsch */ public class CharSequence { /** * The character used to start a comment line in a sequence file. When this character * is found, the rest of the line is ignored. */ protected static final char COMMENT_CHAR = '>'; /** * Stores the sequence as an array of characters. */ protected char sequence[]; /** * Creates a new instance of aCharSequence, loading the sequence data
* from the Reader input stream.
*
* @param reader source of characters for this sequence
* @throws IOException if an I/O exception occurs when reading the input
* @throws InvalidSequenceException if the input does not contain a valid sequence
*/
public CharSequence (Reader reader) throws IOException, InvalidSequenceException
{
int ch;
char c;
BufferedReader input = new BufferedReader(reader);
StringBuffer buf = new StringBuffer();
// read characters
while ((ch = input.read()) != -1)
{
// conver to char
c = (char) ch;
// skip line if comment character is found
if (c == COMMENT_CHAR)
input.readLine();
// accept letters only
else if (Character.isLetter(c))
buf.append(c);
// anything else, except whitespaces, will throw an exception
else if (!Character.isWhitespace(c))
throw new InvalidSequenceException
("Sequences can contain letters only.");
}
// check if read anything!
if (buf.length() > 0)
sequence = new char[buf.length()];
else
throw new InvalidSequenceException ("Empty sequence.");
// copy data to
buf.getChars(0, buf.length(), sequence, 0);
}
/**
* Returns the number of characters of this sequence.
*
* @return int number of characters of this sequence
*/
public int length ()
{
return sequence.length;
}
/**
* Returns the character at a given position. For the client, the first character is
* at position 1, while the last character is at position length(). This
* is convinient for sequence alignment algorithms based on a classic dynamic
* programming matrix since the sequences usually start at row/column 1. This method
* does not check boundaries, therefore an ArrayIndexOutOfBoundsException
* may be raised if pos is out of bounds.
*
* @param pos position of character (from 1 to length() inclusive)
* @return the character
*/
public char charAt (int pos)
{
// convert from one-based to zero-based index
return sequence[pos-1];
}
/**
* Returns a string representation of the sequence.
*
* @return a string representation of the sequence
*/
public String toString ()
{
return new String(sequence);
}
}
neobio-0.0.20030929/src/neobio/alignment/IncompatibleScoringSchemeException.java 0000644 0002656 0002032 00000005117 07717074376 026527 0 ustar tillea admin /*
* IncompatibleScoringSchemeException.java
*
* Copyright 2003 Sergio Anibal de Carvalho Junior
*
* This file is part of NeoBio.
*
* NeoBio is free software; you can redistribute it and/or modify it under the terms of
* the GNU General Public License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with NeoBio;
* if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307, USA.
*
* Proper attribution of the author as the source of the software would be appreciated.
*
* Sergio Anibal de Carvalho Junior mailto:sergioanibaljr@users.sourceforge.net
* Department of Computer Science http://www.dcs.kcl.ac.uk
* King's College London, UK http://www.kcl.ac.uk
*
* Please visit http://neobio.sourceforge.net
*
* This project was supervised by Professor Maxime Crochemore.
*
*/
package neobio.alignment;
/**
* Signals that an scoring scheme is not compatible with the sequences being aligned.
*
* @author Sergio A. de Carvalho Jr.
* @see ScoringScheme
* @see PairwiseAlignmentAlgorithm
*/
public class IncompatibleScoringSchemeException extends Exception
{
/**
* Constructs an IncompatibleScoringSchemeException with null as its
* error detail message.
*/
public IncompatibleScoringSchemeException ()
{
super();
}
/**
* Constructs an IncompatibleScoringSchemeException with the specified
* detail message.
*
* @param message an error message
*/
public IncompatibleScoringSchemeException (String message)
{
super(message);
}
/**
* Constructs an IncompatibleScoringSchemeException with the specified
* cause (and a detail message that typically contains the class and detail message
* of cause).
*
* @param cause a cause
*/
public IncompatibleScoringSchemeException (Throwable cause)
{
super(cause);
}
/**
* Constructs an IncompatibleScoringSchemeException with the specified
* detail message and cause.
*
* @param message an error message
* @param cause a cause
*/
public IncompatibleScoringSchemeException (String message, Throwable cause)
{
super(message, cause);
}
}
neobio-0.0.20030929/src/neobio/alignment/Trie.java 0000644 0002656 0002032 00000025134 07723762434 020470 0 ustar tillea admin /*
* Trie.java
*
* Copyright 2003 Sergio Anibal de Carvalho Junior
*
* This file is part of NeoBio.
*
* NeoBio is free software; you can redistribute it and/or modify it under the terms of
* the GNU General Public License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with NeoBio;
* if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307, USA.
*
* Proper attribution of the author as the source of the software would be appreciated.
*
* Sergio Anibal de Carvalho Junior mailto:sergioanibaljr@users.sourceforge.net
* Department of Computer Science http://www.dcs.kcl.ac.uk
* King's College London, UK http://www.kcl.ac.uk
*
* Please visit http://neobio.sourceforge.net
*
* This project was supervised by Professor Maxime Crochemore.
*
*/
package neobio.alignment;
/**
* This class implements a trie, or a digital search tree. A trie is a multiway tree
* (each node can have multiple children) that represents a set of strings.
*
* Each node contains data encapsulated in an object instance. Each edge spells out a * character and each path from the root represents a string described by the characters * labelling the traversed edges. Moreover, for each string represented, there is a unique * path from the root.
* *The trie of the following example represents the strings 'a', 'd', 'b', 'ac', 'ba', * 'be', 'bd', 'bad' and 'bae'.
* *
* [0]
* --+--
* / | \
* a/ d| \b
* [1] [2] [4]
* | --+--
* | / | \
* c| a/ e| d\
* [3] [5] [6] [9]
* --+--
* / \
* d/ e\
* [7] [8]
*
It is easy to see that strings with common prefixes will branch off from each other * at the first distinguishing character. This feature makes the trie a good data * structure to identify and represent phrases of a text such as the ones induced by the * Lempel-Ziv familiy of compression algorithms. For instance, the LZ78 version parses * the text into phrases, where each phrase is the longest matching phrase seen previously * plus one character.
* *In this implementation, each node is actually an instance of this class. To build a * trie, one must first create the root using the public constructor:
* *
* Trie root = new Trie (some_object);
*
Here some_object contains any relevant information encapsulated in an
* object instance. Typically, that's the only moment the public constructor is used. From
* now on, all new nodes will be added as a new child of one existing node using the
* add method:
* new_node = any_node.add (some_object, character);
*
Here character is the character that will label the edge from
* any_node to new_node. Note that this transition must not
* already exist, otherwise an exception is raised.
*
*
To find the longest prefix of a given string, we follow a path from the root down
* the tree, character by character, with the spellDown method:
* next_node = root;
* while (next_node != null)
* {
* current_node = next_node;
* char c = get next character from somewhere
* next_node = current_node.spellDown (c);
* }
*
spellDown follows the edge out of current_node labelled by
* the character c and returns the next node. If there is no such a path, it
* returns null.
To retrieve the information stored at any node, simply use the getData
* method.
In fact, there are many ways to implement a trie. To avoid wasting space with * multiple pointers at each node, this implementation uses an approach with a linked list * of siblings. Each node actually contains a pointer to one of its children and a pointer * to one of its siblings only. Together with the pointers, each node also stores the * character that labels the edge to the pointed node.
*
*
* [0]
* |
* a| d b
* [1]---[2]---[4]
* | |
* c| a| e d
* [3] [5]---[6]---[9]
* |
* d| e
* [7]---[8]
*
In this way, a trie is similar to a binary tree. Although this implementation is
* more efficient in terms of space, the search for a label with a given character leaving
* a node n is no more constant but proportional to the number of children of
* n. In the previous example, it is necessary to traverse three edges to
* reach node 9 from node 4 with character d.
This class is used by the {@linkplain FactorSequence} to build a linked list of * factors of a sequence in a LZ78 fashion, i.e. where each factor is the longest factor * previously seen plus one character.
* * @author Sergio A. de Carvalho Jr. * @see FactorSequence */ public class Trie { /** * A pointer to the first of this node's children. */ protected Trie son; /** * The character that labels the edge from this node to the child node pointer by *son.
*/
protected char to_son;
/**
* A pointer to this node's next sibling.
*/
protected Trie sibling;
/**
* The character that labels the edge from this node to the sibling pointer by
* sibling.
*/
protected char to_sibling;
/**
* This node's stored data.
*/
protected Object data;
/**
* Creates a new trie node with the specified data. This constructor is typically used
* by the client only once to instantiate the root node. After that, all new nodes are
* implicitly instantiated by the add method.
*
* @param data the data that will be associated with the new node
*/
public Trie (Object data)
{
this.son = null;
this.sibling = null;
this.data = data;
}
/**
* Returns the data associated with this node.
*
* @return data associated with this node
*/
public Object getData ()
{
return data;
}
/**
* Adds a new child to this node. The new node will be implicitly instantiated with
* the data argument, and the edge from this node to the new node will be
* labelled by the character argument. If this node already have an edge labelled with
* this character, an exception is raised. Otherwise, the new node created and
* returned.
*
* If this node have no child, a new node is created straight away. Otherwise, the * task is assigned to its first child that will add the new node as a sibling.
* * @param data the data that will be associated with the new node * @param c the character that will label the edge from this node to the new node * @return the added node * @throws IllegalStateException if this node already have an edge labelled by *c
*/
public Trie add (Object data, char c)
{
if (son == null)
{
son = new Trie (data);
to_son = c;
return son;
}
else
{
if (to_son != c)
return son.addSibling (data, c);
else
// duplicate char
throw new IllegalStateException ("Failed to add character " + c +
" already exists.");
}
}
/**
* Adds a sibling to this node. The new node will be implicitly instantiated with
* the data argument, and the edge from this node to the new node will be
* labelled by the character argument. If this node already have a sibling with this
* character, an exception is raised. Otherwise, the new node is created and returned.
*
* If this node have no direct sibling, a new node is created straight away. * Otherwise, the task is assigned to its next sibling.
* * @param data the data that will be associated with the new node * @param c the character that will label the edge from this node to the new node * @return the added node * @throws IllegalStateException if this node already have an edge labelled by *c
*/
protected Trie addSibling (Object data, char c)
{
if (sibling == null)
{
sibling = new Trie (data);
to_sibling = c;
return sibling;
}
else
{
if (to_sibling != c)
return sibling.addSibling (data, c);
else
// duplicate char
throw new IllegalStateException ("Failed to add character: " + c +
" already exists.");
}
}
/**
* Follows a path from this node to one of its children by spelling the character
* supplied as an argument. If there is no such a path, null is returned.
* Otherwise, the reached child node is returned.
*
* If this node's direct child is reached with an edge labelled by the character, * it is returned straight away. Otherwise, it is assigned the task of finding another * sibling labelled with that character.
* * @param c the character that labels the path to be followed to this node's child * @return the child node reached by traversing the edge labelled byc
*/
public Trie spellDown (char c)
{
if (son == null) return null;
if (to_son == c)
return son;
else
return son.spellRight(c);
}
/**
* Follows a path from this node to one of its sibling by spelling the character
* supplied as an argument. If there is no such a path, null is returned.
* Otherwise, the reached sibling node is returned.
*
* If this node's direct sibling is reached with an edge labelled by the character, * it is returned straight away. Otherwise, it is assigned the task of finding another * sibling labelled with that character.
* * @param c the character that labels the path to be followed to the sibling * @return the sibling node reached by traversing the edge labelled byc
*/
protected Trie spellRight (char c)
{
if (sibling == null) return null;
if (to_sibling == c)
return sibling;
else
return sibling.spellRight(c);
}
}
neobio-0.0.20030929/src/neobio/alignment/CrochemoreLandauZivUkelson.java 0000644 0002656 0002032 00000074667 07725335516 025050 0 ustar tillea admin /*
* CrochemoreLandauZivUkelson.java
*
* Copyright 2003 Sergio Anibal de Carvalho Junior
*
* This file is part of NeoBio.
*
* NeoBio is free software; you can redistribute it and/or modify it under the terms of
* the GNU General Public License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with NeoBio;
* if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307, USA.
*
* Proper attribution of the author as the source of the software would be appreciated.
*
* Sergio Anibal de Carvalho Junior mailto:sergioanibaljr@users.sourceforge.net
* Department of Computer Science http://www.dcs.kcl.ac.uk
* King's College London, UK http://www.kcl.ac.uk
*
* Please visit http://neobio.sourceforge.net
*
* This project was supervised by Professor Maxime Crochemore.
*
*/
package neobio.alignment;
import java.io.Reader;
import java.io.IOException;
/**
* This abstract class is the superclass of both global and local sequence alignment
* algorithms (with linear gap penalty function) due to Maxime Crochemore, Gad Landau and
* Michal Ziv-Ukelson (2002).
*
* This implementation derives from the paper of M.Crochemore, G.Landau and * M.Ziv-Ukelson, A Sub-quadratic Sequence Alignment Algorithm for Unrestricted Scoring * Matrices (available here as * PDF or * Postscript).
* *It employs Lempel-Ziv compression techniques to speed up the classic dynamic * programmin approach to sequence alignment (see {@linkplain NeedlemanWunsch} and * {@linkplain SmithWaterman} classes). It reduces the time and space complexity from * O(n2) to O(n2/log n). In fact, the complexity is actually O(h * n2/log n), where 0 <= h <= 1 is a real number denoting the entropy of the * text (a measure of how compressible it is). This means that, the more compressible a * sequence is, the less memory the algorithm will require, and the faster it will * run.
* *The idea behind this improvement is to identify repetitions in the sequences and * reuse the computation of their alignments. The first step is, therefore, to parse the * sequences into LZ78-like factors. LZ78 is a popular compression algorithm of the * Lempel-Ziv familiy due to J.Ziv and A.Lempel (1978). This factorisation is accomplished * by the {@linkplain FactorSequence} class (for more information about this * factorisation, please refer to the specification of that class) that builds a * doubly-linked list of factors. Each factor is an instance of the {@linkplain Factor} * class (refer to the specification of this class for more information).
* *Once the sequences have been parsed, the algorithm builds a matrix of blocks, called
* block table, that is vaguely similar to the dynamic programming matrix used by both
* NeedlemanWunsch and SmithWaterman. Each block contains an
* instance of an {@linkplain AlignmentBlock} (please refer to its specification for more
* information on what information is stored) and represents the alignment beteween one
* factor of each sequence. This block table is, in fact, a partition of the alignment
* graph.
Consider a block B which corresponds to the alignment of factor F1 = xa from * sequence S1 and factor F2 = yb from sequence S2. Here, F1 extends a previous factor of * S1 with character a, while F2 extends a previous factor of S2 with character b. We can * define the input border of B as the set of values at the left and top borders of block * B, and the output border as the set of values at the right and bottom borders of B. * Moreover, we can define the following prefix blocks of B:
* *-
*
- Left prefix - is the block that contains the alignment of factor F1 with * a factor F2' = y (a prefix of factor F2). *
- Diagonal prefix - is the block that contains the alignment of factor F1' = x * (a prefix of factor F1) with a factor F2' = y (a prefix of factor F2). *
- Top prefix - is the block that contains the alignment of factor F1' = x (a * prefix of factor F1) with factor F2. *
Note that each factor has a pointer to its prefix factor, called ancestor (see the
* specification of the Factor class). This pointer makes it easy to retrieve
* any of the three prefix blocks of B in constant time.
Rather than computing each value of the alignment block B, the algorithm will only * compute the values on its input and output borders. This is precisely what makes it * more efficient.
* *In this class there is a general specification of how the block table is computed * (see the {@link #computeBlockTable computeBlockTable} method for details). The actual * method depends on the subclasses. In general, there are two phases:
* *-
*
- Encoding - the structure of a block B is studied and represented in an * efficient way by computing weights of optimal paths connecting each entry of its input * border to each entry of its output border. This information is encoded in a DIST matrix * where DIST[i,j] stores the weight of an optimal paths connecting entry i of the input * border to entry j the output border of B. *
- Propagation - the input border of a block B is retrieved (from the left and * top blocks of B) and its output border is computed with the help of the DIST matrix. *
In fact, for each block, only one column of the DIST matrix needs to be computed, * all other columns are actually retrieved from its prefix blocks. This is precisely what * is accomplished by the {@link #assembleDistMatrix assembleDistMatrix} method found in * this class (it is general enough for both global and local alignment versions of the * algorithm.
* *From the DIST matrix, we obtain the OUT matrix defined as
* OUT[i,j] = I[i] + DIST[i,j] where I is the input border array. This means
* that the OUT matrix is the DIST matrix updated by the input border of a block. The
* output border is then computed from the OUT matrix by taking the maximum value of each
* column. This class also have a general method for assembling the input border (see
* {@link #assembleInputBorder assembleInputBorder}
The OUT matrix is encoded by the {@linkplain OutMatrix} class that takes as * both a DIST matrix and an input border array. Note that it does not compute the OUT * matrix, it just stores the necessary information to retrieve a value at any * position of the matrix.
* *A naive approach to compute the output border of a block from the OUT matrix of size * n x n would take a time proportional to n2. However, it happens that, due to * the nature of the DIST matrix, both DIST and OUT matrices are Monge arrays, which * implies that they are also totally monotone. This property allows the * computation of the output border of B in linear time with the SMAWK algorithm (see the * specification of the {@linkplain Smawk} class for more information on SMAWK).
* *This class contains a general specification that is pertinent to both global and * local versions of the algorithm. For more information on each version of, please refer * to the appropriate subclass.
* *A note about the performance of these algorithms. Although theoretical * results suggest that these algorithms are faster and consume less memory than the * classical methods, in practice it is hard to realise their performance gains. * *
These algorithms are extremely complex and require the storage of many extra
* pointers and other auxiliary data for each block (see the AlignmentBlock
* class for more details). Hence, even though the space requirement is
* O(n2/log n), which is less than O(n2), in practice, for most of
* the cases these algorithms will take more time and memory space than their clasical
* counterparts (we have to keep in mind that the Big Oh notation ignores all constants
* involved).
Therefore, in order to realise the full power of these algorithms, they have to be * used with extremly large and redundant sequences. This will allow a proper * reutilisation of the computations and, maybe, provide an improvement in terms of space * and run time. For instance, it is easy to devise such a sequence if we use a * one-character alphabet because, in this case, a sequence is factorised into a series * of factors that are a prefix of the next.
* * @author Sergio A. de Carvalho Jr. * @see CrochemoreLandauZivUkelsonGlobalAlignment * @see CrochemoreLandauZivUkelsonLocalAlignment * @see NeedlemanWunsch * @see SmithWaterman * @see FactorSequence * @see AlignmentBlock * @see OutMatrix * @see Smawk * @see #computeBlockTable * @see #assembleDistMatrix */ public abstract class CrochemoreLandauZivUkelson extends PairwiseAlignmentAlgorithm { /** * A constant that indicates that the source of an optimal path has been reached in a * block and that the trace back procedure to retrieve a high scoring alignment can * stop. */ protected static final byte STOP_DIRECTION = 0; /** * A constant that indicates that the left direction must be followed to reach the * source of an optimal path in a block during the trace back procedure to retrieve a * high scoring alignment. */ protected static final byte LEFT_DIRECTION = 1; /** * A constant that indicates that the diagonal direction must be followed to reach the * source of an optimal path in a block during the trace back procedure to retrieve a * high scoring alignment. */ protected static final byte DIAGONAL_DIRECTION = 2; /** * A constant that indicates that the top direction must be followed to reach the * source of an optimal path in a block during the trace back procedure to retrieve a * high scoring alignment. */ protected static final byte TOP_DIRECTION = 3; /** * The first factorised sequence being aligned. */ protected FactorSequence seq1; /** * The second factorised sequence being aligned. */ protected FactorSequence seq2; /** * The block table, which is a matrix of alignment blocks where each block represents * the alignment between one factor of each sequence. */ protected AlignmentBlock[][] block_table; /** * Number of rows of the block table. It is determined by the number of factors of the * first sequence. */ protected int num_rows; /** * Number of columns of the block table. It is determined by the number of factors of * the second sequence. */ protected int num_cols; /** * An instance of theSmawk class that implements the SMAWK algorithm to
* compute the column maxima of a totally monotone matrix. It is used to speed up the
* computation of the output border of a block.
*/
protected Smawk smawk = new Smawk();
/**
* An instance of the OutMatrix class that encodes the OUT matrix of a
* block when supplied with the DIST matrix and the input border array of a block.
* Note that it does not compute the OUT matrix itselft, it just stores the necessary
* information to retrieve a value at any position of the matrix.
*
* This object is then used to compute the output border of a block with the
* Smawk class. Note that the OutMatrix class implements the
* Matrix interface as required by the Smawk class.
*
* @see Matrix
* @see Smawk
*/
protected OutMatrix out_matrix = new OutMatrix ();
/**
* Loads sequences into FactorSequence instances. In case of any error,
* an exception is raised by the constructor of FactorSequence (please
* check the specification of that class for specific requirements).
*
*
A FactorSequence is an LZ78-like factorisation of the sequences
* being aligned.
*
* @param input1 Input for first sequence
* @param input2 Input for second sequence
* @throws IOException If an I/O error occurs when reading the sequences
* @throws InvalidSequenceException If the sequences are not valid
* @see FactorSequence
*/
protected void loadSequencesInternal (Reader input1, Reader input2)
throws IOException, InvalidSequenceException
{
// load sequences into instances of CharSequence
this.seq1 = new FactorSequence(input1);
this.seq2 = new FactorSequence(input2);
// determine the block table's dimensions
this.num_rows = seq1.numFactors();
this.num_cols = seq2.numFactors();
}
/**
* Frees pointers to loaded sequences and the the block table so that their data can
* be garbage collected.
*/
protected void unloadSequencesInternal ()
{
this.seq1 = null;
this.seq2 = null;
this.block_table = null;
}
/**
* Computes the block table (the result depends on subclasses, see
* computeBlockTable for details) and requests subclasses to retrieve an
* optimal alignment between the loaded sequences. The actual product depends on the
* subclasses which can produce a global (see
* CrochemoreLandauZivUkelsonGlobalAlignment) or local alignment (see
* CrochemoreLandauZivUkelsonLocalAlignment).
*
*
Subclasses are required to implement the buildOptimalAlignment
* abstract method defined by this class according to their own method.
computeBlockTable for details) and requests subclasses to locate the
* score of the highest scoring alignment between the two sequences in the block
* table. The result depends on the subclasses, and either a global alignment
* (see CrochemoreLandauZivUkelsonGlobalAlignment) or local alignment
* score (see CrochemoreLandauZivUkelsonLocalAlignment) will be produced.
*
* Subclasses are required to implement the locateScore abstract
* method defined by this class according to their own method.
Note that this method calculates the similarity value only (it doesn't trace * back into the block table to retrieve the alignment itself).
* * @return the score of the highest scoring alignment between the loaded sequences * @throws IncompatibleScoringSchemeException If the scoring scheme is not compatible * with the loaded sequences. * @see CrochemoreLandauZivUkelsonGlobalAlignment * @see CrochemoreLandauZivUkelsonLocalAlignment * @see #locateScore */ protected int computeScore () throws IncompatibleScoringSchemeException { // compute block table computeBlockTable (); // get score int score = locateScore (); // allow the block table to be garbage collected block_table = null; return score; } /** * Computes the block table. This method is a general specification of how the block * table should be computed. It creates the block table according to the number of * factors of each sequence. It then goes over each position of the block table, * retrieves the corresponding factors from each sequence, and repasses the * information to the subclasses that will do the actual computation of each block * using the scoring scheme previously set. * *There are four different cases that defines four abstract methods in this class, * which subclasses must implement:
* *-
*
- createRootBlock - creates and computes block at row 0, column 0; *
- createFirstColumnBlock - creates and computes blocks at column 0 which * corresponds to alignment blocks between factors of sequence 1 and an empty string; *
- createFirstRowBlock - creates and computes blocks at row 0 which * corresponds to alignment blocks between factors of sequence 2 and an empty string; *
- createBlock - creates and computes blocks at row > 0 and column > 0 * which corresponds to alignment blocks between one factor of sequence 1 and one * factor of sequence 2; *
Note that each factor has a serial number which indicates its order in the list * of factors of a sequence. This number will match with the row and column index of * a block in the block table. For instance, if a block has factors F1 and F2 with * serial numbers 12 and 53, respectively, this means that this block is found at row * 12, column 53 of the block table.
* * @throws IncompatibleScoringSchemeException If the scoring scheme is not compatible * with the loaded sequences. * @see #createRootBlock * @see #createFirstColumnBlock * @see #createFirstRowBlock * @see #createBlock */ protected void computeBlockTable () throws IncompatibleScoringSchemeException { Factor factor1, factor2; int r, c, max_length; // create block table block_table = new AlignmentBlock[num_rows][num_cols]; // find the length of the longest sequence (number of characters) max_length = Math.max(seq1.numChars(), seq2.numChars()); // prepares the OUT matrix object out_matrix.init (max_length, scoring.maxAbsoluteScore()); // start at the root of each trie factor1 = seq1.getRootFactor(); factor2 = seq2.getRootFactor(); // check if roots' indexes are both zero if (factor1.getSerialNumber() != 0 || factor2.getSerialNumber() != 0) throw new IndexOutOfBoundsException ("Unexpected factor index."); // initiate first cell of block table block_table[0][0] = createRootBlock (factor1, factor2); // compute first row for (c = 1; c < num_cols; c++) { factor2 = factor2.getNext(); // check if factor2's index equals its column number (except for // the last factor that can be a repetition of a previous one) if (c < num_cols - 1 && factor2.getSerialNumber() != c) throw new IndexOutOfBoundsException ("Unexpected factor index."); block_table[0][c] = createFirstRowBlock (factor1, factor2, c); } for (r = 1; r < num_rows; r++) { factor1 = factor1.getNext(); // check if factor1's index equals its row number (except for // the last factor that can be a repetition of a previous one) if (r < num_rows - 1 && factor1.getSerialNumber() != r) throw new IndexOutOfBoundsException ("Unexpected factor index."); // go back to the root of sequence 2 factor2 = seq2.getRootFactor(); if (factor2.getSerialNumber() != 0) throw new IndexOutOfBoundsException ("Unexpected factor index."); // compute first column of current row block_table[r][0] = createFirstColumnBlock (factor1, factor2, r); for (c = 1; c < num_cols; c++) { factor2 = factor2.getNext(); // check if factor2's index equals its column number (except for // the last factor that can be a repetition of a previous one) if (c < num_cols - 1 && factor2.getSerialNumber() != c) throw new IndexOutOfBoundsException ("Unexpected factor index."); // compute row r, col c block_table[r][c] = createBlock (factor1, factor2, r, c); } } } /** * Assembles the DIST matrix of a block by retrieving the DIST columns of its prefix * blocks. In fact, it also stores pointers to the owner block for each column * retrieved. These pointers are later used during the trace back procedure that * builds an optimal alignment from the information computed in the block table. This * method is general enough to suit both global and local alignment versions of the * algorithm. * * @param block the block for which the DIST matrix is needed * @param dim the dimension of the DIST matrix * @param r the row index of this block in the block table * @param c the column index of this block in the block table * @param lc the number of columns of the alignment block * @return the DIST matrix */ protected int[][] assembleDistMatrix (AlignmentBlock block, int dim, int r, int c, int lc) { AlignmentBlock ancestor; Factor parent; int[][] dist; int i; dist = new int[dim][]; // columns to the left of lc parent = block.factor2.getAncestor(); for (i = lc - 1; i >= 0; i--) { ancestor = block_table[r][parent.getSerialNumber()]; block.ancestor[i] = ancestor; dist[i] = ancestor.dist_column; parent = parent.getAncestor(); } // column lc dist[lc] = block.dist_column; block.ancestor[lc] = block; // columns to the right of lc parent = block.factor1.getAncestor(); for (i = lc + 1; i < dim; i++) { ancestor = block_table[parent.getSerialNumber()][c]; block.ancestor[i] = ancestor; dist[i] = ancestor.dist_column; parent = parent.getAncestor(); } return dist; } /** * Assembles the input border of a block by retrieving the values at the output * borders of the left and top blocks. This method is general enough to suit both * global and local alignment versions of the algorithm. Note that it can be used to * assemble the input border of any block but the root one (it will cause an *ArrayIndexOutOfBoundsException.
*
* @param dim dimension of the input border
* @param r row index of the block in the block table
* @param c column index of the block in the block table
* @param lr number of row of the block
* @return the block's input border
*/
protected int[] assembleInputBorder (int dim, int r, int c, int lr)
{
AlignmentBlock left = null, top = null;
int[] input;
int i;
input = new int [dim];
// set up pointers to the left and top blocks (if applicable)
if (c > 0) left = block_table[r][c-1];
if (r > 0) top = block_table[r-1][c];
for (i = 0; i < dim; i++)
{
if (i < lr)
{
if (left != null)
input[i] = left.output_border[left.factor2.length() + i];
else
// there is no block to the left, so set a big negative value
// to make sure it will not be used (unfortunately, MIN_VALUE
// can overflow to a positive value when substracted by any
// number, so we use half of it as a workaround)
input[i] = Integer.MIN_VALUE / 2;
}
else if (i == lr)
{
if (left != null)
input[i] = left.output_border[left.factor2.length() + i];
else
// no need to check if top is not null
// (because we assume this is not the root block)
input[i] = top.output_border[i - lr];
}
else
{
if (top != null)
input[i] = top.output_border[i - lr];
else
// there is no top block (see note for the left case)
input[i] = Integer.MIN_VALUE / 2;
}
}
return input;
}
/**
* Traverses a block to retrieve a part of an optimal alignment from the specified
* source in the output border to an entry in the input border.
*
* @param block the block to be traversed
* @param source the source of the path in the output border
* @param gapped_seq1 the StringBuffer to where the gapped sequence 1 is written to
* @param tag_line the StringBuffer to where the tag_line is written to
* @param gapped_seq2 the StringBuffer to where the gapped sequence 2 is written to
* @throws IncompatibleScoringSchemeException If the scoring scheme is not compatible
* with the loaded sequences.
*/
protected void traverseBlock (AlignmentBlock block, int source,
StringBuffer gapped_seq1, StringBuffer tag_line, StringBuffer gapped_seq2)
throws IncompatibleScoringSchemeException
{
char char1, char2;
while (block.direction[source] != STOP_DIRECTION)
{
char1 = block.factor1.getNewChar();
char2 = block.factor2.getNewChar();
switch (block.direction[source])
{
case LEFT_DIRECTION:
gapped_seq1.insert (0, GAP_CHARACTER);
tag_line.insert (0, GAP_TAG);
gapped_seq2.insert (0, char2);
block = getLeftPrefix (block);
break;
case DIAGONAL_DIRECTION:
gapped_seq1.insert (0, char1);
if (char1 == char2)
if (useMatchTag())
tag_line.insert (0, MATCH_TAG);
else
tag_line.insert (0, char1);
else if (scoreSubstitution(char1, char2) > 0)
tag_line.insert (0, APPROXIMATE_MATCH_TAG);
else
tag_line.insert (0, MISMATCH_TAG);
gapped_seq2.insert (0, char2);
block = getDiagonalPrefix (block);
source --;
break;
case TOP_DIRECTION:
gapped_seq1.insert (0, char1);
tag_line.insert (0, GAP_TAG);
gapped_seq2.insert (0, GAP_CHARACTER);
block = getTopPrefix (block);
source --;
break;
}
}
}
/**
* This method is a shorthand to retrieve the left prefix of a block from the block
* table.
*
* @param block the block
* @return the block's left prefix
*/
protected AlignmentBlock getLeftPrefix (AlignmentBlock block)
{
int prefix_row = block.factor1.getSerialNumber();
int prefix_col = block.factor2.getAncestorSerialNumber();
return block_table[prefix_row][prefix_col];
}
/**
* This method is a shorthand to retrieve the diagonal prefix of a block from the
* block table.
*
* @param block the block
* @return the block's diagonal prefix
*/
protected AlignmentBlock getDiagonalPrefix (AlignmentBlock block)
{
int prefix_row = block.factor1.getAncestorSerialNumber();
int prefix_col = block.factor2.getAncestorSerialNumber();
return block_table[prefix_row][prefix_col];
}
/**
* This method is a shorthand to retrieve the top prefix of a block from the block
* table.
*
* @param block the block
* @return the block's top prefix
*/
protected AlignmentBlock getTopPrefix (AlignmentBlock block)
{
int prefix_row = block.factor1.getAncestorSerialNumber();
int prefix_col = block.factor2.getSerialNumber();
return block_table[prefix_row][prefix_col];
}
/**
* Computes the root block of the block table. See subclasses for actual
* implementation.
*
* @param factor1 the factor of the first sequence being aligned
* @param factor2 the factor of the second sequence being aligned
* @return the root block
* @throws IncompatibleScoringSchemeException If the scoring scheme is not compatible
* with the loaded sequences.
*/
protected abstract AlignmentBlock createRootBlock (Factor factor1, Factor factor2)
throws IncompatibleScoringSchemeException;
/**
* Computes a block at the first row (row zero) of the block table, which corresponds
* to an alignment block between one factor of sequence 2 and an empty string. See
* subclasses for actual implementation.
*
* @param factor1 the factor of the first sequence being aligned
* @param factor2 the factor of the second sequence being aligned
* @param col the column index of block in the block table
* @return the computed block
* @throws IncompatibleScoringSchemeException If the scoring scheme is not compatible
* with the loaded sequences.
*/
protected abstract AlignmentBlock createFirstRowBlock (Factor factor1, Factor factor2,
int col) throws IncompatibleScoringSchemeException;
/**
* Computes a block at the first column (column zero) of the block table, which
* corresponds to an alignment block between one factor of sequence 1 and an empty
* string. See subclasses for actual implementation.
*
* @param factor1 the factor of the first sequence being aligned
* @param factor2 the factor of the second sequence being aligned
* @param row the row index of block in the block table
* @return the computed block
* @throws IncompatibleScoringSchemeException If the scoring scheme is not compatible
* with the loaded sequences.
*/
protected abstract AlignmentBlock createFirstColumnBlock (Factor factor1,
Factor factor2, int row) throws IncompatibleScoringSchemeException;
/**
* Computes a block of the block table, which corresponds to an alignment block
* between one factor of sequence 1 and one factor of sequence 2. See subclasses for
* actual implementation.
*
* @param factor1 the factor of the first sequence being aligned
* @param factor2 the factor of the second sequence being aligned
* @param row the row index of block in the block table
* @param col the column index of block in the block table
* @return the computed block
* @throws IncompatibleScoringSchemeException If the scoring scheme is not compatible
* with the loaded sequences.
*/
protected abstract AlignmentBlock createBlock (Factor factor1, Factor factor2,
int row, int col) throws IncompatibleScoringSchemeException;
/**
* Retrieves an optimal alignment between the loaded sequences. See subclasses for
* actual implementation.
*
* @return the computed block
* @throws IncompatibleScoringSchemeException If the scoring scheme is not compatible
* with the loaded sequences.
*/
protected abstract PairwiseAlignment buildOptimalAlignment ()
throws IncompatibleScoringSchemeException;
/**
* Locates the score of the highest scoring alignment between the two sequences in the
* block table after is thas been computed. See subclasses for actual implementation.
*
* @return the score of the highest scoring alignment between the loaded sequences
* @throws IncompatibleScoringSchemeException If the scoring scheme is not compatible
* with the loaded sequences.
*/
protected abstract int locateScore ();
}
neobio-0.0.20030929/src/neobio/alignment/InvalidScoringMatrixException.java 0000644 0002656 0002032 00000005044 07717074370 025540 0 ustar tillea admin /*
* InvalidScoringMatrixException.java
*
* Copyright 2003 Sergio Anibal de Carvalho Junior
*
* This file is part of NeoBio.
*
* NeoBio is free software; you can redistribute it and/or modify it under the terms of
* the GNU General Public License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with NeoBio;
* if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307, USA.
*
* Proper attribution of the author as the source of the software would be appreciated.
*
* Sergio Anibal de Carvalho Junior mailto:sergioanibaljr@users.sourceforge.net
* Department of Computer Science http://www.dcs.kcl.ac.uk
* King's College London, UK http://www.kcl.ac.uk
*
* Please visit http://neobio.sourceforge.net
*
* This project was supervised by Professor Maxime Crochemore.
*
*/
package neobio.alignment;
/**
* Signals that the substitution matrix does not comply with the specification (see
* {@linkplain ScoringMatrix} for details).
*
* @author Sergio A. de Carvalho Jr.
* @see ScoringMatrix
*/
public class InvalidScoringMatrixException extends Exception
{
/**
* Constructs an InvalidScoringMatrixException with null as its error
* detail message.
*/
public InvalidScoringMatrixException ()
{
super();
}
/**
* Constructs an InvalidScoringMatrixException with the specified detail
* message.
*
* @param message an error message
*/
public InvalidScoringMatrixException (String message)
{
super(message);
}
/**
* Constructs an InvalidScoringMatrixException with the specified cause
* (and a detail message that typically contains the class and detail message of
* cause).
*
* @param cause a cause
*/
public InvalidScoringMatrixException (Throwable cause)
{
super(cause);
}
/**
* Constructs an InvalidScoringMatrixException with the specified detail
* message and cause.
*
* @param message an error message
* @param cause a cause
*/
public InvalidScoringMatrixException (String message, Throwable cause)
{
super(message, cause);
}
}
neobio-0.0.20030929/src/neobio/alignment/Smawk.java 0000644 0002656 0002032 00000046673 07725335744 020664 0 ustar tillea admin /*
* Smawk.java
*
* Copyright 2003 Sergio Anibal de Carvalho Junior
*
* This file is part of NeoBio.
*
* NeoBio is free software; you can redistribute it and/or modify it under the terms of
* the GNU General Public License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with NeoBio;
* if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307, USA.
*
* Proper attribution of the author as the source of the software would be appreciated.
*
* Sergio Anibal de Carvalho Junior mailto:sergioanibaljr@users.sourceforge.net
* Department of Computer Science http://www.dcs.kcl.ac.uk
* King's College London, UK http://www.kcl.ac.uk
*
* Please visit http://neobio.sourceforge.net
*
* This project was supervised by Professor Maxime Crochemore.
*
*/
package neobio.alignment;
/**
* This class implement the SMAWK algorithm to compute column maxima on a totally monotone
* matrix as described.
*
* This implementation derives from the paper of A.Aggarwal, M.Klawe, S.Moran, P.Shor, * and R.Wilber, Geometric Applications of a Matrix Searching Algorithm, * Algorithmica, 2, 195-208 (1987).
* *The matrix must be an object that implements the {@linkplain Matrix} interface. It * is also expected to be totally monotone, and the number of rows should be greater than * or equals to the number of columns. If these conditions are not met, the the result is * unpredictable and can lead to an ArrayIndexOutOfBoundsException.
* *{@link #computeColumnMaxima computeColumnMaxima} is the main public method of this * class. It computes the column maxima of a given matrix, i.e. the rows that contain the * maximum value of each column in O(n) (linear) time, where n is the number of rows. This * method does not return the maximum values itself, but just the indexes of their * rows.
* *Note that it is necessary to create an instance of this class to execute the
* computeColumnMaxima because it stores temporary data is that instance. To
* prevent problems with concurrent access, the computeColumnMaxima method is
* declared synchronized.
*
*
* // create an instance of Smawk
* Smawk smawk = new Smawk();
*
* // create an array to store the result
* int col_maxima = new int [some_matrix.numColumns()];
*
* // now compute column maxima
* smawk.computeColumnMaxima (some_matrix, col_maxima)
*
Note that the array of column maxima indexes (the computation result) must be * created beforehand and its size must be equal to the number of columns of the * matrix.
* *This implementation creates arrays of row and column indexes from the original array * and simulates all operations (reducing, deletion of odd columns, etc.) by manipulating * these arrays. The benefit is two-fold. First the matrix is not required to implement * any of these this operations but only a simple method to retrieve a value at a given * position. Moreover, it tends to be faster since it uses a manipulation of these small * vectors and no row or column is actually deleted. The downside is, of course, the use * of extra memory (in practice, however, this is negligible).
* *Note that this class does not contain a computeRowMaxima method,
* however, the computeColumnMaxima can easily be used to compute row maxima
* by using a transposed matrix interface, i.e. one that inverts the indexes of the
* valueAt method (returning [col,row] when [row,col] is requested) and swaps
* the number of rows by the number of columns, and vice-versa.
Another simpler method, {@link #naiveComputeColumnMaxima naiveComputeColumnMaxima}, * does the same job without using the SMAWK algorithm. It takes advantage of the monotone * property of the matrix only (SMAWK explores the stronger constraint of total * monotonicity), and therefore has a worst case time complexity of O(n * m), where n is * the number of rows and m is the number of columns. However, this method tends to be * faster for small matrices because it avoids recursions and row and column * manipulations. There is also a * {@linkplain #naiveComputeRowMaxima naiveComputeRowMaxima} method to compute row maxima * with the naive approach.
* * @author Sergio A. de Carvalho Jr. * @see Matrix */ public class Smawk { /** * A pointer to the matrix that is being manipulated. */ protected Matrix matrix; /** * The matrix's current number of rows. This reflects any deletion of rows already * performed. */ protected int numrows; /** * An array of row indexes reflecting the current state of the matrix. When rows are * deleted, the corresponding indexes are simply moved to the end of the vector. */ protected int row[]; /** * This array is used to store for each row of the original matrix, its index in the * current state of the matrix, i.e. its index in therow array.
*/
protected int row_position[];
/**
* The matrix's current number of columns. This reflects any deletion of columns
* already performed.
*/
protected int numcols;
/**
* An array of column indexes reflecting the current state of the matrix. When columns
* are deleted, the corresponding indexes are simply moved to the end of the vector.
*/
protected int col[];
/**
* Computes the column maxima of a given matrix. It first sets up arrays of row and
* column indexes to simulate a copy of the matrix (where all operations will be
* performed). It then calls the recursive protected computeColumnMaxima
* method.
*
* The matrix is required to be an object that implements the Matrix
* interface. It is also expected to be totally monotone, and the number of rows
* should be greater than or equals to the number of columns. If it is not, the the
* result is unpredictable and can lead to an ArrayIndexOutOfBoundsException.
This method does not return the maximum values itself, but just the indexes of * their rows. Note that the array of column maxima (the computation result) must be * created beforehand and its size must be equal to the number of columns of the * matrix.
* *To prevent problems with concurrent access, this method is declared
* synchronized.
The first step is to reduce the matrix to a quadratic size (if necessary). It
* then delete all odd columns and recursively computes column maxima for this matrix.
* Finally, using the information computed for the odd columns, it searches for
* column maxima of the even columns. The column maxima are progressively stored in
* the col_maxima array (each recursive call will compute a set of
* column maxima).
valueAt method
* of the matrix. It returns the value at row r, column c.
*
* @param r the row number of the value being retrieved
* @param c the column number of the value being retrieved
* @return the value at row r, column c
* @see Matrix#valueAt
*/
protected final int valueAt (int r, int c)
{
return matrix.valueAt (row[r], col[c]);
}
/**
* This method simulates a deletion of odd rows by manipulating the col
* array of indexes. In fact, nothing is deleted, but the indexes are moved to the end
* of the array in a way that they can be easily restored by the
* restoreOddColumns method using a reverse approach.
*
* @see #restoreOddColumns
*/
protected void deleteOddColumns ()
{
int tmp;
for (int c = 2; c < numcols; c = c + 2)
{
// swap column c with c/2
tmp = col[c / 2];
col[c / 2] = col[c];
col[c] = tmp;
}
numcols = ((numcols - 1) / 2 + 1);
}
/**
* Restores the col array of indexes to the state it was before the
* deleteOddColumns method was called. It only needs to know how many
* columns there was originally. The indexes that were moved to the end of the array
* are restored to their original position.
*
* @param original_numcols the number of columns before the odd ones were deleted
* @see #deleteOddColumns
*/
protected void restoreOddColumns (int original_numcols)
{
int tmp;
for (int c = 2 * ((original_numcols - 1) / 2); c > 0; c = c - 2)
{
// swap back column c with c/2
tmp = col[c / 2];
col[c / 2] = col[c];
col[c] = tmp;
}
numcols = original_numcols;
}
/**
* This method is the key component of the SMAWK algorithm. It reduces an n x m matrix
* (n rows and m columns), where n >= m, to an n x n matrix by deleting m - n rows
* that are guaranteed to have no maximum value for any column. The result is an
* squared submatrix matrix that contains, for each column c, the row that has the
* maximum value of c in the original matrix. The rows are deleted with the
* deleteRowmethod.
*
* It uses the total monotonicity property of the matrix to identify which rows can
* safely be deleted.
*
* @see #deleteRow
*/
protected void reduce ()
{
int k = 0, reduced_numrows = numrows;
// until there is more rows than columns
while (reduced_numrows > numcols)
{
if (valueAt(k, k) < valueAt(k + 1, k))
{
// delete row k
deleteRow (reduced_numrows, k);
reduced_numrows --;
k --;
}
else
{
if (k < numcols - 1)
{
k++;
}
else
{
// delete row k+1
deleteRow (reduced_numrows, k+1);
reduced_numrows --;
}
}
}
numrows = reduced_numrows;
}
/**
* This method simulates a deletion of a row in the matrix during the
* reduce operation. It just moves the index to the end of the array in a
* way that it can be restored afterwards by the restoreRows method
* (nothing is actually deleted). Deleted indexes are kept in ascending order.
*
* @param reduced_rows the current number of rows in the reducing matrix
* @param k the index of the row to be deleted
* @see #restoreRows
*/
protected void deleteRow (int reduced_rows, int k)
{
int r, saved_row = row[k];
for (r = k + 1; r < reduced_rows; r++)
row[r - 1] = row[r];
for (r = reduced_rows - 1; r < (numrows - 1) && row[r+1] < saved_row; r++)
row[r] = row[r+1];
row[r] = saved_row;
}
/**
* Restores the row array of indexes to the state it was before the
* reduce method was called. It only needs to know how many rows there
* was originally. The indexes that were moved to the end of the array are restored to
* their original position.
*
* @param original_numrows the number of rows before the reduction was performed
* @see #deleteRow
* @see #reduce
*/
protected void restoreRows (int original_numrows)
{
int r, r2, s, d = numrows;
for (r = 0; r < d; r++)
{
if (row[r] > row[d])
{
s = row[d];
for (r2 = d; r2 > r; r2--)
row[r2] = row[r2-1];
row[r] = s;
d++;
if (d > original_numrows - 1) break;
}
}
numrows = original_numrows;
}
/**
* This is a simpler method for calculating column maxima. It does the same job as
* computeColumnMaxima, but without complexity of the SMAWK algorithm.
*
*
The matrix is required to be an object that implements the Matrix
* interface. It is also expected to be monotone. If it is not, the result is
* unpredictable but, unlike computeColumnMaxima, it cannot lead to an
* ArrayIndexOutOfBoundsException.
This method does not return the maximum values itself, but just the indexes of * their rows. Note that the array of column maxima (the computation result) must be * created beforehand and its size must be equal to the number of columns of the * matrix.
* *It takes advantage of the monotone property of the matrix only (SMAWK explores * the stronger constraint of total monotonicity), and therefore has a worst case time * complexity of O(n * m), where n is the number of rows and m is the number of * columns. However, this method tends to be faster for small matrices because it * avoids recursions and row and column manipulations.
* * @param matrix the matrix that will have its column maxima computed * @param col_maxima the array of column maxima (indexes of the rows containing * maximum values of each column); this is the computation result * @see #naiveComputeRowMaxima */ public static void naiveComputeColumnMaxima (Matrix matrix, int col_maxima[]) { int max_row = 0; //int last_max = 0; for (int c = 0; c < matrix.numColumns(); c ++) { for (int r = max_row; r < matrix.numRows(); r++) if (matrix.valueAt(r,c) > matrix.valueAt(max_row,c)) max_row = r; col_maxima[c] = max_row; // uncomment the following code to raise an exception when // the matrix is not monotone /* if (max_row < last_max) throw new IllegalArgumentException ("Non totally monotone matrix."); last_max = max_row; max_row = 0; */ } } /** * This is a simpler method for calculating row maxima. It does not use the SMAWK * algorithm. * *The matrix is required to be an object that implements the Matrix
* interface. It is also expected to be monotone. If it is not, the result is
* unpredictable but, unlike computeColumnMaxima, it cannot lead to an
* ArrayIndexOutOfBoundsException.
This method does not return the maximum values itself, but just the indexes of * their columns. Note that the array of row maxima (the computation result) must be * created beforehand and its size must be equal to the number of columns of the * matrix.
* *It takes advantage of the monotone property of the matrix only (SMAWK explores * the stronger constraint of total monotonicity), and therefore has a worst case time * complexity of O(n * m), where n is the number of rows and m is the number of * columns. However, this method tends to be faster for small matrices because it * avoids recursions and row and column manipulations.
* * @param matrix the matrix that will have its row maxima computed * @param row_maxima the array of row maxima (indexes of the columns containing * maximum values of each row); this is the computation result * @see #naiveComputeColumnMaxima */ public static void naiveComputeRowMaxima (Matrix matrix, int row_maxima[]) { int max_col = 0; //int last_max = 0; for (int r = 0; r < matrix.numRows(); r++) { for (int c = max_col; c < matrix.numColumns(); c ++) if (matrix.valueAt(r,c) > matrix.valueAt(r,max_col)) max_col = c; row_maxima[r] = max_col; // uncomment the following code to raise an exception when // the matrix is not monotone /* if (max_col < last_max) throw new IllegalArgumentException ("Non-monotone matrix."); last_max = max_col; max_col = 0; */ } } /** * Prints the current state of the matrix (reflecting deleted rows and columns) in the * standard output. It can be used internally for debugging. */ protected void printMatrix () { int r, c; System.out.print("row\\col\t| "); for (c = 0; c < numcols; c++) System.out.print(col[c] + "\t"); for (r = 0; r < numrows; r++) { System.out.print(row[r] + "\n\t| "); for (c = 0; c < numcols; c++) System.out.print(matrix.valueAt(r,c) + "\t"); } } /** * Prints the contents of an object implementing the matrix interface in the standard * output. It can be used for debugging. * * @param matrix a matrix */ public static void printMatrix (Matrix matrix) { for (int r = 0; r < matrix.numRows(); r++) { for (int c = 0; c < matrix.numColumns(); c++) System.out.print(matrix.valueAt(r,c) + "\t"); System.out.print("\n"); } } } neobio-0.0.20030929/src/neobio/alignment/BasicScoringScheme.java 0000644 0002656 0002032 00000015461 07717074372 023262 0 ustar tillea admin /* * BasicScoringScheme.java * * Copyright 2003 Sergio Anibal de Carvalho Junior * * This file is part of NeoBio. * * NeoBio is free software; you can redistribute it and/or modify it under the terms of * the GNU General Public License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR * PURPOSE. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along with NeoBio; * if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, * Boston, MA 02111-1307, USA. * * Proper attribution of the author as the source of the software would be appreciated. * * Sergio Anibal de Carvalho Junior mailto:sergioanibaljr@users.sourceforge.net * Department of Computer Science http://www.dcs.kcl.ac.uk * King's College London, UK http://www.kcl.ac.uk * * Please visit http://neobio.sourceforge.net * * This project was supervised by Professor Maxime Crochemore. * */ package neobio.alignment; /** * This class implements a basic scoring scheme. At least three parameters must be * provided to the constructor: the reward for a match (a substitution of equal * characters), the penalty for a mismatch (a substitution of different characters) and * the cost of a gap (an insertion or deletion of a character). Note that it only supports * an additive gap cost function. * *Although the match reward is expected to be a positive value, and the mismatch * penalty and the gap cost are expected to be negative, no attempt is made to enforce * these behaviour.
* * @author Sergio A. de Carvalho Jr. */ public class BasicScoringScheme extends ScoringScheme { /** * The reward for a match (a substitution of equal characters). */ protected int match_reward; /** * The penalty for a mismatch (a substitution of different characters). */ protected int mismatch_penalty; /** * The cost of a gap (an insertion or deletion of a character). */ protected int gap_cost; /** * The maximum absolute score that this scoring scheme can return, which is the * maximum absolute value amongmatch_reward,
* mismatch_penalty and gap_cost.
*/
protected int max_absolute_score;
/**
* Creates a new instance of a basic scoring scheme with the specified values of
* match reward, mismatch penalty and gap cost. The case of characters is significant
* when subsequently computing their score.
*
* @param match_reward reward for a substitution of equal characters
* @param mismatch_penalty penalty for a substitution of different characters
* @param gap_cost cost of an insertion or deletion of any character
*/
public BasicScoringScheme (int match_reward, int mismatch_penalty, int gap_cost)
{
this (match_reward, mismatch_penalty, gap_cost, true);
}
/**
* Creates a new instance of basic scoring scheme with the specified values of
* match reward, mismatch penalty and gap cost. If case_sensitive is
* true, the case of characters is significant when subsequently
* computing their score; otherwise the case is ignored.
*
* @param match_reward reward for a substitution of equal characters
* @param mismatch_penalty penalty for a substitution of different characters
* @param gap_cost cost of an insertion or deletion of any character
* @param case_sensitive true if the case of characters must be
* significant, false otherwise
*/
public BasicScoringScheme (int match_reward, int mismatch_penalty, int gap_cost,
boolean case_sensitive)
{
super(case_sensitive);
this.match_reward = match_reward;
this.mismatch_penalty = mismatch_penalty;
this.gap_cost = gap_cost;
// store the maximum absolute score that this scoring scheme can return,
// which is the maximum absolute value among match_reward, mismatch_penalty
// and gap_cost
if (Math.abs(match_reward) >= Math.abs(mismatch_penalty))
if (Math.abs(match_reward) >= Math.abs(gap_cost))
this.max_absolute_score = Math.abs(match_reward);
else
this.max_absolute_score = Math.abs(gap_cost);
else
if (Math.abs(mismatch_penalty) >= Math.abs(gap_cost))
this.max_absolute_score = Math.abs(mismatch_penalty);
else
this.max_absolute_score = Math.abs(gap_cost);
}
/**
* Returns the score of a substitution of character a for character
* b according to this scoring scheme. It is match_reward
* if a equals b, mismatch_penalty otherwise.
*
* @param a first character
* @param b second character
* @return match_reward if a equals b,
* mismatch_penalty otherwise.
*/
public int scoreSubstitution (char a, char b)
{
if (isCaseSensitive())
if (a == b)
return match_reward;
else
return mismatch_penalty;
else
if (Character.toLowerCase(a) == Character.toLowerCase(b))
return match_reward;
else
return mismatch_penalty;
}
/**
* Always returns gap_cost for the insertion of any character.
*
* @param a the character to be inserted
* @return gap_cost
*/
public int scoreInsertion (char a)
{
return gap_cost;
}
/**
* Always returns gap_cost for the deletion of any character.
*
* @param a the character to be deleted
* @return gap_cost
*/
public int scoreDeletion (char a)
{
return gap_cost;
}
/**
* Returns the maximum absolute score that this scoring scheme can return for any
* substitution, deletion or insertion, which is the maximum absolute value among
* match_reward, mismatch_penalty and
* gap_cost.
*
* @return the maximum absolute value among match_reward,
* mismatch_penalty and gap_cost.
*/
public int maxAbsoluteScore ()
{
return max_absolute_score;
}
/**
* Tells whether this scoring scheme supports partial matches, which it does not.
*
* @return always return false
*/
public boolean isPartialMatchSupported ()
{
return false;
}
/**
* Returns a String representation of this scoring scheme.
*
* @return a String representation of this scoring scheme
*/
public String toString ()
{
return "Basic scoring scheme: match reward = " + match_reward +
", mismatch penalty = " + mismatch_penalty + ", gap cost = " + gap_cost;
}
}
neobio-0.0.20030929/src/neobio/alignment/LocalAlignmentBlock.java 0000644 0002656 0002032 00000007351 07723462324 023425 0 ustar tillea admin /*
* LocalAlignmentBlock.java
*
* Copyright 2003 Sergio Anibal de Carvalho Junior
*
* This file is part of NeoBio.
*
* NeoBio is free software; you can redistribute it and/or modify it under the terms of
* the GNU General Public License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with NeoBio;
* if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307, USA.
*
* Proper attribution of the author as the source of the software would be appreciated.
*
* Sergio Anibal de Carvalho Junior mailto:sergioanibaljr@users.sourceforge.net
* Department of Computer Science http://www.dcs.kcl.ac.uk
* King's College London, UK http://www.kcl.ac.uk
*
* Please visit http://neobio.sourceforge.net
*
* This project was supervised by Professor Maxime Crochemore.
*
*/
package neobio.alignment;
/**
* This class is used by the {@linkplain CrochemoreLandauZivUkelsonLocalAlignment}
* algorithm to store the information of an alignment block. All fields are public (but
* final) in order to simplify the access to the data.
*
* For more information on how this class is used, please refer to the specification
* of the CrochemoreLandauZivUkelsonLocalAlignment class.
row column col
*/
public int valueAt (int row, int col);
/**
* Returns the number of rows that this matrix has.
*
* @return number of rows
*/
public int numRows ();
/**
* Returns the number of columns that this matrix has.
*
* @return number of columns
*/
public int numColumns ();
}
neobio-0.0.20030929/src/neobio/alignment/CrochemoreLandauZivUkelsonGlobalAlignment.java 0000644 0002656 0002032 00000030174 07725336372 030012 0 ustar tillea admin /*
* CrochemoreLandauZivUkelsonGlobalAlignment.java
*
* Copyright 2003 Sergio Anibal de Carvalho Junior
*
* This file is part of NeoBio.
*
* NeoBio is free software; you can redistribute it and/or modify it under the terms of
* the GNU General Public License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with NeoBio;
* if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307, USA.
*
* Proper attribution of the author as the source of the software would be appreciated.
*
* Sergio Anibal de Carvalho Junior mailto:sergioanibaljr@users.sourceforge.net
* Department of Computer Science http://www.dcs.kcl.ac.uk
* King's College London, UK http://www.kcl.ac.uk
*
* Please visit http://neobio.sourceforge.net
*
* This project was supervised by Professor Maxime Crochemore.
*
*/
package neobio.alignment;
/**
* This class implements the global pairwise sequence alignment algorithm (with
* linear gap penalty function) due to Maxime Crochemore, Gad Landau and Michal
* Ziv-Ukelson (2002).
*
* This implementation derives from the paper of M.Crochemore, G.Landau and * M.Ziv-Ukelson, A Sub-quadratic Sequence Alignment Algorithm for Unrestricted Scoring * Matrices (available here as * PDF or * Postscript).
* *For a general description of the algorithm, please refer to the specification of the * abstract {@linkplain CrochemoreLandauZivUkelson} superclass.
* *This class consist mainly of methods that:
* *computeOutputBorder method to compute the block's output border.
*
* @param factor1 factor of the first sequence
* @param factor2 factor of the second sequence
* @param row row index of the block in the block table
* @param col column index of the block in the block table
* @return the computed block
* @throws IncompatibleScoringSchemeException if the scoring scheme is not compatible
* with the sequences being aligned
*/
protected AlignmentBlock createBlock (Factor factor1, Factor factor2, int row,
int col) throws IncompatibleScoringSchemeException
{
AlignmentBlock block, left_prefix, diag_prefix, top_prefix;
int size, lr, lc, score_ins, score_sub, score_del, ins, del, sub, max;
lr = factor1.length();
lc = factor2.length();
size = lr + lc + 1;
block = new AlignmentBlock (factor1, factor2, size);
// set up pointers to prefixes
left_prefix = getLeftPrefix (block);
diag_prefix = getDiagonalPrefix (block);
top_prefix = getTopPrefix (block);
// compute scores
score_ins = scoreInsertion (factor2.getNewChar());
score_sub = scoreSubstitution (factor1.getNewChar(), factor2.getNewChar());
score_del = scoreDeletion (factor1.getNewChar());
// compute dist column and direction
for (int i = 0; i < size; i++)
{
// compute optimal path to
// input border's ith position
ins = sub = del = Integer.MIN_VALUE;
if (i < size - 1)
ins = left_prefix.dist_column[i] + score_ins;
if ((i > 0) && (i < size - 1))
sub = diag_prefix.dist_column[i - 1] + score_sub;
if (i > 0)
del = top_prefix.dist_column[i - 1] + score_del;
block.dist_column[i] = max = max (ins, sub, del);
// record the direction to of the optimal
// path to input border's ith position
if (max == ins)
block.direction[i] = LEFT_DIRECTION;
else if (max == sub)
block.direction[i] = DIAGONAL_DIRECTION;
else
block.direction[i] = TOP_DIRECTION;
}
computeOutputBorder (block, row, col, size, lc, lr);
return block;
}
/**
* Creates the root block. This is a special case of the createBlock
* method. No information is actually computed.
*
* @param factor1 factor of the first sequence
* @param factor2 factor of the second sequence
* @return the root block
*/
protected AlignmentBlock createRootBlock (Factor factor1, Factor factor2)
{
return new AlignmentBlock (factor1, factor2);
}
/**
* Creates and computes all information of an alignment block of the first row of the
* block table. This is a special case of the createBlock method.
*
* @param factor1 factor of the first sequence
* @param factor2 factor of the second sequence
* @param col column index of the block in the block table
* @return the computed block
* @throws IncompatibleScoringSchemeException if the scoring scheme is not compatible
* with the sequences being aligned
* @see #createBlock createBlock
*/
protected AlignmentBlock createFirstRowBlock (Factor factor1, Factor factor2, int col)
throws IncompatibleScoringSchemeException
{
AlignmentBlock block, left_prefix;
int size, lr, lc, score_ins;
lr = 0; // factor1.length();
lc = factor2.length();
size = lr + lc + 1;
block = new AlignmentBlock (factor1, factor2, size);
// set up pointer to left prefix
left_prefix = getLeftPrefix (block);
// compute insertion's score
score_ins = scoreInsertion (factor2.getNewChar());
// compute dist column and direction
for (int i = 0; i < lc; i++)
{
block.dist_column[i] = left_prefix.dist_column[i] + score_ins;
block.direction[i] = LEFT_DIRECTION;
}
// last position
block.dist_column[lc] = 0;
block.direction[lc] = STOP_DIRECTION;
computeOutputBorder (block, 0, col, size, lc, lr);
return block;
}
/**
* Creates and computes all information of an alignment block of the first column of
* the block table. This is a special case of the createBlock method.
*
* @param factor1 factor of the first sequence
* @param factor2 factor of the second sequence
* @param row row index of the block in the block table
* @return the computed block
* @throws IncompatibleScoringSchemeException if the scoring scheme is not compatible
* with the sequences being aligned
* @see #createBlock createBlock
*/
protected AlignmentBlock createFirstColumnBlock (Factor factor1, Factor factor2,
int row) throws IncompatibleScoringSchemeException
{
AlignmentBlock block, top_prefix;
int size, lr, lc, score_del;
lr = factor1.length();
lc = 0; // factor2.length();
size = lr + lc + 1;
block = new AlignmentBlock (factor1, factor2, size);
// set up pointer to top prefix
top_prefix = getTopPrefix (block);
// compute deletion's score
score_del = scoreDeletion (factor1.getNewChar());
// first position
block.dist_column[0] = 0;
block.direction[0] = STOP_DIRECTION;
// compute dist column and direction
for (int i = 1; i < size; i++)
{
block.dist_column[i] = top_prefix.dist_column[i - 1] + score_del;
block.direction[i] = TOP_DIRECTION;
}
computeOutputBorder (block, row, 0, size, lc, lr);
return block;
}
/**
* Computes the output border of a block. This is performed in five steps:
*
* case_sensitive is
* true, the case of characters is significant when subsequently
* computing their score; otherwise the case is ignored.
*
* @param case_sensitive true if the case of characters must be
* significant, false otherwise
*/
public ScoringScheme (boolean case_sensitive)
{
this.case_sensitive = case_sensitive;
}
/**
* Tells whether this scoring scheme ignores the case of characters when computing
* their score.
*
* @return true if the case of characters is significant,
* false otherwise
*/
public boolean isCaseSensitive ()
{
return this.case_sensitive;
}
/**
* Returns the score of a substitution of character a for character
* b according to this scoring scheme. If this substitution is not
* defined, an exception is raised.
*
* @param a first character
* @param b second character
* @return score of substitution of a for b
* @throws IncompatibleScoringSchemeException if this substitution is not defined
*/
public abstract int scoreSubstitution (char a, char b)
throws IncompatibleScoringSchemeException;
/**
* Returns the score of an insertion of character a according to this
* scoring scheme. If this character is not recognised, an exception is raised.
*
* @param a the character to be inserted
* @return score of insertion of a
* @throws IncompatibleScoringSchemeException if character is not recognised by this
* scoring scheme
*/
public abstract int scoreInsertion (char a)
throws IncompatibleScoringSchemeException;
/**
* Returns the score of a deletion of character a according to this
* scoring scheme. If this character is not recognised, an exception is raised.
*
* @param a the character to be deleted
* @return score of insertion of a
* @throws IncompatibleScoringSchemeException if character is not recognised by this
* scoring scheme
*/
public abstract int scoreDeletion (char a)
throws IncompatibleScoringSchemeException;
/**
* Returns the maximum absolute score that this scoring scheme can return for any
* substitution, deletion or insertion.
*
* @return maximum absolute score that can be returned
*/
public abstract int maxAbsoluteScore ();
/**
* Returns true if this scoring scheme supports partial matches,
* false otherwise. A partial match is a situation when two characters
* are not equal but, for any reason, are regarded as similar by this scoring scheme,
* which then returns a positive score. This is common when for scoring schemes
* that implement amino acid scoring matrices.
*
* @return true if this scoring scheme supports partial matches,
* false otherwise
*/
public abstract boolean isPartialMatchSupported ();
}
neobio-0.0.20030929/src/neobio/alignment/NeedlemanWunsch.java 0000644 0002656 0002032 00000027513 07725254026 022643 0 ustar tillea admin /*
* NeedlemanWunsch.java
*
* Copyright 2003 Sergio Anibal de Carvalho Junior
*
* This file is part of NeoBio.
*
* NeoBio is free software; you can redistribute it and/or modify it under the terms of
* the GNU General Public License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with NeoBio;
* if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307, USA.
*
* Proper attribution of the author as the source of the software would be appreciated.
*
* Sergio Anibal de Carvalho Junior mailto:sergioanibaljr@users.sourceforge.net
* Department of Computer Science http://www.dcs.kcl.ac.uk
* King's College London, UK http://www.kcl.ac.uk
*
* Please visit http://neobio.sourceforge.net
*
* This project was supervised by Professor Maxime Crochemore.
*
*/
package neobio.alignment;
import java.io.Reader;
import java.io.IOException;
/**
* This class implements the classic global alignment algorithm (with linear gap penalty
* function) due to S.B.Needleman and C.D.Wunsch (1970).
*
* It is based on a dynamic programming approach. The idea consists of, given two * sequences A and B of sizes n and m, respectively, building an (n+1 x m+1) matrix M that * contains the similarity of prefixes of A and B. Every position M[i,j] in the matrix * holds the score between the subsequences A[1..i] and B[1..j]. The first row and column * represent alignments with spaces.
* *Starting from row 0, column 0, the algorithm computes each position M[i,j] with the * following recurrence:
* *
* M[0,0] = 0
* M[i,j] = max { M[i,j-1] + scoreInsertion (B[j]),
* M[i-1,j-1] + scoreSubstitution (A[i], B[j]),
* M[i-1,j] + scoreDeletion(A[i]) }
*
In the end, the value at the last position (last row, last column) will contain * the similarity between the two sequences. This part of the algorithm is accomplished * by the {@link #computeMatrix computeMatrix} method. It has quadratic space complexity * since it needs to keep an (n+1 x m+1) matrix in memory. And since the work of computing * each cell is constant, it also has quadratic time complexity.
* *After the matrix has been computed, the alignment can be retrieved by tracing a path * back in the matrix from the last position to the first. This step is performed by * the {@link #buildOptimalAlignment buildOptimalAlignment} method, and since the path can * be roughly as long as (m + n), this method has O(n) time complexity.
* *If the similarity value only is needed (and not the alignment itself), it is easy to * reduce the space requirement to O(n) by keeping just the last row or column in memory. * This is precisely what is done by the {@link #computeScore computeScore} method. Note * that it still requires O(n2) time.
* *For a more efficient approach to the global alignment problem, see the * {@linkplain CrochemoreLandauZivUkelson} algorithm. For local alignment, see the * {@linkplain SmithWaterman} algorithm.
* * @author Sergio A. de Carvalho Jr. * @see SmithWaterman * @see CrochemoreLandauZivUkelson * @see CrochemoreLandauZivUkelsonLocalAlignment * @see CrochemoreLandauZivUkelsonGlobalAlignment */ public class NeedlemanWunsch extends PairwiseAlignmentAlgorithm { /** * The first sequence of an alignment. */ protected CharSequence seq1; /** * The second sequence of an alignment. */ protected CharSequence seq2; /** * The dynamic programming matrix. Each position (i, j) represents the best score * between the firsts i characters ofseq1 and j characters of
* seq2.
*/
protected int[][] matrix;
/**
* Loads sequences into {@linkplain CharSequence} instances. In case of any error,
* an exception is raised by the constructor of CharSequence (please
* check the specification of that class for specific requirements).
*
* @param input1 Input for first sequence
* @param input2 Input for second sequence
* @throws IOException If an I/O error occurs when reading the sequences
* @throws InvalidSequenceException If the sequences are not valid
* @see CharSequence
*/
protected void loadSequencesInternal (Reader input1, Reader input2)
throws IOException, InvalidSequenceException
{
// load sequences into instances of CharSequence
this.seq1 = new CharSequence(input1);
this.seq2 = new CharSequence(input2);
}
/**
* Frees pointers to loaded sequences and the dynamic programming matrix so that their
* data can be garbage collected.
*/
protected void unloadSequencesInternal ()
{
this.seq1 = null;
this.seq2 = null;
this.matrix = null;
}
/**
* Builds an optimal global alignment between the loaded sequences after computing the
* dynamic programming matrix. It calls the buildOptimalAlignment method
* after the computeMatrix method computes the dynamic programming
* matrix.
*
* @return an optimal global alignment between the loaded sequences
* @throws IncompatibleScoringSchemeException If the scoring scheme is not compatible
* with the loaded sequences.
* @see #computeMatrix
* @see #buildOptimalAlignment
*/
protected PairwiseAlignment computePairwiseAlignment ()
throws IncompatibleScoringSchemeException
{
// compute the matrix
computeMatrix ();
// build and return an optimal global alignment
PairwiseAlignment alignment = buildOptimalAlignment ();
// allow the matrix to be garbage collected
matrix = null;
return alignment;
}
/**
* Computes the dynamic programming matrix.
*
* @throws IncompatibleScoringSchemeException If the scoring scheme is not compatible
* with the loaded sequences.
*/
protected void computeMatrix () throws IncompatibleScoringSchemeException
{
int r, c, rows, cols, ins, del, sub;
rows = seq1.length()+1;
cols = seq2.length()+1;
matrix = new int [rows][cols];
// initiate first row
matrix[0][0] = 0;
for (c = 1; c < cols; c++)
matrix[0][c] = matrix[0][c-1] + scoreInsertion(seq2.charAt(c));
// calculates the similarity matrix (row-wise)
for (r = 1; r < rows; r++)
{
// initiate first column
matrix[r][0] = matrix[r-1][0] + scoreDeletion(seq1.charAt(r));
for (c = 1; c < cols; c++)
{
ins = matrix[r][c-1] + scoreInsertion(seq2.charAt(c));
sub = matrix[r-1][c-1] + scoreSubstitution(seq1.charAt(r),seq2.charAt(c));
del = matrix[r-1][c] + scoreDeletion(seq1.charAt(r));
// choose the greatest
matrix[r][c] = max (ins, sub, del);
}
}
}
/**
* Builds an optimal global alignment between the loaded sequences. Before it is
* executed, the dynamic programming matrix must already have been computed by
* the computeMatrix method.
*
* @return an optimal global alignment between the loaded sequences
* @throws IncompatibleScoringSchemeException If the scoring scheme
* is not compatible with the loaded sequences.
* @see #computeMatrix
*/
protected PairwiseAlignment buildOptimalAlignment ()
throws IncompatibleScoringSchemeException
{
StringBuffer gapped_seq1, score_tag_line, gapped_seq2;
int r, c, sub, max_score;
gapped_seq1 = new StringBuffer();
score_tag_line = new StringBuffer();
gapped_seq2 = new StringBuffer();
// start at the last row, last column
r = matrix.length - 1;
c = matrix[r].length - 1;
max_score = matrix[r][c];
while ((r > 0) || (c > 0))
{
if (c > 0)
if (matrix[r][c] == matrix[r][c-1] + scoreInsertion(seq2.charAt(c)))
{
// insertion was used
gapped_seq1.insert (0, GAP_CHARACTER);
score_tag_line.insert (0, GAP_TAG);
gapped_seq2.insert (0, seq2.charAt(c));
c = c - 1;
// skip to the next iteration
continue;
}
if ((r > 0) && (c > 0))
{
sub = scoreSubstitution(seq1.charAt(r), seq2.charAt(c));
if (matrix[r][c] == matrix[r-1][c-1] + sub)
{
// substitution was used
gapped_seq1.insert (0, seq1.charAt(r));
if (seq1.charAt(r) == seq2.charAt(c))
if (useMatchTag())
score_tag_line.insert (0, MATCH_TAG);
else
score_tag_line.insert (0, seq1.charAt(r));
else if (sub > 0)
score_tag_line.insert (0, APPROXIMATE_MATCH_TAG);
else
score_tag_line.insert (0, MISMATCH_TAG);
gapped_seq2.insert (0, seq2.charAt(c));
r = r - 1; c = c - 1;
// skip to the next iteration
continue;
}
}
// must be a deletion
gapped_seq1.insert (0, seq1.charAt(r));
score_tag_line.insert (0, GAP_TAG);
gapped_seq2.insert (0, GAP_CHARACTER);
r = r - 1;
}
return new PairwiseAlignment (gapped_seq1.toString(), score_tag_line.toString(),
gapped_seq2.toString(), max_score);
}
/**
* Computes the score of the best global alignment between the two sequences using the
* scoring scheme previously set. This method calculates the similarity value only
* (doesn't build the whole matrix so the alignment cannot be recovered, however it
* has the advantage of requiring O(n) space only).
*
* @return score of the best global alignment between the loaded sequences
* @throws IncompatibleScoringSchemeException If the scoring scheme is not compatible
* with the loaded sequences.
*/
protected int computeScore () throws IncompatibleScoringSchemeException
{
int[] array;
int r, c, rows, cols, tmp, ins, del, sub;
rows = seq1.length()+1;
cols = seq2.length()+1;
if (rows <= cols)
{
// goes columnwise
array = new int [rows];
// initiate first column
array[0] = 0;
for (r = 1; r < rows; r++)
array[r] = array[r-1] + scoreDeletion(seq1.charAt(r));
// calculate the similarity matrix (keep current column only)
for (c = 1; c < cols; c++)
{
// initiate first row (tmp hold values
// that will be later moved to the array)
tmp = array[0] + scoreInsertion(seq2.charAt(c));
for (r = 1; r < rows; r++)
{
ins = array[r] + scoreInsertion(seq2.charAt(c));
sub = array[r-1] + scoreSubstitution(seq1.charAt(r), seq2.charAt(c));
del = tmp + scoreDeletion(seq1.charAt(r));
// move the temp value to the array
array[r-1] = tmp;
// choose the greatest
tmp = max (ins, sub, del);
}
// move the temp value to the array
array[rows - 1] = tmp;
}
return array[rows - 1];
}
else
{
// goes rowwise
array = new int [cols];
// initiate first row
array[0] = 0;
for (c = 1; c < cols; c++)
array[c] = array[c-1] + scoreInsertion(seq2.charAt(c));
// calculate the similarity matrix (keep current row only)
for (r = 1; r < rows; r++)
{
// initiate first column (tmp hold values
// that will be later moved to the array)
tmp = array[0] + scoreDeletion(seq1.charAt(r));
for (c = 1; c < cols; c++)
{
ins = tmp + scoreInsertion(seq2.charAt(c));
sub = array[c-1] + scoreSubstitution(seq1.charAt(r), seq2.charAt(c));
del = array[c] + scoreDeletion(seq1.charAt(r));
// move the temp value to the array
array[c-1] = tmp;
// choose the greatest
tmp = max (ins, sub, del);
}
// move the temp value to the array
array[cols - 1] = tmp;
}
return array[cols - 1];
}
}
}
neobio-0.0.20030929/src/neobio/alignment/Factor.java 0000644 0002656 0002032 00000014334 07717074374 021005 0 ustar tillea admin /*
* Factor.java
*
* Copyright 2003 Sergio Anibal de Carvalho Junior
*
* This file is part of NeoBio.
*
* NeoBio is free software; you can redistribute it and/or modify it under the terms of
* the GNU General Public License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with NeoBio;
* if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307, USA.
*
* Proper attribution of the author as the source of the software would be appreciated.
*
* Sergio Anibal de Carvalho Junior mailto:sergioanibaljr@users.sourceforge.net
* Department of Computer Science http://www.dcs.kcl.ac.uk
* King's College London, UK http://www.kcl.ac.uk
*
* Please visit http://neobio.sourceforge.net
*
* This project was supervised by Professor Maxime Crochemore.
*
*/
package neobio.alignment;
/**
* This class is used by {@linkplain FactorSequence} to create a linked list of factors of
* a text as induced by its Lempel-Ziv (LZ78) factorisation.
*
* Each instance of this class represent a string composed of its an ancestor factor's * string plus one character, and contains: * *
-
*
- a pointer to its ancestor factor (the longest factor previously seen in the text * during its LZ78 factorisation); *
- the new character; *
- a serial number (which represents its order in the text) *
- a pointer to the next factor of the text *
- its length (number of characters, which is equal to its ancestor's length plus one) *
Factor. It has no ancestor and no character (both
* are set to null). Its serial number is set to zero as well as its
* length.
*
* This constructor is used to initiate the a linked list of factors of a text. Its
* next pointer is initially null, but it is typically set
* to point to the first factor afterwards (with the setNext method).
*
* @see #setNext
*/
public Factor ()
{
this.ancestor = null;
this.next = null;
this.serial_number = 0;
this.length = 0;
this.new_char = 0;
}
/**
* Creates a new Factor instance with the specified serial number and
* new character, and pointing to the given ancestor. Its length is set to its
* ancestor's length plus 1.
*
*
Its next pointer is initially null, but it is
* typically set to point to the next factor afterwards (with the setNext
* method).
*
* @param ancestor this factor's ancestor
* @param serial_number this factor's serial number
* @param new_char this factor's new character
* @see #setNext
*/
public Factor (Factor ancestor, int serial_number, char new_char)
{
this.ancestor = ancestor;
this.serial_number = serial_number;
this.new_char = new_char;
if (ancestor != null)
this.length = ancestor.length() + 1;
else
throw new IllegalArgumentException ("Ancestor factor cannot be null.");
}
/**
* Sets this factor's next pointer to point to the specified factor.
* Although the next factor has typically a serial number equal to this factor's
* serial number plus 1, no attempt is made to guarantee this rule. This allows
* special constructs or a different order in the factorisation.
*
* @param next the factor that will be pointed to
* @see #getNext
*/
public void setNext (Factor next)
{
this.next = next;
}
/**
* Returns this factor's ancestor factor.
*
* @return this factor's ancestor factor
*/
public Factor getAncestor ()
{
return ancestor;
}
/**
* This method is a shorthand to return the serial number of this factor's ancestor.
* Note that it does not check if this factor has an ancestor or not, therefore, if
* it is called on the root factor, a NullPointerException is raised.
*
* @return the serial number of this factor's ancestor
*/
public int getAncestorSerialNumber ()
{
return ancestor.getSerialNumber();
}
/**
* Returns this factor's next factor.
*
* @return this factor's next factor
* @see #setNext
*/
public Factor getNext ()
{
return next;
}
/**
* Returns this factor's serial number.
*
* @return this factor's serial number
*/
public int getSerialNumber ()
{
return serial_number;
}
/**
* Returns this factor's length.
*
* @return this factor's length
*/
public int length ()
{
return length;
}
/**
* Returns this factor's new character.
*
* @return this factor's new character
*/
public char getNewChar ()
{
return new_char;
}
/**
* Returns a string representation of the text represented by this factor. It inspects
* its chain of ancestors up until as far as the root factor, spelling their new
* characters out.
*
* @return a string representation of the text denoted by this factor
*/
public String toString ()
{
StringBuffer buf = new StringBuffer();
Factor ancestor = this;
while (ancestor.getAncestor() != null)
{
buf.insert(0, ancestor.getNewChar());
ancestor = ancestor.getAncestor();
}
return buf.toString();
}
}
neobio-0.0.20030929/src/neobio/alignment/SmithWaterman.java 0000644 0002656 0002032 00000030631 07717234470 022343 0 ustar tillea admin /*
* SmithWaterman.java
*
* Copyright 2003 Sergio Anibal de Carvalho Junior
*
* This file is part of NeoBio.
*
* NeoBio is free software; you can redistribute it and/or modify it under the terms of
* the GNU General Public License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with NeoBio;
* if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307, USA.
*
* Proper attribution of the author as the source of the software would be appreciated.
*
* Sergio Anibal de Carvalho Junior mailto:sergioanibaljr@users.sourceforge.net
* Department of Computer Science http://www.dcs.kcl.ac.uk
* King's College London, UK http://www.kcl.ac.uk
*
* Please visit http://neobio.sourceforge.net
*
* This project was supervised by Professor Maxime Crochemore.
*
*/
package neobio.alignment;
import java.io.Reader;
import java.io.IOException;
/**
* This class implement the classic local alignment algorithm (with linear gap penalty
* function) due to T.F.Smith and M.S.Waterman (1981).
*
*
This algorithm is very similar to the {@linkplain NeedlemanWunsch} algorithm for * global alignment. The idea here also consists of building an (n+1 x m+1) matrix M given * two sequences A and B of sizes n and m, respectively. However, unlike in the global * alignment case, every position M[i,j] in the matrix contains the similarity score of * suffixes of A[1..i] and B[1..j].
* *Starting from row 0, column 0, the {@link #computeMatrix computeMatrix} method * computes each position M[i,j] with the following recurrence:
* *
* M[0,0] = M[0,j] = M[i,0] = 0
* M[i,j] = max { M[i,j-1] + scoreInsertion (B[j]),
* M[i-1,j-1] + scoreSubstitution (A[i], B[j]),
* M[i-1,j] + scoreDeletion(A[i]) }
*
Note that, here, all cells in the first row and column are set to zero. The best * local alignment score is the highest value found anywhere in the matrix.
* *Just like in global alignment case, this algorithm has quadratic space complexity * because it needs to keep an (n+1 x m+1) matrix in memory. And since the work of * computing each cell is constant, it also has quadratic time complexity.
* *After the matrix has been computed, the alignment can be retrieved by tracing a path * back in the matrix from the position of the highest score until a cell of value zero is * reached. This step is performed by the {@link #buildOptimalAlignment * buildOptimalAlignment} method, and its time complexity is linear on the size of the * alignment. * *
If the similarity value only is needed (and not the alignment itself), it is easy to * reduce the space requirement to O(n) by keeping just the last row or column in memory. * This is precisely what is done by the {@link #computeScore computeScore} method. Note * that it still requires O(n2) time.
* *For a more efficient approach to the local alignment problem, see the * {@linkplain CrochemoreLandauZivUkelson} algorithm. For global alignment, see the * {@linkplain NeedlemanWunsch} algorithm.
* * @author Sergio A. de Carvalho Jr. * @see NeedlemanWunsch * @see CrochemoreLandauZivUkelson * @see CrochemoreLandauZivUkelsonLocalAlignment * @see CrochemoreLandauZivUkelsonGlobalAlignment */ public class SmithWaterman extends PairwiseAlignmentAlgorithm { /** * The first sequence of an alignment. */ protected CharSequence seq1; /** * The second sequence of an alignment. */ protected CharSequence seq2; /** * The dynamic programming matrix. Each position (i, j) represents the best score * between a suffic of the firsts i characters ofseq1 and a suffix of
* the first j characters of seq2.
*/
protected int[][] matrix;
/**
* Indicate the row of where an optimal local alignment can be found in the matrix..
*/
protected int max_row;
/**
* Indicate the column of where an optimal local alignment can be found in the matrix.
*/
protected int max_col;
/**
* Loads sequences into {@linkplain CharSequence} instances. In case of any error, an
* exception is raised by the constructor of CharSequence (please check
* the specification of that class for specific requirements).
*
* @param input1 Input for first sequence
* @param input2 Input for second sequence
* @throws IOException If an I/O error occurs when reading the sequences
* @throws InvalidSequenceException If the sequences are not valid
* @see CharSequence
*/
protected void loadSequencesInternal (Reader input1, Reader input2)
throws IOException, InvalidSequenceException
{
// load sequences into instances of CharSequence
this.seq1 = new CharSequence(input1);
this.seq2 = new CharSequence(input2);
}
/**
* Frees pointers to loaded sequences and the dynamic programming matrix so that their
* data can be garbage collected.
*/
protected void unloadSequencesInternal ()
{
this.seq1 = null;
this.seq2 = null;
this.matrix = null;
}
/**
* Builds an optimal local alignment between the loaded sequences after computing the
* dynamic programming matrix. It calls the buildOptimalAlignment method
* after the computeMatrix method computes the dynamic programming
* matrix.
*
* @return an optimal pairwise alignment between the loaded sequences
* @throws IncompatibleScoringSchemeException If the scoring scheme is not compatible
* with the loaded sequences.
* @see #computeMatrix
* @see #buildOptimalAlignment
*/
protected PairwiseAlignment computePairwiseAlignment ()
throws IncompatibleScoringSchemeException
{
// compute the matrix
computeMatrix ();
// build and return an optimal local alignment
PairwiseAlignment alignment = buildOptimalAlignment ();
// allow the matrix to be garbage collected
matrix = null;
return alignment;
}
/**
* Computes the dynamic programming matrix.
*
* @throws IncompatibleScoringSchemeException If the scoring scheme is not compatible
* with the loaded sequences.
*/
protected void computeMatrix () throws IncompatibleScoringSchemeException
{
int r, c, rows, cols, ins, sub, del, max_score;
rows = seq1.length()+1;
cols = seq2.length()+1;
matrix = new int [rows][cols];
// initiate first row
for (c = 0; c < cols; c++)
matrix[0][c] = 0;
// keep track of the maximum score
this.max_row = this.max_col = max_score = 0;
// calculates the similarity matrix (row-wise)
for (r = 1; r < rows; r++)
{
// initiate first column
matrix[r][0] = 0;
for (c = 1; c < cols; c++)
{
ins = matrix[r][c-1] + scoreInsertion(seq2.charAt(c));
sub = matrix[r-1][c-1] + scoreSubstitution(seq1.charAt(r),seq2.charAt(c));
del = matrix[r-1][c] + scoreDeletion(seq1.charAt(r));
// choose the greatest
matrix[r][c] = max (ins, sub, del, 0);
if (matrix[r][c] > max_score)
{
// keep track of the maximum score
max_score = matrix[r][c];
this.max_row = r; this.max_col = c;
}
}
}
}
/**
* Builds an optimal local alignment between the loaded sequences. Before it is
* executed, the dynamic programming matrix must already have been computed by
* the computeMatrix method.
*
* @return an optimal local alignment between the loaded sequences
* @throws IncompatibleScoringSchemeException If the scoring scheme is not compatible
* with the loaded sequences.
* @see #computeMatrix
*/
protected PairwiseAlignment buildOptimalAlignment () throws
IncompatibleScoringSchemeException
{
StringBuffer gapped_seq1, score_tag_line, gapped_seq2;
int r, c, max_score, sub;
// start at the cell with maximum score
r = this.max_row;
c = this.max_col;
max_score = matrix[r][c];
gapped_seq1 = new StringBuffer();
score_tag_line = new StringBuffer();
gapped_seq2 = new StringBuffer();
while ((r > 0 || c > 0) && (matrix[r][c] > 0))
{
if (c > 0)
if (matrix[r][c] == matrix[r][c-1] + scoreInsertion(seq2.charAt(c)))
{
// insertion
gapped_seq1.insert (0, GAP_CHARACTER);
score_tag_line.insert (0, GAP_TAG);
gapped_seq2.insert (0, seq2.charAt(c));
c = c - 1;
// skip to the next iteration
continue;
}
if ((r > 0) && (c > 0))
{
sub = scoreSubstitution(seq1.charAt(r), seq2.charAt(c));
if (matrix[r][c] == matrix[r-1][c-1] + sub)
{
// substitution
gapped_seq1.insert (0, seq1.charAt(r));
if (seq1.charAt(r) == seq2.charAt(c))
if (useMatchTag())
score_tag_line.insert (0, MATCH_TAG);
else
score_tag_line.insert (0, seq1.charAt(r));
else if (sub > 0)
score_tag_line.insert (0, APPROXIMATE_MATCH_TAG);
else
score_tag_line.insert (0, MISMATCH_TAG);
gapped_seq2.insert (0, seq2.charAt(c));
r = r - 1; c = c - 1;
// skip to the next iteration
continue;
}
}
// must be a deletion
gapped_seq1.insert (0, seq1.charAt(r));
score_tag_line.insert (0, GAP_TAG);
gapped_seq2.insert (0,GAP_CHARACTER);
r = r - 1;
}
return new PairwiseAlignment (gapped_seq1.toString(), score_tag_line.toString(),
gapped_seq2.toString(), max_score);
}
/**
* Computes the score of the best local alignment between the two sequences using the
* scoring scheme previously set. This method calculates the similarity value only
* (doesn't build the whole matrix so the alignment cannot be recovered, however it
* has the advantage of requiring O(n) space only).
*
* @return the score of the best local alignment between the loaded sequences
* @throws IncompatibleScoringSchemeException If the scoring scheme is not compatible
* with the loaded sequences.
*/
protected int computeScore () throws IncompatibleScoringSchemeException
{
int[] array;
int rows = seq1.length()+1, cols = seq2.length()+1;
int r, c, tmp, ins, del, sub, max_score;
// keep track of the maximum score
max_score = 0;
if (rows <= cols)
{
// goes columnwise
array = new int [rows];
// initiate first column
for (r = 0; r < rows; r++)
array[r] = 0;
// calculate the similarity matrix (keep current column only)
for (c = 1; c < cols; c++)
{
// set first position to zero (tmp hold values
// that will be later moved to the array)
tmp = 0;
for (r = 1; r < rows; r++)
{
ins = array[r] + scoreInsertion(seq2.charAt(c));
sub = array[r-1] + scoreSubstitution(seq1.charAt(r), seq2.charAt(c));
del = tmp + scoreDeletion(seq1.charAt(r));
// move the temp value to the array
array[r-1] = tmp;
// choose the greatest (or zero if all negative)
tmp = max (ins, sub, del, 0);
// keep track of the maximum score
if (tmp > max_score) max_score = tmp;
}
// move the temp value to the array
array[rows - 1] = tmp;
}
}
else
{
// goes rowwise
array = new int [cols];
// initiate first row
for (c = 0; c < cols; c++)
array[c] = 0;
// calculate the similarity matrix (keep current row only)
for (r = 1; r < rows; r++)
{
// set first position to zero (tmp hold values
// that will be later moved to the array)
tmp = 0;
for (c = 1; c < cols; c++)
{
ins = tmp + scoreInsertion(seq2.charAt(c));
sub = array[c-1] + scoreSubstitution(seq1.charAt(r), seq2.charAt(c));
del = array[c] + scoreDeletion(seq1.charAt(r));
// move the temp value to the array
array[c-1] = tmp;
// choose the greatest (or zero if all negative)
tmp = max (ins, sub, del, 0);
// keep track of the maximum score
if (tmp > max_score) max_score = tmp;
}
// move the temp value to the array
array[cols - 1] = tmp;
}
}
return max_score;
}
}
neobio-0.0.20030929/src/neobio/alignment/ScoringMatrix.java 0000644 0002656 0002032 00000032555 07725336634 022364 0 ustar tillea admin /*
* ScoringMatrix.java
*
* Copyright 2003 Sergio Anibal de Carvalho Junior
*
* This file is part of NeoBio.
*
* NeoBio is free software; you can redistribute it and/or modify it under the terms of
* the GNU General Public License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with NeoBio;
* if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307, USA.
*
* Proper attribution of the author as the source of the software would be appreciated.
*
* Sergio Anibal de Carvalho Junior mailto:sergioanibaljr@users.sourceforge.net
* Department of Computer Science http://www.dcs.kcl.ac.uk
* King's College London, UK http://www.kcl.ac.uk
*
* Please visit http://neobio.sourceforge.net
*
* This project was supervised by Professor Maxime Crochemore.
*
*/
package neobio.alignment;
import java.io.Reader;
import java.io.StreamTokenizer;
import java.io.IOException;
/**
* This class implements a scoring scheme based on a substitution matrix. It is useful
* to represent PAM and BLOSUM family of amino acids scoring matrices. Its constructor
* loads such matrices from a file (or any other character stream). The following is an
* extract of a BLOSUM62 scoring matrix file:
*
* A R N D C Q E G H I L K M F P S T W Y V B Z X *
* A 4 -1 -2 -2 0 -1 -1 0 -2 -1 -1 -1 -1 -2 -1 1 0 -3 -2 0 -2 -1 0 -4
* R -1 5 0 -2 -3 1 0 -2 0 -3 -2 2 -1 -3 -2 -1 -1 -3 -2 -3 -1 0 -1 -4
* ...
* B -2 -1 3 4 -3 0 1 -1 0 -3 -4 0 -3 -3 -2 0 -1 -4 -3 -3 4 1 -1 -4
* Z -1 0 0 1 -3 3 4 -2 0 -3 -3 1 -1 -3 -1 0 -1 -3 -2 -2 1 4 -1 -4
* X 0 -1 -1 -1 -2 -1 -1 -1 -1 -1 -1 -1 -1 -1 -2 0 0 -2 -1 -1 -1 -1 -1 -4
* * -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 1
*
Matrices are expected to follow this format. They must have one row an one column * for each defined character (not necessarily in the same order). Each row and column * must start with a distinct character (no repetition) and all row characters must have a * correspondent column, and vice versa.
* *Value at position (i,j) represent the score of substituting character of row i for
* character of column j. Insertion penalties are specified by the last row while deletion
* penalties must be located at the last column (both represented by the special character
* defined by the INDEL_CHAR constant). Note that it only supports an
* additive gap cost function. In case any of this rules are not followed, an
* {@linkplain InvalidScoringMatrixException} exception is raised by the constructor.
If a scoring operation (substitution, insertion or deletion) involves a character * not found in the matrix, an exception is raised.
* * @author Sergio A. de Carvalho Jr. * @see InvalidScoringMatrixException */ public class ScoringMatrix extends ScoringScheme { /** * The character that indicates the row and column for insertion and deletion * penalties in the matrix. */ protected static final char INDEL_CHAR = '*'; /** * The character used to start a comment line in the scoring matrix file. */ protected static final char COMMENT_CHAR = '#'; /** * Stores matrix column headers in the order they were found. */ protected String col_codes; /** * Stores matrix row headers in the order they were found. */ protected String row_codes; /** * Stores values for each operation (substitution, insertion or deletion) defined by * this matrix. */ protected int matrix[][]; /** * Dimension of the (squared) matrix. */ protected int dimension; /** * The maximum absolute score that this matrix can return for any substitution, * deletion or insertion. */ protected int max_absolute_score; /** * Creates a new instance of a substitution matrix loaded from the character stream. * The case of characters is significant when subsequently computing their score. * * @param input character stream from where the matrix is read * @throws IOException if an I/O operation fails when reading from input * @throws InvalidScoringMatrixException if the matrix does not comply with the * specification */ public ScoringMatrix (Reader input) throws IOException, InvalidScoringMatrixException { this (input, true); } /** * Creates a new instance of a substitution matrix loaded from the character stream. * Ifcase_sensitive is true, the case of characters is
* significant when subsequently computing their score; otherwise the case is
* ignored.
*
* @param input character stream from where the matrix is read
* @param case_sensitive true if the case of characters must be
* @throws IOException if an I/O operation fails when reading from input
* @throws InvalidScoringMatrixException if the matrix does not comply with the
* specification
*/
public ScoringMatrix (Reader input, boolean case_sensitive)
throws IOException, InvalidScoringMatrixException
{
super (case_sensitive);
StreamTokenizer in;
StringBuffer buf = new StringBuffer();
int row, col, max_abs = 0;
char c;
// create a stream tokenizer on top of the input
// stream and set the COMMENT_CHAR as the comment character
in = new StreamTokenizer(input);
in.commentChar(COMMENT_CHAR);
// consider ends of line when reading the first row
in.eolIsSignificant(true);
// skip blank lines (if any)
for (in.nextToken(); in.ttype == StreamTokenizer.TT_EOL; in.nextToken());
// read first row: column character codes
while ((in.ttype != StreamTokenizer.TT_EOF) &&
(in.ttype != StreamTokenizer.TT_EOL))
{
if (in.ttype == StreamTokenizer.TT_WORD)
{
if (in.sval.length() > 1)
throw new InvalidScoringMatrixException
("Column headers must have one-character only.");
buf.append(in.sval.charAt(0));
}
else if (in.ttype == INDEL_CHAR)
{
buf.append(INDEL_CHAR);
}
else
{
throw new InvalidScoringMatrixException("Column headers must be " +
"one-character codes or the special character '" + INDEL_CHAR + "'.");
}
in.nextToken();
}
// convert everything to upper case if it's not case sensitive
if (case_sensitive)
col_codes = buf.toString();
else
col_codes = buf.toString().toUpperCase();
dimension = col_codes.length();
// check if there's a column for deletion penalties
if (col_codes.indexOf (INDEL_CHAR) == -1)
throw new InvalidScoringMatrixException
("Matrix have no column for deletion penalties.");
// check if there is at least one character code (besides the INDEL char)
if (dimension < 2)
throw new InvalidScoringMatrixException
("Matrix must have at least one column with a character code.");
// check for repeated column codes
for (int i = 0; i < dimension; i++)
if (col_codes.indexOf(col_codes.charAt(i),i+1) > i)
throw new InvalidScoringMatrixException
("Columns must have distinct one-character codes.");
// allocate matrix
matrix = new int[dimension][dimension];
// reset buffer
buf.delete (0, dimension);
// from now on, ignore ends of line
in.eolIsSignificant(false);
if (in.ttype == StreamTokenizer.TT_EOL) in.nextToken();
// read rest of matrix (one line for each character, but
// not necessarily in the same order as the columns)
for (row = 0; row < dimension && in.ttype != StreamTokenizer.TT_EOF; row++)
{
// start reading the line: the character code must come first
if (in.ttype == StreamTokenizer.TT_WORD)
{
if (in.sval.length() > 1)
throw new InvalidScoringMatrixException
("Codes must have one character only.");
buf.append(in.sval.charAt(0));
}
else if (in.ttype == INDEL_CHAR)
{
buf.append(INDEL_CHAR);
}
else
{
throw new InvalidScoringMatrixException ("Rows must start with an" +
" one-character code or the special character '" + INDEL_CHAR + "'.");
}
// now, the set of values
for (col = 0; col < dimension; col++)
{
// start reading the values
if (in.nextToken() != StreamTokenizer.TT_NUMBER)
throw new InvalidScoringMatrixException
("Invalid value at row " + (row+1) + ", column " + (col+1) + ".");
matrix[row][col] = (int) in.nval;
if (Math.abs(matrix[row][col]) > max_abs)
max_abs = Math.abs(matrix[row][col]);
}
in.nextToken();
}
// convert everything to upper case if it's not case sensitive
if (case_sensitive)
row_codes = buf.toString();
else
row_codes = buf.toString().toUpperCase();
// check if read as many rows as columns
if (row_codes.length() != dimension)
throw new InvalidScoringMatrixException
("Matrix must have as many rows as columns.");
// check if there's a row for insertion penalties
if (row_codes.indexOf(INDEL_CHAR) == -1)
throw new InvalidScoringMatrixException
("Matrix have no row for insertion penalties.");
// check for repeated row codes
for (int i = 0; i < dimension; i++)
if (row_codes.indexOf(row_codes.charAt(i),i+1) > i)
throw new InvalidScoringMatrixException
("Rows must have distinct one-character codes.");
// check if all rows have a corresponding column
for (int i = 0; i < dimension; i++)
if (col_codes.indexOf(c = row_codes.charAt(i)) == -1)
throw new InvalidScoringMatrixException
("There is no corresponding column for row character '" + c + "'.");
// store the maximum absolute value found
this.max_absolute_score = max_abs;
}
/**
* Returns the score of a substitution of character a for character
* b according to this scoring matrix.
*
* @param a first character
* @param b second character
* @return score of a substitution of character a for b
* @throws IncompatibleScoringSchemeException if this substitution is not defined
*/
public int scoreSubstitution (char a, char b)
throws IncompatibleScoringSchemeException
{
int r,c;
if (case_sensitive)
{
r = row_codes.indexOf(a);
c = col_codes.indexOf(b);
}
else
{
r = row_codes.indexOf(Character.toUpperCase(a));
c = col_codes.indexOf(Character.toUpperCase(b));
}
if (r < 0 || c < 0)
throw new IncompatibleScoringSchemeException ("Substitution of character " +
a + " for " + b + " is not defined.");
return matrix[r][c];
}
/**
* Returns the score of an insertion of character a according to this
* scoring matrix.
*
* @param a character to be inserted
* @return score of insertion of a
* @throws IncompatibleScoringSchemeException if this character is not recognised
*/
public int scoreInsertion (char a) throws IncompatibleScoringSchemeException
{
return scoreSubstitution (INDEL_CHAR, a);
}
/**
* Returns the score of a deletion of character a according to this
* scoring matrix.
*
* @param a character to be deleted
* @return score of deletion of a
* @throws IncompatibleScoringSchemeException if this character is not recognised
*/
public int scoreDeletion (char a) throws IncompatibleScoringSchemeException
{
return scoreSubstitution (a, INDEL_CHAR);
}
/**
* Tells whether this scoring scheme supports partial matches, which it does, although
* a particular scoring matrix loaded by this instace might not. A partial match is
* a situation when two characters are not equal but, for any reason, are regarded
* as similar by this scoring scheme, which then returns a positive score value. This
* is common for amino acid scoring matrices.
*
* @return always return true
*/
public boolean isPartialMatchSupported ()
{
return true;
}
/**
* Returns the maximum absolute score that this scoring scheme can return for any
* substitution, deletion or insertion.
*
* @return maximum absolute score that can be returned
*/
public int maxAbsoluteScore ()
{
return max_absolute_score;
}
/**
* Returns a String representation of this scoring matrix.
*
* @return a String representation of this scoring matrix
*/
public String toString ()
{
int row, col;
StringBuffer buf = new StringBuffer();
// column numbers
buf.append("Scoring matrix:\n\t");
for (col = 0; col < dimension; col++)
{
buf.append("\t" + col);
}
buf.append("\n\t");
// column headers
for (col = 0; col < dimension; col++)
{
buf.append('\t');
buf.append(col_codes.charAt(col));
}
// rest of matrix
for (row = 0; row < dimension; row++)
{
// row number and code
buf.append("\n" + row + "\t" + row_codes.charAt(row));
for (col = 0; col < dimension; col++)
{
buf.append('\t');
buf.append(matrix[row][col]);
}
}
return buf.toString();
}
}
neobio-0.0.20030929/src/neobio/alignment/OutMatrix.java 0000644 0002656 0002032 00000012466 07724676562 021534 0 ustar tillea admin /*
* OutMatrix.java
*
* Copyright 2003 Sergio Anibal de Carvalho Junior
*
* This file is part of NeoBio.
*
* NeoBio is free software; you can redistribute it and/or modify it under the terms of
* the GNU General Public License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with NeoBio;
* if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307, USA.
*
* Proper attribution of the author as the source of the software would be appreciated.
*
* Sergio Anibal de Carvalho Junior mailto:sergioanibaljr@users.sourceforge.net
* Department of Computer Science http://www.dcs.kcl.ac.uk
* King's College London, UK http://www.kcl.ac.uk
*
* Please visit http://neobio.sourceforge.net
*
* This project was supervised by Professor Maxime Crochemore.
*
*/
package neobio.alignment;
/**
* Implements an interface to the OUT matrix of a block. This class is used by the
* {@linkplain CrochemoreLandauZivUkelson} and subclasses to enconde the OUT matrix
* from the input border and DIST matrix of an {@linkplain AlignmentBlock}.
*
* The OUT matrix defined as OUT[i,j] = I[i] + DIST[i,j] where I is the
* input border array and DIST is the DIST matrix.
The output border of a block is computed from the OUT matrix by taking the maximum * value of each column. Note that this class does not compute the OUT matrix, it * just stores the necessary information to retrieve a value at any position of the * matrix.
* *It implements the Matrix interface so that the SMAWK algorithm can be used to * compute its column maxima.
* *For more information on how this class is used, please refer to the specification
* of the
This class is the internal frame of NeoBio's graphical interface for computing pairwise
sequence alignments using one of the the algorithms provided in the neobio.alignment package.
About screen.
See:
Graphical user interface tools to run the algorithms provided by other packages.
This class is a simple GUI utility for computing pairwise sequence alignments using one
of the the algorithms provided in the neobio.alignment package.
This class is a simple command line based utility for generating random sequences with
optimal LZ78 factorisation.
The main method takes three parameters from the command line to generate a
sequence: CrochemoreLandauZivUkelson and its subclasses.
*
* @author Sergio A. de Carvalho Jr.
* @see CrochemoreLandauZivUkelson
* @see CrochemoreLandauZivUkelsonGlobalAlignment
* @see CrochemoreLandauZivUkelsonLocalAlignment
* @see AlignmentBlock
* @see Smawk
*/
public class OutMatrix implements Matrix
{
/**
* The length of the longest sequence (number of characters) being aligned. It needs
* to be set only once per alignment.
*/
protected int max_length;
/**
* The maximum absolute score that the current scoring scheme can return. It needs
* to be set only once per alignment.
*/
protected int max_score;
/**
* The DIST matrix of a block.
*/
protected int[][] dist;
/**
* The input border of a block.
*/
protected int[] input_border;
/**
* The dimension of the OUT matrix.
*/
protected int dim;
/**
* The number of columns of the block.
*/
protected int lc;
/**
* Initialised this OUT matrix interface. This method needs to be executed only once
* per alignment.
*
* @param max_length the length of the longest sequence (number of characters) being
* aligned
* @param max_score the maximum absolute score that the current scoring scheme can
* return
*/
public void init (int max_length, int max_score)
{
this.max_length = max_length;
this.max_score = max_score;
}
/**
* Sets this interface's data to represent an OUT matrix for a block. This method
* is typically executed once for each block being aligned.
*
* @param dist the DIST matrix
* @param input_border the input border
* @param dim the dimension of the OUT matrix
* @param lc the number of columns of the block
*/
public void setData (int[][] dist, int[] input_border, int dim, int lc)
{
this.dist = dist;
this.input_border = input_border;
this.dim = dim;
this.lc = lc;
}
/**
* Returns the value at a given position of the matrix. In general it returns the
* value of DIST[col][row] + input_border[row]. However, special cases
* occur for its upper right and lower left triangular parts.
*
* @param row row index
* @param col column index
* @return the value at row row, column col of this OUT
* matrix
*/
public int valueAt (int row, int col)
{
// The DIST matrix is indexed by [column][row]
if (col < lc)
{
if (row < dim - (lc - col))
return dist[col][row] + input_border[row];
else
// lower left triangle entries
return - (max_length + row + 1) * max_score;
}
else if (col == lc)
{
return dist[col][row] + input_border[row];
}
else
{
if (row < (col - lc))
// upper right triangle entries
return Integer.MIN_VALUE + row;
else
return dist[col][row - (col - lc)] + input_border[row];
}
}
/**
* Returns the number of rows of this OUT matrix.
*
* @return the number of rows of this OUT matrix
*/
public int numRows ()
{
return dim;
}
/**
* Returns the number of columns of this OUT matrix.
*
* @return the number of columns of this OUT matrix
*/
public int numColumns ()
{
return dim;
}
}
neobio-0.0.20030929/license.txt 0000644 0002656 0002032 00000043131 07627203426 015054 0 ustar tillea admin GNU GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1989, 1991 Free Software Foundation, Inc.
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users. This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it. (Some other Free Software Foundation software is covered by
the GNU Library General Public License instead.) You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have. You must make sure that they, too, receive or can get the
source code. And you must show them these terms so they know their
rights.
We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.
Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software. If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.
Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary. To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.
The precise terms and conditions for copying, distribution and
modification follow.
GNU GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License. The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language. (Hereinafter, translation is included without limitation in
the term "modification".) Each licensee is addressed as "you".
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.
1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.
You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.
2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) You must cause the modified files to carry prominent notices
stating that you changed the files and the date of any change.
b) You must cause any work that you distribute or publish, that in
whole or in part contains or is derived from the Program or any
part thereof, to be licensed as a whole at no charge to all third
parties under the terms of this License.
c) If the modified program normally reads commands interactively
when run, you must cause it, when started running for such
interactive use in the most ordinary way, to print or display an
announcement including an appropriate copyright notice and a
notice that there is no warranty (or else, saying that you provide
a warranty) and that users may redistribute the program under
these conditions, and telling the user how to view a copy of this
License. (Exception: if the Program itself is interactive but
does not normally print such an announcement, your work based on
the Program is not required to print an announcement.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.
In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:
a) Accompany it with the complete corresponding machine-readable
source code, which must be distributed under the terms of Sections
1 and 2 above on a medium customarily used for software interchange; or,
b) Accompany it with a written offer, valid for at least three
years, to give any third party, for a charge no more than your
cost of physically performing source distribution, a complete
machine-readable copy of the corresponding source code, to be
distributed under the terms of Sections 1 and 2 above on a medium
customarily used for software interchange; or,
c) Accompany it with the information you received as to the offer
to distribute corresponding source code. (This alternative is
allowed only for noncommercial distribution and only if you
received the program in object code or executable form with such
an offer, in accord with Subsection b above.)
The source code for a work means the preferred form of the work for
making modifications to it. For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable. However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.
If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.
4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License. Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.
5. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Program or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.
6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all. For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.
If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded. In such case, this License incorporates
the limitation as if written in the body of this License.
9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation. If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.
10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission. For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this. Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.
NO WARRANTY
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
>gi|21326584|ref|NC_003977.1| Hepatitis B virus, complete genome
Length = 3215
Score = 24.6 bits (29), Expect = 0.96
Identities = 21/26 (80%), Gaps = 1/26 (3%)
Strand = Plus / Plus
Query: 4802 ttcattttt-caaaaatcctcacaat 4826
||| | || ||| ||||||||||||
Sbjct: 212 ttcttgttgacaagaatcctcacaat 237
Score = 23.8 bits (28), Expect = 1.7
Identities = 15/16 (93%)
Strand = Plus / Plus
Query: 6939 ccagttttcttttgtc 6954
||| ||||||||||||
Sbjct: 803 ccaattttcttttgtc 818
Score = 22.2 bits (26), Expect = 5.0
Identities = 13/13 (100%)
Strand = Plus / Minus
Query: 6887 tattaataatgtc 6899
|||||||||||||
Sbjct: 2577 tattaataatgtc 2565
Lambda K H
0.549 0.333 0.549
Gapped
Lambda K H
0.549 0.333 0.549
Matrix: blastn matrix:2 -2
Gap Penalties: Existence: 3, Extension: 2
Number of Hits to DB: 13
Number of Sequences: 0
Number of extensions: 13
Number of successful extensions: 3
Number of sequences better than 10.0: 1
Number of HSP's better than 10.0 without gapping: 1
Number of HSP's successfully gapped in prelim test: 0
Number of HSP's that attempted gapping in prelim test: 0
Number of HSP's gapped (non-prelim): 3
length of query: 3215
length of database: 7478
effective HSP length: 27
effective length of query: 3188
effective length of database: 7451
effective search space: 23753788
effective search space used: 23753788
T: 0
A: 0
X1: 13 (10.3 bits)
X2: 37 (29.3 bits)
S1: 29 (24.6 bits)
S2: 25 (21.4 bits)
neobio-0.0.20030929/data/dna14a.txt 0000644 0002656 0002032 00000003244 07710231022 015376 0 ustar tillea admin TCGGCTGTATTGGCGACCCAGGCGTGGGCTTAATGAATCAGAGACTCTGCAGCCAGGGAGTATGTATAGCAGTTCTTTAAACGGTCTGCGACGAGGAAGGTTTCGAGTGTGCAACGTGAGGCTATCGTAAAAGTGTTTCAACAGATGGGGGGCTATGAGCCGCTCGAACGTTACACACTGCACGCGGGGTCGACTAATGGAAGCTAACCTAAGCTAATTGCCCTATTCGTGAAGAAACATCTAATTCCTTCCTTGTATGTGTTCTCCCTACAGCACATATCGACAATAGGTTTTAGTGCTTTACCACAAGTAGCAAGTACAACTTGAATTGGGTAAGACTTGCACTTCATGTATTTGAAATCGCTATCCCACGACTTGGTGTCAACCCCCGGCTCTTTATCACCTTGCATACCCAGCGGCATCAAGTGACCGACATATGATCTGGTAGTAGTTCAACCCTGAAGACTATCTTTAGCTCAGCGCGTTAAGTCCTTATACACTCTAGCGAGTGGGAAGGATGGATCGGCCGGACATCGTACGTAATTTAGAACCCAGTACCGAGACGCGTTCGACAGTCCTAAGGCTCCATCAGAGTAGCTTACTACGTCACGAGTCAGGTAAAGCCGAGAGCGTCCGATCCATCCTTGGTGGATCAGCGTTCTCTGTTGTTGAACGCGAGGTAAACGTTGGTAACTTTTTCAACAGCAGTAGAGTAGCGTGTAGTTACTCGGAGATCGACGTAACTGCGCGCCCTGCAACACTAAGCGCTGCGCTGTCTGCTGCGCAGACTCTATGAGAGTCGCTCGTCTCCGTCTGCTTAGGGGGCGTTAGCACACTAATCACGGCTCAAATATGTTAAAGAAGGAGCCCCATTTCCGTGACGTCAGTACGAGCAATTTACGATGGCAAAGAGAGCAAGACCTTCGCGCAGGGTACGGACCTGACAGCATGGGTTATCAAGGCCCTTTCCAGGTAATAAATTTCAGATTTAGTACTTATCATGTAGATAAGTTGGAAACCTTGACGGTCCAACAAAGATACGACCTGCAGTTTTATAAGTCGTTCAGTTCGGTGGGCAAGGTGCGGGTGGTCCGGGAAGATAGTAGCAGGTTGGATTTGGCAACTGACCTCGCATCCGCGTTAGCCTCGGCAGGTCAGTATACGCAATACCGTCTGACGCGTCGATTAGACGCAATACCAAAAAAAGGGTCATCAGAACTTTGAGAAATTAAAGAAATAGTATCCCACTCTATGGCGTTTCAGGCACAGAATCTTTCGGTTCACGCAAAACCGAGCAACTACTTGGAATGATGTTCGCGCAAGCACGGCTCCATATAATAGATGGTTTTGCGACACTCGCAATGAGGACAAGAGTCTCCATCGCATATCACCTGGGGAACCAGTGGGCGAGCATTCCTTCTCGCCAGGCAAGAGCCAGAATAGGGCTCGACAACAAAGCCCCTCTCAACTAGCCCCAATATGTTATACACAGCCTTTACAAATGGAGGCCCATCAGTATCATAATTAGCGGAATGACTCCCGAATCCAAAGCCGAGGGTGAGATCAGACGCGTCACTAGGTGAGTTTGGAGCTTCTTTTAGTGAGCCTATTTGTAGCCGTCCCAACGGGTCGCGACGATCCTCAAGCTTCTATTAATTTACCCAATCCCCCCATGCTTCCCTGTGAAGCATAATTTAGTG neobio-0.0.20030929/data/dna11b.txt 0000644 0002656 0002032 00000004222 07705606332 015407 0 ustar tillea admin >gi|1786181|gb|AE000111.1|AE000111 Escherichia coli K-12 MG1655
ACCCATAACGGGCAATGATAAAAGGAGTAACCTGTGAAAAAGATGCAATCTATCGTACTCGCACTTTCCCTGGTTCTGGT
CGCTCCCATGGCAGCAGAGGCTGCGGAAATTACGTTAGTCCCGTCAGTAAAATTACAGATAGGCGATCGTGATAATCGTG
GCTATTACTGGGATGGAGGTCACTGGCGCGACCACGGCTGGTGGAAACAACATTATGAATGGCGAGGCAATCGCTGGCAC
CTACACGGACCGCCGCCACCGCCGCGCCACCATAAGAAAGCTCCTCATGATCATCACGGCGGTCATGGTCCAGGCAAACA
TCACCGCTAAATGACAAATGCCGGGTAACAATCCGGCATTCAGCGCCTGATGCGACGCTGGCGCGTCTTATCAGGCCTAC
GTTAATTCTGCAATATATTGAATCTGCATGCTTTTGTAGGCAGGATAAGGCGTTCACGCCGCATCCGGCATTGACTGCAA
ACTTAACGCTGCTCGTAGCGTTTAAACACCAGTTCGCCATTGCTGGAGGAATCTTCATCAAAGAAGTAACCTTCGCTATT
AAAACCAGTCAGTTGCTCTGGTTTGGTCAGCCGATTTTCAATAATGAAACGACTCATCAGACCGCGTGCTTTCTTAGCGT
AGAAGCTGATGATCTTAAATTTGCCGTTCTTCTCATCGAGGAACACCGGCTTGATAATCTCGGCATTCAATTTCTTCGGC
TTCACCGATTTAAAATACTCATCTGACGCCAGATTAATCACCACATTATCGCCTTGTGCTGCGAGCGCCTCGTTCAGCTT
GTTGGTGATGATATCTCCCCAGAATTGATACAGATCTTTCCCTCGGGCATTCTCAAGACGGATCCCCATTTCCAGACGAT
AAGGCTGCATTAAATCGAGCGGGCGGAGTACGCCATACAAGCCGGAAAGCATTCGCAAATGCTGTTGGGCAAAATCGAAA
TCGTCTTCGCTGAAGGTTTCGGCCTGCAAGCCGGTGTAGACATCACCTTTAAACGCCAGAATCGCCTGGCGGGCATTCGC
CGGCGTGAAATCTGGCTGCCAGTCATGAAAGCGGGCGGCGTTGATACCCGCCAGTTTGTCGCTGATGCGCATCAGCGTGC
TAATCTGCGGAGGCGTCAGTTTCCGCGCCTCATGGATCAACTGCTGGGAATTGTCTAACAGCTCCGGCAGCGTATAGCGC
GTGGTGGTCAACGGGCTTTGGTAATCAAGCGTTTTCGCAGGTGAAATAAGAATCAGCATATCCAGTCCTTGCAGGAAATT
TATGCCGACTTTAGCAAAAAATGAGAATGAGTTGATCGATAGTTGTGATTACTCCTGCGAAACATCATCCCACGCGTCCG
GAGAAAGCTGGCGACCGATATCCGGATAACGCAATGGATCAAACACCGGGCGCACGCCGAGTTTACGCTGGCGTAGATAA
TCACTGGCAATGGTATGAACCACAGGCGAGAGCAGTAAAATGGCGGTCAAATTGGTAATAGCCATGCAGGCCATTATGAT
ATCTGCCAGTTGCCACATCAGCGGAAGGCTTAGCAAGGTGCCGCCGATGACCGTTGGAAGGTGCAGATCCGCAAACACCA
GATCGCTTTAGGGTTGTTCAGGCGTAAAAAGAAGAGATTGTTTTCGGCATAAATGTAGTTGGCAACGATGGAGCTGAAGG
CAAACAGAATAACCACAAGGGTAACAAACTCAGCACCCCAGGAACCCATTAGCACCCGCATCGCCTTCTGGATAAGCTGA
ATACCTTCCAGCGGCATGTAGGTTGTGCCGTTACCCGCCAGTAATATCAGCATGGCGCTTGCCGTACAGATGACCAGGGT
GTCGATAAAAATGCCAATCATCTGGACAATCCCTTGCGCTGCCGGATGCGGAGGCCAGGACGCCGCTGCCGCTGCCGCGT
TTGGCGTCGAACCCATTCCCGCCTCATTGGAAACATACTGCGCTGAATTTTAACCGTTAGTAATCGCCTGGCTTAAGGTA
TATCCCGCCGCGCCGCCTGCCGCTTCCTGCCAGCCAAAAGCACTCTCAAAAATGACCAAATGACGTGGGGAAGTTGCCC neobio-0.0.20030929/data/dna26a.txt 0000644 0002656 0002032 00000000012 07714476442 015414 0 ustar tillea admin BXNXYTQDCL neobio-0.0.20030929/data/human_chromosome_y.txt 0000644 0002656 0002032 00000302705 07721467504 020247 0 ustar tillea admin >gi|13626247|ref|NT_025975.2|HsY_26131 Homo sapiens chromosome Y genomic contig
GAATTCCATTCCATTCCAATCCATTCCTTTCCTTTCGCTTGCATTCCATTCTATTCTCTTCTACTGCATA
CAATTTCACTCCATTCGTTCCCATTCCATTCAATTCCATTCCATTCAATTCCATTCCATTTGTTTCCATT
CTCTTCGATTCCATTTCTTTATATTCCATGCCATTCGATTCCATTCTATTGGGTTGCATTACATTCGTGT
TCATTCCATTCCAGACCATTCCATTTGACTCCATTCCTTTCGAGCCCTTTCAATTTGAGTCCATTCCTTT
CCAGTCCATTTCACTCCAGTCCATTACTATCCATTCCATACCATTCCATCCCATTCCATTACATTCCATT
CCATTACATTCCATTCCATTCCATTCCATTGCATTCCATTCCATTCCATTCCATTGCACTGCACTCCATT
CCATTACATTCTACTCTATCTGAGTCGATTTTATTGCATTAGATTCTATTCCATTGGATTACTTTCCATT
CGATTACATTCCATTCATGTACATTCCATTCCAGTCAATTACATTCGAGTTCATTACGTTACATTCCAGT
ATATTCCATTGTATTCGATCCCATTCCTTTCAATTCCATTTCATTCGACTCCATTATATTCAATTCCATT
CCACTCGAATCCATTCCATTAGAGGACATTCCATTCCAATGCATTCCATTCCATTCCATAGCATTCCATT
GCATTCGATTCCATTCCATTTGATGCCATTCCATTTGATGCAATCCCATGACATTCCATTCCATTCGAGT
CCATTCCGTTCCAATTCATTCCATTCCGTTTCATGAAATTCGAGTCCTTTCCAGTACATTTCATTCCAAT
CCCATCCAATCCCATCTACTCCATTCAATTCCTTTCCATTCCATTTGATTTGATTCCATTGATTTGATTC
CATTCAGTTTGATTCCATTCCGTGAAATTTCGTTCCATTCTATTCCATTGCATTACTTTCCATTCAATTC
CATTCCATTTCATTTCAGTCCATTCGCTTCCTTTCCTTTCGATTCAATTCCATTTGATTCCACTCCATTC
TATGCGATTTCATTCCAATCGATTCAATTCCATTCGATGACATTCCTTTCGTTTCCATTCCATTCGAGTC
CATTTAATTTGAGCATTCGTGTCCGTTCTATTCGAGTCCATTCCATTACAGTCTATTCTATTCCCTTCCA
TTCGTGTTGATTCAATTTCATTCCCTTCCATTCGATTCCTTTCCATTCGATTCCATTCCTTTCCATTCCA
TTCCATTCGTTCCCATTCCATGTGATTTCATTCCATTCCAGTCCATTATATTCGAGTCCACTCCACTCCA
TTCTATTACATTCAATTCCTTTTGAGTCCGTTCCATAACACTCCATTCATTTCGATTCCATTTCTTGCCA
GTTTTCTTCCATTTTATTCCATTCCGTTCGATTCCATTCCATTCGATTGCATTCCATTCGAATCCTTTCC
ATTCCATTTCATTCCATTCCTTTCTATTCCATTCCATTTCATTCGATTTGATTCCATTCTGTTCTATTCC
ATTCAATTCTTTTTCATTCCATTCGAATCCTTTCTATTGCAGTCCATTCCATTCGAGTCCATTCCAATCC
CTTCCATTCCATTCCATTACAGTCCATTCCAATAGATTCCATTCCTTTGCCTTCCATTCGAATCCATTCC
ATTCTAGTCCATTCCATTTGAGTCAATTCCATTCCATTCCATTCTATTCCTTTCCAATCCATTCGATTCC
ATTCGATTCAATTCCATTTGATTCTCTTTCATTCTATTTTATTCCATGCCATTTGATTGCATTGCATTCC
ATTCCGTTTGATTCCAGTCCATCCAAGAAAGTTCCATTCCAGTCCAGTGCTTTCCAGTCCATTCCATTCC
ACTCTAGTCTATTCCACTCCATTCCCTTCCATTGCATTCCATACTATTCCATTCCATTCCTTTGCATTCC
GTTTACAATCTATTCGAGTCCATTGCATTCCAGTCCAATCCATTCGATTACATTCCTTTTGATTCCCTGC
CAGTCGATTGCATTGCATACTACACCATTCCAAAGGAGTTCATTCCATTCTATCTCCACACTTTCCATTC
CACTCTGTTTGAGTCCATTCCATTCCAGTCCATTTAATTCAAGGGCATTCCATTCCATTCCATTCCATTC
CATTTCATATTATTCCATTCCATTCAATTCCATTCCAGATGATTCCATTCCATTCTATACCATTGCTCTC
TGTTCCATTCCATTCCATCTGTCTCCATTCCTTTCGTTTCGATTCCTTTCCATTCCATTCCATTACATTT
GATCCTATTTTATTAAATTGCATTCTATTCGAGTGATTTCCATTCGAGTCCTTTCCATTCGATTCCATTC
CATTCTATTCCATTCCTTTGGATTCCATTCCATTCCGTTCCGTTCACATCAATTCCTGGCGATTCCATTA
CATTCGATTTCTTGCCATTCGATTCCATTCCTTTTGACTCCATTTCATTCGATTCCATTCCATTCCATTA
ATTTCCATTCCATTCGAGACCTTTCCATTGCAGTCTTTTCCCTTCGAGTCCATTCCGTTCGATTCCATTC
CGTTCGATTCCCTTCCATTCGATTCCATTCCATTGGAGTCCGTACCAGTCGAGTCCATTCTATTCCAGTC
CATTAGTTTCGACTCCATTGCATTCGAGTGCATTCCATTCCGTGGCTGTCCATTCCATTCCGTTTGATGC
CATTCCATACGATTCCATTCAATTCGAGACCATTCTATTCCTGTCCATTCCTTGTGGTTCGATTCCATTT
CACTCTAGTCCATTCCATTCCATTCAATTCCATTCGACTCTATTCCGTTCCATTCAATTCCATTCCATTC
GATTCCATTTTTTTCGAGAACCTTCCATTACACTCCCTTCCATTCCAGTGCATTCCATTCCAGTCTCTTC
AGTTCGATTCCATTCCATTCGTTTCGATTCCTTTCCATTCCAGCCCATTCCATTCCATTCCATTCCTTTC
CTTTCCGTTTCATTAGATTCCATTGCATTCCATTCCATTCAATTCAATTCCGTGCTATTCAATTTGATTC
ATTTCCATTTAATTCCATTCCATTAGATTCCATTCCGTACGATTCCATTCCTTTTGAATCCATTCCATTG
GAGTCCATTCACTTCCAGAACATTCCATTCCAGTCGAATCCATTCGAGTACATTCCATTAAAGTTCATTA
CATTCTAATACATTCCATTCCATTGCATTCCATTCCATTCCATTCGATGCCATTCGATTCCATTCCATGC
CAAATCATTGCATTCCTTTCCATTCCGTTCCTATCAATTCCATTCCATTCGATTTAGTTCGATTCTATTC
ACTTCCATTCCATTCGATTCCATTCCATTGGAGTCAATTCCTTTCGACACCCAGCCTTTCCAGTCAATGA
TTTTGGATTCCATTTTTTTGCATTCCATTACATTCTATGACATTCGATTCCGTTTCATTGCATTCCATTC
CATACATTTTTATTCCATTCGAGACCGTAGCATTCCACTTTATTCCAGGCCTGTCCATTACACTACATTC
CCTTCCATTCCAATGAATTCCATTCCATTCCAATCCATTCCTTTCCTTTCGCTTGCATTCCATTCTATTC
TCTTCTACTGCATACAATTTCACTCCATTCGTTCCCATTCCATTCAATTCCATTCCATTCAATTCCATTC
CATTTGTTTCCATTCTCTTCGATTCCATTTCTTTATATTCCATGCCATTCGATTCCATTCTATTGGGTTG
CATTACATTCGTGTTCATTCCATTCCAGACCATTCCATTTGACTCCATTCCTTTCGAGACCTTTCAATTT
GAGTCCATTCCTTTCCAGTCCATTTCACTCCAGTCCATTACTATCCATTCCATACCATTCCATCCCATTC
CATCTCATTCCATTCCATTCCATTCCATTCCATTCCATTCCATTCCATTGCATTCATTCCCATTCCATTC
ATTGCACTGCACTCCATTCCATTACATTCTACTCTATCTGAGTCGATTTTATTGCATTAGATTCTATTCC
ATTGGATTACTTTCCATTCGATTACATTCCATTCATGTACATTCCATTCCAGTCAATTACATTCGAGTTC
ATTACATTACATTCCAGTATATTCCATTGTATTCGATCCCATTCCTTTCAATTCCATTTCATTCGACTCC
ATTATATTCAATTCCATTCCACTCGAATCCATTCCATTAGAGGACATTCCATTCCAATGCATTCCATTCC
ATTCCATAGCATTCCATTGCATTCGATTCCATTCCATTTGATGCCATTCCATTTGATGCCATCCCATGAC
ATTCCATTCCATTCGAGTCCATTCCGTTCCAATTCATTCCATTCCGTTTCATGAAATTCGAGTCCTTTCC
AGTACATTTCATTCCAATCCCATCCAATCCCATCTACTCCATTCAATTCCTTTCCATTCCATTTGATTTG
ATTCCATTGATTTGACTCCATTCAGTTTGATTCCATTCCGTGAAATTTCGTTCCATTCTATTCCATTGCA
TTACTTTCCATTCAATTCCATTCCATTTCATTTCAGTCCATTCGCTTCCTTTCCTTTCGATTCAATTCCA
TTTGATTCCACTCCATTCTATGCGATTTCATTCCAATCGATTCAATTCCATTCGATGACATTCCTTTCGT
TTCCATTCCATTCGAGTCCATTTAATTTGAGCATTCGTGTCCGTTCTATTCGAGTCCATTCCATTACAGT
CTATTCTATTCCCTTCCATTCGTGTTGATTCAATTTCATTCCCTTCCATTCGATTCCTTTCCATTCGATT
CCATTCCTTTCCATTCCATTCCATTCGTTCCCATTCCATGTGATTTCATTCCATTCCAGTCCATTATATT
CGAGTCCACTCCACTCCATTCTATTACATTCAATTCCTTTTGAGTCCGTTCCATAACACTCCATTCATTT
CGATTCCATTTCTTGCCAGTTTTCTTCCATTTTATTCCATTCCGTTCGATTCCATTCCATTCGATTGCAT
TCCATTCGAATCCTTTCCATTCCATTTCATTCCATTCCTTTCTATTCCATTCCATTTCATTCGATTTGAT
TCCATTCTGTTCTATTCCATTCAATTCTTTTTCATTCCATTCGAATCCTTTCTATTGCAGTCCATTCCAT
TCGAGTCCATTCCAATCCCTTCCATTCCATTCCAATAGATTCCATTCCTTTGCCTTCCATTCGAATCCAT
TCCATTCTAGTCCATTCCATTTGAGTCAATTCCATTCCATTCCATTCTATTCCTTTCCAATCCATTCGAT
TCCATTCGATTCAATTCCATTTGATTCTCTTTCATTCTAATTTATTCCATGCCATTTGATTGCATTGCAT
TCCATTCCGTTTGATTCCAGTCCATCCAAGAAAGTTCCATTCCAGTCCATTGCTTTCCAGTCCATTCCAT
TCCACTCTAGTCTATTCCACTCCATTCCCTTCCATTGCATTCCATACTATTCCATTCCATTCCTTTGCAT
TCCGTTTCCAATCTATTCGAGTCCATTGCATTCCAGTCCAATCCATTCGATTACATTCCTTTTGATTCCC
TGCCAGTCGATTGCATTGCATACTACACCATTCCAAAGGAGTTCACTCCATTCTATCTCCACACTTTCCA
TTCCACTCTGTTTGAGTCCATTCCATTCCAGTCCATTTAATTCAAGGGCATTCCATTCCATTCCATTCCA
TTCCATTTCATATTATTCCATTCCATTCAATTCCATTCCAGATGATTCCATTCCGTTCTATACCATTGCT
CTCTGTTCCATTCCATTCCATCTGTCTCCATTCCTTTCGTTTCGATTCCTTTCCATTCCATTCCATTACA
TTTGATCCTATTTTATTAAATTGCATTCTATTCGAGTGATTTCCATTCGAGTCCTTTCCATTCGATTCCA
TTCCATTCTATTCCATTCCTTTGGATTCCATTCCATTCCGTTCCGTTCACATCAATTCCTGGCGATTCCA
TTACATTCGATTTCTTGCCATTCGATTCCATTCCTTTTGACTCCATTTCATTCGATTCCATTCCATTCCA
TTAATTTCCATTCCATTCGAGACCTTTCCATTGCAGTCTTTTCCCTTCGAGTCCATTCCGTTCGATTCCC
TTCCATTCGATTCCATTCCATTGGAGTCCGTACCAGTCGAGTCCATTCTATTCCAGTCCATTAGTTTCGA
CTCCATTGCATTCGAGTGCATTCCATTCCGTGGCTGTCCATTCCATTCCGTTTGATGCCATTCCATACGA
TTCCATTCAATTCGAGACCATTCTATTCCTGTCCATTCCTTGTGGTTCGATTCCATTTCACTCTAGTCCA
TTCCATTCCATTCAATTCCATTCGACTCTATTCCGTTCCATTCAATTCCATTCCATTCGATTCCATTTTT
TTCGAGAACCTTGCATTACACTCCCTTCCATTCCAGTGCATTCCATTCCAGTCTCTTCACTTCGATTCCA
TTCCATTCGTTTCGATTCCTTTCCATTCCAGCCCATTCCATTCCATTCCATTCCTTTCCTTTCCGTTTCA
TTAGATTCCATTGCATTCCATTCCATTCAATTCAATTCCGTGCTATTCAATTTGATTCATTTCCATTTAA
TTCCATTCCATTAGATTCCATTCCGTACGATTCCATTCCTTTTGAATCCATTCCATTGGAGTCCATTCAC
TTCCAGAACATTCCATTCCAGTCGAATCCATTCGAGTACATTCCATTAAAGTTCATTACATTCTAATACA
TTCCATTCCATTGCATTCCATTCCATTCCATTCGATGCCATTCGATTCCATTCCATGCCAAATCATTGCA
TTCCTTTCCATTCCGTTCCTATCAATTCCATTCCATTCGATTTAGTTCGATTCTATTCACTTCCATTCCA
TTCGATTCCATTCCATTGGAGTCAATTCCTTTCGACACCCAGCCTTTCCAGTCAATGATTTTGGATTCCA
TTTTTTTGCATTCCATTACATTCTATGACATTCGATTCCGTTTCATTGCATTCCATTCCATACATTTTTA
TTCCATTCGAGACCGTAGCATTCCACTTTATTCCAGGCCTGTCCATTACACTACATTCCCTTCCATTCCA
ATGAATTCCATTCCATTCCAATCCATTCCTTTCCTTTCGCTTGCATTCCATTCTATTCTCTTCTACTGCA
TACAATTTCACTCCATTCGTTCCCATTCCATTCAATTCCATTCCATTCAATTCCATTCCATTTGTTTCCA
TTCTCTTCGATTCCATTTCTTTATATTCCATGCCATTCGATTCCATTCTATTGGGTTGCATTACATTCGT
GTTCATTCCATTCCAGACCATTCCATTTGACTCCATTCCTTTCGAGCCCTTTCAATTTGAGTCCATTCCT
TTCCAGTCCATTTCACTCCAGTCCATTACTATCCATTCCATACCATTCCATCCCATTCCATTCCATTCCA
TTCCATTCCATTCCATTCCATTCCATTGCATTCCATTCCATTCCATTCCATTGCACTGCACTCCATTCCA
TTACATTCTACTCTATCTGAGTCGATTTTATTGCATTAGATTCTATTCCATTGGATTACTTTCCATTCGA
TTACATTCCATTCATGTACATTCCATTCCAGTCAATTACATTCGAGTTCATTACGTTACATTCCTGTATA
TTCCATTGTATTCGATCCCATTCCTTTCAATTCCATTTCATTCGACTCCATTATATTCAATTCCATTCCA
CTCGAATCCATTCCATTAGAGGACATTCCATTCCAATGCATTCCATTCCATTCCATAGCATTCCATTGCA
TTCGATTCCATTCCATTTGATGTCATTCCATTTGATGCCATCCCATGACATTCCATTCCATTCGAGTCCA
TTCCGTTCCAATTCATTCCATTCCGTTTCATGAAATTCGAGTCCTTTCCAGTACATTTCATTCCAATCCC
ATCCAATCCAATCTACTCCATTCAATTCCTTTCCATTCCATTTGATTTGATTCCATTGATTTGATTCCAT
TCAGTTTGATTCCATTCCGTGAAATTTCGTTCCATTCTATTCCATTGCATTACTTTCCATTCAATTCCAT
TCCATTTCATTTCAGTCCATTCGCTTCCTTTCCTTTCGATTCAATTCCATTTGATTCCACTCCATTCTAT
GCGATTTCATTCCAATCGATTCAATTCCATTCGATGACATTCCTTTCGTTTCCATTCCATTCGAGTCCAT
TTAATTTGAGCATTCGTGTCCATTCTATTCGAGTCCATTCCATTACAGTCTATTCTATTCCCTTCCATTC
GTGTTGATTCAATTTCATTCCCTTCCATTCGATTCCTTTCCATTCGATTCCATTCCTTTCCATTCCATTC
CATTCGTTCCCATTCCATGTGATTTCATTCCATTCCAGTCCATTATATTCGAGTCCACTCCACTCCATTC
TATTACATTCAATTCCTTTTGAGTCCGTTCCATAACACTCCATTCATTTCGATTCCATTTCTTGCCAGTT
TTCTTCCATTTTATTCCATTCCGTTCGATTCCATTCCATTCGATTGCATTCCATTCGAATCCTTTCCATT
CCATTTCATTCCATTCCTTTCTATTCCATTCCATTTCATTCGATTTGATTCCATTCTGTTCTATTCCATT
CAATTCTTTTTCATTCCATTCGAATCCTTTCTATTGCAGTCCATTCCATTCGAGTCCATTCCAATCCCTT
CCATTCCATTCCAATAGATTCCATTCCTTTGCCTTCCATTCGAATCCATTCCATTCTAGTCCATTCCATT
TGAGTCAATTCCATTCCATTCCATTCTATTCCTTTCCAATCCATTCGATTCCATTCGATTCAATTCCATT
TGATTCTCTTTCATTCTATTTTATTCCATGCCATTTGATTGCATTGCATTCCATTCCGTTTGATTCCAAT
CCATCCAAGAAAGTTCCATTCCAGTCCATTGCTTTCCAGTCCATTCCATTCCACTCTAGTCTATTCCACT
CCATTCCCTTCCATTGCATTCCATACTATTCCATTCCATTCCTTTGCATTCCGTTTCCAATCTCTTCGAG
TCCATTGCATTCCAGTCCAATCCATTCGATTACATTCCTTTTGATTCCCTGCCAGTCGATTGCATTGCAT
ACTACACCATTCCAAAGGAGTTCATTCCATTCTATCTCCACACTTTCCATTCCACTCTGTTTGAGTCCAT
TCCATTCCAGTCCATTTAATTCAAGGGCATTCCATTCCATTCCATTCCATTCCATTTCATATTATTCCAT
TCCATTCAATTCCATTCCAGATGATTCCATTCCATTCTATACCATTGCTCTCTGTTCCATTCCATTCCAT
CTGTCTCCATTCCTTTCGTTTCGATTCCTTTCCATTCCATTCCATTACATTTGATCCTATTTTATCAAAT
TGCATTCTATTCGAGTGATTTCCATTCGAGTCCTTTCCATTCGATTCCATTCCATTCTATTCCATTCCTT
TGGATCCCATTCCATTCCGTTCCGTTCACATCAATTCCTGGCGATTCCATTACATTCGATTTCTTGCCAT
TCGATTCCATTCCTTTTGACTCCATTTCATTCGATTCCATTCCATTCCATTAATTTCCATTCCATTCGAG
ACCTTTCCATTGCAGTCTTTTCCCTTCGAGTCCATTCCGTTCGATTCCCTTCCGTTCGATTCCCTTCCAT
TCGATTCCATTCCATTGGAGTCCGTACCAGTCGAGTCCATTCTATTCCAGTCCATTAGTTTCGACTCCAT
TGCATTCGAGTGCATTCCATTCCGTGGCTGTCCATTCCATTCCGTTTGATGCCATTCCATACGATTCCAT
TCAATTCGAGACCATTCTATTCCTGTCCATTCCTTGTGGTTCGATTCCATTTCACTCTAGTCCATTCCAT
TCCATTCAATTCCATTCGACTCTATTCCGTTCCATTCAATTCCATTCCATTCGATTCCATTATTTTCGAG
AACCTTGCATTACACTCCCTTCCATTCCAGTGCATTCCATTCCAGTCTCTTCACTTCGATTCCATTCCAT
TCGTTTCGATTCCTTTCCATTCCAGCCCATTCCATTCCATTCCATTCCTTTCCTTTCCGTTTCATTAGAT
TCCATTGCATTCGATTCCATTCAATTCAATTCCGTGCTATTCAATTTGATTCATTTCCATTTAATTCCAT
TCCATTAGATTCCATTCCGTACGATTCCATTCCTTTTGAATCCATTCCATTGGAGTCCATTCACTTCCAG
AACATTCCATTCCAGTCGAATCCATTCGAGTACATTCCATTAAAGTTCATTACATTCTAATACATTCCAT
TCCATTGCATTCCATTCCATTCCATTCGATGCCATTCGATTCCATTCCATGCCAAATCATTGCATTCCTT
TCCATTCCGTTCCTATCAATTCCATTCCATTCGATTTAGTTCGATTCTATTCACTTCCATTCCATTCGAT
TCCATTCCATTGGAGTCAATTCCTTTCGACACCCAGCCTTTCCAGTCAATGATTTTGGATTCCATTTTTT
TGCATTCCATTACATTCTATGACATTCGATTCCGTTTCATTGCATTCCATTCCATACATTTTTATTCCAT
TCGAGACCGTAGCATTCCACTTTATTCCAGGCCTGTCCATTACACTACATTCCCTTCCATTCCAATGAAT
TCCATTCCATTCCAATCCATTCCTTTCCTTTCGCTTGCATTCCATTCTATTCTCTTCTACTGCATACAAT
TTCACTCCATTCGTTCCCATTCCATTCAATTCCATTCCATTCAATTCCATTCCATTTGTTTCCATTCTCT
TCGATTCCATTTCTTTATATTCCATGCCATTCGATTCCATTCTATTGGGTTGCATTACATTCGTGTTCAT
TCCATTCCAGACCATTCCATTTGACTCCATTCCTTTCGAGCCCTTTCAATTTGAGTCCATTCCTTTCCAG
TCCATTTCACTCCAGTCCATTACTATCCATTCCATACCATTCCATCCCATTCCATTCCATTCCATTCCAT
TCCATTCCATTCCATTCCATTCCATTCCATTGCATTCCATTCCATTCCATTCCATTGCACTGCACTCCAT
TCCATTACATTCTACTCTATCTGAGTCGATTTTATTGCATTAGATTCTATTCCATTGGATTACTTTCCAT
TCGATTACATTCCATTCATGTACATTCCATTCCAGTCAATTACATTCGAGTTCATTACGTTACATTCCAG
TATATTCCATTGTATTCGATCCCATTCCTTTCAATTCCATTTCATTCGACTCCATTATATTCAATTCCAT
TCCACTCGAATCCATTCCATTAGCGGACATTCCATTCCAATGCATTCCATTCCATTCCATAGCATTCCAT
TGCATTCGATTCCATTCCATTTGATGTCATTCCATTTGATGCCATCCCATGACATTCCATTCCATTCGAG
TCAATTCCGTTCCAATTCATTCCATTCCGTTTCATGAAATTCGAGTCCTTTCCAGTACATTTCATTCCAA
TCCCATCCAATCCCATCTACTCCATTCAATTCCTTTCCATTCCATTTGATTTGATTCCATTGATTTGATT
CCATTCAGTTTGATTCCATTCCGTGAAATTTCGTTCCATTCTATTCCATTGCATTACTTTCCATTCAATT
CCATTCCATTTCATTTCAGTCCATTCGCTTCCTTTCCTTTCAATTCAATTCCATTTGATTACACTCCATT
CTATGCGATTTCATTCCAATCGATTCAATTCCATTCGATGACATTCCTTTCGTTTCCATTCCATTCGAGT
CCATTTAATTTGAGCATTCGTGTCCATTCTATTCGAGTCCATTCCATTACAGTCTATTCTATTCCCTTCC
ATTCCTGTTGATTCAATTTCATTCCCTTCCATTCGATTCCTTTCCATTCGATTCCATTCCTTTCCATTCC
ATTCCATTCGTTCCCATTCCATGTGATTTCATTCCATTCCAGTCCATTATATTCGAGTCCACTCCACTCC
ATTCTATTACATTCAATTCCTTTTGAGTCCGTTCCATAACACTCCATTCATTTCGATTCCATTTCTTGCC
AGTTTTCTTCCATTTTATTCCATTCCGTTCGATTCCATTCCATTCGATTGCATTCCATTCGAATCCTTTC
CATTCCATTTCATTCCATTCCTTTCTATTCCATTCCATTTCATTCGATTTGATTCCATTCTGTTCTATTC
CATTCAATTCTTTTTCATTCCATTCGAATCCTTTCTATTGCAGTCCATTCCATTCGAGTCCATTCCAATC
CCTTCCATTCCATTCCATTACAGTCCATTCCAATAGATTCCATTCCTTTGCCTTCCATTCGAATCCATTC
CATTCTAGTACATTCCATTTGAGTCCATTCCATTCCATTCCATTCTATTCCTTTCCAATCCATTCGATTC
CATTCGATTCAATTCCATTTGATTCTCTTTCATTCTATTTTATTCCATGCCATTTGATTGCATTGCATTC
CATTCCGTTTGATTCCAGTCCATCCAAGAAAGTTCCATTCCAGTCCATTGCTTTCCAGTCCATTCCATTC
CACTCTAGTCTATTCCACTCCATTCCCTTCCATTGCATTCCATACTATTCCATTCCATTCCTTTGCATTC
CGTTTCCAATCTATTCGAGTCCATTGCATTCCAGTCCAATCCATTCGATTACATTCCTTTTGATTCCCTG
CCAGTCGATTGCATTGCATACTACACCATTCCAAAGGAGTTCATTCCATTCTATCTCCACACTTTCCATT
CCACTCTGTTTGAGTCCATTCCATTCCAGTCCATTTAATTCAAGGGCATTCCATTCCATTCCATTCCATT
CCATTTCATATTATTCCATTCCATTCAATTCCATTCCAGATGATTCCATTCCATTCTATACCATTGCTCT
CTGTTCCATTCCATTCCATCTGTCTCCATTCCTTTCGTTTCGATTCCTTTCCATTCCATTCCATTACATT
TGATCCTATTTTATTAAATTGCATTCTATTCGAGTGATTTCCATTCGAGTCCTTTCCATTCGATTCCATT
CCATTCTATTCCATTCCTTTGGATTCCATTCCATTCCGTTCCGTTCACATCAATTCCTGGCGATTCCATT
ACATTCGATTTCTTGCCATTCGATTCCATTCCTTTTGACTCCATTTCATTCGATTCCATTCCATTCCATT
AATTTCCATTCCATTCGAGACCTTTCCATTGCAGTCTTTTCCCTTCGAGTCCATTCCGTTCGATTCCATT
CCGTTCGATTCCCTTCCATTCGATTCCATTCCATTGGAGTCCGTACCAGTCGAGTCCATTCTATTCCAGT
CCATTAGTTTCGACTCCATTGCATTCGAGTGCATTCCATTCCGTGGCTGTCCATTCCATTCCGTTTGATG
CCATTCCATACGATTCCATTCAATTCGAGACCATTCTATTCCTGTCCATTCCTTGTGGTTCGATTCCATT
TCACTCTAGTCCATTCCATTCCATTCAATTCCATTCGACTCTATTCCGTTCCAATCAATTCCATTCCATT
CGATTCCATTTTTTTCGAGAACCTTCCATTACACTCCCTTCCATTCCAGTGCATTCCATTCCAGTCTCTT
CACTTCGATTCCATTCCATTCGTTTCGATTCCTTTCCATTCCAGCCCATTCCATTCCATTCCATTCCTTT
CCTTTCCGTTTCATTAGATTCCATTGCATTCCATTCCATTCAATTCAATTCCGTGCTATTCAATTTGATT
CATTTCCATTTAATTCCATTCCATTAGATTCCATTCCGTACGATTCCATTCCTTTTGAATCCATTCCATT
GGAGTCCATTCACTTCCAGAACATTCCATTCCAGTCGAATCCATTCGAGTACATTCCATTAAAGTTCATT
ACATTCTAATACATTCCATTCCATTGCATTCCATTCCATTCCATTCGATGCCATTCGATTCCATTCCAAG
CCAAATCATTGCATTCCTTTCCATTCCGTTCCTATCAATTCCATTCCATTCGATTTAGTTCGATTCTATT
CACTTCCATTCCATTCGATTCCATTCCATTGGAGTCAATTCCTTTCGACACCCAGCCTTTCCAGTCAATG
ATTTTGGATTCCATTTTTTTGCATTCCATTACATTCTATGACATTCGATTCCGTTTCATTGCATTCCATT
CCATACATTTTTATTCCATTCGAGACCGTAGCATTCCACTTTATTCCAGGCCTGTCCATTACACTACATT
CCCTTCCATTCCAATGAATTCCATTCCATTCCAATCCATTCCTTTCCTTTCGCTTGCATTCCATTCTATT
CTCTTCTACTGCATACAATTTCACTCCATTCGTTCCCATTCCATTCAATTCCATTCCATTCAATTCCATT
CCATTTGTTTCCATTCTCTTCGATTCCATTTCTTTATATTCCATGCCATTCGATTCCATTCTATTGGGTT
GCATTACATTCGTGTTCATTCCATTCCAGACCATTCCATTTGACTCCATTCCTTTCGAGCCCTTTCAATT
TGAGTCCATTCCTTTCCAGTCCATTTCACTCCAGTCCATTACTATCCATTCCATACCATTCCATCCCATT
CCATTCCATTCCATTCCATTCCATTCCATTCCATTGCACTGCACTCCATTCCATTACATTCTACTCTATC
TGAGTCGATTTTATTGCATTAGATTCTATTCCATTGGATTACTTTCCATTCGATTACATTCCATTCATGT
ACATTCCATTCCAGTCAATTACATTCCAGTTCATTACGTTACATTCCAGTATATTCCATTGTATTCGATC
CCATTCCTTTCAATTCGATTTCATTCGACTCCATTATATTCAATTCCATTCCACTCGAATCCATTCCATT
AGCGGACATTCCATTCCAATGCATTCCATTCCATTCCATAGCATTCCATTGCATTCGATTCCATTCCATT
TGATGTCATTCCATTTGATGCCATCCCATGACATTCCATTCCATTCGAGTCAATTCCGTTCCAATTCATT
CCATTCCGTTTCATGAAATTCGAGTCCTTTCCAGTACATTTCATTCCAATCCCATCCAATCCCATCTACT
CCATTCAATTCCTTTCCATTCCATTTGATTTGATTCCATTGATTTGATTCCATTCAGTTTGATTCCATTC
CGTGAAATTTCGTTCCATTCTATTCCATTGCATTACTTTCCATTCAATTCCATTCCATTTCATTTCAGTC
CATTCGCTTCCTTTCCTTTCGATTCAATTCCATTTGATTCCACTCCATTCTATGCGATTTCATTCCAATC
GATTCAATTCCATTCGATGACATTCCTTTCGTTTCCATTCCATTCGAGTCCATTTAATTTGAGCATTCGT
GTCCATTCTATTCGAGTCCATTCCATTACCGTCTATTCTATTCCCTTCCATTCCTGTTGATTCAATTTCA
TTCCCTTCCATTCGATTCCTTTCCATTCGATTCCATTCCTTTCCATTCCATTCCATTCGTTCCCATTCCA
TGTGATTTCATTCCATTCCAGTCCATTATATTCGAGTCCACTCCACTCCATTCTATTACATTCAATTCCT
TTTGAGTCCGTTCCATAACACTCCATTCATTTCGATTCCATTTCTTGCCAGTTTTCTTCCATTTTATTCC
ATTCCGTTCGATTCCATTCCATTCGATTGCATTCCATTCGAATCCTTTCCATTCCATTTCATTCCATTCC
TTTCTATTCCATTCCATTTCATTCGATTTGATTCCATTCTGTTCTATTCCATTCAATTCTTTTTCATTCC
ATTCGAATCCTTTCTATTGCAGTCCATTCCATTCGAGTCCATTCCAATCCCTTCCATTCCATTCCATTAC
AGTCCATTCCAATAGATTCCATTCCTTTGCCTTCCATTCGAATCCATTCCATTCTAGTCCATTCCATTTG
AGTCAATTCCATTCCATTCCATTCTATTCCTTTCCAATCCATTCGATTCCATTCGATTCAATTCCATTTG
ATTCTCTTTCATTCTATTTTATTCCATGCCATTTGATTGCACTGCATTCCATTCCGTTTGATTCCAGTCC
ATCCAAGAAAGTTCCATTCCAGTCCATTGCTTTCCAGTCCATTCCATTCCACTCTAGTCTATTCCACTCC
ATTCCCTTCCATTGCATTCCATACTATTCCATTCCATTCCTTTGCATTCCGTTTCCAATCTATTCGAGTC
CATTGCATTCCAGTCCAATCCATTCGATTACATTCCTTTTGATTCCCTGCCAGTCGATTGCATTGCATAC
TACACCATTCCAAAGGAGTTCATTCCATTCTATCTCCACACTTTCCATTCCACTCTGTTTGAGTCCATTC
CATTCCAGTCCATTTAATTCAAGGGCATTCCATTCCATTCCATTCCATTCCATTTCATATTATTCCATTC
CATTCAATTCCATTCCAGATGATTCCATTCCATTCTATACCATTGCTCTCTGTTCCATTCCATTCCATCT
GTCTCCATTCCTTTCGTTTCGATTCCTTTCCATTCCATTCCATTACATTTGATCCTATTTTATTAAATTG
CATTCTATTCGAGTGATTTCCATTCGAGTCCTTTCCATTCGATTCCATTCCATTCTATTCCATTCCTTTG
GATTCCATTCCATTCCGTTCCGTTCACATCAATTCCTGGCGATTCCATTACATTCGATTTCTTGCCATTC
GATTCCATTCCTTTTGACTCCATTTCATTCGATTCCATTCCATTCCATTAATTTCCATTCCATTCGAGAC
CTTTCCATTGCAGTCTTTTCCCTTCGAGTCCATTCCGTTCGATTCCCTTCCATTCGATTCCATTCCATTG
GGGTCCGTACCAGTCGAGTCCATTCTATTCCAGTCCATTAGTTTCGACTCCATTGCATTCGAGTGCATTC
CATTCCGTGGCTGTCCATTCCATTCCGTTTGATGCCATTCCATACGATTCCATTCAATTCGAGACCATTC
TATTCCTGTCCATTCCTTGTGGTTCGATTCCATTTCACTCTAGTCCATTCCATTCCATTCAATTCCATTC
GACTCTATTCCGTTCCATTCAATTCCATTCCATTCGATTCCATTTTTTTCGACAACCTTCCATTACACTC
CCTTCCATTCCAGTGCATTCCATTCCAGTCTCTTCAGTTCGATTCCATTCCATTCGTTTCGATTCCTTTC
CATTCCAGCCCATTCCATTCCATTCCATTCCTTTCCTTTCCGTTTCATTAGATTCCATTGCATTCCATTC
CATTCAATTCAATTCCGTGCTATTCAATTTGATTCATTTCCATTTAATTGCATTCCATTAGATTCCATTC
CGTACGATTCCATTCCTTTTGAATCCATTCCATTGGAGTCCATTCACTTCCAGAACATTCCATTCCAGTC
GAATCCATTCGAGTACATTCCATTAAAGTTCATTACATTCTAATACATTCCATTCCATTGCATTCCATTC
CATTCCATTCGATGCCATTCGATTCCATTCCATACCAAATCATTGCATTCCTTTCCATTCCGTTCCTATC
AATTCCATTCCATTCGATTTAGTTCGATTCTATTCACTTCCATTCCATTCGATTCCATTCCATTGGAGTC
AATTCCTTTCGACACCCAGCCTTTCCAGTCAATGATTTTGGATTCCATTTTTTTGCATTCCATTACATTC
TATGACATTCGATTCCGTTTCATTGCATTCCATTCCATACATTTTTATTCCATTCGAGACCGTAGCATTC
CACTTTATTCCAGGCCTGTCCATTACACTACATTCCCTTCCATTCCAATGAATTCCATTCCATTCCAATC
CATTCCTTTCCTTTCGCTTGCATTCCATTCTATTCTCTTCTACCGCATACAATTTCACTCCATTCGTTCC
CATTCCATTCAATTCCATTCCATTCAATTCCATTCCATTTGTTTCCATTCTCTTCGATTCCATTTCTTTA
TATTCCATGCCATTCGATTCCATTCTATTGGGTTGCATTACATTCGTGTTCATTCCATTCCAGACCATTC
CATTTGACTCCATTCCTTTCGAGCCCTTTCAATTTGAGTCCATTCCTTTCCAGTCCATTTCACTCCAGTC
CATTACTATCCATTCCATACCATTCCATCCCATTCCATTCCATTCCATTCCATTCCATTCCATTCCATTC
CATTGCATTCCATTCCATTCCATTCCATTGCACTGCACTCCATTCCATTACATTCTACTCTATCTTAGTC
GATTTTATTGCATTAGATTCTATTCCATTGGATTACTTTCCATTCGGTTACATTCCATTCATGTACATTC
CATTCCAGTCAATTACATTCGAGTTCATTACGTTACATTCCAGTATATTCCATTGTATTCGATCCCATTC
CTTTCAATTCCATTTCATTCGACTCCATTATATTCAATTCCATTCCACTCGAATCCATTCCATTAGAGGA
CATTCCATTCCAATGCATTCCATTCCATTCCATAGCATTCCATTGCATTCGATTCCATTCCATTTGATGC
CATTCCATTTGATGCCATCCCATGACATTCCATTCCATTCGAGTCCATTCCGTTCCAATTCATTCCATTC
CGTTTCATGAAATTCGAGTCCTTTCCAGTACATTTCATTCCAATCCCATCCAATCCCATCTACTCCATTC
AATTCCTTTCCATTCCATTTGATTTGATTCCATTGATTTGATTCCATTCAGTTTGATTCCATTCCGTGAA
ATTTCGTTCCATTCTATTCCATTGCATTACTTTCCATTCAATTCCATTCCATTTCATTTCAGTCCATTCG
CTTCCTTTCCTTTCGATTCAATTCCATTTGATTCCACTCCATTCTATGCGATTTCATTCCAATTGATTCA
ATTCCATTCGATGACATTCCTTTCGTTTCCATTCCATTCGAGTCCATTTAATTTGAGCATTCGTGTCCAT
TCTATTCGAGTCCATTCCATTACAGTCTATTCTATTCCCTTCCATTCGTGTTGATTCAATTTCATTCCCT
TCCATTCGATTCCTTTCCATTCGATTCCATTCCTTTCCATTCCATTCCATTCGTTCCCATTCCATGTGAT
TTCATTCCATTCCAGTCCATTATATTCGAGTCCACTCCACTCCATTCTATTACATTCAATTCCTTTTGAG
TCCGTTCCATAACACTCCATTCATTTCGATTCCATTTCTTGCCAGTTTTCTTCCATTTTATTCCATTCCG
TTCGATTCCATTCCATTCGATTGCATTCCATTCGAATCCTTTCTATTGCAGTCCATTCCATTCGAGTCCA
TTCCAATCCCTTCCATTCCATTCCATTACAGTCCATTCCAATAGATTCCATTCCTTTGCCTTCCATTCGA
ATCCATTCCATTCTAGTCCATTCCATTTGAGTCAATTCCATTCCATTCCATTCTATTCCTTTCCAATCCA
TTCGATTCCATTCGATTCAATTCCATTTGATTCTCTTTCATTCTAATTTATTCCATGCCATTTGATTGCA
TTGCATTCCATTCCGTTTGATTCCAGTCCATCCAAGAAAGTTCCATTCCAGTCCATTGCTTTCCAGTCCA
TTCCATTCCACTCTAGTCTATTCCACTCCATTCCCTTCCATTGCATTCCATACTATTCCATTCCATTCCT
TTGCATTCCGTTTCCAATCTATTCGAGTCCATTGCATTCCAGTCCAATCCATTCGATTACATTCCTTTTG
ATTCCCTGCCAGTCGATTGCATTGCATACTACACCATTCCAAAGGAGTTCATTCCATTCTATCTCCACAC
TTTCCATTCCACTCTGTTTGAGTCCATTCCATTCCAGTCCATTTAATTCAAGGGCATTCCATTCCATTCC
ATTCCATTCCATTTCATATTATTCCATTCCATTCAATTCCATTCCAGATGATTCCATTCCATTCTATACC
ATTGCTCTCTGTTCCATTCCATTCCATCTGTCTCCATTCCTTTCGTTTCGATTCCTTTCCATTCCATTCC
ATTACATTTGATCCTATTTTATCAAATTGCATTCTATTCGAGTGATTTCCATTCGAGTCCTTTCCATTCG
ATTCCATTCCATTCTATTCCATTCCTTTGGATCCCATTCCATTCCGTTCCGTTCACATCAATTCCTGGCG
ATTCCATTACATTCGATTTCTTGCCATTCGATTCCATTCCTTTTGACTCCATTTCATTCGATTCCATTCC
ATTCCATTAATTTCCATTCCATTCGAGACCTTTCCATTGCAGTCTTTTCCCTTCGAGTCCATTCCGTTCG
ATTCCCTTCCGTTCGATTCCCTTCCATTCGATTCCATTCCATTGGAGTCCGTACCAGTCGAGTCCATTCT
ATTCCAGTCCATTAGTTTCGACTCCATTGCATTCGAGTGCATTCCATTCCGTGGCTGTCCATTCCATTCC
GTTTGATGCCATTCCATACGATTCCATTCAATTCGAGACCATTCTATTCCTGTCCATTCCTTGTGGTTCG
ATTCCATTTCACTCTAGTCCATTCCATTCCATTCAATTCCATTCGACTCTATTACGTTCCATTCAATTCC
ATTCCATTCGATTCCATTTTTTTCGAGAACCTTGCATTACACTCCCTTCCATTCCAGTGCATTCCATTCC
AGTCTCTTCACTTCGATTCCATTCCATTCGTTTCGATTCCTTTCCATTCCAGCCCATTCCATTCCATTCC
ATTCCTTTCCTTTCCGTTTCATTAGATTCCATTGCATTCCATTCCATTCAATTCAATTCCGTGCTATTCA
ATTTGATTCATTTCCATTTAATTCCATTCCATTAGATTCCATTCCGTACGATTCCATTCCTTTTGAATCC
ATTCCATTGGAGTCCATTCACTTCCAGAACATTCCATTCCAGTCGAATCCATTCGAGTACATTCCATTAA
AGTTCATTACATTCTAATACATTCCATTCCATTGCATTCCATTCCATTCCATTCGATGCCATTCGATTCC
ATTCCATGCCAAATCATTGCATTCCTTTCCATTCCGTTCCTATCAATTCCATTCCATTCGATTTAGTTCG
ATTCTATTCACTTCCATTCCATTCGATTCCATTCCATTGGAGTCAATTCCTTTCGACACCCAGCCTTTCC
AGTCAATGATTTTGGATTCCATTTTTTTGCATTCCATTACATTCTATGACATTCGATTCCGTTTCATTGC
ATTCCATTCCATACATTTTTATTCCATTCGAGACCGTAGCATTCCACTTTATTCCAGGCCTGTCCATTAC
ACTACATTCCCTTCCATTCCAATGAATTCCATTCCATTCCAATCCATTCCTTTCCTTTCGCTTGCATTCC
ATTCTATTCTCTTCTACTGCATACAATTTCACTCCATTCGTTCCCATTCCATTCAATTCCATTCCATTCA
ATTCCATTCCCTTTGTTTCCATTCTCTTCGATTCCATTTCTTTATATTCCATGCCATTCGATTCCATTCT
ATTGGGTTGCATTACATTCGAGTTCATTCCATTCCAGACCATTCCATTTGACTCCATTCCTTTCGAGCCC
TTTCAATTTGAGTCCATTCCTTTCCAGTCCATTTCACTCCAGTCCATTACTATCCATTCCATACCATTCC
ATCCCATTCCATTCCATTCCATTCCATTCCATTCCATTCCATTCCATTGCATTCCATTCCATTCCATTCC
ATTGCACTGCACTCCATTCCATTACATTCTACTCTATCTGAGTCGATTTTATTGCATTAGATTCTATTCC
ATTGGATTACTTTCCATTCGATTACATTCCATTCATGTACATTCCATTCCAGTCAATTACATTCGAGTTC
ATTACGTTACATTCCAGTATATTCCATTGTATTCGATCCCATTCCTTTCAATTCCATTTCATTCGACTCC
ATTATATTCAATTCCATTCCACTCGAATCCATTCCATTAGCGGACATTCCATTCCAATGCATTCCATTCC
ATTCCATAGCATTCCATTGCATTCGATTCCATTCCATTTGATGTCATTCCATTTGATGCCATCCCATGAC
ATTCCATTCCATTCGAGTCAATTCCGTTCCAATTCATTCCATTCCGTTTCATGAAATTCGAGTCCTTTCC
AGTACATTTCATTCCAATCCCATCCAATCCCATCTACTCCATTCAATTCCTTTCCATTCCATTTGATTTG
ATTCCATTGATTTGATTCCATTCAGTTTGATTCCATTCCGTGAAATTTCGTTCCATTCTATTCCATTGCA
TTACTTTCCATTCAATTCCATTCCATTTCATTTCAGTCCATTCGCTTCCTTTCCTTTCGATTCAATTCCA
TTTGATTCCACTCCATTCTATGCGATTTCATTCCAATCGATTCAATTCCATTCGATGACATTCCTTTCGT
TTCCATTCCATTCGAGTCCATTTAATTTGAGCATTCGTGTCCATTCTATTCGAGTCCATTCCATTACAGT
CTATTCTATTCCCTTCCATTCCTGTTGATTCAATTTCATTCCCTTCCATTCGATTCCTTTCCATTCGATT
CCATTCCTTTCCATTCCATTCCATTCGTTCCCATTCCATGTGATTTCATTCCATTCCAGTCCATTATATT
CGAGTCCACTCCACTCCATTCTATTACATTCAATTCCTTTTGAGTCCGTTCCATAACACTCCATTCATTT
CGATTCCATTTCTTGCCAGTTTTCTTCCATTTTATTCCATTCCGTTCGATTCCATTCCATTCGATTGCAT
TCCATTCGAATCCTTTCCATTCCATTTCATTCCATTCCTTTCTATTCCATTCCATTTCATTCGATTTCAT
TCCATTCTGTTCTATTCCATTCAATTCTTTTTCATTCCATTCGAATCCTTTCTATTGCAGTCCATTCCAT
TCGAGTCCATTCCAATCCCTTCCATTCCATTCCATTACAGTCCATTCCAATAGATTCCATTCCTTTGCCT
TCCATTCGAATCCATTCCATTCTAGTCCATTCCATTTGAGTCAATTCCATTCCATTCCATTCTATTCCTT
TCCAATCCATTCGATTCCATTCGATTCAATTCCATTTGATTCTCTTTCATTCTATTTTATTCCATGCCAT
TTGATTGCACTGCATTCCATTCCGTTTGATTCCAGTCCATCCAAGAAAGTTCCATTCCAGTCCATTGCTT
TCCAGTCCATTCCATTCCACTCTAGTCTATTCCACTCCATTCCCTTCCATTGCATTCCATACTATTCCAT
TCCATTCCTTTGCATTCCGTTTCCAATCTATTCGAGTCCTTTGCATTCCAGTCCAATCCTTTCGATTACG
TACCTTTTGATTCCCTGCCAGTCGATTGCATTGCATACTACACCATTCCAAAGGAGTTCATTCCATTCTA
TCTCCACACTTTCCATTCCACTCTGTTTGAGTCCATTCTATTCCAGTCCATTCAATTCAAGGGCATTCCA
TTCCATTCCATTCCATTCCATTTCATATTATTCCATTCCATTCAATTCCATTCCAGATGATTCCATTCCA
TTCTATACCATTGCTCTCTGTTCCATTCCATTCCATCTGTCTCCATTCCTTTCGTTTCGATTCCTTTCCA
TTCCATTCCATTACATTTGATCCTATTTTATTAAATTGCATTCTATTCGAGTGATTTCCATTCGAGTCCT
TTCCATTCGATTCCATTCCATTCTATTCCATTCCTTTGGATTCCATTCCATTCCGTTCCATTCACATCAA
TTCCTGGCGATTCCATTACATTCGATTTCTTGCCATTCGATTCCATTCCTTTTGACTCCATTTCATTCGA
TTCCATTCCATTCCATTAATTTCCATTCCATTCGAGACCTTTCCATTGCAGTCTTTTCCCTTCGAGTCCA
TTCCGTTCGATTCCCTTCCGTTCGATTCCCTTCCATTCGATTCCATTCCATTGGAGTCCGTACCAGTCGA
GTCCATTCTATTCCAGTCCATTAGTTTCGACTCCATTGCTTTCGAGTGCATTCCATTCCGTGGCTGTCCA
TTCCATTCCGTTTGATGCCATTCCATACGATTCCATTCAATTCGAGACCATTCTATTCCTGTCCATTCCT
TGTGGTTCGATTCCATTTCACTCTAGTCCATTCCATTCCATTCAATTCCATTCGACTCTATTCCGTTCCA
TTCAATTCCATTCCATTCGATTCCATTTTTTTCGAGAACCTTCCATTACACTCCCTTCCATTCCAGTGCA
TTCCATTCCAGTCTCTTCACTTCGATTCCATTCCATTCGTTTCGATTCCTTTCCATTCCAGCCCATTCCA
TTCCATTCCATTCCTTTCCTTTCCGTTTCATTAGATTCCATTGCATTCCATTCCATTCAATTCAATTCCG
TGCTATTCAATTTGATTCATTTCCATTTAATTCCATTCCATTAGATTCCATTCCGTACGATTCCATTCCT
TTTGAATCCATTCCATTGGAGTCCATTCACTTCCAGAACATTCCATTCCAGTCGAATCCATTCGAGTACA
TTCCATTAAAGTTCATTACATTCTAATACATTCCATTCCATTGCATTCCATTCCATTCCATTCGATGCCA
TTCGATTCCATTCCATGCCAAATCATTGCATTCCTTTCGATGCCGTTCCTATCAATTCCATTCCATTCGA
TTTAGTTCGATTCTATTCACTTCCATTTCCATTCGATTCCATTCCATTGGAGTCAATTCCTTTCGACACC
CAGCCTTTCCAGTCAATGATTTTGGATTCCATTTTTTTGCATTCCATTACATTCTATGACATTCGATTCC
GTTTCATTGCATTCCATTCCATACATTTTTATTCCATTCGAGACCGTAGCATTCCACTTTATTCCAGGCC
TGTCCATTACACTACATTCCCTTCCATTCCAATGAATTCCATTCCATTCCAATCCATTCCTTTCCTTTCG
CTTGCATTCCATTCTATTCTCTTCTACTGCATACAATTTCACTCCATTCGTTCCCATTCCATTCAATTCC
ATTCCATTCAATTCCATTCCATTTGTTTCCATTCTCTTCGATTCCATTTCTTTATATTCCATGCCATTCG
ATTCCATTCTATTGGGTTGCATTACATTCGTGTTCATTCCATTCCAGACCATTCCATTTGACTCCATTCC
TTTCGAGCCCTTTCAATTTGAGTCCATTCCTTTCCAGTCCATTTCACTCCAGTCTATTACTATCCATTCC
ATACCATTCCATCCCATTCCATTCCATTCCATTCCATTCCATTCCATTCCATTCCATTCCATTCCATTGC
ATTCCATTCCATTCCATTCCTTTGCACTGCACTCCATTCCATTACATTCTACTCTATCTGAGTCGATTTT
ATTGCATTAGATTCTATTCCATTGGATTACTTTCCATTCGATTACATTCCATTCATGTACATTCCATTCC
AGTCAATTACATTCGAGTTCATTACATTACATTCCAGTATATTCCATTGTATTCGATCCCATTCCTTTCA
ATTCCATTTCATTCGACTCCATTATATTCAATTCCATTCCACTCGAATCCATTCCATTAGAGGACATTCC
ATTCCAATGCATTCCATTCCATTCCATAGCATTCCATTGCATTCGATTCCATTCCATTTGATGCCATTCC
ATTTGATGCCATCCCATGACATTCCATTCCATTCGAGTCCATTCCGTTCCAATTCATTCCATTCCGTTTC
ATGAAATTCGAGTCCTTTCCAGTACATTTCATTCCAATCCCATCCAATCCCATCTACTCCATTCAATTCC
TTTCCATTCCATTTGATTTGATTCCATTGATTTGACTCCATTCAGTTTGATTCCATTCCGTGAAATTTCG
TTCCATTCTATTCCATTGCATTACTTTCCATTCAATTCCATTCCATTTCATTTCAGTCCATTCGCTTCCT
TTCCTTTCGATTCAATTCCATTTGATTCCACTCCATTCTATGCGATTTCATTCCAATCGATTCAATTCCA
TTCGATGACATTCCTTTCGTTTCCATTCCATTCGAGTCCATTTAATTTGAGCATTCGTGTCCATTCTATT
CGAGTCCATTCCATTACAGTCTATTCTATTCCCTTCCATTCGTGTTGATTCAATTTCATTTCCTTCCATT
CGATTCCTTTCCATTCGATTCCATTCCTTTCCATTCCATTCCATTCGTTCCCATTCCATGTGATTTCATT
CCATTCCAGTCCATTATATTCGAGTCCACTCCACTCCATTCTATTACATTCAATTCCTTTTGAGTCCGTT
CCATAACACTCCATTCATTTCGATTCCATTTCTTGCCAGTTTTCTTCCATTTTATTCCATTCCGTTCGAT
TCCATTCCATTCGATTGCATTCCATTCGAATCCTTTCCATTCCATTTCATTCCATTCCTTTCTATTCCAT
TCCATTTCATTCGATTTGATTCCATTCTGTTCTATTCCATTCAATTCTTTTTCATTCCATTCGAATCCTT
TCTATTGCAGTCCATTCCATTCGAGTCCATTCGAATCCCTTCCATTCCATTCCATTACAGTCCATTCCAA
TAGATTCCATTCCTTTGCCTTCCATTCGAATCCATTCCATTCTAGTCCATTCCATTTGAGTCAATTCCAT
TCCATTCCATTCTATTCCTTTCCAATCCATTCGATTCCATTCGATTCAATTCCATTTGATTCTCTTTCAT
TCTATTTTATTCCATGCCATTTGATTGCATTGCATTCCATTCCGTTTGATTCCAGTCCATCCAAGAATGT
TCCATTCCAGTCCATTGCTTTCCAGTCCATTCCATTCCACTCTAGTCTATTCCACTCCATTCCCTTCCAT
TGCATTCCATACTATTCCATTCCATTCCTTTGCGTTCCGTTTCCAATCTATTCGAGTCCATTGCATTTCA
GTCCAATCCATTCGATTACATTCCTTTTGATTCCCTGCCAGTCGATTGCATTGCATACTACACCATTCCA
AAGGAGTTCATTCCATTCTATCTCCACACTTTCCATTCCACTCTGTTTGAGTCCATTCCATTCCAGTCCA
TTTAATTCAAGGGCATTCCATTCCATTCCATTCCATTCCATTTCATATTATTCCATTCCATTCAAATCCA
TTCCAGATGATTCCATTCCATTCTATACCATTGCTCTCTATTCCATTCCATTCTATCTGTCTCCATTCCT
TTCGTTTCAATTCCTTTCCATTCCATTCCATTACATTTGATCCTATTTTATTAAATTGCATTCTATTCGA
GTGATTTCCATTCGAGTCCTTTCCATTCGATTCCATTCCATTCTATTCCATTCCTTTGGATTCCATTCCA
TTCCGTTCCGTTCACATCAATTCCTGGCGATTCCATTACATTCGATTTCTTGCCATTCGATTCCATTCCT
TTTGACTCCATTTCATTCGATTCCATTCCATTCCATTAATTTCCATTCCATTCGAGACCTTTCCATTGCA
GTCTTTTCCCTTCGAGTCCATTCCGTTCGATTCCCTTCCATTCGATTCCATTCCATTGGAGTCCGTACCA
GTCGAGTCCATTCTATTCCAGTCCATTAGTTTCGACTCCATTGCATTCGAGTGCATTCCATTCCGTGGCT
GTCCATTCCATTCCGTTTGATGCCATTCCATACGATTCCATTCAATTCGAGACCATTCTATTCCTGTCCA
TTCCTTGTGGTTCGATTCCATTTCACTCTAGTCCATTCCATTCCATTCAATTCCATTCGACTCTATTCCG
TTCCATTCAATTCCATTCCATTCGATTCCATTTTTTTCGAGAACCTTCCATTACACTCCCTTCCATTCCA
GTGCATTCCATTCCAGTCTCTTCACTTCGATTCCATTCCATTCGTTTCGATTCCTTTCCATTCCAGCCCA
TTCCATTCCATTCCATTCCTTTCCTTTCCGTTTCATTAGATTCCATTGCATTCCATTCCATTCAATTCAA
TTCCGTGCTATTCAATTTGATTCATTTCCATTTAATTCCATTCCATTAGATTCCATTCCGTACGATTCCA
TTCCTTTTGAATCCATTCCATTGGAGTCCATTCACTTCCAGAACATTCCATTCCAGTCGAATCCATTCGA
GTACATTCCATTAAAGTTCATTCCATTCTAATACATTCCATTCCATTGCATTCCATTCCATTCCATTCGA
TGCCATTCGATTCCATTCCATGCCAAATCATTGCATTCCTTTCCATTCCGTTCCTATCAATTCCATTCCA
TTCGATTTAGTTCGATTCTATTCACTTCCATTCCATTCGATTCCATTCCATTGGAGTCAATTCCTTTCGA
CACCCAGCCTTTCCAGTCAATGATTTTGGATTCCATTTTTTTGCATTCCATTACATTCTATGACATTCGA
TTCCGTTTCATTGCATTCCATTCCATACATTTTTATTCCATTCGAGACCGTAGCATTCCACTTTATTCCA
GGCCTGTCCATTACACTACATTCCCTTCCATTCCAATGAATTCCATTCCATTCCAATCCATTCCTTTCCT
TTCGCTTGCATTCCATTCTATTCTCTTCTACTGCATACAATTTCACTCCATTCGTTCCCATTCCATTCAA
TTCCATTCCATTCAATTCCATTCCATTTGTTTCCATTCTCTTCGATTCCATTTCTTTATATTCCATGCCA
TTCGATTCCATTCTATTGGGTTGCATTACATTCGTGTTCATTCCATTCCAGACCATTCCATTTGACTCCA
TTCCTTTCGAGACCTTTCAATTTGAGTCCATTCCTTTCCAGTCCATTTCACTCCAGTCCATTACTATCCA
TTCCATACCATTCCATCCCATTCCATCCCATTCCATTCCATTCCATTCCATTCCATTCCATTCCATTCCA
TTCCATTGCATTCCATTCCATTCCATTCCATTGCACTGCACTCCATTCCATTACATTCTACTCTATCTGA
GTCGATTTTATTGCATTAGATTCTATTCCATTGGATTACTTTCCATTCGATTACATTCCATTCATGTACA
TTCCATTCCAGTCAATTACATTCGAGTTCATTACGTTACATTCCAGTATATTCCATTGTATTCGATCCCA
TTCCTTTCAATTCCATTTCATTCGACTCCATTATATTCAATTCCATTCCACTCGAATCCATTCCATTAGC
GGACATTCCATTCCAATGCATTCCATTCCATTCCATAGCATTCCATTGCATTCGATTCCATTCCATTTGA
TGTCATTCCATTTGATGCCATCCCATGACATTCCATTCCATTCGAGTCCATTCCGTTCCAATTCATTCCA
TTCCGTTTCATGAAATTCGAGTCCTTTCCAGTACATTTCATTCCAATCCCATCCAATCCCATCTACTCCA
TTCAATTCCTTTCCATTCCATTTGATTTGATTCCATTGATTTGATTCCATTCAGTTTGATTCCATTCCGT
GAAATTTCGTTCCATTCTATTCCATTGCATTACTTTCCATTCAATTCCATTCCATTTCATTTCAGTCCAT
TCGCTTCCTTTCCTTTCGATTCAATTCCATTTGATTCCACTCCATTCTATGCGATTTCATTCCAATCGAT
TCAATTCCATTCGATGACATTCCTTTCGTTTCCAATCCATTCGAGTCCATTTAATTTGAGCATTCGTGTC
CATTCTATTCGAGTCCATTCCATTACAGTCTATTCTATTCCCTTCCATTCGTGTTGATTCAATTTCATTC
CCTTCCATTCGATTCCTTTCCATTCGATTCCATTCCTTTCCATTCCATTCCATTCGTTCCCATTCCATGT
GATTTCATTCCATTCCAGTCCATTATATTCGAGTCCACTCCACTCCATTCTATTACATTCAATTCCTTTT
GAGTCCGTTCCATAACACTCCATTCATTTCGATTCCATTTCTTGCCAGTTTTCTTCCATTTTCTTCCATT
CCGTTCGATTCCATTCCATTCGATTGCATTCCATTCGAATCCTTTCCATTCCATTTCATTCCATTCCTTT
CTATTCCATTCCATTTCATTCGATTTGATTCCATTCTGTTCTATTCCATTCAATTCTTTTTCATTCCATT
CGAATCCTTTCTATTGCAGTCCATTCCATTCGAGTCCATTCCAATCCCTTCCATTCCATTCCATTACAGA
CCATTCCAATAGATTCCATTCCTTTGCCTTCCATTCGAATCCATTCCATTCTAGTCCATTCCATTTGAGT
CCATTCCATTCCATTCCATTCTATTCCTTTCCAATCCATTCGATTCCATTCGATTCAATTCCATTTGATT
CTCTTTCATTCTATTTTATTCCATGCCATTTGATTGCATTGCATTCCATTCCGTTTGATTCCAGTCCATC
CAAGAAAGTTCCATTCCAGTCCAGTGCTTTCCAGTCCATTCCATTCCACTCTAGTCTATTCCACTCCATT
CCCTTCCATTGCATTCCATACTATTCCATTCCATTCCTTTGCATTCCGTTTACAATCTATTCGAGTCCAT
TGCATTCCAGTCCAATCCATTCGATTACATTCCTTTTGATTCCCTGCCAGTCGATTGCATTGCATACTAC
ACCATTCCAAAGGAGTTCATTCCATTCTATCTCCACACTTTCCATTCCACTCTGTTTGAGTCCATTCCAT
TCCAGTCCATTTAATTCAAGGGCATTCCATTCCATTCCATTCCATTCCATTTCATATTATTCCATTCCAT
TCAATTCCATTCCAGATGATTCCATTCCATTCTATACCATTGCTCTCTGTTCCATTCCATTCCATCTGTC
TCCATTCCTTTCGTTTCGATTCCTTTCCATTCCATTCCATTACATTTGATCCTATTTTATTAAATTGCAT
TCTATTCGAGTGATTTCCATTCGAGTCCTTTCCATTCGATTCCATTCCATTCTATTCCATTCCTTTGGAT
TCCATTCCATTCCGTTCCGTTCACATCAATTCCTGGCGATTCCATTACATTCGATTTCTTGCCATTCGAT
TCCATTCCTTTTGACTCCATTTCATTCGATTCCATTCCATTCCATTAATTTCCATTCCATTCGAGACCTT
TCCATTGCAGTCTTTTCCCTTCGAGTCCATTCCGTTCGATTCCCTTCCGTTCGATTCCCTTCCATTCGAT
TCCATTCCATTGGAGTCCGTACCAGTCGAGTCCATTCTATTCCAGTCCATTAGTTTCGACTCCATTGCAT
TCGAGTGCATTCCATTCCGTGGCTGTCCATTCCATTCCGTTTGATGCCATTCCATACGATTCCATTCAAT
TCGAGACCATTCTATTCCTGTCCATTCCTTGTGGTTCGATTCCATTTCACTCTAGTCCATTCCATTCCAT
TCAATTCCATTCGACTCTATTCCGTTCCATTCAATTCCATTCCATTCGATTCCATTTTTTTCGAGAACCT
TGCATTACACTCCCTTCCATTCCAGTGCATTCCATTCCAGTCTCTTCAGTTCGATTCCATTCCATTCGTT
TCGATTCCTTTCCATTCCAGCCCATTCCATTCCATTCCATTCCTTTCCTTTCCGTTTCATTAGATTCCAT
TGCATTCCATTCCATTCAATTCAATTCCGTGCTATTCAATTTGATTCATTTCCATTTAATTCCATTCCAT
TAGATTCCATTCCGTACGATTCCATTCCTTTTGAATCCATTCCATTGGAGTCCATTCACTTCCAGAACAT
TCCATTCCAGTCGAATCCATTCGAGTACATTCCATTAAAGTTCATTACATTCTAATACATTCCATTCCAT
TGCATTCCATTCCATTCCATTCGATGCCATTCGATTCCATTCCATGCCAAATCATTGCATTCCTTTCCAT
TCCGTTCCTATCAATTCCATTCCATTCGATTTAGTTCGATTCTATTCACTTCCATTCCATTCGATTCCAT
TCCATTGGAGTCAATTCCTTTCGACACCCAGCCTTTCCAGTCAATGATTTTGGATTCCATTTTTTTGCAT
TCCATTACATTCTATGACATTCGATTCCGTTTCATTGCATTCCATTCCATACATTTTTATTCCATTCGAG
ACCGTAGCATTCCACTTTATTCCAGGCCTGTCCATTACACTACATTCCCTTCCATTCCAATGAATTCCAT
TCCATTCCAATCCATTCCTTTCCTTTCGCTTGCATTCCATTCTATTCTCTTCTACTGCATACAATTTCAC
TCCATTCGTTCCCATTCCATTCAATTCCATTCCATTCAATTCCATTCCATTTGTTTCCATTCTCTTCGAT
TCCATTTCTTTATATTCCATGCCATTCGATTCCATTCTATTGGGTTGCATTACATTCGTGTTCATTCCAT
TCCAGACCATTCCATTTGACTCCATTCCTTTCGAGCCCTTTCAATTTGAGTCCATTCCTTTCCAGTCCAT
TTCACTCCAGTCCATTACTATCCATTCCATACCATTCCATCCCATTCCATTCCATTCCATTCCATTCCAT
TCCATTCCATTCCATTGCATTCCATTCCATTCCATTCCATTGCACTGCACTCCATTCCATTACATTCTAC
TCTATCTGAGTCGATTTTATTGCATTAGAATCTATTCCATTGGATTACTTTCCATTCGATTACATTCCAT
TCATGTACATTCCATTCCAGTCAATTACATTCGAGTTCATTACGTTACATTCCAGTATATTCCATTGTAT
TCGATCCCATTCCTTTCAATTCCATTTCATTCGACTCCATTATATTCAATTCCATTCCACTCGAATCCAT
TCCATTAGAGGACATTCCATTCCAATGCATTCCATTCCATTCCATAGCATTCCATTGCATTCGATTCCAT
TCCATTTGATGCCATTCCATTTGATGCCATCCCATGACATTCCATTCCATTCGAGTCCATTCCGTTCCAA
TTCATTCCATTCCGTTTCATCAAATTCGAGTCCTTTCCAGTACATTTCATTCCAATCCCATCCAATCCCA
TCTACTCCATTCAATTCCTTTCCATTCCATTTGATTTGATTCCATTGATTTGATTCCATTCAGTTTGATT
CCATTCCGTGAAATTTCGTTCCATTCTATTCCATTGCATTACTTTCCATTCAATTCCATTCCATTTCATT
TCAGTCCATTCGCTTCCTTTCCTTTCGATTCAATTCCATTTGATTCCACTCCATTCTATGCGATTTCATT
CCAATTGATTCAATTCCATTCGATGACATTCCTTTCGTTTCCATTCCATTCGAGTCCATTTAATTTGAGC
ATTCGTGTCCATTCTATTCGAGTCCATTCCATTACAGTCTATTCTATTCCCTTCCATTCGTGTTGATTCA
ATTTCATTCCCTTCCATTCGATTCCTTTCCATTCGATTCCATTCCTTTCCATTCCATTCCATTCGTTCCC
ATTCCATGTGATTTCATTCCATTCCAGTCCATTATATTCGAGTCCACTCCACTCCATTCTATTACATTCA
ATTCCTTTTGAGTCCGTTCCATAACACTCCATTCATTTCGATTCCATTTCTTGCCAGTTTTCTTCCATTT
TATTCCATTCCGTTCGATTCCATTCCATTCGATTGCATTCCATTCGAATCCTTTCCATTCCATTTCATTC
CATTCCTTTCTATTCCATTCCATTTCATTCGATTTGATTCCATTCTGTTCTATTCCATTCAATTCTTTTT
CATTCCATTCGAATCCTTTCTATTGCAGTCCATTCCATTCGAGTCCATTCCAATCCCTTCCATTCCATTC
CATTACAGTCCATTCCAATAGATTCCATTCCTTTGCCTTCCATTCGAATCCATTCCATTCTAGTCCATTC
CATTTGAGTCAATTCCATTCCATTCCATTCTATTCCTTTCCAATCCATTCGATTCCATTCGATTCAATTC
CATTTGATTCTCTTTCATTCTAATTTATTCCATGCCATTTGATTGCATTGCATTCCATTCCGTTTGATTC
CAGTCCATCCAAGAAAGTTCCATTCCAGTCCATTGCTTTCCAGTCCATTCCATTCCACTCTAGTCTATTC
CACTCCATTCCCTTCCATTGCATTCCATACTATTCCATTCCATTCCTTTGCATTCCGTTTCCAATCTATT
CGAGTCCATTGCATTCCAGTCCAATCCATTCGATTACATTCCTTTTGATTCCCTGCCAGTCGATTGCATT
GCATACTACACCATTCCAAAGGAGTTCATTCCATTCTATCTCCACACTTTCCATTCCACTCTGTTTGAGT
CCATTCCATTCCAGTCCATTTAATTCAAGGGCATTCCATTCCATTCCATTCCATTCCATTTCATATTATT
CCATTCCATTCAATTCCATTCCAGATGATTCCATTCCGTTCTATACCATTGCTCTCTGTTCCATTCCATT
CCATCTGTCTCCATTCCTTTCGTTTCGATTCCTTTCCATTCCATTCCATTACATTTGATCCTATTTTATT
AAATTGCATTCTATTCGAGTGATTTCCATTCGAGTCCTTTCCATTCGATTCCATTCCATTCTATTCCATT
CCTTTGGATTCCATTCCATTCCGTTCCGTTCACATCAATTCCTGGCGATTCCATTACATTCGATTTCTTG
CCATTCGATTCCATTCCTTTTGACTCCATTTCATTCGATTCCATTCCATTCCATTAATTTCCATTCCATT
CGAGACCTTTCCATTGCAGTCTTTTCCCTTCGAGTCCATTCCGTTCGATTCCCTTCCATTCGATTCCATT
CCATTGGAGTCCGTACCAGTCGAGTCCATTCTATTCCAGTCCATTAGTTTCGACTCCATTGCATTCGAGT
GCATTCCATTCCGTGGCTGTCCATTCCATTCCGTTTGATGCCATTCCATACGATTCCATTCAATTCGAGA
CCATTCTATTCCTGTCCATTCCTTGTGGTTCGATTCCATTTCACTCTAGTCCATTCCATTCCATTCAATT
CCATTCGACTCTATTCCGTTCCATTCAATTCCATTCCATTCGATTCCATTTTTTTCGAGAACCTTCCATT
ACACTCCCTTCCATTCCAGTGCATTCCATTCCAGTCTCTTCACTTCGATTCCATTCCATTCGTTTCGATT
CCTTTCCATTCCAGCCCATTCCATTCCATTCCATTCCTTTCCTTTCCGTTTCATTAGATTCCATTGCATT
CCATTCCATTCAATTCAATTCCGTGCTATTCAATTTGATTCATTTCCATTTAATTCCATTCCATTAGATT
CCATTCCGTACGATTCCATTCCTTTTGAATCCATTCCATTGGAGTCCATTCACTTCCAGAACATTCCATT
CCAGTCGAATCCATTCGAGTACATTCCATTAAAGTTCATTACATTCTAATACATTCCATTCCATTCGATG
CCATTCGATTCCATTCCATGCCAAATCATTGCATTCCTTTCCATTCCGTTCCTATCAATTCCATTCCATT
CGATTTAGTTCGATTCTATTCACTTCCATTCCATTCGATTCCATTCCATTGGAGTCAATTCCTTTCGACA
CCCAGCCTTTCCAGTCAATGATTTTGGATTCCATTTTTTTGCATTCCATTACATTCTATGACATTCGATT
CCGTTTCATTGCATTCCATTCCATACATTTTTATTCCATTCGAGACCGTAGCATTCCACTTTATTCCAGG
CCTGTCCATTACACTACATTCCCTTCCATTCCAATGAATTCCATTCCATTCCAATCCATTCCTTTCCTTT
CGCTTGCATTCCATTCTATTCTCTTCTACTGCATACAATTTCACTCCATTCGTTCCCATTCCATTCAATT
CCATTCCATTCAATTCCATTCCATTTGTTTCCATTCTCTTCGATTCCATTTCTTTATATTCCATGCCATT
CGATTCCATTCTATTGGGTTGCATTACATTCGTGTTCATTCCATTCCAGACCATTCCATTTGACTCCATT
CCTTTCGAGCCCTTTCAATTTGAGTCCATTCCTTTCCAGTCCATTTCACTCCAGTCCATTACTATCCATT
CCATACCATTCCAACCCATTCCATTCCATTCCATTCCATTCCATTCCATTCCATTCCATTGCATTCCATT
CCATTCCATTCCATTGCACTGCACTCCATTCCATTACATTCTACTCTATCTGAGTCGATTTTATTGCATT
AGATTCTATTCCATTGGATTACTTTCCATTCGATTACATTCCATTCATGTACATTCCATTCCAGTCAATT
ACATTCCAGTTCATTACGTTACATTCCAGTATATTCCATTGTATTCGATCCCATTCCTTTCAATTCCATT
TCATTCGACTCCATTATATTCAATTACATTCCACTCGAATCCATTCCATTAGCGGACATTCCATTCCAAT
GCATTCCATTCCATTCCATAGCATTCCATTGCATTCGATTCCATTCCATTTGATGTCATTCCATTTGATG
CCATCCCATGACATTCCATTCCATTCGAGTCCATTCCGTTCCAATTCATTCCATTCCGTTTCATGAAATT
CGAGTCCTTTCCAGTACATTTCATTCCAATCCCATCCAATCCCATCTACTCCATTCAATTCCTTTCCATT
CCATTTGATTTGATTCCATTGATTTGATTCCATTCAGTTTGATTCCATTCCGTGAAATTTCGTTCCATTC
TATTCCATTGCATTATTTTCCATTCAATTCCATTCCATTTCATTTCAGTCCATTCGCTTCCTTTCCTTTC
GATTCAATTCCATTTGATTCCACTCCATTCTATGCGATTTCATTCCAATCGATTCAATTCCATTCGGTGA
CATTCCTTTCGTTTCCATTCCATTCGAGTCCATTCAATTTGAGCATTCGTGTCCATTCTATTCGAGTCCA
TTCCATTACAGTCTATTCTATTCCCTTCCATTCGTGTTGATTCAATTTCATTCCCTTCCATTCGATTCCT
TTCCATTCGATTCCATTCCTTTCCATTCCATTCCATTCGTTCCCATTCCATGTGATTTCATTCCATTCCA
GTCCATTATATTCGAGTCCACTCCACTCCATTCTATTACATTCAATTCCTTTTGAGTCCGTTCCATAACA
CTCCATTCATTTCGATTCCATTTCTTGCCAGTTTTCTTCCATTTTATTCCATTCCGTTCGATTCCATTCC
ATTTGATTGCATTCCATTCGAATCCTTTCCATTCCATTTCATTCCATTCCTTTCTATTCCATTCCATTTC
ATTCGATTTGATTCCATTCTGTTCTATTCCATTCAATTCTTTTTCATTCCATTCGAATCCTTTCTATTGC
AGTCCATTCCATTCGAGTCCATTCCAATCCCTTCCATTCCATTCCATTACAGTCCATTCCAATAGATTCC
ATTCCTTTGCCTTCCATTCGAATCCATTCCATTCTAGTCCATTCCATTTGAGTCAATTCCATTCCATTCC
ATTCTATTCCTTTCCAATCCATTTGATTCCATTCGATTCAATTCCATTTGATTCTCTTTCATTCTATTTT
ATTCCATGCCATTTGATTGCATTGCATTCCATTCCGTTTGATTCCAGTCCATCCAAGAAAGTTCCATTCC
AGTCCATTGCTTTCCAGTCCATTCCATTCCACTCTAGTCTATTCCACTCCATTCCCTTCCATTGCATTCC
ATACTATTCCATTCCATTCCTTTGCATTCCGTTTCCAATCTAATCGAGTCCATTACATTCCAGTCCAATC
CATTCGATTACATTCCTTTTGATTCCCTGCCAGTCGATTGCATTGCATACTACACCATTCCAAAGGAGTT
CATTCCATTCTATCTCCACACTTTCCATTCCACTCTGTTTGAGTCCATTCCATTCCAGTCCATTTAATTC
AAGGGCATTCCACTCCATTCCATTCCATTCCATTTCATATTATTCCATTCCATTCAATTCCATTCCAGAT
GATTCCATTCCATTCTATACCATTGCTCTCTGTTCCATTCCATTCCATCTGTCTCCATTCCTTTCGTTTC
GATTCCTTTCCATTCCATTCCATTACATTTGATCCTATTTTATTAAATTGCATTCTATTCGAGTGATTTC
CATTCGAGTCCTTTCCATTCGATTCCATTCCATTCTATTCCATTCCTTTAGATTCCATTCCATTCCGTTC
CGTTCACATCAATTCCTGGCGATTCCATTACATTCGATTTCTTGCCATTCGATTCCATTCCTTTTGACTC
CATTTCATTCGATTCCATTCCATTCCATTAATTTCCATTCCATTCGAGACCTTTCCATTGCAGTCTTTTC
CCTTCGAGTCCATTCCGTTCGATTCCCTTCCGTTCGATTCCCTTCCATTCGATTCCATTCCATTGGAGTC
CGTACCAGTCGAGTCCATTCTATTCCAGTCCATTAGTTTCGACTCCATTGCATTCGAGTGCATTCCATTC
CGTGGCTGTCCATTCCATTCCGTTTGATGCCATTCCATACGATTCCATTCAATTCGAGACCATTCTATTC
CTGTCCATTCCTTGTGGTTCGATTCCATTTCACTCTAGTCCATTCCATTCCATTCAATTCCATTCGACTC
TATTCCGTTCCATTCAATTCCATTCCATTCGATTCCATTTTTTTCGACAACCTTCCATTACACTCCCTTC
CATTCCAGTGCATTCCATTCCAGTCTCTTCAGTTCGATTCCATTCCATTCGTTTCGATTCCTTTCCATTC
CAGCCCATTCCATTCCATTCCATTCCTTTCCTTTCCGTTTCATTAGATTCCATTGCATTCCATTCCATTC
AATTCAATTCCGTGCTATTCAATTTGATTCATTTCCATTTAATTCCATTCCATTAGATTCCATTCCGTAC
GATTCCATTCCTTTTGAATCCATTCCATTGGAGTCCATTCACTTCCAGAACATTCCATTCCAGTCGAATC
CATTCGAGTACATTCCATTAAAGTTCATTACATTCTAATACATTCCATTCCATTGCATTCCATTCCATTC
CATTCGATGCCATTCGATTCCATTCCATGCCAAATCATTGCATTCCTTTCCATTCCGTTCCTATCAATTC
CATTCCATTCGATTTAGTTCGATTCTATTCACTTCCATTCCATTCGATTCCATTCCATTGGAGTCAATTC
CTTTCGACACCCAGCCTTTCCAGTCAATGATTTTGGATTCCATTTTTTTGCATTCCATTACATTCTATGA
CATTCGATTCCGTTTCATTGCATTCCATTCCATACATTTTTATTCCATTCGAGACCGTAGCATTCCACTT
TATTCCAGGCCTGTCCATTACACTACATTCCCTTCCATTCCAATGAATTCCATTCCATTCCAATCCATTC
CTTTCCTTTCGCTTGCATTCCATTCTATTCTCTTCTACTGCATACAATTTCACTCCATTCGTTCCCATTC
CATTCAATTCCATTCCATTCAATTCCATTCCATTTGTTTCCATTCTCTTCGATTCCATTTCTTTATATTC
CATGCCATTCGATTCCATTCTATTGGGTTGCATTACATTCGTGTTCATTCCATTCCAGACCATTCCATTT
GACTCCATTCCTTTCGAGCCCTTTCAATTTGAGTCCATTCCTTTCCAGTCCATTTCACTCCAGTCCATTA
CTATCCATTCCATACCATTCCATCCCATTCCATTCCATTCCATTCCATTCCATTCCATTCCATTCCATTC
CATTGCATTCCATTCCATTGCACTGCACTCCATTCCATTACATTCTACTCTATCTGAGTCGATTTTATTG
CATTAGATTCTATTCCATTGGATTACTTTCCATTCGATTACATTCCATTCATGTACATTCCATTCCAGTC
AATTACATTCGAGTTCATTACGTTACATTCCAGTATATTCCATTGTATTCGATCCCATTCCTTTCAATTC
CATTTCATTCGACTCCATTATATTCAATTCCATTCCACTCGAATCCATTCCATTAGCGGACATTCCATTC
CAATGCATTCCATTCCATTCCATAGCATTCCATTGCATTCGATTCCATTCCATTTGATGTCATTCCATTT
GATGCCATCCCATGACATTCCATTCCATTCGAGTCCATTCCGTTCCAATTCATTCCATTCCGTTTCATGA
AATTCGAGTCCTTTCCAGTACATTTCATTCCAATCCCATCCAATCCCATCTACTCCATTCAATTCCTTTC
CATTCCATTTGATTTGATTCCATTGATTTGATTCCATTCAGTTTGATTCCATTCCGTGAAATTTCGTTCC
ATTCTATTCCATTGCATTACTTTCCATTCAATTCCATTCCATTTCATTTCAGTCCATTCGCTTCCTTTCC
TTTCGATTCAATTCCATTTGATAACACTCCATTCTATGCGATTTCATTCCAATCGATTCAATTCCATTCG
ATAACATTCCTTTCGTTTCCATTCAATTCGAGTCCATTTAATTTGAGCATTCGTGTCCATTCTATCCGAG
TCCATTCCATTACCGTCTATTCTATTCCCTTCCATTCCTGTTGATTCAATTTCATTCCCTTCCATTCGAT
TCCTTTCCATTGGATTCCATTCCTTTCCATTCCATTCCATTCGTTCCCATTCCATGTGATTTCATTCCAT
TCCAGTCCATTATATTCGAGTCCACTCCACTCAATTCTATTACATTCAATTCCTTTTGAGTCCGTTCCAT
AACACTCCATTCATTTCGATTCCATTTCTTGCCAGTTTTCTTCCATTTTATTCCATTCCGTTCGATTCCA
TTCCATTCGATTGCATTCCATTCGAATCCTTTCCATTCCATTTCATTCCATTCCTTTCTATTCCATTCCA
TTTCATTCGATTTGATTCCATTCTGTTCTATTCCATTCAATTCTTTTTCATTCCATTCGAATCCTTTCTA
TTGCAGTCCATTCCATTCGAGTCCATTCCAATCCCTTCCATTCCATTCCATTACAGTCCATTCCAATAGA
TTCCATTCCTTTGCCTTCCATTCGAATCCATTCCATTCTAGTCCATTCCATTTGAGTCAATTCCATTCCA
TTCCATTCTATTCCTTTCCAATCCATTCGATTCCATTCGATTCAATTCCATTTGATTCTCTTTCATTCTA
TTTTATTCCATGCCATTTGATTGCATTGCATTCCATTCCGTTTGATTCCAATCCATCCAAGAAAGTTCCA
TTCCAGTCCATTGCTTTCCAGTCCATTCCATTCCACTCTAGTCTATTCCACTCCATTCCCTTCCATTGCA
TTCCATACTATTCCATTCCATTCCTTTGCATTCCGTTTCCAATCTCTTCGAGTCCATTGCATTCCAGTCC
AATCCATTCGATTACATTCCTTTTGATTCCCTGCCAGTCGATTGCATTGCATACTACACCATTCCAAAGG
AGTTCATTCCATTCTATCTCCACACTTTCCATTCCACTCTGTTTGAGTCCATTCCATTCCAGTCCATTTA
ATTCAAGGGCATTCCATTCCATTCCATTCCATTCCATTTCATATTATTCCATTCCATTCAATTCCATTCC
AGATGATTCCATTCCATTCTATACCATTGCTCTCTGTTCCATTCCATTCCATCTGTCTCCATTCCTTTCG
TTTCGATTCCTTTCCATTCCATTCCATTACATTTGATCCTATTTTATTAAATTGCATTCTATTCGAGTGA
TTTCCATTCGAGTCCTTTCCATTCGATTCCATTCCATTCTATTCCATTCCTTTGGATTCCATTCCATTCC
GTTCCGTTCACATCAATTCCTGGCGATTCCATTACATTCGATTTCTTGCCATTCGATTCCATTCCTTTTG
ACTCCATTTCATTCGATTCCATTCCATTCCATTAATTTCCATTCCATTCGAGACCTTTCCATTGCAGTCT
TTTCCCTTCGAGTCCATTCCGTTCGATTCCATTCCGTTCGATTCCCTTCCATTCGATTCCATTCCATTGG
AGTCCGTACCAGTCGAGTCCATTCTATTCCAGTCCATTAGTTTCGACTCCATTGCATTCGAGTGCATTCC
ATTCCGTGGCTGTCCATTCCATTCCGTTTGATGCCATTCCATACGATTCCATTCAATTCGAGACCATTCT
ATTCCTGTCCATTCCTTGTGGTTCGATTCCATTTCACTCTAGTCCATTCCATTCCATTCAATTCCATTCG
ACTCTATTCCGTTCCATTCAATTCCATTCCATTCGATTCCATTTTTTTCGAGAACCTTCCATTACACTCC
CTTCCATTCCAGTGCATTCCATTCCAGTCTCTTCACTTCGATTCCATTCCATTCGTTTCGATTCCTTTCC
ATTCCAGCCCATTCCATTCCATTCCATTCCTTTCCTTTCCGTTTCATTAGATTCCATTGCATTCCATTCC
ATTCAATTCAATTCCGTGCTATTCAATTTGATTCATTTCCATTTAATTCCATTCCATTAGATTCCATTCC
GTACGATTCCATTCCTTTTGAATCCATTCCATTGGAGTCCATTCACTTCCAGAACATTCCATTCCAGTCG
AATCCATTCGAGTACATTCCATTAAAGTTCATTACATTCTAATACATTCCATTCCATTGCATTCCATTCC
ATTCCATTCGATGCCATTCGATTCCATTCCATGCCAAATCATTGCATTCCTTTCCATTCCGTTCCTATCA
ATTCCATTCCATTCGATTTAGTTCGATTCTATTCACTTCCATTCCATTCGATTCCATTCCATTGGAGTCA
ATTCCTTTCGACACCCAGCCTTTCCAGTCAATGATTTTGGATTCATTTTTTTGCATCCATTACATTCTAT
GACATTCGATTCCGTTTCATTGCATTCCATTCCATACATTTTTATTCCATTCGAGACCGTAGCATTCCAC
TTTATTCCAGGCCTGTCCATTACACTACATTCCCTTCCATTCCAATGAATTCCATTCCATTCCAATCCAT
TCCTTTCCTTTCGCTTGCATTCCATTCTATTCTCTTCTACTGCATACAATTTCACTCCATTCGTTCCCAT
TCCATTCAATTCCATTCCATTCAATTCCATTCCATTTGTTTCCATTCTCTTCGATTCCATTTCTTTATAT
TCCATGCCATTCGATTCCATTCTATTGGGTTGCATTACATTCGTGTTCATTCCATTCCAGACCATTCCAT
TTGACTCCATTCCTTTCGAGCGCTTTCAATTTGAGTCCATTCCTTTCCAGTCCATTTCACTCCAGTGCAT
TACTATCCATTCCATACCATTCCATCCCATTCCATTCCATTCCATTCCATTCCATTCCATTCCATTCCAT
TCCATTGCATTCCATTCCATTCCATTCCATTGCACTGCACTCCATTCCATTACATTCTACTCTATCTGAG
TCGATTTTATTGCATTAGATTCTATTCCATTGGATTACTTTCCATTCGATTACATTCCATTCATGTACAT
TCCATTCCAGTCAATTACATTCCAGTTCATTACGTTACATTCCAGTATATTCCATTGTATTCGATCCCAT
TCCTTTCAATTCCATTTCATTCGACTCCATTATATTCGATTCCATTCCACTCGAATCCATTCCATTAGCG
GACATTCCATTCCAATGCATTCCATTCCATTCCATAGCATTCCATTGCATTCGATTCCATTCCATTTGAT
GTCATTCCATTTGATGCCATCCCATGACATTCCATTCCATTTGAGTCCATTCCGTTCCAATTCATTCCAT
TCCGTTTCATGAAATTCGAGTCCTTTCCAGTACATTTCATTCCAATCCCATCCAATCCCATCTACTCCAT
TCAATTCCTTTCCATTCCATTTGATTTGATTCCATTGATTTGATTCCATTCAGTTTCATTCCATTCCGTG
AAATTTCGTTCCATTCTATTCCATTGCATTACTTTCCATTCAATTCCATTCCATTTCATTTCAGTCCATT
CGCTTCCTTTCCTTTCGATTCAATTCCATTTGATTCCACTCCATTCTATGCGATTTCATTCCAATCGATT
CAATTCCATTCGGTGACATTCCTTTCGTTTCCATTCCATTCGAGTCCATTTAATTTGAGCATTCGTGTCC
ATTCTATTCGAGTCCATTCCATTACAGTCTATTCTATTCCCTTCCATTCGTGTTGATTCAATTTCATTCC
CTTCCATTCGATTCCTTTCCATTCGATTCCATTCCTTTCCATTCCATTCCATTCGTTCCCATTCCATGTG
ATTTCATTCCATTCCAGTCCATTATATTCGAGTCCACTCCACTCCATTCTATTACATTCAATTCCTTTTG
AGTCCGTTCCATAACACTCCATTCATTTCGATTCCATTTCTTGCCAGTTTTCTTCCATTTTATTCCATTC
CGTTCGATTCCATTCCATTCGATTGCATTCCATTCGAATCCTTTCCATTCCATTTCATTCCATTCCTTTC
TATTCCATTCCATTTCATTCGATTTGATTCCATTCTGTTCTATTCCATTCAATTCTTTTTCATTCCATTC
GAATCCTTTCTATTGCAGTCCATTCCATTCGAGTCCATTCCAATCCCTTCCATTCCATTCCATTACAGTC
CATTCCAATAGATTCCATTCCTTTGCCTTCCATTCGAATCGATTCCATTCTAGTACATTCCATTTGAGTC
CATTCCATTCCATTCCATTCTATTCCTTTCCAATCCATTCGATTCCATTCGATTCAATTCCATTTGATTC
TCTTTCATTCTATTTTATTCCATGCCATTTGATTGCATTGCATTCCATTCCGTTTGATTCCAGTCCATCC
AAGAAAGTTCCATTCCAGTCCATTGCTTTCCAGTCCATTCCATTCCACTCTAGTCTATTCCACTCCATTC
CCTTCCATTGCATTCCATACTATTCCATTCCATTCCTTTGCATTCCGTTTCCAATCTATTCGAGTCCTTT
GCATTCCAGTCCAATCCATTCGATTACATTCCTTTTGATTCCCTGCCAGTCGATTGCATTGCATACTACA
CCATTCCAAAGGAGTTCATTCCATTCTATCTCCACACTTTCCATTCCACTCTGTTTGAGTCCATTCCATT
CCAGTCCATTTAATTCAAGGGCATTCCATTCCATTCCATTCCATTCCATTTCATATTATTCCATTCCATT
CAATTCCATTCCAGATGATTCCATTCCATTCTATACCATTGCTCTCTGTTCCATTCCATTCCATCTGTCT
CCATTCCTTTCGTTTCGATTCCTTTCCATTCCATTCCATTACATTTGATCCTATTTTATTAAATTGCATT
CTATTCGAGTGATTTCCATTCGAGTCCTTTCCATTCGATTCCATTCCATTCTATTCCATTCCTTTGGATT
CCATTCCATTCCGTTCCGTTCACATCAATTCCTGGCGATTCCATTACATTCGATTTCTTGCCATTCGATT
CCATTCCTTTTGACTCCATTTCATTCGATTCCATTCCATTCCATTAATTTCCATTCCATTCGAGACCTTT
CCATTGCAGTCTTTTCCCTTCGAGTCCATTCCGTTCGATTCCCTTCCGTTCGATTCCCTTCCATTCGATT
CCATTCCATTGGAGTCCGTACCAGTCGAGTCCATTCTATTCCAGTCCATTTGTTTCGACTCCATTGCATT
CGAGTGCATTCCATTCCGTGGCTGTCCATTCCATTCCGTTTGATGCCATTCCATACGATTCCATTCAATT
CGAGACCATTCTATTCCTGTCCATTCCTTGTGGTTCGATTCCATTTCACTCTAGTCCATTCCATTCCATT
CAATTCCATTCGACTCTATTCCGTTCCATTCAATTCCATTCCATTCGATTCCATTTTTTTCGAGAACCTT
CCATTACACTCCCTTCCATTCCAGTGCATTCCATTCCAGTCTCTTCACTTCGATTCCATTCCATTCGTTT
CGATTCCTTTCCATTCCAGCCCATTCCATTCCATTCCATTCCTTTCCTTTCCGTTTCATTAGATTCCATT
GCATTCCATTCCATTCAATTCAATTCCGTGCTATTCAATTTGATTCATTTCCATTTAATTCCATTCCATT
AGATTCCATTCCGTACGATTCCATTCCTTTTGAATCCATTCCATTGGAGTCCATTCACTTCCAGAACATT
CCATTCCAGTCGAATCCATTCGAGTACATTCCATTAAAGTTCATTACATTCTAATACATTCCATTCCATT
GCATTCCATTCCATTCCATTCGATGCCATTCGATTCCATTCCATGCCAAATCATTGCATTCCTTTCCATT
CCGTTCCTATCAATTCCATTCCATTCGATTTAGTTCGATTCTATTCACTTCCATTCCATTCGATTCCATT
CCATTGGAGTCAATTCCTTTCGACACCCAGCCTTTCCAGTCAATGATTTTGGATTCCATTTTTTTGCATT
CCATTACATTCTATGACATTCGATTCCGTTTCATTGCATTCCATTCCATACATTTTTATTCCATTCGAGA
CCGTAGCATTCCACTTTATTCCAGGCCTGTCCATTACACTACATTCCCTTCCATTCCAATGAATTCCATT
CCATTCCAATCCATTCCTTTCCTTTCGCTTGCATTCCATTCTATTCTCTTCTACTGCATACAATTTCACT
CCATTCGTTCCCATTCCATTCAATTCCATTCCATTCAATTCCATTCCATTTGTTTCCATTCTCTTCGATT
CCATTTCTTTATATTCCATGCCATTCGATTCCATTCTATTGGGTTGCATTACATTCGTGTTCATTCCATT
CCAGACCATTCCATTTGACTCCATTCCTTTCGAGCCCTTTCAATTTGAGTCCATTCCTTTCCAGTCCATT
TCACTCCAGTCCATTACTATCCATTCCATACCATTCCATCCCATTCCATTCCATTCCATTCCATTCCATT
CCATTCCATTCCATTCCATTCCATTCCATTGCATTCCATTCCATTCCATTCCATTGCACTGCACTCCATT
CCATTACATTCTACTCTATCTGAGTCGATTTTATTGCATTAGATTCTATTCCATTGGATTACTTTCCATT
CGATTACATTCCATTCATGTACATTCCATTCCAGTCAATTACATTCGAGTTCATTACGTTACATTCCAGT
ATATTCCATTGTATTCGATCCCATTCCTTTCAATTCCATTTCATTCGACTCCATTATATTCAATTCCATT
CCACTCGAATCCACTCCATTAGAGGACATTCCATTCCAATGCATTCCATTCCATTCCATAGCATTCCATT
GCATTCGATTCCATTCCATTTGATGCCATTCCATTTGATGCCATCCCATGACATTCCATTCCATTCGAGT
CCATTCCGTTCCAATTCATTCCATTCCGTTTCATGAAATTCGAGTCCTTTCCAGTACATTTCATTCCAAT
CCCATCCAATCCCATCTACTCCATTCAATTCCTTTCCATTCCATTTGATTTGATTCCATTGATTTGATTC
CATTCAGTTTGATTCCATTCCGTGAAATTTCGTTCCATTCTATTCCATTGCATTACTTTCCATTCAATTC
CATTCCATTTCATTTCAGTCCATTCGCTTCCTTTCCTTTCGATTCAATTCCATTTGATTCCACTCCATTC
TATGCGATTTCATTCCAATCGATTGAATTCCATTCGATGACATTCCTTTCGTTTCCATTCCATTCGAGTC
CATTTAATTTGAGCATTCGTGTCCATTCTATTCGAGTCCATTCCATTACAGTCTATTCTATTCCCTTCCA
TTCCTGTTGATTCAATTTCATTCCCTTCCATTCGATTCCTTTCCATTCGATTCCATTCCTTTCCATTCCA
TTCCATTCGTTCCCATTCCATGTGATTTCATTCCATTCCAGTCCATTATATTCGAGTCCACTCCACTCCA
TTCTATTACATTCAATTCCTTTTGAGTCCGTTCCATAACACTCCATTCATTTCGATTCCATTTCTTGCCA
GTTTTCTTCCATTTTATTCCATTCCGTTCGATTCCATTCCATTCGATTGCATTACATTCGAATCCTTTCC
ATTCCATTTCATTCCATTCCTTTCTATTCCATTCCATTTCATTCGATTTGATTCCATTCTGTTCTATTCC
ATTCAATTCTTTTTCATTCCATTCGAATCCTTTCTATTGCAGTCCATTCCATTCGAGTCCATTCCAATCC
CTTCCATTCCATTCCATTACAGTCCATTCCAATAGATTCCATTCCTTTGCCTTCCATTCGAATCCATTCC
ATTCTAGTCCATTCCATTTGAGTCAATTCCATTCCATTCCATTCTATTCCTTTCCAATCCATTCGATTCC
ATTCGATTCAATTCCATTTGATTCTCTTTCATTCTATTTTATTCCATGCCATTTGATTGCACTGCATTCC
ATTCCGTTTGATTCCAGTCCATCCAAGAAAGTTCCATTCCAGTCCATTGCTTTCCAGTCCATTCCATTCC
ACTCTAGTCTATTCCACTGCATTCCCTTCCATTGCATTCCATACTATTCCATTCCATTCCTTTGCATTCC
GTTTCCAATCTATTCGAGTCCTTTGCATTCCAGTCCAATCCATTCGATTACATACCTTTTGACTCCCTGC
CAGTCGATTGCATTGCATACTACACCATTCCAAAGGAGTTCATTCCATTCTATCTCCACACTTTCCATTC
CACTCTGTTTGAGTCCATTCCATTCCAGTCCATTTAATTCAAGGGCATTCCATTCCATTCCATTCCATTC
CATTTCATATTATTCCATTCCATTCAATTCCATTCCAGATGATTCCATTCCATTCTATACCATTGCTCTC
TGTTCCATTCCATTCCATCTGTCTCCATTCCTTTCGTTTCGATTCCTTTCCATTCCATTCCATTACATTT
GATCCTATTTTATTAAATTGCATTCTATTCGAGTGATTTCCATTCGAGTCCTTTCCATTCGATTCCATTC
CATTCTATTCCATTCCTTTGGATTCCATTCCATTCCGTTCCGTTCACATCAATTCCTGGCGATTCCATTA
CATTCGATTTCTTGCCATTCGATTCCATTCCTTTTGACTCCATTTCATTCGATTCCATTCCATTCCATTA
ATTTCCATTCCATTCGAGACCTTTCCATTGCAGTCTTTTCCCTTCGAGTCCATTCCGTTCGATTCCATTC
CGTTCGATTCCCTTCCATTCGATTCCATTCCATTGGAGTCCGTACCAGTCGAGTCCATTCTATTCCAGTC
CATTAGTTTCGACTCCATTGCATTCGAGTGCATTCCATTCCGTGGCTGTCCATTCCATTCCGTTTGATGC
CATTACATACGATTCCATTCAATTCGAGACCATTCTATTCCTGTCCATTCCTTGTGGTTCGATTCCATTT
CACTCTAGTCCATTCCATTCCATTCAATTCCATTCGACTCTATTCCGTTCCATTCAATTCCATTCCATTC
GATTCCATTTTTTTCGAGAACCTTCCATTACACTCCCTTCCATTCCAGTGCATTCCATTCCAGTCTCTTC
ACTTCGATTCCATTCCATTCGTTTCGATTCCTTTCCATTCCAGCCCATTCCATTCCATTCCATTCCTTTC
CTTTCCGTTTCATTAGATTCCATTGCATTCCATTCCATTCAATTCAATTCCGTGCTATTCAATTTGATTC
ATTTCCATTTAATTCCATTCCATTAGATTCCATTCCGTACGATTCCATTCCTTTTGAATCCATTCCATTG
GAGTCCATTCACTTCCAGAACATTCCATTCCAGTCGAATCCATTCGAGTACATTCCATTAAAGTTCATTA
CATTCTAATACATTCCATTCCATTGCATTCCATTCCATTCCATTCGATGCCATTCGATTCCATTCCATGC
CAAATCATTGCATTCCTTTCCATTCCGTTCCTATCAATTCCATTCCATTCGATTTAGTTCGATTCTATTC
ACTTCCATTCCATTCGATTCCATTCCATTGGAGTCATTTCTTTTCGACACCCAGCCTTTCCAGTCAATGA
TTTTGGATTCCATTTTTTGCATTCCATTACATTCTATGACATTCGATTCCGTTTCATTGCATTCCATTCC
ATACATTTTTATTCCATTCGAGACCGTAGCATTCCACTTTATTCCAGGCCTGTCCATTACACTACATTCC
CTTCCATTCCAATGAATTCCATTCCATTCCAATCCATTCCTTTCCTTTCGCTTGCATTCCATTCTATTCT
CTTCTACTGCATACAATTTCACTCCATTCGTTCCCATTCCATTCAATTCCATTCCATTCAATTCCATTCC
ATTTGTTTCCATTCTCTTCGATTCCATTTCTTTATATTCCATGCCATTCGATTCCATTCTATTGGGTTGC
ATTACATTCGTGTTCATTCCATTCCAGACCATTCCATTTGACTCCATTCCTTTCGAGCCCTTTCAATTTG
AGTCCATTCCTTTCCAGTCCATTTCACTCCAGTCCATTACTATCCATTCCATACCATTCCATCCCATTCC
ATTCCATTCCATTCCATTCCATTCCATTCCATTCCATTCCATTCCATTGCATTCCATTCCATTCCATTCC
ATTGCACTGCACTCCATTCCATTACATTCTACTCTATCTGAGTCGATTTTATTGCATTAGATTCTATTCC
ATTGGATTACTTTCCATTCGATTACATTCCATTCATGTACATTCCATTCCAGTCAATTACATTCGAGTTC
ATTACGTTACATTCCAGTGTATTCCATTGTATTCGATCCCATTCCTTTCAATTCCATTTCATTCGACTCC
ATTATATTCAATTCCATTCCACTCGAATCCATTCCATTAGAGGACATTCCATTCCAATGCATTCCATTCC
ATTCCATAGCATTCCATTGCATTCGATTCCATTCCATTTGATGTCATTCCATTTGATGCCATCCCATGAC
ATTCCATTCCATTCGAGTCCATTCCGTTCCAATTCATTCCATTCCGTTTCATGAAATTCGAGTCCTTTCC
AGTACATTTCATTCCAATCCCATCCAATCCCATCTACTCCATTCAATTCCTTTCCATTCCATTTGATTTG
ATTCCATTGATTTGATTCCATTCAGTTTGATTCCATTCCGTGAAATTTCGTTCCATTCTATTCCATTGCA
TTACTTTCCATTCAATTCCATTCCATTTCATTTCAGTCCATTCGCTTCCTTTCCTTTCGATTCAATTCCA
TTTGATTCCACTCCATTCTATGCGATTTCATTCCAATCGATTCAATTCCATTCGATGACATTCCTTTCGT
TTCCATTCCATTCGAGTCCATTTAATTTGAGCATTCGTGTCCATTCTATTCGAGTCCATTCCATTACAGT
CTATTCTATTCCTTCCATTCGTGTTGATTCAATTTCATTCCCTTCCATCGATTCCTTTCCATGATCCATT
CCTTTCCATCCATTCCATTGTCCCATTCCATGTATTTCATCCATTCCAGTCCATTAATTCGAGCCACCCA
TCCATTCTATTACATTCAATTCCTTTTGAGTCCGTTCCATAACACTCCATTCATTTCGATTCCATTTCTT
GCCAGTTTTCTTCCATTTTATTCCATTCCGTTCGATTCCATTCCATTCGATTGCATTCCATTCGAATCCT
TTCCATTCCATTTCATTCCATTCCTTTCTATTCCATTCCATTTCATTCGATTTCATTCCATTCTGTTCTA
TTCCATTCAATTCTTTTTCATTCCATTCGAATCCTTTCTATTGCAGTCCATTCCATTCGAGTCCATTCCA
ATCCCTTCCATTCCATTCCATTACAGTCCATTCCAATAGATTCCATTCCTTTGCCTTCCATTCGAATCCA
TTCCATTCTAGTCCATTCCATTTGAGTCAATTCCATTCCATTCCATTCTATTCCTTTCCAATCCATTCGA
TTCCATTCGATTCAATTCCATTTGATTCTCTTTCATTCTATTTTATTCCATGCCATTTGATTGCACTGCA
TTCCATTCCGTTTGATTCCAGTCCATCCAAGAAAGTTCCATTCCAGTCCATTGCTTTCCAGTCCATTCCA
TTCCACTCTAGTCTATTCCACTCCATTCCCTTCCATTGCATTCCATACTATTCCATTCCATTCCTTTGCA
TTCCGTTTCCAATCTATTCGAGTCCATTGCATTCCAGTCCAATCCATTCGATTACATTCCTTTTGATTCC
CTGCCAGTCGATTGCATTGCATACTACACCATTCCAAAGGAGTTCATTCCATTCTATCTCCACACTTTCC
ATTCCACTCTGTTTGAGTCCATTCCATTCCAGTCCATTTAATTCAAGGGCATTCCATTCCATTCCATTCC
ATTCCATTTCATATTATTCCATTCCATTCAATTCCATTCCAGATGATTCCATTCCATTCTATACCATTGC
TCTCTGTTCCATTCCATTCCATCTGTCTCCATTCCTTTCGTTTCGATTCCTTTCCATTCCATTCCATTAC
ATTTGATCCTATTTTATTAAATTGCATTCTATTCGAGTGATTTCCATTCGAGTCCTTTCCATTCGATTCC
ATTCCATTCTATTCCATTCCTTTGGATTCCATTCCATTCCGTTCCGTTCACATCAATTCCTGGCGATTCC
ATTACATTCGATTTCTTGCCATTCGATTCCATTCCTTTTGACTCCATTTCATTCGATTCCATTCCATTCC
ATTAATTTCCATTCCATTCGAGACCTTTCCATTGCAGTCTTTTCCCTTCGAGTCCATTCCGTTCGATTCC
CTTCCGTTCGATTCCCGTCCATTCGATTCCATTCCATTGGAGTCCGTACCAGTCGAGTCCATTCTATTCC
AGTCCATTAGTTTCGACTCCATTGCATTCGAGTGCATTCCATTCCGTGGCTGTCCATTCCATTCCGTTTG
ATGCCATTCCATACGATTCCATTCAATTCGAGACCATTCTATTCCTGTCCATTCCTTGTGGTTCGATTCC
ATTTCACTCTAGTCCATTCCATTCCATTCAATTCCATTCGACTCTATTCCGTTCCATTCAATTCCATTCC
ATTCGATTCCATTTTTTTCGACAACCTTCCATTACACTCCCTTCCATTCCAGTGCATTCCATTCCAGTCT
CTTCAGTTCGATTCCATTCCATTCGTTTCGATTCCTTTCCATTCCAGCCCATTCCATTCCATTCCATTCC
TTTCCTTTCCGTTTCATTAGATTCCATTGCATTCCATTCCATTCAATTCAATTCCGTGCTATTCAATTTG
ATTCATTTCCATTTAATTCCATTCCATTAGATTCCATTCCGTACGATTCCATTCCTTTTGAATCCATTCC
ATTGGAGTCCATTCACTTCCAGAACATTCCATTCCAGTCGAATCCATTCGAGTACATTCCATTAAAGTTC
ATTACATTCTAATACATTCCATTCCATTGCATTCCATTCCATTCCATTCGATGCCATTCGATTCCATTCC
ATGCCAAATCATTGCATTCCTTTCCATTCCGTTCCTATCAATTCCATTCCATTCGATTTAGTTTGATTCT
ATTCACTTCCATTCCATTCGATTCCATTCCATTGGAGTCAATTCCTTTCGACACCCAGCCTTTCCAGTCA
ATGATTTTGGATTCCATTTTTTTGCATTCCATTACATTCTATGACATTCGATTCCGTTTCATTGCATTCC
ATTCCATACATTTTTATTCCATTCGAGACCGTAGCATTCCACTTTATTCCAGGCCTGTCCATTACACTAC
ATTCCCTTCCATTCCAATGAATTCCATTCCATTCCAATCCATTCCTTTCCTTTCGCTTGCATTCCATTCT
ATTCTCTTCTACTGCATACAATTTCACTCCATTCGTTCCCATTCCATTCAATTCCATTCCATTCAATTCC
ATTCCCTTTGTTTCCATTCTCTTCGATTCCATTTCTTTATATTCCATGCCATTCGATTCCATTCTATTGG
GTTGCATTACATTCGTGTTCATTCCATTCCAGACCATTCCATTTGACTCCATTCCTTTCGAGCCCTTTCA
ATTTGAGTCCATTCCTTTCCAGTCCATTTCACTCCAGTCTATTACTATCCATTCCATACCATTCCATCCC
ATTCCATTCCATTCCATTCCATTGCATTCCATTCCATTCCATTCCATTGCACTGCACTCCATTCCATTAC
ATTCTACTCTATCTGAGTCGATTTTATTGCATTAGATTCTATTCCATTGGATTACTTTCCATTCGATTAC
ATTCCATTCATGTACATTCCATTCCAGTCAATTACATTCGAGTTCATTACGTTACATTCCAGTATATTCC
ATTGTATTCGATCCCATTCCTTTCAATTCCATTTCATTCGACTCCATTATATTCAATTCCATTCCACTCG
AATCCATTCCATTAGAGGACATTCCATTCCAATGCATTCCATTCCATTCCATAGCATTCCATTGCATTCG
ATTCCATTCCATTTGATGCCATTCCATTTGATGCCATCCCATGACATTCCATTCCATTCGAGTCCATTCC
GTTCCAATTCATTCCATTCCGTTTCATGAAATTCGAGTCCTTTCCAGTACATTTCATTCCAATCCCATCC
AATCCCATCTACTCCATTCAATTCCTTTCCATTCCATTTGATTTGATTCCATTGATTTGATTCCATTCAG
TTTGATTCCATTCCGTGAAATTTCGTTCCATTCTATTCCATTGCATTACTTTCCATTCAATTCCATTCCA
TTTCATTTCAGTCCATTCGCTTCCTTTCCTTTCGATTCAATTCCATTTGATTCCACTCCATTCTATGCGA
TTTCATTCCAATCGATTCAATTCCATTCGATGACATTCCTTTCGTTTCCATTCCATTCGAGTCCATTTAA
TTTGAGCATTCGTGTCCATTCTATTCGAGTCCATTCCATTACAGTCTATTCTATTCCCTTCCATTCGTGT
TGATTCAATTTCATTCCCTTCCATTCGATTCCTTTCCATTCGATTCCATTCCTTTCCATTCCATTCCATT
CGTTCCCATTCCATGTGATTTCATTCCATTCCAGTCCATTATATTCGAGTCCACTCCACTCCATTCTATT
ACATTCAATTCCTTTTGAGTCCGTTCCATAACACTCCATTCATTTCGATTCCATTTCTTGCCAGTTTTCT
TCCATTTTATTCCATTCCGTTCGATTCCATTCCATTCGATTGCATTCCATTCGAATCCTTTCCATTCCAT
TTCATTCCATTCCTTTCTATTCCATTCCATTTCATTCGATTTGATTCCATTCTGTTCTATTCCATTCAAT
TCTTTTTCATTCCATTCGAATCCTTTCTATTGCAGTCCATTCCATTCGAGTCCATTCCAATCCCTTCCAT
TCCATTCCATTACAGTCCATTCCAATAGATTCCATTCCTTTGCCTTCCATTCGAATCCATTCCATTCTAG
TCCATTCCATTTGAGTCAATTCCATTCCATTCCATTCTATTCCTTTCCAATCCATTCGATTCCATTCGAT
TCAATTCCATTTGATTCTCTTTCATTCTATTTTATTCCATGCCATTTGATTGCACTGCATTCCATTCCGT
TTGATTCCAGTCCATCCAAGAAAGTTCCATTCCAGTCCATTGCTTTCCAGTCCATTCCATTCCACTCTAG
TCTATTCCACTCCATTCCCTTCCATTGCATTCCATACTATTCCATTCCATTACTTTGCATTCCGTTTCCA
ATCTATTCGAGTCCATTGCATTCCAGTCCAATCCATTCGATTACATTCCTTTTGATTCCCTGCCAGTCGA
TTGCATTGCATACTACACCATTCCAAAGGAGTTCATTCCATTCTATCTCCACACTTTCCATTCCACTCTG
TTTGAGTCCATTCCATTCCAGTCCATTTAATTCAAGGGCATTCCATTCCATTCCATTCCATTCCATTTCA
TATTATTCCATTCCATTCAATTCCATTCCAGATGATTCCATTCCATTCTATACCATTGCTCTCTGTTCCA
TTCCATTCCATCTGTCTCCATTCCTTTCGTTTCGATTCCTTTCCATTCCATTCCATTACATTTGATCCTA
TTTTATTAAATTGCATTCTATTCGAGTGATTTCCATTCGAGTCCTTTCCATTCGATTCCATTCCATTCTA
TTCCATTCCTTTGGATTCCATTCCATTCCGTTCCGTTCACATCAATTCCTGGCGATTCCATTACATTCGA
TTTCTTGCCATTCGATTCCATTCCTTTTGACTCCATTTCATTCGATTCCATTCCATTCCATTAATTTCCA
TTCCATTCGAGACCTTTCCATTGCAGTCTTTTCCCTTCGAGTCCATTCCGTTCGATTCCCTTCCATTCGA
TTCCATTCCATTGGAGTCCGTACCAGTCGAGTCCATTCTATTCCAGTCCATTAGTTTCGACTCCATTGCA
TTCGAGTGCATTCCATTCCGTGGCTGTCCATTCCATTCCGTTTGATGCCATTCCATACGATTCCATTCAA
TTCGAGACCATTCTATTCCTGTCCATTCCTTGTGGTTCGATTCCATTTCACTCTAGTCCATTCCATTCCA
TTCAATTCCATTCGACTCTATTCCGTTCCATTCAATTCCATTCCATTCGATTCCATTTTTTTCGACAACC
TTCCATTACACTCCCTTCCATTCCAGTGCATTCCATTCCAGTCTCTTCAGTTCGATTCCATTCCATTCGT
TTCGATTCCTTTCCATTCCAGCCCATTCCATTCCATTCCATTCCTTTCCTTTCCGTTTCATTAGATTCCA
TTGCATTCCATTCCATTCAATTCAATTCCGTGCTATTCAATTTGATTCATTTCCATTTAATTCCATTCCA
TTAGATTCCATTCCGTACGATTCCATTCCTTTTGAATCCATTCCATTGGAGTCCATTCACTTCCAGAACA
TTCCATTCCAGTCGAATCCATTCGAGTACATTCCATTAAAGTTCATTACATTCTAATACATTCCATTCCA
TTGCATTCCATTCCATTCCATTCGATGCCATTCGATTCCATTCCATGCCAAATCATTGCATTCCTTTCCA
TTCCGTTCCTATCAATTCCATTCCATTCGATTTAGTTCGATTCTATTCACTTCCATTCCATTCGATTCCA
TTCCATTGGAGTCAATTCCTTTCGACACCCAGCCTTTCCAGTCAATGATTTTGGATTCCATTTTTTTGCA
TTCCATTACATTCTATGACATTCGATTCCGTTTCATTGCATTCCATTCCATACATTTTTATTCCATTCGA
GACCGTAGCATTCCACTTTATTCCAGGCCTGTCCATTACACTACATTCCCTTCCATTCCAATGAATTCCA
TTCCATTCCAATCCATTCCTTTCCTTTCGCTTGCATTCCATTCTATTCTCTTCTACTGCATACAATTTCA
CTCCATTCGTTCCCATTCCATTCAATTCCATTCCATTCAATTCCATTCCATTTGTTTCCATTCTCTTCGA
ATCCATTTCTTTATAATCCATGCCATTCGATTCCATTCTATTGGGTTGCATTACATTCGTGTTCATTCCA
TTCCAGACCATTCCATTTGACTCCATTCCTTTCGAGACCTTTCAATTTGAGTCCATTCCTTTCCAGTCCA
TTTCACTCCAGTCCATTACTATCCATTCCATACCATTCCATCCCATTCCATCTCATTCCATTCCATTCCA
TTCCATTCCATTCCATTCCATTCCATTGCATTCCATTCCATTCCATTCCATTGCACTGCACTCCATTCCA
TTACATTCTACTCTATCTGAGTCGATTTTATTGCATTAGATTCTATTCCATTGGATTACTTTCCATTCGA
TTACATTCCATTCATGTACATTCCATTCCAGTCAATTACATTCGAGTTCATTACGTTACATTCCAGTATA
TTCCATTGTATTCGATCCCATTCCTTTCAATTCCATTTCATTCGACTCCATTATATTCAATTCCATTCCA
CTCGAATCCATTCCATTAGCGGACATTCCATTCCAATGCATTCCATTCCATTCCATAGCATTCCATTGCA
TTCGATTCCATTCCATTTGATGTCATTCCATTTGATGCCATCCCATGACATTCCATTCCATTCGAGTCCA
TTCCGTTCCAATTCATTCCATTCCGTTTCATGAAATTCGAGTCCTTTCCAGTACATTTCATTCCAATCCC
ATCCAATCCCATCTACTCCATTCAATTCCTTTCCATTCCATTTGATTTGATTCCATTGATTTGATTCCAT
TCAGTTTGATTCCATTCCGTGAAATTTCGTTCCATTCTATTCCATTGCATTACTTTCCATTCAATTCCAT
TCCATTTCATTTCAGTCCATTCGCTTCCTTTCCTTTCGATTCAATTCCATTTGATTCCACTCCATTCTAT
GCGATTTCATTCCAATCGATTCAATTCCATTCGATGACATTCCTTTCGTTTCCATTCCATTCGAGTCCAT
TTAATTTGAGCATTCGTGTCCATTCTATTCGAGTCCATTCCATTACAGTCTATTCTATTCCCTTCCATTC
GTGTTGATTCAATTTCATTCCCTTCCATTCGATTCCTTTCCATTCGATTCCATTCCTTTCCATTCCATTC
CATTCGTTCCCATTCCATGTGATTTCATTCCATTCCAGTCCATTATATTCGAGTCCACTCCACTCCATTC
TATTACATTCAATTCCTTTTGAGTCCGTTCCATAACACTCCATTCATTTCGATTCCATTTCTTGCCAGTT
TTCTTCCATTTTATTCCATTCCGTTCGATTCCATTCCATTCGATTGCATTCCATTCGAATCCTTTCCATT
CCATTTCATTCCATTCCTTTCTATTCCATTCCATTTCATTCGATTTCATTCCATTCTGTTCTATTCCATT
CAATTCTTTTTCATTCCATTCGAATCCTTTCTATTGCAGTCCATTCCATTCGAGTCCATTCCAATCCCTT
CCATTCCATTCCATTACAGTCCATTCCAATAGATTCCATTCCTTTGCCTTCCATTCGAATCCATTCCATT
CTAGTCCATTCCATTTGAGTCAATTCCATTCCATTCCATTCTATTCCTTTCCAATCCATTCGATTCCATT
CGATTCAATTCCATTTGATTCTCTTTCATTCTATTTTATTCCATGCCATTTGATTGCACTGCATTCCATT
CCGTTTGATTCCAGTCCATCCAAGAAAGTTCCATTCCAGTCCATTGCTTTCCAGTCCATTCCATTCCACT
CTAGTCTATTCCACTCCATTCCCTTCCATTGCATTCCATACTATTCCATTCCATTCCTTTGCATTCCGTT
TCCAATCTATTCGAGTCCATTGCATTCCAGTCCAATCCATTCGATTACATTCCTTTTGATTCCCTGCCAG
TCGATTGCATTGCATACTACACCATTCCAAAGGAGTTCATTCCATTCTATCTCCACACTTTCCATTCCAC
TCTGTTTGAGTCCATTCCATTCCAGTCCATTTAATTCAAGGGCATTCCATTCCATTCCATTCCATTCCAT
TTCATATTATTCCATTCCATTCAATTCCATTCCAGATGATTCCATTCCATTCTATACCATTGCTCTCTGT
TCCATTCCATTCCATCTGTCTCCATTCCTTTCGTTTCCATTCCTTTCCATTCCATTCCATTCCATTTGAT
CCTATTTTGTTAAATTGCATTCTATTCGAGTGATTTCCATTCGAGTCCTTTCCATTCGATTCCATTCCAT
TCTATTCCATTCCTTTGGATTCCATTCCATTCCGTTCCGTTCACATCAATTCCTGGCGATTCCATTACAT
TCGATTTCTTGCCATTCGATTCCATTCCTTTTGACTCCATTTCATTCGATTCCATTCCATTCCATTAATT
TCCATTCCATTCGAGACCTTTCCATTGCAGTCTTTTCCCTTCGAGTCCATTCCGTTCGATTCCATTCCGT
TCGATTCCCTTCCATTCGATTCCATTCCATTGGAGTCCGTACCAGTCGAGTCCATTCTATTCCAGTCCAT
TAGTTTCGACTCCATTGCATTCGAGTGCATTCCATTCCGTGGCTGTCCATTCCATTCCGTTTGATGCCAT
TCCATACGATTCCATTCAATTCGAGACCATTCTATTCCTGTCCATTCCTTGTGGTTCGATTCCATTTCAC
TCTAGTCCATTCCATTCCATTCAATTCCATTCGACTCTATTCCGTTCCATTCAATTCCATTCCATTCGAT
TCCATTTTTTTCGAGAGCCTTCCATTACACTCCCTTCCATTCCAGTGCATTCCATTACAGTCTCTTCACT
TCGATTCCATTCCATTCGTTTCGATTCCTATCCATTCCAGCCCATTCCATTCCATTCCATTCCTTTCCTT
TCCGTTTCATTAGATTCCATTGCATTCCATTCCATTCAATTCAATTCCGTGCTATTCAATTTGATTCATT
TCCATTTAATTCCATTCCATTAGATTCCATTCCGTACGATTCCATTCCTTTTGAATCCATTCCATTGGAG
TCCATTCACTTCCAGAACATTCCATTCCAGTCGAATCCATTCGAGTACATTCCATTAAAGTTCATTACAT
TCTAATACATTCCATTCCATTGCATTCCATTCCATTCCATTCGATGCCATTCGATTCCATTCCATGCCAA
ATCATTGCATTCCTTTCCATTCCGTTCCTATCAATTCCATTCCATTCGATTTAGTTCGATTCTATTCACT
TCCATTCCATTCGATTCCATTCCATTGGAGTCAATTCCTTTCGACACCCAGCCTTTCCAGTCAATGATTT
TGGATTCCATTTTTTTGCATTCCATTACATTCTATGACATTCGATTCCGTTTCATTGCATTCCATTCCAT
ACATTTTTATTCCATTCGAGACCGTAGCATTCCACTTTATTCCAGACCTGTCCATTACACTACATTCCCT
TCCATTCCAATGAATTCCATTCCATTCCAATCCATTCCTTTCCTTTCGCTTGCATTCCATTCTATTCTCT
TCTACTGCATACAATTTCACTCCATTCGTTCCCATTCCATTCAATTCCATTCCATTCAATTCCATTCCAT
TTGTTTCCATTCTCTTCGATTCCATTTCTTTATATTCCATGCCATTCGATTCCATTCTATTGGGTTGCAT
TACATTCGTGTTCATTCCATTCCAGACCATTCCATTTGACTCCATTCCTTTCGAGCCCTTTCAATTTGAG
TCCATTCCTTTCCAGTCCATTACACTCCAGTCTATTACTATCCATTCCATACCATTCCATCCCATTCCAT
TCCATTCCATTCCATTCCATTCCATTCCATTCCATTCCATTGCATTCCATTCCATTCCATTCCATTGCAC
TGCACTCCATTCCATTACATTCTACTCTAACTGAGTCGATTTTATTGCATTAGATTCTATTCCATTGGAT
TACTTTCCATTCGATTACATTCCATTCATGTACATTCCATTCCAGTCAATTACATTCGAGTTCATTACGT
TACATTCCAGTATATTCCATTGTATTCGATCCCATTCCTTTCAATTCCATTTCATTCGACTCCATTATAT
TCAATTCCATTCCACTCGAATCCATTCCATTAGAGGACATTCCATTCCAATGCATTCCATTCCATTCCAT
AGCATTCCACTGCATTCGATTCCATTCCATTTGATGCCATTACATTTGATGCCATCCCATGACATTCCAT
TCCATTCGAGTCCATTCCGTTCCAATTCATTCCATTCCGTTTCATGAAATTCGAGTCCTTTCCAGTACAT
TTCATTCCAATCCCATCCAATCCCATCTACTCCATTCAATTCCTTTCCATTCCATTTGATTTGATTCCAT
TGATTTGATTCCATTCAGTTTGATTCCATTCCGTGAAATTTCGTTCCATTCTATTCCATTGCATTACTTT
CCATTCAATTCCATTCCATTTCATTTCAGTCCATTCGCTTCCTTTCCTTTCGATTCAATTCCATTTGATT
CCACTCCATTCTATGCGATGTCATTCCAATCGATTCAATTCCATTCGATGACATTCCTTTCGTTTCCATT
CCATTCGAGTCCATTTAATTTGAGCATTCGTGTCCATTCTATTCGAGTCCATTCCATTACAGTCTATTCT
ATTCCCTTCCATTCGTGTTGATTCAATTTCATTCCCTTCCATTCGATTCCTTTCCATTCGATTCCATTCC
TTTCCATTCCATTCCATTCGTTCCCATTCCATGTGATTTCATTCCATTCCAGTCCATTATATTCGAGTCC
ACTCCACTCCATTCTATTACATTCAATTCCTTTTGAGTCCGTTCCATAACACTCCATTCATTTCGATTCC
ATTTCTTGCCAGTTTTCTTCCATTTTATTCCATTCCGTTCGATTCCATTCCATTCGATTGCATTCCATTC
GAATCCTTTCCATTCCATTTCATTCCATTCCTTTCTATTCCATTCCATTTCATTCGATTTGATTCCATTC
TGTTCTATTCCATTCAATTCTTTTTCATTCCATTCGAATCCTTTCTATTGCAGTCCATTCCATTCCATTA
CAGTCCATTCCAATCCCTTCCATTCCTTTGCCTTCCATTCGAATCCATTCCATTCTAGTCCATTCCATTT
GAGTCAATTCCATTCCATTCCATTCTATTCCTTTCCAATCCATTCGATTCCATTCGATTCAATTCCATTT
GATTCTCTTTCATTCTATTTTATTCCATGCCATTTGATTGCACTGCATTCCATTCCGTTTGATTCCAGTC
CATCCAAGAAAGTTCCATTCCAGTCCATTGCTTTCCAGTCCATTCCATTCCACTCTAGTCTATTCCACTG
CATTCCCTTCCATTGCATTCCATACTATTCCATTCCATTCCTTTGCATTCCGTTTCCAATCTATTCGAGT
CCTTTGCATTCCAGTCCAATCCATTCGATTACATACCTTTTGACTCCCTGCCAGTCGATTGCATTGCATA
CTACACCATTCCAAAGGAGTTCATTCCATTCTATCTCCACACTTTCCATTCCACTCTGTTTGAGTCCATT
CCATTCCAGTCCATTTAATTCAAGGGCATTCCATTCCATTCCATTCCATTCCATTTCATATTATTCCATT
CCATTCAATTCCATTCCAGATGATTCCATTCCATTCTATACCATTGCTCTCTGTTCCATTCCATTCCATC
TGTCTCCATTCCTTTCGTTTCGATTCCTTTCCATTCCATTCCATTACATTTGATCCTATTTTATTAAATT
GCATTCTATTCGAGTGATTTCCATTCGAGTCCTTTCCATTCGATTCCATTCCATTCTATTCCATTCCTTT
GGATTCCATTCCATTCCGTTCCGTTCACATCAATTCCTGGCGATTCCATTACATTCGATTTCTTGTCATT
CGATTCCATTCCTTTTGACTCCATTTCATTCGATTCCATTCCATTCCATTAATTTCCATTCCATTCGAGA
CCTTTCCATTGCAGTCTTTTCCCTTCGAGTCCATTCCGTTCGATTCCATTCCGTTCGATTCCCTTCCATT
CGATTCCATTCCATTGGAGTCCGTACCAGTCGAGTCCATTCTATTCCAGTCCATTAGTTTCGACTCCATT
GCATTCGAGTGCATTCCATTCCGTGGCTGTCCATTCCATTCCGTTTGATGCCATTCCATACGATTCCATT
CAATTCGAGACCATTCTATTCCTGTCCATTCCTTGTGGTTCGATTCCATTTCACTCTAGTCCATTCCATT
CCATTCAATTCCATTCGACTCTATTCCGTTCCATTCAATTCCATTCCATTCGATTCCATTTTTTTCGAGA
ACCTTCCATTACACTCCCTTCCATTCCAGTGCATTCCATTCCAGTCTCTTCACTTCGATTCCATTCCATT
CGTTTCGATTCCTTTCCATTCCAGCCCATTCCATTCCATTCCATTCCTTTCCTTTCCGTTTCATTAGATT
CCATTGCATTCGATTCCATTCAATTCAATTCCGTGCTATTCAATTTGATTCATTTCCATTTAATTCCATT
CCATTAGATTCCATTCCGTACGATTCCATTCCTTTTGAATCCATTCCATTGGAGTCCATTCACTTCCAGA
ACATTCCATTCCAGTCGAATCCATTCGAGTACATTCCATTAAAGTTCATTACATTCTAATACATTCCATT
CCATTGCATTCCATTCCATTCCATTCGATGCCATTCGATTCCATTCCATGCCAAATCATTGCATTCCTTT
CCATTCCGTTCCTATCAATTCCATTCCATTCGATTTAGTTCGATTCTATTCACTTCCATTCCATTCGATT
CCATTCCATTGGAGTCAATTCCTTTCGACACCCAGCCTTTCCAGTCAATGATTTTGGATTCCATTTTTTT
GCATTCCATTACATTCTATGACATTCGATTCCGTTTCATTGCATTCCATTCCATACATTTTTATTCCATT
CGAGACCGTAGCATTCCACTTTATTCCAGGCCTGTCCATTACACTACATTCCCTTCCATTCCAATGAATT
CCATTCCATTCCAATCCATTCCTTTCCTTTCGCTTGCATTCCATTCTATTCACTTCTACTGCATACAATT
TCACTCCATTCGTTCCCATTCCATTCAATTCCATTCCATTTGTTTCCATTCTCTTCGATTCCATTTCTTT
ATATTCCATGCCATTCGATTCCATTCTATTGGGTTGCATTACATTCGTGTTCATTCCATTCCAGACCATT
CCATTTGACTCCATTCCTTTCGTGCCCTTTCAATTTGAGTCCATTCCTTTCCAGTCCATTTCACTCCAGT
CCATTACTATCCATTCCATACCATTCCATCCCATTCCATTCCATTCCATTCCATTGCATTCCATTCCATT
CCATTCCATTGCACTGCACTCCATTCCATTACATTCTACTCTATCTGAGTCGATTTTATTGCATTAGATT
CTATTCCATTGGATTACTTTCCATTCGATTACATTCCATTCATGTACATTCCATTCCAGTCAATTACATT
CGAGTTCATTACGTTACATTCCAGTATATTCCATTGTATTCGATCCCATTCCTTTCAATTCCATTTCATT
CGACTCCATTATATTCAATTCCATTCCACTCGAATCCATTCCATTAGAGGACATTCCATTCCAATGCATT
CCATTCCATTCCATAGCATTCCATTGCATTCGATTCCATTCCATTTGATGCCATTCCGTTTGATGCCATC
CCATGACATTCCATTCCATTCGAGTCCATTCCGTTCCAATTCATTCCATTCCGTTTCATGAAATTCGAGT
CCTTTCCAGTACATTTCATTCCAATCCCATCCAATCCCATCTACTCCATTCAATTCCTTTCCATTCCATT
TGATTTGATTCCATTGATTTGATTCCATTCAGTTTGATTCCATTCCGTGAAATTTCGTTCCATTCTATTC
CATTGCATTACTTTCCATTCAATTCCATTCCATTTCATTTCAGTCCATTCGCTTCCTTTCCTTTCGATTC
AATTCCATTTGATTCCACTCCATTCTATGCGATTTCATTCCAATCGATTCAATTCCATTCGATGACATTC
CTTTCGTTTCCATTCCATTCATGTCCATTTAATTTGAGCATTCGTGTCCATTCTATTCGAGTCCATTCCA
TTACCGTCTATTCTATTCCCTTCCATTCCTGTTGATTCAATTTCATTCCCTTCCATTCGATTCCTTTCCA
TTCGATTCCATTCCTTTCCATTCCATTCCATTCGTTCCCATTCCATGTGATTTCATTCCATTCCAGTCCA
TTATATTCGAGTCCACTCCACTCCATTCTATTACATTCAATTCCTTTTGAGTCCGTTCCATAACACTCCA
TTCATTTCGATTCCATTTCTTGCCAGTTTTCTTCCATTTTATTCCATTCCATTCGATTGCATTCCATTCG
AATCCTTTCCATTCCATTTCATTCCATTCCTTTCTATTCCATTCCATTTCATTCGATTTGATTCCATTCT
GTTCTATTCCATTCAATTCTTTTTCATTCCATTCGAATCCTTTCTATTGCAGTCCATTCCATTCGAGTCC
ATTCCAATCCCTTCCATTCCATTCCATTACAGTCCATTCCAATAGATTCCATTCCTTTGCCTTCCATTCC
AATCCATTCCATTCTAGTCCATTCCATTTGAGTCAATTCCATTCCATTCCATTCTATTCCTTTCCAATCC
ATTCGATTCCATTCGATTCAATTCCATTTGATTCTCTTTCATTCTATTTTATTCCATGCCATTTGATTGC
ATTGCATTCCATTCCGTTTGGTTCCAGTCCATCCAAGAAAGTTCCATTCCAGTCCATTGCTTTCCAGTCC
ATTCCATTCCACTCTAGTCTATTCCACTCCATTCCCTTCCATTGCATTCCATACTATTCCATTCCATTCC
TTTGCATTCCGTTTCCAATCTATTCGAGTCCATTGCATTCCAGTCCAATCCATTCGATTACATTCCTTTT
GATTCCCTGCCAGTCGATTGCATTGCATACTACACCATTCCAAAGGAGTTCATTCCATTCTATCTCCACA
CTTTCCATTCCACTCTGTTTGAGTCCATTCCATTCCAGTCCATTTAATTCAAGGGCATTCCATTCCATTC
CATTCCATTCCATTTCATATTATTCCATTCCATTCAATTCCATTCCAGATGATTCCATTCCATTCTATAC
CATTGCTCTCTGTTCCATTCCATTCCATCTGTCTCCATTCCTTTCGTTTCGATTCCTTTCCATTCCATTC
CATTACATTTGATCCTATTTTATTAAATTGCATTCTATTCGAGTGATTTCCATTCGAGTCCTTTCCATTC
GATTCCATTCCATTCTATTCCATTCCTTTGGATTCCATTCCATTCCGTTCCGTTCACATCAATTCCTGGC
GATTCCATTACATTCGATTTCTTGCCATTCGATTCCATTCCTTTTGACTCCATTTCATTCGATTCCATTC
CATTCCATTAATTTCCATTCCATTCGAGACCTTTCCATTGCAGTCTTTTCCCTTCGAGTCCATTCCGTTC
GATTCCATTCCGTTCGATTCCCTTCCATTCGATTCCATTCCATTGGAGTCCGTACCAGTCGAGTCCATTC
TATTCCAGTCCATTAGTTTTGACTCCATTGCATTCGAGTGCATTCCATTCCGTGGCTGTCCATTCCATTC
CGTTTGATGCCATTCCATACGATTCCATTCAATTCGAGACCATTCTATTCCTGTCCATTCCTTGTGGTTC
GATTCCATTTCACTCTAGTCCATTCCATTCCATTCAATTCCATTCGACTCTATTCCGTTCCATTCAATTC
CATTCCATTCGATTCCATTTTTTTCGAGAACCTTCCATTACACTCCCTTCCATTCCAGTGCATTCCATTC
CAGTCTCTTCACTTCGATTCCATTCCATTCGTTTCGATTCCTTTCCATTCCAGCCCATTCCATTCCATTC
CATTCCTTTCCTTTCCGTTTCATTAGATTCCATTGCATTCCATTCCATTCAATTCAATTCCGTGCTATTC
AATTTGATTCATTTCCATTTAATTCCATTCCATTAGATTCCATTCCGTACGATTCCATTCCTTTTGAATC
CATTCCATTGGAGTCCATTCACTTCCAGAACATTCCATTCCAGTCGAATCCATTCGAGTACATTCCATTA
AAGTTCATTCCATTCTAATACATTCCATTCCATTGCATTCCATTCCATTCCATTCGATGCCATTCGATTC
CATTCCATGCCAAATCATTGCATTCTTTTCCATTCCGTTCCTATCAATTCCATTCCATTCGATTTAGTTC
GATTCTATTCACTTCCATTCCATTCGATTCCATTCCATTGGAGTCAATTCCTTTCGACACCCAGCCTTTC
CAGTCAATGATTTTGGATTCCATTTTTTTGCATTCCATTACATTCTATGACATTCGATTCCGTTTCATTG
CATTCCATTCCATACATTTTTATTCCATTCGAGACCGTAGCATTCCACTTTATTCCAGGCCTGTCCATTA
CACTACATTCCCTTCCATTCCAATGAATTCCATTCCATTCCAATCCATTCCTTTCCTTTCGCTTGCATTC
CATTCTATTCTCTTCTACTGCATACAATTTCACTCCATTCGTTCCCATTCCATTCAATTCCATTCCATTC
AATTCCATTCCATTTGTTTCCATTCTCTTCGATTCCATTTCTTTATATTCCATGCCATTCGATTCCATTC
TATTGGGTTGCATTACATTCGTGTTCATTCCATTCCAGACCATTCCATTTGACTCCATTCCTTTCGAGCC
CTTTCAATTTGAGTCCATTCCTTTCCAGTCCATTTCACTCCAGTCCATTACTATCCATTCCATACCATTC
CATCCCATTCCATTCCATTCCATTCCATTCCATTCCATTCCATTCCATTCCATTGCATTCCATTCCATTC
CATTCCATTGCACTGCACTCCATTCCATTACATTCTACTCTATCTGAGTCGATTTTATTGCATTAGATTC
TATTCCATTGGATTACTTTCCATTCGATTACATTCCATTCATGTACATTCCATTCCAGTCAATTACATTC
GAGTTCATTACGTTACATTCCAGTATATTCCATTGTATTCGATCCCATTCCTTTCAATTCCATTTCATTC
GACTCCATTATATTCAATTCCATTCCACTCGAATCCATTCCATTAGCGGACATTCCATTCCAATGCATTC
CATTCCATTCCATAGCATTCCATTGCATTCGATTCCATTCCATTTGATGTCATTCCATTTGATGCCATCC
CATGACATTCCATTCCATTCGAGTCAATTCCGTTCCAATTCATTCCATTCCGTTTCATGAAATTCGAGTC
CTTTCCAGTACATTTCATTCCAATCCCATCCAATCCCATCTACTCCATTCAATTCCTTTCCATTCCATTT
GATTTGATTCCATTGATTTGATTCCATTCAGTTTGATTCCATTCCGTGAAATTTCGTTCCATTCTATTCC
ATTGCATTACTTTCCATTCAATTCCATTCCATTTCATTTCAGTCCATTCGCTTCCTTTCCTTTCGATTCA
ATTCCATTTGATTCCACTCCATTCTATGCGATTTCATTCCAATCGATTCAATTCCATTCGATGACATTCC
TTTCGTTTCCATTCCATTCGAGTCCATTTAATTTGAGCATTCGTGTCCATTCTATTCGAGTCCATTCCAT
TACCGTCTATTCTATTCCCTTCCATTCCTGTTGATTCAATTTCATTCCCTTCCATTCGATTCCTTTCCAT
TCGATTCCATTCCTTTCCATTCCATTCCATTCGTTCCCATTCCATGTGATTTCATTCCATTCCAGTCCAT
TATATTCGAGTCCACTCCACTCCATTCTATTACATTCAATTCCTTTTGAGTCCGTTCCATAACACTCCAT
TCATTTCGATTCCATTTCTTGCCAGTTTTCTTCCATTTTATTCCATTCCGTTCGATTCCATTCCATTCGA
TTGCATTCCATTCGAATCCTTTCCATTCCATTTCATTCCATTCCTTTCTATTCCATTCCATTTCATTCGA
TTTGATTCCATTCTGTTCTATTCCATTCAATTCTTTTTCATTCCATTCGAATCCTTTCTATTGCAGTCCA
TTCCATTCGAGTCCATTCCAATCCCTTCCATTCCATTCCATTACAGTCCATTCCAATAGATTCCATTCCT
TTGCCTTCCATTCGAATCCATTCCATTCTAGTCCATTCCATTTGAGTCAATTCCATTCCATTCCATTCTA
TTCCTTTCCAATCCATTCGATTCCATTCGATTCAATTCCATTTGATTCTCTTTCATTCTATTTTATTCCA
TGCCATTTGATTGCATTGCATTCCATTCCGTTTGGTTCCAGTCCATCCAAGAAAGTTCCATTCCAGTCCA
TTGCTTTCCAGTCCATTCCATTCCACTCTAGTCTATTCCACTCCATTCCCTTCCATTGCATTCCATACTA
TTCCATTCCATTCCTTTGCATTCCGTTTCCAATCTATTCGAGTCCATTGCATTCCAGTCCAATCCATTCG
ATTACATTCCTTTTGATTCCCTGCCAGTCGATTGCATTGCATACTACACCATTCCAAAGGAGTTCATTCC
ATTCTATCTCCACACTTTCCATTCCACTCTGTTTGAGTCCATTCCATTCCAGTCCATTTAATTCAAGGGC
ATTCCATTCCATTCCATTCCATTCCATTTCATATTATTCCATTCCATTCAATTCCATTCCAGATGATTCC
ATTCCATTCTATACCATTGCTCTCTGTTCCATTCCATTCCATCTGTCTCCATTCCTTTCGTTTCCATTCC
TTTCCATTCCATTCCATTCCATTTGATCCTATTTTGTTAAATTGCATTCTATTCGAGTGATTTCCATTCG
AGTCCTTTCCATTCGATTCCATTCCATTCTATTCCATTCCTTTGGATTCCATTCCATTCCGTTCCGTTCA
CATCAATTCCTGGCGATTCCATTACATTCGATTTCTTGCCATTCGATTCCATTCCTTTTGACTCCATTTC
ATTCGATTCCATTCCATTCCATTAATTTCCATTCCATTCGAGACCTTTCCATTGCAGTCTTTTCCCTTCG
AGTCCATTCCGTTCGATTCCATTCCGTTCGATTCCCTTCCATTCGATTCCATTCCATTGGAGTCCGTACC
AGTCGAGTCCATTCTATTCCAGTCCATTAGTTTTGACTCCATTGCATTCGAGTGCATTCCATTCCGTGGC
TGTCCATTCCATTCCGTTTGATGCCATTCCATACGATTCCATTCAATTCGAGACCATTCTATTCCTGTCC
ATTCCTTGTGGTTCGATTCCATTTCACTCTAGTCCATTCCATTCCATTCAATTCCATTCGACTCTATTCC
GTTCCATTCAATTCCATTCCATTCGATTCCATTTTTTTCGAGAGCCTTCCATTACACTCCCTTCCATTCC
AGTGCATTCCATTACAGTCTCTTCACTTCGATTCCATTCCATTCGTTTCGATTCCTATCCATTCCAGCCC
ATTCCATTCCATTCCATTCCTTTCCTTTCCGTTTCATTAGATTCCATTGCATTCCATTCCATTCAATTCA
ATTCCATGCTATTCAATTTGATTCATTTCCATTTAATTCCATTCCATTAGATTCCATTCCGTACGATTCC
ATTCCTTTTGAATCCATTCCATTGGAGTCCATTCACTTCCAGAACATTCCATTCCAGTCGAATCCATTCG
AGTACATTCCATTAAAGTTCATTACATTCTAATACATTCCATTCCATTGCATTCCATTCCATTCCATTCG
ATGCCATTCGATTCCATTCCATGCCAAATCATTGCATTCCTTTCCATTCCGTTCCTATCAATTCCATTCC
ATTCGATTTAGTTCGATTCTATTCACTTCCATTCCATTCGATTCCATTCCATTGGAGTCAATTCCTTTCG
ACACCCAGCCTCTCCAGTCAGTGATTTTGGATTCCATTTTTTTGCATTCCATTACATTCTATGACATTCG
ATTCCGTTTCATTGCATTCCATTCCATACATTTTTATTCCATTCGAGACCGTAGCATTCCACTTTATTCC
AGGCCTGTCCATTACACTACATTCCCTTCCATTCCAATGAATTCCATTCCATTCCAATCCATTCCTTTCC
TTTCGCTTGCATTCCATTCTATTCTCTTCTACTGCATACAATTTCACTCCATTCGTTCCCATTCCATTCA
ATTCCATTCCATTCAATTCCATTCCATTTGTTTCCATTCTCTTCGATTCCATTTCTTTATATTCCATGCC
ATTCGATTCCATTCTATTGGGTTGCATTACATTCGTGTTCATTCCATTCCAGACCATTCCATTTGACTCC
ATTCCTTTCGAGCCCTTTCAATTTGAGTCCATTCCTTTCCAGTCCATTTCACACCAGTCCATTACTATCC
ATTCCATACCATTCCATCCCACTCCATTCCATTCCATTCCATTCCATTCCATTCCATTCCATTGCATTCC
ATTCCATTCCATTCCATTGCACTGCACTCCATTCCATTACATTCTACTCTATCTGAGTCGATTTTATTGC
ATTAGATTCTATTCCATTGGATTACTTTCCATTCGATTACATTCCATTCATGTACATTCCTTTCCAGTCA
ATTACATTCGAGTTCATTACGTTACATTCCAGTATATTCCATTGTATTCGATCCCATTCCTTTCAATTCC
ATTTCATTCGACTCCATTATATTCAATTCCATTCCACTCGAATCCATTCCATTAGAGGACTTTCCATTCC
AATGCATTCCATTCCATTCCATAGCATTCCATTGCATTCGATTCCATTCCATTTGATGCCATTCCATTTG
ATGCCATCCCATGACATTCCATTCCATTCGAGTCCATTCCGTTCCAATTCATTCCATTCCGTTTCATGAA
ATTCGAGTCCTTTCCAGTACATTTCATTCCAATCCCATCCAATCCCATCTACTCCATTCAATTCCTTTCC
ATTCCATTTGATTTGATTCCATTGATTTGATTCCATTCAGTTTGATTCCATTCCGTGAAATTTCGTTCCA
TTCTATTCCATTGCATTACTTTCCATTCAATTCCATTCCATTTCATTTCAGTCCATTCGCTTCCTTTCCT
TTCGATTCAATTCCATTTGATTCCACTCCATTCTATGCGATTTCATTCCAATCGATTCAATTCCATTCGA
TGACATTCCTTTCGTTTCCATTCCATTCGAGTCCATTTAATTTGAGCATTCGTGTCCATTCTATTCGAGT
CCATTCCATTACAGTCTATTCTATTCCCTTCCATTCGTGTTGATTCAATTTCATTCACTTCCATTCGATT
CCTTTCCATTCGATTCCATTCCTTTCCATTCCATTCCATTCGTTCCCATTCCATGTGATTTCATTCCATT
CCAGTCCATTATATTCGAGTCCACTCCACTCCATTCTATTACATTCAATTCCTTTTGAGTCCGTTCCATA
ACACTCCATTCATTTCGATTCCATTTCTTGCCAGTTTTCTTCCATTTTATTCCATTCCGTTCGATTCCAT
TCCATTCGATTGCATTCCATTCGAATCCTTTCCATTCCATTTCATTCCATTCCTTTCTATTCCATTCCAT
TTCATTCGATTTGATTCCATTCTGTTCTATTCCATTCAATTCTTTTTCATTCCATTCGAATCCTTTCTAT
TGCAGTCCATTCCATTCGAGTCCATTCCAATCCCTTCCATTCCATTCCATTACAGTCCATTCCAATAGAT
TCCATTCCTTTGCTTTCCGTTCGAATCCATTCCATTCTAGTCCATTCCATTTGAGTCAATTCCATTCCAT
TCCATTCTATTCATTTCCAATCCATTCGATTCCATTCGATTCAATTCCATTTGATTCTCTTTCATTCTAT
TTTATTCCATGCCATTTGATTGCATTGCATTCCATTCCGTTTGATTCCAGTCCATCCAAGAAAGTTCCAT
TCCAGTCCATTGCTTTCCAGTCCATTCCATTCCACTCTAGTCTATTCCACTCCATTCCCTTCCATTGCAT
TCCATACTATTCCATTCCATTCCTTTGCATTCCGTTTCCAATCTATTCGAGTCCATTGCATTCCAGTCCA
ATCCATTCGATTACATTCCTTTTGATTCCCTGCCAGTCGATTGCATTGCATACTACACCATTCCAAAGGA
GTTCATTCCATTCTATCTCCACACTTTCCATTCCACTCTGTTTGAGTCCATTCCATTCCAGTCCATTTAA
TTCAAGGGCATTCCATTCCATTCCATTCCATTCCATTTCATATTATTCCATTCCATTCAATTCCATTCCA
GATGATTCCATTCCATTCTATACCATTGCTCTCTGTTCCATTCCATTCCATCTGTCTCCATTCCTTTCGT
TTCGATTCCTTTCCATTCCATTCCATTACATTTGATCCTATTTTATTAAATTGCATTCTATTCGAGTGAT
TTCCATTCGAGTCCTTTCCATTCGATTCCATTCCATTCTATTCCATTCCTTTGGATTCCATTCCATTCCG
TTCCGTTCACATCAATTCCTGGCGATTCCATTACATTCGATTTCTTGCCATTCGATTCCATTCCTTTTGA
CTCCATTTCATTCGATTCCATTCCATTCCATTAATTTCCATTCCATTCGAGACCTTTCCATTGCAGTCTT
TTCCCTTCGAGTCCATTCCGTTCGATTCCATTCCGTTCGATTCCCTTCCATTCGATTCCATTCCATTGGA
GTCCGTACCAGTCGAGTCCATTCTATTCCAGTCCATTAGTTTCGACTCCATTGCATTCGAGTGCATTCCA
TTCCGTGGCTGTCCATTCCATTCCGTTTGATGCCATTCCATACGATTCCATTCAATTCGAGACCATTCTA
TTCCTGTCCATTCCTTGTGGTTCGATTCCATTTCACTCTAGTCCATTCCATTCCATTCAATTCCATTCGA
CTCTATTCCGTTCCATTCAATTCCATTCCATTCGATTCCATTTTTTTCGAGAGCCTTCCATTACACTCCC
TTCCATTCCAGTGCATTCCATTACAGTCTCTTCACTTCGATTCCATTCCATTCGTTTCGATTCCTATCCA
TTCCAGCCCATTCCATTCCATTCCTTTCCTTTCCGTTTCATTAGATTCCATTGCATTCCATTCCATTCAA
TTCAATTCCGTGCTATTCAATTTGATTCATTTCCATTTAATTCCATTCCATTAGATTCCATTCCGTACGA
TTCCATTCCTTTTGAATCCATTCCATTGGAGTCCATTCACTTCCAGAACATTCCATTCCAGTCGAATCCA
TTCGAGTACATTCCATTAAAGTTCATTACATTCTAATACATTCCATTCCATTGCATTCCATTCCATTCCA
TTCGATGCCATTCGATTCCATTCCATGCCAAATCATTGCATTCCTTTCCATTCCGTTCCTATCAATTCCA
TTCCATTCGATTTAGTTCGATTCTATTCACTTCCATTCCATTCGATTCCATTCCATTGGAGTCAATTCCT
TTCGACACCCAGCCTCTCCAGTCAGTGATTTTGGATTCCATTTTTTTGCATTCCATTACATTCTATGACA
TTCGATTCCGTTTCATTGCATTCCATTCCATACATTTTTATTCCATTCGAGACCGTAGCATTCCACTTTA
TTCCAGGCCTGTCCATTACACTACATTCCCTTCCATTCCAATGAATTCCATTCCATTCCAATCCATTCCT
TTCCTTTCGCTTGCATTCCATTCTATTCTCTTCTACTGCATACAATTTCACTCCATTCGTTCCCATTCCA
TTCAATTCCATTCCATTCAATTCCATTCCATTTGTTTCCATTCTCTTCGATTCCATTTCTTTATATTCCA
TGCCATTCGATTCCATTCTATTGGGTTGCATTACATTCGTGTTCATTCCATTCCAGACCATTCCATTTGA
CTCCATTCCTTTCGAGCCCTTTCAATTTGAGTCCATTCCTTTCCAGTCCATTTCACTCCAGTCCATTACT
ATCCATTCCATACCATTCCATCCCATTCCATTCCATTCCATTCCATTCCATTCCATTCCATTCCATTCCA
TTGCATTCCATTCCATTCCATTCCATTGCACTGCACTCCATTCCATTACATTCTACTCTATCTGAGTCGA
TTTTATTGCATTAGATTCTATTCCATTGGATTACTTTCCATTCGATTACATTCCATTCATGTACATTCCA
TTCCAGTCAATTACATTCGAGTTCATTACGTTACATTCCAGTATATTCCATTGTATTCGATCCCATTCCT
TTCAATTCCATTTCATTCGACTCCATTATATTCAATTCCATTCCACTCGAATCCGTTCCATTAGAGGACA
TTCCATTCCAATGCATTCCATTCCATTCCATAGCATTCCACTGCATTCGATTCCATTCCATTTGATGCCA
TTACATTTGATGCCATCCCATGACATTCCATTCCATTCGAGTCCATTCCGTTCCAATTCATTCCATTCCG
TTTCATGAAATTCGAGTCCTTTCCAGTACATTTCATTCCAATCCCATCCAATCCCATCTACTCCATTCAA
TTCCTTTCCATTCCATTTGATTTGATTCCATTGATTTGATTCCATTCAGTTTGATTCCATTCCGTGAAAT
TTCGTTCCATTCTATTCCATTGCATTACTTTCCATTCAATTCCATTCCATTTCATTTCAGTCCATTCGCT
TCCTTTCCTTTCGATTTAATTCCATTTGATTCCACTCCATTCTATGCGATTTCATTCCAATCGATTGAAT
TCCATTCGGTGACATTCCTTTCGTTTCCATTCCATTCGAGTCCATTTAATTTGAGCATTCGTGTCCATTC
TATTCGAGTCCATTCCATTACAGTCTATTCTATTCCCTTCCATTCCTGTTGATTCAATTTCATTCCCTTC
CATTCGATTCCTTTCCATTCGATTCCATTCCTTTCCATTCCATTCCATTCGTTCCCATTCCATGTGATTT
CATTCCATTCCAGTCCATTATATTCGAGTCCACTCCACTCCATTCTATTACATTCAATTCCTTTTGAGCC
CGTTCCATAACACTCCATTCATTTCGATTCCATTTCTTGCCAGTTTTCTTCCATTTTCTTCCATTCCGTT
CGATTCCATTCCATTCGATTGCATTCCATTCGAATCCTTTCCATTCCATTTCATTCCATTCCTTTCTATT
CCATTCCATTTCATTCGATTTGATTCCATTCTGTTCTATTCCATTCAATTCTTTTTCATTCCATTCGAAT
CCTTTCTATTGCAGTCCATTCCATTCGAGTCCATTCCAATCCCTTCCATTCCATTCCATTACAGTCCATT
CCAATAGATTCCATTCCTTTGCCTTCCATTCGAATCCATTCCATTCTAGTACATTCCATTTGAGTCCATT
CCATTCCATTCCATTCTATTCCTTTCCAATCCATTCGATTCCATTCGATTCAATTCCATTTGATTCTCTT
TCATTCTATTTTATTCCATGCCATTTGATTGCATTGCATTCCATTCCGTTTGATTCCAGTCCATCCAAGA
AAGTTCCATTCCAGTCCATTGCTTTCCAGTCCATTCCATTCCACTCTAGTCTATTCCACTCCATTCCCTT
CCATTGCATTCCATACTATTCCATTCCATTCCTTTGCATTCCGTTTCCAATCTATTCGAGTCCTTTGCAT
TCCAGTCCAATCCATTCGATTACATTCCTTTTGATTCCCTGCCAGTCGATTGCATTGCATACTACACCAT
TCCAAAGGAGTTCATTCCATTCTATCTCCACACTTTCCATTCCACTCTGTTTGAGTCCATTCCATTCCAG
TCCATTTAATTCAAGGGCATTCCATTCCATTCCATTCCATTCCATTTCATATTATTCCATTCCATTCAAT
TCCATTCCAGATGATTCCATTCCATTCTATACCATTGCTCTCTGTTCCATTCCATTCCATCTGTCTCCAT
TCCTTTCGTTTCGATTCCTTTCCATTCCATTCCATTACATTTGATCCTATTTTATTAAATTGCATTCTAT
TCGAGTGATTTCCATTCGAGTCCTTTCCATTCGATTCCATTCCATTCTATTCCATTCCTTTGGATTCCAT
TCCATTCCGTTCCGTTCACATCAATTCCTGGCGATTCCATTACATTCGATTTCTTGCCATTCGATTCCAT
TCCTTTTGACTCCATTTCATTCGATTCCATTCCATTCCATTAATTTCCATTCCATTCGAGACCTTTCCAT
TGCAGTCTTTTCCCTTCGAGTCCATTCCGTTCGATTCCCTTCCGTTCGATTCCCTTCCATTCGATTCCAT
TCCATTGGAGTCCGTACCAGTCGAGTCCATTCTATTCCAGTCCATTTGTTTCGACTCCATTGCATTCGAG
TGCATTCCATTCCGTGGCTGTCCATTCCATTCCGTTTGATGCCATTCCATACGATTCCATTCAATTCGAG
ACCATTCTATTCCTGTCCATTCCTTGTGGTTCGATTCCATTTCACTCTAGTCCATTCCATTCCATTCAAT
TCCATTCGACTCTATTCCGTTCCATTCAATTCCATTCCATTCGATTCCATTTTTTTCGACAACCTTCCAT
TACACTCCCTTCCATTCCAGTGCATTCCATTCCAGTCTCTTCAGTTCGATTCCATTCCATTCGTTTCGAT
TCCTTTCCATTCCAGCCCATTCCATTCCATTCCATTCCTTTCCTTTCCGTTTCATTAGATTCCATTGCAT
TCCATTCCATTCAATTCAATTCCGTGCTATTCAATTTGATTCATTTCCATTTAATTCCATTCCATTAGAT
TCCATTCCGTACGATTCCATTCCTTTTGAATCCATTCCATTGGAGTCCATTCACTTCCAGAACATTCCAT
TCCAGTCGAATCCATTCGAGTACATTCCATTAAAGTTCATTACATTCTAATACATTCCATTCCATTGCAT
TCCATTCCATTCCATTCGATGCCATTCGATTCCATTCCATGCCAAATCATTGCATTCCTTTCCATTCCGT
TCCTATCAATTCCATTCCATTCGATTTAGTTCGATTCTATTCACTTCCATTCCATTCGATTCCATTCCAT
TGGAGTCAATTCCTTTCGACACCCAGCCTTTCCAGTCAATGATTTTGGATTCCATTTTTTTGCATTCCAT
TACATTCTATGACATTCGATTCCGTTTCATTGCATTCCATTCCATACATTTTTATTCCATTCGAGACCGT
AGCATTCCACTTTATTCCAGGCCTGTCCATTACACTACATTCCCTTCCATTCCAATGAATTCCATTCCAT
TCCAATCCATTCCTTTCCTTTCGCTTGCATTCCATTCTATTCTCTTCTACTGCATACAATTTCACTCCAT
TCGTTCCCATTCCATTCAATTCCATTCCATTCAATTCCATTCCCTTTGTTTCCATTCTCTTCGATTCCAT
TTCTTTATATTCCATGCCATTCGATTCCATTCTATTGGGTTGCATTACATTCGTGTTCATTCCATTCCAG
ACCATTCCATTTGACTCCATTCCTTTCGAGCCCTTTCAATTTGAGTCCATTCCTTTCCAGTCCATTTCAC
TCCAGTCTATTACTATCCATTCCATACCATTCCATCCCATTCCATTCCATTCCATTCCATTGCATTCCAT
TCCATTCCATTCCATTGCACTGCACTCCATTCCATTACATTCTACTCTATCTGAGTCGATTTTATTGCAT
TAGATTCTATTCCATTGGATTACTTTCCATTCGATTACATTCCATTCATGTACATTCCATTCCAGTCAAT
TACATTCGAGTTCATTACGTTACATTCCACTATATTCCATTGTATTCGATCCCATTCCTTTCAATTCCAT
TTCATTCGACTCCATTATATTCAATTCCATTCCACTCGAATCCATTCCATTAGAGGACATTCCATTCCAA
TGCATTCCATTCCATTCCATAGCATTCCATTGCATTCGATTCCATTCCATTTGATGCCATTCCATTTGAT
GCCATCCCATGACATTCCATTCCATTCGAGTCCATTCCGTTCCAATTCATTCCATTCCGTTTCATGAAAT
TCGAGTCCTTTCCAGTACATTTCATTCCAATCCCATCCAATCCCATCTACTCCATTCAATTCCTTTCCAT
TCCATTTGATTTGATTCCATTGATTTGATTCCATTCAGTTTGATTCCATTCCGTGAAATTTCGTTCCATT
CTATTCCATTGCATTACTTTCCATTCAATTCCATTCCATTTCATTTCAGTCCATTCGCTTCCTTTCCTTT
CGATTCAATTCCATTTGATTCCACTCCATTCTATGCGATTTCATTCCAATCGATTCAATTCCATTCGATG
ACATTCCTTTCGTTTCCATTCCATTCGAGTCCATTTAATTTGAGCATTCGTGTCCATTCTATTCGAGTCC
ATTCCATTACAGTCTATTCTATTCCCTTCCATTCCTGTTGATTCAATTTCATTCCCTTCCATTCGATTCC
TTTCCATTCGATTCCATTCCTTTCCATTCCATTCCATTCGTTCCCATTCCATGTGATTTCATTCCATTCC
AGTCCATTATATTCGAGTCCACTCCACTCCATTCTATTACATTCAATTCCTTTTGAGTCCGTTCCATAAC
ACTCCATTCATTTCGATTCCATTTCTTGCCAGTTTTCTTCCATTTTATTCCATTCCGTTCGATTCCATTC
CATTCGATTGCATTCCATTCGAATCCTTTCCATTCCATTTCATTCCATTCCTTTCTATTCCATTCCATTT
CATTCGATTTCATTCCATTCTGTTCTATTCCATTCAATTCTTTTTCATTCCATTCGAATCCTTTCTATTG
CAGTCCATTCCATTCGAGTCCATTCCAATCCCTTCCATTCCATTCCATTACAGTCCATTCCAATAGATTC
CATTCCTTTGCCTTCCATTCGAATCCATTCCATTCTAGTCCATTCCATTTGAGTCAATTCCATTCCATTC
CATTCTATTCCTTTCCAATCCATTCGATTCCATTCGATTCAATTCCATTTGATTCTCTTTCATTCTAATT
TATTCCATGCCATTTGATTGCATTGCATTCCATTCCGTTTGATTCCAGTCCATCCAAGAAAGTTCCATTC
CAGTCCATTGCTTTCCAGTCCATTCCATTCCACTCTAGTCTATTCCACTCCATTCCCTTCCATTGCATTC
CATACTATTCCATTCCATTCCTTTGCATTCCGTTTCCAATCTATTCGAGTCCATTGCATTCCAGTCCAAT
CCATTCGATTACATTCCTTTTGATTCCCTGCCAGTCGATTGCATTGCATACTACACCATTCCAAAGGAGT
TCATTCCATTCTATCTCCACACTTTCCATTCCACTCTGTTTGAGTCCATTCCATTCCAGTCCATTTAATT
CAAGGGCATTCCATTCCATTCCATTCCATTCCATTTCATATTATTCCATTCCATTCAATTCCATTCCAGA
TGATTCCATTCCATTCTATACCATTGCTCTCTATTCCATTCCATTCCATCTGTCTCCATTCCTTTCGTTT
CAATTCCTTTCCATTCCATTCCATTACATTTGATCCCATTTTATTAAATTGCATTCTATTCGAGTGATTT
CCATTCGAGTCCTTTCCATTCGATTCCATTCCATTCTATTCCATTCCTTTGGATTCCATTCCATTCCGTT
CCGTTCACATCAATTCCTGGCGATTCCATTACATTCGATTTCTTGCCATTCGATTCCATTCCTTTTGACT
CCATTTCATTCGATTCCATTCCATTCCATTAATTTCCATTCCATTCGAGACCTTTCCATTGCAGTCTTTT
CCCTTCGAGTCCATTCCGTTCGATTCCCTTCCGTTCGATTCCCTTCCATTCGATTCCATTCCATTGGAGT
CCGTACCAGTCGAGTCCATTCTATTCCAGTCCATTTGTTTCGACTCCATTGCATTCGAGTGCATTCCATT
CCGTGGCTGTCCATTCCATTCCGTTTGATGCCATTCCATACGATTCCATTCAATTCGAGACCATTCTATT
CCTGTCCATTCCTTGTGGTTCGATTCCATTTCACTCTAGTCCATTCCATTCCATTCAATTCCATTCGACT
CTATTCCGTTCCATTCAATTCCATTCCATTCGATTCCATTTTTTTCGAGAACCTTCCATTACACTCCCTT
CCATTCCAGTGCATTCCATTCCAGTCTCTTCAGTTCGATTCCATTCCATTCGTTTCGATTCCTTTCCATT
CCAGCCCATTCCATTCCATTCCATTCCTTTCCTTTCCGTTTCATTAGATTCCATTGCATTCCATTCCATT
CAATTCAATTCCGTGCTATTCAATTTGATTCATTTCCATTTAATTCCATTCCATTAGATTCCATTCCGTA
CGATTCCATTCCTTTTGAATCCATTCCATTGGAGTCCATTCACTTCCAGAACATTCCATTCCAGTCGAAT
CCATTCGAGTACATTCCATTAAAGTTCATTACATTCTAATACATTCCATTCCATTGCATTCCATTCCATT
CCATTCGATGCCATTCGATTCCATTCCATGCCAAATCATTGCATTCCTTTCCATTCCGTTCCTATCAATT
CCATTCCATTCGATTTAGTTCGATTCTATTCACTTCCATTCCATTCGATTCCATTCCATTGGAGTCAATT
CCTTTCGACACCCAGCCTTTCCAGTCAATGATTTTGGATTCCATTTTTTTGCATTCCATTACATTCTATG
ACATTCGATTCCGTTTCATTGCATTCCATTCCATACATTTTTATTCCATTCGAGACCGTAGCATTCCACT
TTATTCCAGGCCTGTCCATTACACTACATTCCCTTCCATTCCAATGAATTCCATTCCATTCCAATCCATT
CCTTTCCTTTCGCTTGCATTCCATTCTATTCTCTTCTACTGCATACAATTTCACTCCATTCGTTCCCATT
CCATTCAATTCCATTCCATTCAATTCCATTCCCTTTGTTTCCATTCTCTTCGATTCCATTTCTTTATATT
CCATGCCATTCGATTCCATTCTATTGGGTTGCATTACATTCGTGTTCATTCCATTCCAGACCATTCCATT
TGACTCCATTCCTTTCGAGCCCTTTCAATTTGAGTCCATTCCTTTCCAGTCCATTTCACTCCAGTCCATT
ACTATCCATTCCATACCATTCCATCCCATTCCATTCCATTCCATTCCATTCCATTCCATTCCATTCCATT
GCATTCCATTCCATTCCATTCCATTGCACTGCACTCCATTCCATTACATTCTACTCTATCTGAGTCGATT
TTATTGCATTAGAATCTATTCCATTGGATTACTTTCCATTCGATTACATTCCATTCATGTACATTCCATT
CCAGTCAATTACATTCGAGTTCATTACGTTACATTCCAGTATATTCCATTGTATTCGATCCCATTCCTTT
CAATTCCATTTCATTCGACTCCATTATATTCAATTCCATTCCACTCGAATCCATTCCATTAGAGGACATT
CCATTCCAATGCATTCCATTCCATTCCATAGCATTCCATTGCATTCGATTCCATTCCATTTGATGCCATT
CCATTTGATGCCATCCCATGACATTCCATTCCATTCGAGTCCATTCCGTTCCAATTCATTCCATTCCGTT
TCATGAAATTCGAGTCCTTTCCAGTACATTTCATTCCAATCCCATCCAATCCCATCTACTCCATTCAATT
CCTTTCCATTCCATTTGATTTGATTCCATTGATTTGATTCCATTCAGTTTGATTCCATTCCGTGAAATTT
CGTTCCATTCTATTCCATTGCATTACTTTCCATTCAATTCCATTCCATTTCATTTCAGTCCATTCGCTTC
CTTTCCTTTCGATTCAATTCCATTTGATTCCACTCCATTCTATGCGATTTCATTCCAATTGATTCAATTC
CATTCGATGACATTCCTTTCGTTTCCATTCCATTCGAGTCCATTTAATTTGAGCATTCGTGTCCATTCTA
TTCGAGTCCATTCCATTACAGTCTATTCTATTCCCTTCCATTCGTGTTGATTCAATTTCATTCACTTCCA
TTCGATTCCTTTCCATTCGATTCCATTCCTTTCCATTCCATTCCATTCGTTCCCATTCCATGTGATTTCA
TTCCATTCCAGTCCATTATATTCGAGTCCACTCCACTCCATTCTATTACATTCAATTCCTTTTGAGTCCG
TTCCATAACACTCCATTCATTTCGATTCCATTTCTTGCCAGTTTTCTTCCATTTTATTCCATTCCGTTCG
ATTCCATTCCATTCGATTGCATTCCATTCGAATCCTTTCCATTCCATTTCATTCCATTCCTTTCTATTCC
ATTCCATTTCATTCGATTTGATTCCATTCTGTTCTATTCCATTCAATTCTTTTTCATTCCATTCGAATCC
TTTCTATTGCAGTCCATTCCATTCGAGTCCATTCCAATCCCTTCCATTCCATTCCATTACAGTCCATTCC
AATAGATTCCATTCCTTTGCCTTCCATTCGAATCCATTCCATTCTAGTCCATTCCATTTGAGTCAATTCC
ATTCCATTCCATTCTATTCCTTTCCAATCCATTCGATTCCATTCGATTCAATTCCATTTGATTCTCTTTC
ATTCTATTTTATTCCATGCCATTTGATTGCATTGCATTCCATTCCGTTTGATTCCAGTCCATCCAAGAAT
GTTCCATTCCAGTCCATTGCTTTCCAGTCCATTCCATTCCACTCTAGTCTATTCCACTCCATTCCCTTCC
ATTGCATTCCATACTATTCCATTCCATTCCTTTGCGTTCCGTTTCCAATCTATTCGAGTCCATTGCATTT
CAGTCCAATCCATTCGATTACATTCCTTTTGATTCCCTGCCAGTCGATTGCATTGCATACTACACCATTC
CAAAGGAGTTCATTCCATTCTATCTCCACACTTTCCATTCCACTCTGTTTGAGTCCATTCCATTCCAGTC
CATTTAATTCAAGGGCATTCCATTCCATTCCATTCCATTCCATTTCATATTATTCCATTCCATTCAATTC
CATTCCAGATGATTCCATTCCATTCTATACCATTGCTCTCTATTCCATTCCATTCCATCTGTCTCCATTC
CTTTCGTTTCAATTCCTTTCCATTCCATTCCATTACATTTGATCCCATTTTATTAAATTGCATTCTATTC
GAGTGATTTCCATTCGAGTCCTTTCCATTCGATTCCATTCCATTCTATTCCATTCCTTTGGATTCCATTC
CATTCCGTTCCGTTCACATCAATTCCTGGCGATTCCATTACATTCGATTTCTTGCCATTCGATTCCATTC
CTTTTGACTCCATTTCATTCGATTCCATTCCTTTCCATTAATTTCCATTCCATTCGAGACCTTTCCATTG
CAGTCTTTTCCCTTCGAGTCCATTCCGTTCGATTCCCTTCCATTCGATTCCATTCCATTGGAGTCCGTAC
CAGTCGAGTCCATTCTATTCCAGTCCATTAGTTTCGACTCCATTGCATTCGAGTGCATTCCATTCCGTGG
CTGTCCATTCCATTCCGTTTGATGCCATTCCATACGATTCCATTCAATTCGAGACCATTCTATTCCTGTC
CATTCCTTGTGGTTCGATTCCATTTCACTCTAGTCCATTCCATTCCATTCAATTCCATTCGACTCTATTC
CGTTCCATTCAATTCCATTCCATTCGATTCCATTTTTTTCGAGAACCTTGCATTACACTCCCTTCCATTC
CAGTGCATTCCATTCCAGTCTCTTCACTTCGATTCCATTCCATTCGTTTCGATTCCTTTCCATTCCAGCC
CATTCCATTCCATTCCATTCCTTTCCTTTCCGTTTCATTAGATTCCATTGCATTCCATTCCATTCAATTC
AATTCCGTGCTATTCAATTTGATTCATTTCCATTTAATTCCATTCCATTAGATTCCATTCCGTACGATTC
CATTCCTTTTGAATCCATTCCATTGGAGTCCATTCACTTCCAGAACATTCCATTCCAGTCGAATCCATTC
GAGTACATTCCATTAAAGTTCATTACATTCTAATACATTCCATTCCATGCATTCCATTCCATTCCATTCG
ATGCCATTCGATTCCATTCCATGCCAAATCATTGCATTCCTTTCCATTCCGTTCCTATCAATTCCATTCC
ATTCGATTTAGTTCGATTCTATTCACTTCCATTCCATTCGATTCCATTCCATTGGAGTCAATTCCTTTCG
ACACCCAGCCTTTCCAGTCAATGATTTTGGATTCCATTTTTTTGCATTCCATTACATTCTATGACATTCG
ATTCCGTTTCATTGCATTCCATTCCATACATTTTTATTCCATTCGAGACCGTAGCATTCCACTTTATTCC
AGGCCTGTCCATTACACTACATTCCCTTCCATTCCAATGAATTCCATTCCATTCCAATCCATTCCTTTCC
TTTCGCTTGCATTCCATTCTATTCTCTTCTACTGCATACAATTTCACTCCATTCGTTCCCATTCCATTCA
ATTCCATTCCATTCAATTCCATTCCATTTGTTTCCATTCTCTTCGATTCCATTTCTTTATATTCCATGCC
ATTCGATTCCATTCTATTGGGTTGCATTACATTCGTGTTCATTCCATTCCAGACCATTCCATTTGACTCC
ATTCCTTTCGAGCCCTTTCAATTTGAGTCCATTCCTTTCCAGTCCATTTCACTCCAGTCCATTACTATCC
ATTCCATACCATTCCATCCCATTCCATTCCATTCCATTCCATTCCATTCCATTCCATTGCATTCCATTCC
ATTCCATTCCATTGCACTGCACTCCATTCCATTACATTCTACTCTATCTGAGTCGATTTTATTGCATTAG
ATTCTATTCCATTGGATTACTTTCCATTCGATTACATTCCATTCATGTACATTCCATTCCAGTCAATTAC
ATTCCAGTTCATTACGTTACATTCCAGTATATTCCATTGTATTCGATCCCATTCCTTTCAATTCGATTTC
ATTCGACTCCATTATATTCAATTCCATTCCACTCGAATCCATTCCATTAGCGGACATTCCATTCCAATGC
ATTCCATTCCATTCCATAGCATTCCATTGCATTCGATTCCATTCCATTTGATGTCATTCCATTTGATGCC
ATCCCATGACATTCCATTCCATTCGAGTCAATTCCGTTCCAATTCATTCCATTCCGTTTCATGAAATTCG
AGTCCTTTCCAGTACATTTCATTCCAATCCCATCCAATCCCATCTACTCCATTCAATTCCTTTCCATTCC
ATTTGATTTGATTCCATTGATTTGATTCCATTCAGTTTGATTCCATTCCGTGAAATTTCGTTCCATTCTA
TTCCATTGCATTACTTTCCATTCAATTCCATTCCATTTCATTTCAGTCCATTCGCTTCCTTTCCTTTCGA
TTCAATTCCATTTGATTCCACTCCATTCTATGCGATTTCATTCCAATCGATTCAATTCCATTCGATGACA
TTCCTTTCGTTTCCATTCCATTCGAGTCCATTTAATTTGAGCATTCGTGTCCATTCTATTCGAGTCCATT
CCATTACAGTCTATTCTATTCCCTTCCATTCCTGTTGATTCAATTTCATTCCCTTCCATTCGATTCCTTT
CCATTCGATTCCATTCCTTTCCATTCCATTCCATTCGTTCCCATTCCATGTGATTTCATTCCATTCCAGT
CCATTATATTCGAGTCCACTCCACTCCATTCTATTACATTCAATTCCTTTTGAGTCCGTTCCATAACACT
CCATTCATTTCGATTCCATTTCTTGCCAGTTTTCTTCCATTTTATTCCATTCCGTTCGATTCCATTCCAT
TCGATTGCATTCCATTCGAATCCTTTCCATTCCATTTCATTCCATTCCTTTCTATTCCATTCCATTTCAT
TCGATTTGATTCCATTCTGTTCTATTCCATTCAATTCTTTTTCATTCCATTCGAATCCTTTCTATTGCAG
TCCATTCCATTCGAGTCCATTCCAATCCCTTCCATTCCATTCCATTACAGTCCATTCCAATAGATTCCAT
TCCTTTGCCTTCCATTCGAATCCATTCCATTCTAGTCCATTCCATTTGAGTCAATTCCATTCCATTCCAT
TCTATTCATTTCCAATCCATTCGATTCCATTCGATTCAATTCCATTTGATTCTCTTTCATTCTATTTTAT
TCCATGCCATTTGATTGCATTGCATTCCATTCCGTTTGATTCCAGTCCATCCAAGAAAGTTCCATTTCAG
TCCATTGCTTTCCAGTCCATTCCATTCCACTCTAGTCTATTCCACTCCATTCCCTTCCATTGCATTCCAT
ACTATTCCATTCCATTCCTTTGCATTCCGTTTCCAATCTATTCGAGTCCATTGCATTCCAGTCCAATCCA
TTCGATTACATTCCTTTTGATTCCCTGCCAGTCGATTGCATTGCATACTACACCATTCCAAAGGAGTTCA
TTCCATTCTATCTCCACACTTTCCATTCCACTCTGTTTGAGTCCATTCCATTCCAGTCCATTTAATTCAA
GGGCATTCCATTCCATTCCATTCCATTCCATTTCATATTATTCCATTCCATTCAATTCCATTCCAGATGA
TTCCATTCCATTCTATACCATTGCTCTCTGTTCCATTCCATTCCATCTGTCTCCATTCCTTTCGTTTCGA
TTCCTTTCCATTCCATTCCATTACATTTGATCCTATTTTATCAAATTGCATTCTATTCGAGTGATTTCCA
TTCGAGTCCTTTCCATTCGATTCCATTCCATTCTATTCCATTCCTTTGGATTCCATTCCATTCCGTTCCG
TTCACATCAATTCCTGGCGATTCCATTACATTCGATTTCTTGCCATTCGATTCCATTCCTTTTGACTCCA
TTTCATTCGATTCCATTCCATTCCATTAATTTCCATTCCATTCGAGACCTTTCCATTGCAGTCTTTTCCC
TTCGAGTCCATTCCGTTCGATTCCCTTCCGTTCGATTCCCTTCCATTCGATTCCATTCCATTGGAGTCCG
TACCAGTCGAGTCCATTCTATTCCAGTCCATTTGTTTCGACTCCATTGCATTCGAGTGCATTCCATTCCG
TGGCTGTCCATTCCATTCCGTTTGATGCCATTCCATACGATTCCATTCAATTCGAGACCATTCTATTCCT
GTCCATTCCTTGTGGTTCGATTCCATTTCACTCTAGTCCATTCCATTCCATTCAATTCCATTCGACTCTA
TTCCGTTCCATTCAATTCCATTCCATTCGATTCCATTTTTTTCGAGAACCTTCCATTACACTCCCTTCCA
TTCCAGTGCATTCCATTCCAGTCTCTTCACTTCGATTCCATTCCATTCGTTTCGATTCCTTTCCATTCCA
GCCCATTCCATTCCATTCCATTCCTTTCCTTTCCGTTTCATTAGATTCCATTGCATTCGATTCCATTCAA
TTCAATTCCGTGCTATTCAATTTGATTCATTTCCATTTAATTCCATTCCATTAGATTCCATTCCGTACGA
TTCCATTCCTTTTGAATCCATTCCATTGGAGTCCATTCACTTCCAGAACATTCCATTCCAGTCGAATCCA
TTCGAGTACATTCCATTAAAGTTCATTACATTCTAATACATTCCATTCCATTGCATTCCATTCCATTCCA
TTCGATGCCATTCGATTCCATTCCATGCCAAATCATTGCATTCCTTTCCATTCCGTTCCTATCAATTCCA
TTCCATTCGATTTAGTTCGATTCTATTCACTTCCATTCCATTCGATTCCATTCCATTGGAGTCAATTCCT
TTCGACACCCAGCCTTTCCAGTCAATGATTTTGGATTCCATTTTTTTGCATTCCATTACATTCTATGACA
TTCGATTCCGTTTCATTGCATTCCATTCCATACATTTTTATTCCATTCGAGACCGTAGCATTCCACTTTA
TTCCAGGCCTGTCCATTACACTACATTCCCTTCCATTCCAATGAATTCCATTCCATTCCAATCCATTCCT
TTCCTTTCGCTTGCATTCCATTCTATTCTCTTCTACTGCATACAATTTCACTCCATTCGTTCCCATTCCA
TTCAATTCCATTCCATTCAATTCCATTCCATTTGTTTCCATTCTCTTCGATTCCATTTCTTTATATTCCA
TGCCATTCGATTCCATTCTATTGGGTTGCATTACATTCGTGTTCATTCCATTCCAGACCATTCCATTTGA
CTCCATTCCTTTCGAGCCCTTTCAATTTGAGTCCATTCCTTTCCAGTCCATTTCACTCCAGTCCATTACT
ATCCATTCCATACCATTCCATCCCATTCCATTCCATTCCATTCCATTCCATTCCATTCCATTCCATTCCA
TTCCATTCCATTGCATTCCATTCCATTGCACTGCACTCCATTCCATTACATTCTACTCTATCTGAGTCGA
TTTTATTGCATTAGATTCTATTCCATTGGATTACTTTCCATTCGATTACATTCCATTCATGTACATTCCA
TTCCAGTCAATTACATTCGAGTTCATTACGTTACATTCCAGTATATTCCATTGTATTCGATCCCATTCCT
TTCAATTCCATTTCATTCGACTCCATTATATTCAATTCCATTCCACTCGAATCCATTCCATTAGCGGACA
TTCCATTCCAATGCATTCCATTCCATTCCATAGCATTCCATTGCATTCGATTCCATTCCATTTGATGTCA
TTCCATTTGATGCCATCCCATGACATTCCATTCCATTCGAGTCCATTCCGTTCCAATTCATTCCATTCCG
TTTCATGAAATTCGAGTCCTTTCCAGTACATTTCATTCCAATCCCATCCAATCCCATCTACTCCATTCAA
TTCCTTTCCATTCCATTTGATTTGATTCCATTGATTTGATTCCATTCAGTTTGATTCCATTCCGTGAAAT
TTCGTTCCATTCTATTCCATTGCATTACTTTCCATTCAATTCCATTCCATTTCATTTCAGTCCATTCGCT
TCCTTTCCTTTCGATTCAATTCCATTTGATTCCACTCCATTCTATGCGATTTCATTCCAATCGATTCAAT
TCCATTCGATAACATTCCTTTCGTTTCCATTCAATTCGAGTCCATTTAATTTGAGCATTCGTGTCCATTC
TATCCGAGTCCATTCCATTACCGTCTATTCTATTCCCTTCCATTCCTGTTGATTCAATTTCATTCCCTTC
CATTCGATTCCTTTCCATTGGATTCCATTCCTTTCCATTCCATTCCATTCGTTCCCATTCCATGTGATTT
CATTCCATTCCAGTCCATTATATTCGAGTCCACTCCACTCAATTCTATTACATTCAATTCCTTTTGAGTC
CGTTCCATAACACTCCATTCATTTCGATTCCATTTCTTGCCAGTTTTCTTCCATTTTATTCCATTCCGTT
CGATTCCATTCCATTCGATTGCATTCCATTCGAATCCTTTCCATTCCATTTCATTCCATTCCTTTCTATT
CCATTCCATTTCATTCGATTTGATTCCATTCTGTTCTATTCCATTCAATTCTTTTTCATTCCATTCGAAT
CCTTTCTATTGCAGTCCATTCCATTCGAGTCCATTCCAATCCCTTCCATTCCATTCCATTACAGACCATT
CCAATAGATTCCATTCCTTTGCCTTCCATTCGAATCCATTCCATTCTAGTCCATTCCATTTGAGTCCATT
CCATTCCATTCCATTCTATTCCTTTCCAATCCATTCGATTCCATTCGATTCAATTCCATTTGATTCTCTT
TCATTCTATTTTATTCCATGCCATTTGATTGCATTGCATTCCATTCCGTTTGATTCCAGTCCATCCAAGA
AAGTTCCATTCCAGTCCATTGCTTTCCAGTCCATTCCATTCCACTCTAGTCTATTCCACTCCATTCCCTT
CCATTGCATTCCATACTATTCCATTCCATTCCTTTGCATTCCGTTTCCAATCTATTCGAGTCCATTGCAT
TCCAGTCCAATCCATTCGATTACATTCCTTTTGATTCCCTGCCAGTCGATTGCATTGCATACTACACCAT
TCCAAAGGAGTTCATTCCATTCTATCTCCACACTTTCCATTCCACTCTGTTTGAGTCCATTCCATTCCAG
TCCATTTAATTCAAGGGCATTCCATTCCATTCCATTCCATTCCATTTCATATTGTTCCATTCCATTCAAT
TCCATTCCAGATGATTCCATTCCATTCTATACCATTGCTCTCTGTTCCATTCCATTCCATCTGTCTCCAT
TCCTTTCGTTTCGATTCCTTTCCATTCCATTCCATTACATTTGATCCTATTTTATTAAATTGCATTCTAT
TCGAGTGATTTCCATTCGAGTCCTTTCCATTCGATTCCATTCCATTCTATTCCATTCCTTTGGATTCCAT
TCCATTCCGTTCCGTTCACATCAATTCCTGGCGATTCGATTACATTAGATTTCTTGCCATTCGATTCCAT
TCCTTTTGACTCCATTTCATTCGATTCCATTCCATTCCATTAATTTCCATTCCATTCGAGACCTTTCCAT
TGCAGTCTTTTCCCTTCGAGTCCATTCTGTTCGATTCCCTTCCGTTCGATTCCCTTCCATTCGATTCCAT
TCCATTGGAGTCCGTACCAGTCGAGTCCATTCTATTCCAGTCCATTAGTTTCGACTCCATTGCATTCGAG
TGCATTCCATTCCGTGGCTGTCCATTCCATTCCGTTTGATGCCATTCCATACGATTCCATTCAATTCGAG
ACCATTCTATTCCTGTCCATTCCTTGTGGTTCGATTCCATTTCACTCTAGTCCATTCCATTCCATTCAAT
TCCATTCGACTCTATTCCGTTCCATTCAATTCCATTCCATTCGATTCCATTTTTTTCGACAACCTTCCAT
TACACTCCCTTCCATTCCAGTGCATTCCATTCCAGTCTCTTCAGTTCGATTCCATTCCATTCGTTTCGAT
TCCTTTCCATTCCAGCCCATTCCATTCCATTCCATTCCTTTCCTTTCCGTTTCATTAGATTCCATTGCAT
TCCATTCCATTCAATTCAATTCCGTGCTATTCAATTTGATTCATTTCCATTTAATTCCATTCCATTAGAT
TCCATTCCGTACGATTCCATTCCTTTTGAATCCATTCCATTGGAGTCCATTCACTTCCAGAACATTCCAT
TCCAGTCGAATCCATTCGAGTACATTCCATTAAAGTTCATTACATTCTAATACATTCCATTCCATGCATT
CCATTCCATTCCATTCGATGCCATTCGATTCCATTCCATGCCAAATCATTGCATTCCTTTCCATTCCGTT
CCTATCAATTCCATTCCATTCGATTTAGTTCGATTCTATTCACTTCCATTCCATTCGATTCCATTCCATT
GGAGTCAATTCCTTTCGACACCCAGCCTTTCCAGTCAATGATTTTGGATTCCATTTTTTTGCATTCCATT
ACATTCTATGACATTCGATTCCGTTTCATTGCATTCCATTCCATACATTTTTATTCCATTCGAGACCGTA
GCATTCCACTTTATTCCAGGCCTGTCCATTACACTACATTCCCTTCCATTCCAATGAATTCCATTCCATT
CCAATCCATTCCTTTCCTTTCGCTTGCATTCCATTCTATTCTCTTCTACTGCATACAATTTCACTCCATT
CGTTCCCATTCCATTCAATTCCATTCCATTCAATTCCATTCCATTTGTTTCCATTCTCTTCGATTCCATT
TCTTTATATTCCATGCCATTCGATTCCATTCTATTGGGTTGCATTACATTCGTGTTCATTCCATTCCAGA
CCATTCCATTTGACTCCATTCCTTTCGAGCCCTTTCAATTTGAGTCCATTCCTTTCCAGTCCATTTCACT
CCAGTCCATTACTATCCATTCCATACCATTCCATCCCATTCCATTCCATTCCATTCCATTCCATTCCATT
CCATTCCATTCCATTGCATTCCATTCCATTCCATTCCTTTGCACTGCACTCCATTCCATTACATTCTACT
CTATCTGAGTCGATTTTATTGCATTAGATTCTATTCCATTGGATTACTTTCCATTCGATTACATTCCATT
CATGTACATTCCATTCCAGTCAATTACATTCGAGTTCATTACATTACATTCCAGTATATTCCATTGTATT
CGATCCCATTCCTTTCAATTCCATTTCATTCGACTCCATTATATTCAATTCCATTCCACTCGAATCCATT
CCATTAGAGGACATTCCATTCCAATGCATTCCATTCCATTCCATAGCATTCCATTGCATTCGATTCCATT
CCATTTGATGCCATTCCATTTGATGCCATCCCATGACATTCCATTCCATTCGAGTCCATTCCATTCGATT
CCATTCCATTCTATTCCATTCCTTTGGATTCCATTCCATTCCGTTCCGTTCACATCAATTCCTGGCGATT
CCATTACATTCGATTTCTTGCCATTCGATTCCATTCCTTTTGACTCCATTTCATTCGATTCCATTCCATT
CCATTAATTTCCATTCCATTCGAGACCTTTCCATTGCAGTCTTTTCCCTTCGAGTCCATTCCGTTCGATT
CCCTTCCGTTCGATTCCCTTCCATTCGATTCCATTCCATTGGAGTCCGTACCAGTCGAGTCCATTCTATT
CCAGTCCATTTGTTTCGACTCCATTGCATTCGAGTGCATTCCATTCCGTGGCTGTCCATTCCATTCCGTT
TGATGCCATTCCATACGATTCCATTCAATTCGAGACCATTCTATTCCTGTCCATTCCTTGTGGTTCGATT
CCATTTCACTCTAGTCCATTCCATTCCATTCAATTCCATTCGACTCTATTCCGTTCCATTCAATTCCATT
CCATTCGATTCCATTTTTTTCGAGAACCTTCCATTACACTCCCTTCCATTCCAGTGCATTCCATTCCAGT
CTCTTCACTTCGATTCCATTCCATTCGTTTCGATTCCTTTCCATTCCAGCCCATTCCATTCCATTCCATT
CCTTTCCTTTCCGTTTCATTAGATTCCATTGCATTCGATTCCATTCAATTCAATTCCGTGCTATTCAATT
TGATTCATTTCCATTTAATTCCATTCCATTAGATTCCATTCCGTACGATTCCATTCCTTTTGAATCCATT
CCATTGGAGTCCATTCACTTCCAGAACATTCCATTCCAGTCGAATCCATTCGAGTACATTCCATTAAAGT
TCATTCCATTCTAATACATTCCATTCCATTGCATTCCATTCCATTCCATTCGATGCCATTCGATTCCATT
CCATGCCAAATCATTGCATTCTTTTCCATTCCGTTCCTATCAATTCCATTCCATTCGATTTAGTTCGATT
CTATTCACTTCCATTCCATTCGATTCCATTCCATTGGAGTCAATTCCTTTCGACACCCAGCCTTTCCAGT
CAATGATTTTGGATTCCATTTTTTTGCATTCCATTACATTCTATGACATTCGATTCCGTTTCATTGCATT
CCATTCCATACATTTTTATTCCATTCGAGACCGTAGCATTCCACTTTATTCCAGGCCTGTCCATTACACT
ACATTCCCTTCCATTCCAATGAATTCCATTCCATTCCAATCCATTCCTTTCCTTTCGCTTGCATTCCATT
CTATTCTCTTCTACTGCATACAATTTCACTCCATTCGTTCCCATTCCATTCAATTCCATTCCATTCAATT
CCATTCCATTTGTTTCCATTCTCTTCGATTCCATTTCTTTATATTCCATGCCATTCGATTCCATTCTATT
GGGTTGCATTACATTCGTGTTCATTCCATTCCAGACCATTCCATTTGACTCCATTCCTTTCGAGCCCTTT
CAATTTGAGTCCATTCCTTTCCAGTCCATTTCACTCCAGTCTATTACTATCCATTCCATACCATTCCATC
CCATTCCATTCCATTCCATTCCATTGCATTCCATTCCATTCCATTCCATTGCACTGCACTCCATTCCATT
ACATTCTACTCTATCTGAGTCGATTTTATTGCATTAGATTCTATTCCATTGGATTACTTTCCATTCGATT
ACATTCCATTCATGTACATTCCATTCCAGTCAATTACATTCGAGTTCATTACGTTACATTCCAGTATATT
CCATTGTATTCGATCCCATTCCTTTCAATTCCATTTCATTCGACTCCATTATATTCAATTCCATTCCACT
CGAATCCATTCCATTAGAGGACATTCCATTCCAATGCATTCCATTCCATTCCATAGCATTCCATTGCATT
CGATTCCATTCCATTTGATGCCATTCCATTTGATGCCATCCCATGACATTCCATTCCATTCGAGTCCATT
CCGTTCCAATTCATTCCATTCCGTTTCATGAAATTCGAGTCCTTTCCAGTACATTTCATTCCAATCCCAT
CCAATCCCATCTACTCCATTCAATTCCTTTCCATTCCATTTGATTTGATTCCATTGATTTGATTCCATTC
AGTTTGATTCCATTCCGTGAAATTTCGTTCCATTCTATTCCATTGCATTACTTTCCATTCAATTCCATTC
CATTTCATTTCAGTCCATTCGCTTCCTTTCCTTTCGATTCAATTCCATTTGATTCCACTCCATTCTATGC
GATTTCATTCCAATCGATTCAATTCCATTCGATGACATTCCTTTCGTTTCCATTCCATTCGAGTCCATTT
AATTTGAGCATTCGTGTCCGTTCTATTCGAGTCCATTCCATTACAGTCTATTCTATTCCCTTCCATTCGT
GTTGATTCAATTTCATTCCCTTCCATTCGATTCCTTTCCATTCGATTCCATTCCTTTCCATTCCATTCCA
TTCGTTCCCATTCCATGTGATTTCATTCCATTCCAGTCCATTATATTCGAGTCCACTCCACTCCATTCTA
TTACATTCAATTCCTTTTGAGTCCGTTCCATAACACTCCATTCATTTCGATTCCATTTCTTGCCAGTTTT
CTTCCATTTTATTCCATTCCGTTCGATTCCATTCCATTCGATTGCATTCCATTCGAATCCTTTCCATTCC
ATTTCATTCCATTCCTTTCTATTCCATTCCATTTCATTCGATTTGATTCCATTCTGTTCTATTCCATTCA
ATTCTTTTTCATTCCATTCGAATCCTTTCTATTGCAGTCCATTCCATTCGAGTCCATTCCAATCCCTTCC
ATTCCATTCCATTACAGTCCATTCCAATAGATTCCATTCCTTTGCCTTCCATTCGAATCCATTCCATTCT
AGTCCATTCCATTTGAGTCAATTCCATTCCATTCCATTCTATTCCTTTCCAATCCATTCGATTCCATTCG
ATTCAATTCCATTTGATTCTCTTTCATTCTATTTTATTCCATGCCATTTGATTGCACTACATTCCATTCC
GTTTGATTCCAGTCCATCCAAGAAAGTTCCATTCCAGTCCATTGCTTTCCAGTCCATTCCATTCCACTCT
AGTCTATTCCACTCCATTCCCTTCCATTGCATTCCATACTATTCCATTCCATTCCTTTGCATTCCGTTTC
CAATCTATTCGAGTCCATTGCATTCCAGTCCAATCCATTCGATTACATTCCTTTTGATTCCCTGCCAGTC
GATTGCATTGCATACTACACCATTCCAAAGGAGTTCATTCCATTCTATCTCCACACTTTCCATTCCACTC
TGTTTGAGTCCATTCCATTCCAGTCCATTTAATTCAAGGGCATTCCATTCCATTCCATTCCATTCCATTT
CATATTATTCCATTCCATTCAATTCCATTCCAGATGATTCCATTCCATTCTATACCATTGCTCTCTGTTC
CATTCCATTCCATCTGTCTCCATTCCTTTCGTTTCGATTCCTTTCCATTCCATTACATTACATTTGATCC
TATTTTATTAAATTGCATTCTATTCGAGTGATTTCCATTCGAGTCCTTTCCATTCGATTCCATTCCATTC
TATTCCATTCCTTTGGATTCCATTCCATTCCGTTCCGTTCACATCAATTCCTGGCGATTCCATTACATTC
GATTTCTTGCCATTCGATTCCATTCCTTTTGACTCCATTTCATTCGATTCCATTCCATTCCATTAATTTC
CATTCCATTCGAGACCTTTCCATTGCAGTCTTTTCCCTTCGAGTCCATTCCGTTCGATTCCCTTCCGTTC
GATTCCCGTCCATTCGATTCCATTCCATTGGAGTCCGTACCAGTCGAGTCCATTCTATTCCAGTCCATTA
GTTTCGACTCCATTGCATTCGAGTGCATTCCATTCCGTGGCTGTCCATTCCATTCCGTTTGATGCCATTC
CATACGATTCCATTCAATTCGAGACCATTCTATTCCTGTCCATTCCTTGTGGTTCGATTCCATTTCACTC
TAGTCCATTCCATTCCATTCAATTCCATTCGACTCTATTCCGTTCCATTCAATTCCATTCCATTCGATTC
CATTTTTTTCGACAACCTTCCATTACACTCCCTTCCATTCCAGTGCATTCCATTCCAGTCTCTTCACTTC
GATTCCATTCCATTCGTTTCGATTCCTTTCCATTCCAGCCCATTCCATTCCATTCCATTCCTTTCCTTTC
CGTTTCATTAGATTCCATTGCATTCCATTCCATTCAATTCAATTCCGTGCTATTCAATTTGATTCATTTC
CATTTAATTCCATTCCATTAGATTCCATTCCGTACGATTCCATTCCTTTTGAATCCATTCCATTGGAGTC
CATTCACTTCCAGAACATTCCATTCCAGTCGAATCCATTCGAGTACATTCCATTAAAGTTCATTACATTC
TAATACATTCCATTCCATTGCATTCCATTCCATTCCATTCGATGCCATTCGATTCCATTCCATGCCAAAT
CATTGCATTCCTTTCCATTCCGTTCCTATCAATTCCATTCCATTCGATTTAGTTCGATTCTATTCACTTC
CATTCCATTCGATTCCATTCCATTGGAGTCAATTCCTTTCGACACCCAGCCTTTCCAGTCAATGATTTTG
GATTCCATTTTTTTGCATTCCATTACATTCTATGACATTCGATTCCGTTTCATTGCATTCCATTCCATAC
ATTTTTATTCCATTCGAGACCGTAGCATTCCACTTTATTCCAGGCCTGTCCATTACACTACATTCCCTTC
CATTCCAATGAATTC
neobio-0.0.20030929/data/dna13a.txt 0000644 0002656 0002032 00000001750 07710231002 015373 0 ustar tillea admin TGCTCTCAGTCTTTGTGTCGGCGTCTGAGTACCGTTGAGCGATCCGACAGTGGGGCCAGCCTGCGGACCGTCACGAACGTCGTTACCTTGATGCGCATAGTTGCCGTTCTCGCCGAGGCTGGGTGTCCAAGGTGGTCTTTAGCGCCTGCTTTTCAAAGGTAGTAACCTGGTATAATCTGGGGCGATAGTGTCGCCAGTTCAAGGCGTTCAACGAGTCGCGCACCTGCTATTACACTGGGAGTAACTATTCAATCAAGTATGAGGCTCAGAACCACAGGTATTATTGATGATAAGCCAGACCTTCGAGGATCGTCTCTAGCACATGATCGTTTGATAGAAAGTGTGCAGCTGGTGAAGTTTTTAACATCCCGTGAGGACGTACACTGGCCTCTCTTGTGCCGGGCGTTAAACAATACCTTAAAGCATGCCACAATCGTACCGGGCATAGGATGCTGATTTATGCCTTCATAAAGGGACTCGGCCACGTTGTAAGGTGTGAATGCTAGATCTACCACGAAAGGGCCTGTTAGCACACATGCCGCCCTTGTCGCTAAAGGTTTTATAATACGCGTACGCTCATGCCCCCGAAAGAAGACCATGAGTTGACATTCGCTCATAATACAGGTCAGGCATAGGTGGAGCTCGTGGATTTCTTATCGTTACAAACCATCGCAGAGCACCGTTCGATATACAATAGAGCTTCGGGCACTACGCCTACGCGGGTGATTAGGAACCCGTTACAAGGCAAGGACTCAATGGTGTCCCGGAATTTACGCCAACAACGGTTGTGAAGGGGATGCGGCGGACTATTGTTTAATGTGGTTGGATCCCACCGTGTGCAATCAGCCTAGGGGAAACGCAGGAGTCAGAGGCAGTTGGAGTCAGATTGTGCATTAATCAGTTCGTAAGCCTTCCACGGAGAGTAATCACAACGTCTCGGACAGAAGCTCCCTAGACGACTAGCTGAAAGTGCCCCCAAAGTGCTATGGCATCAATCCCT neobio-0.0.20030929/data/dna06b.txt 0000644 0002656 0002032 00000000133 07707060770 015412 0 ustar tillea admin >gi|1786181|gb|AE000111.1|AE000111 Escherichia coli K-12 MG1655
AAGCCCAAACCGCAAGTAATAAAAATA neobio-0.0.20030929/data/dna08b.txt 0000644 0002656 0002032 00000000200 07701146106 015377 0 ustar tillea admin >gi|1786181|gb|AE000111.1|AE000111 Escherichia coli K-12 MG1655
ACCCATAACGGGCGAATGATAAAAGGGGTAACCTGTGAAAAGATGCATTCTATCGTACTCGCA
neobio-0.0.20030929/data/dna08a.txt 0000644 0002656 0002032 00000000200 07701146076 015404 0 ustar tillea admin >gi|1786181|gb|AE000111.1|AE000111 Escherichia coli K-12 MG1655
ACCCATAACGGGCAATGATAAAAGGAGTAACCTGTGAAAAAGATGCAATCTATCGTACTCGCA
neobio-0.0.20030929/data/prot11a.txt 0000644 0002656 0002032 00000010241 07710226416 015623 0 ustar tillea admin >gi|1786182|gb|AAC73112.1| (AE000111) thr operon leader peptide [Escherichia coli]
MRVLKFGGTSVANAERFLRVADILESNARQGQVATVLSAPAKITNHLVAMIEKTISGQDALPNISDAERIFAELLTGLAA
AQPGFPLAQLKTFVDQEFAQIKHVLHGISLLGQCPDSINAALICRGEKMSIAIMAGVLEARGHNVTVIDPVEKLLAVGHY
LESTVDIAESTRRIAASRIPADHMVLMAGFTAGNEKGELVVLGRNGSDYSAAVLAACLRADCCEIWTDVDGVYTCDPRQV
PDARLLKSMSYQEAMELSYFGAKVLHPRTITPIAQFQIPCLIKNTGNPQAPGTLIGASRDEDELPVKGISNLNNMAMFSV
SGPGMKGMVGMAARVFAAMSRARISVVLITQSSSEYSISFCVPQSDCVRAERAMQEEFYLELKEGLLEPLAVTERLAIIS
VVGDGMRTLRGISAKFFAALARANINIVAIAQGSSERSISVVVNNDDATTGVRVTHQMLFNTDQVIEVFVIGVGGVGGAL
LEQLKRQQSWLKNKHIDLRVCGVANSKALLTNVHGLNLENWQEELAQAKEPFNLGRLIRLVKEYHLLNPVIVDCTSSQAV
ADQYADFLREGFHVVTPNKKANTSSMDYYHQLRYAAEKSRRKFLYDTNVGAGLPVIENLQNLLNAGDELMKFSGILSGSL
SYIFGKLDEGMSFSEATTLAREMGYTEPDPRDDLSGMDVARKLLILARETGRELELADIEIEPVLPAEFNAEGDVAAFMA
NLSQLDDLFAARVAKARDEGKVLRYVGNIDEDGVCRVKIAEVDGNDPLFKVKNGENALAFYSHYYQPLPLVLRGYGAGND
MVKVYAPASSANMSVGFDVLGAAVTPVDGALLGDVVTVEAAETFSLNNLGRFADKLPSEPRENIVYQCWERFCQELGKQI
PVAMTLEKNMPIGSGLGSSACSVVAALMAMNEHCGKPLNDTRLLALMGELEGRISGSIHYDNVAPCFLGGMQLMIEENDI
ISQQVPGFDEWLWVLAYPGIKVSTAEARAILPAQYRRQDCIAHGRHLAGFIHACYSRQPELAAKLMKDVIAEPYRERLLP
MKLYNLKDHNEQVSFAQAVTQGLGKNQGLFFPHDLPEFSLTEIDEMLKLDFVTRSAKILSAFIGDEIPQEILEERVRAAF
AFPAPVANVESDVGCLELFHGPTLAFKDFGGRFMAQMLTHIAGDKPVTILTATSGDTGAAVAHAFYGLPNVKVVILYPRG
KISPLQEKLFCTLGGNIETVAIDGDFDACQALVKQAFDDEELKVALGLNSANSINISRLLAQICYYFEAVAQLPQETRNQ
MNVNYLNDSDLDFLQHCSEEQLANFARLLTHNEKGKTRLSSVLMRNELFKSMEGHPEQHRRNWQLIAGELQHFGGDSIAN
KLRGHGKLYRAILLDVSKRLKLKADKEMSTFEIEQQLLEQFLRNTWKKMDEEHKQEFLHAVDARVNELEELLPLLMKDKL
MTALTPFSAAPTGPPSPAPRSKPCPSTLIAAWVRKMRVSWLESKCDTPFANNLSFISSGSSSSSSFTLASTACRNSCLCS
SSIFFQVLRRNCSSNCCSISNVDISLSAFSFNRFETSSKMARYNLPCPRSLLAILSPPKCCNSPAISCQLRRCCSGCPSI
MKSVFTISASLAISLMLCCTAQANDHKLLGAIAMPRNETNDLALKLPVCRIVKRIQLSADHGDLQLSGASVYFKAARSAS
MGKIIGIDLGTTNSCVAIMDGTTPRVLENAEGDRTTPSIIAYTQDGETLVGQPAKRQAVTNPQNTLFAIKRLIGRRFQDE
EVQRDVSIMPFKIIAADNGDAWVEVKGQKMAPPQISAEVLKKMKKTAEDYLGEPVTEAVITVPAYFNDAQRQATKDAGRI
AGLEVKRIINEPTAAALAYGLDKGTGNRTIAVYDLGGGTFDISIIEIDEVDGEKTFEVLATNGDTHLGGEDFDSRLINYL
VEEFKKDQGIDLRNDPLAMQRLKEAAEKAKIELSSAQQTDVNLPYITADATGPKHMNIKVTRAKLESLVEDLVNRSIEPL
KVALQDAGLSVSDIDDVILVGGQTRMPMVQKKVAEFFGKEPRKDVNPDEAVAIGAAVQGGVLTGDVKDVLLLDVTPLSLG
IETMGGVMTTLIAKNTTIPTKHSQVFSTAEDNQSAVTIHVLQGERKRAADNKSLGQFNLDGINPAPRGMPQIEVTFDIDA
DGILHVSAKDKNSGKEQKITIKASSGLNEDEIQKMVRDAEANAEADRKFEELVQTRNQGDHLLHSTRKQVEEAGDKLPAD
MAKQDYYEILGVSKTAEEREIRKAYKRLAMKYHPDRNQGDKEAEAKFKEIKEAYEVLTDSQKRAAYDQYGHAAFEQGGMG
GGGFGGGADFSDIFGDVFGDIFGGGRGRQRAARGADLRYNMELTLEEAVRGVTKEIRIPTLEECDVCHGSGAKPGTQPQT
CPTCHGSGQVQMRQGFFAVQQTCPHCQGRGTLIKDPCNKCHGHGRVERSKTLSVKIPAGVDTGDRIRLAGEGEAGEHGAP
AGDLYVQVQVKQHPIFEREGNNLYCEVPINFAMAALGGEIEVPTLDGRVKLKVPGETQTGKLFRMRGKGVKSVRGGAQGD
MNYSHDNWSAILAHIGKPEELDTSARNAGALTRRREIRDAATLLRLGLAYGPGGMSLREVTAWAQLHDVATLSDVALLKR
LRNAADWFGILAAQTLAVRAAVTGCTSGKRLRLVDGTAISAPGGGSAEWRLHMGYDPHTCQFTDFELTDSRDAERLDRFA
QTADEIRIADRGFGSRPECIRSLAFGEADYIVRVHWRGLRWLTAEGMRFDMMGFLRGLDCGKNGETTVMIGNSGNKKAGA
PFPARLIAVSLPPEKALISKTRLLSENRRKGRVVQAETLEAAGHVLLLTSLPEDEYSAEQVADCYRLRWQIELAFKRLKS
MPERELRLFYYLNCLSLQWFHRSYRNPARAENPSCQSAFLLQLTSAILASEPGRYNQLLQKQVSGYIRDANRIPGQQCVS
MKHLHRFFSSDASGGIILIIAAILAMIMANSGATSGWYHDFLETPVQLRVGSLEINKNMLLWINDALMAVFFLLVGLEVK
RELMQGSLASLRQAAFPVIAAIGGMIVPALLYLAFNYADPITREGWAIPAATDIAFALGVLALLGSRVPLALKIFLMALA
IIDDLGAIIIIALFYTNDLSMASLGVAAVAIAVLAVLNLCGARRTGVYILVGVVLWTAVLKSGVHATLAGVIVGFFIPLK
EKHGRSPAKRLEHVLHPWVAYLILPLFAFANAGVSLQGVTLDGLTSILPLGIIAGLLIGKPLGISLFCWLALRLKLAHLP
MSMSHINYNHLYYFWHVYKEGSVVGAAEALYLTPQTITGQIRALEERLQGKLFKRKGRGLEPSELGELVYRYADKMFTLS
QEMLDIVNYRKESNLLFDVGVADALSKRLVSSVLNAAVVEGEPIHLRCFESTHEMLLEQLSQHKLDMIISDCPIDSTQQE
GLFSVRIGECGVSFWCTNPPPEKPFPACLEERRLLIPGRRSMLGRKLLNWFNSQGLNVEILGEFDDAALMKAFGAMHNAI
MPGNSPHYGRWPQHDFTSLKKLRPQSVTSRIQPGSDVIVCAEMDEQWGYVGAKSRQRWLFYAYDSLRKTVVAHVFGERTM
ATLGRLMSLLSPFDVVIWMTDGWPLYESRLKGKLHVISKRYTQRIERHNLNLRQHLARLGRKSLSFSKSVELHDKVIGHY
MASVSISCPSCSATDGVVRNGKSTAGHQRYLCSHCRKTWQLQFTYTASQPGTHQKIIDMAMNGVGCRATARIMGVGLNTI
MANIKSAKKRAIQSEKARKHNASRRSMMRTFIKKVYAAIEAGDKAAAQKAFNEMQPIVDRQAAKGLIHKNKAARHKANLT
MKLIRGIHNLSQAPQEGCVLTIGNFDGVHRGHRALLQGLQEEGRKRNLPVMVMLFEPQPLELFATDKAPARLTRLREKLR
YLAECGVDYVLCVRFDRRFAALTAQNFISDLLVKHLRVKFLAVGDDFRFGAGREGDFLLLQKAGMEYGFDITSTQTFCEG
GVRISSTAVRQALADDNLALAESLLGHPFAISGRVVHGDELGRTIGFPTANVPLRRQVSPVKGVYAVEVLG
neobio-0.0.20030929/data/prot11b.txt 0000644 0002656 0002032 00000010241 07710226412 015620 0 ustar tillea admin >gi|1786182|gb|AAC73112.1| (AE000111) thr operon leader peptide [Escherichia coli]
MRVLKFGGTSVANAERFLRVADILESNARQGQVATVLSAPAKITNHLVAMIEKTISGQDALPNISDAERIFAELLTGLAA
AQPGFPLAQLKTFVDQEFAQIKHVLHGISLLGQCPDSINAALICRGEKMSIAIMAGVLEARGHNVTVIDPVEKLLAVGHY
LESTVDIAESTRRIAASRIPADHMVLMAGFTAGNEKGELVVLGRNGSDYSAAVLAACLRADCCEIWTDVDGVYTCDPRQV
PDARLLKSMSYQEAMELSYFGAKVLHPRTITPIAQFQIPCLIKNTGNPQAPGTLIGASRDEDELPVKGISNLNNMAMFSV
SGPGMKGMVGMAARVFAAMSRARISVVLITQSSSEYSISFCVPQSDCVRAERAMQEEFYLELKEGLLEPLAVTERLAIIS
VVGDGMRTLRGISAKFFAALARANINIVAIAQGSSERSISVVVNNDDATTGVRVTHQMLFNTDQVIEVFVIGVGGVGGAL
LEQLKRQQSWLKNKHIDLRVCGVANSKALLTNVHGLNLENWQEELAQAKEPFNLGRLIRLVKEYHLLNPVIVDCTSSQAV
ADQYADFLREGFHVVTPNKKANTSSMDYYHQLRYAAEKSRRKFLYDTNVGAGLPVIENLQNLLNAGDELMKFSGILSGSL
SYIFGKLDEGMSFSEATTLAREMGYTEPDPRDDLSGMDVARKLLILARETGRELELADIEIEPVLPAEFNAEGDVAAFMA
NLSQLDDLFAARVAKARDEGKVLRYVGNIDEDGVCRVKIAEVDGNDPLFKVKNGENALAFYSHYYQPLPLVLRGYGAGND
MVKVYAPASSANMSVGFDVLGAAVTPVDGALLGDVVTVEAAETFSLNNLGRFADKLPSEPRENIVYQCWERFCQELGKQI
PVAMTLEKNMPIGSGLGSSACSVVAALMAMNEHCGKPLNDTRLLALMGELEGRISGSIHYDNVAPCFLGGMQLMIEENDI
ISQQVPGFDEWLWVLAYPGIKVSTAEARAILPAQYRRQDCIAHGRHLAGFIHACYSRQPELAAKLMKDVIAEPYRERLLP
MKLYNLKDHNEQVSFAQAVTQGLGKNQGLFFPHDLPEFSLTEIDEMLKLDFVTRSAKILSAFIGDEIPQEILEERVRAAF
AFPAPVANVESDVGCLELFHGPTLAFKDFGGRFMAQMLTHIAGDKPVTILTATSGDTGAAVAHAFYGLPNVKVVILYPRG
KISPLQEKLFCTLGGNIETVAIDGDFDACQALVKQAFDDEELKVALGLNSANSINISRLLAQICYYFEAVAQLPQETRNQ
MNVNYLNDSDLDFLQHCSEEQLANFARLLTHNEKGKTRLSSVLMRNELFKSMEGHPEQHRRNWQLIAGELQHFGGDSIAN
KLRGHGKLYRAILLDVSKRLKLKADKEMSTFEIEQQLLEQFLRNTWKKMDEEHKQEFLHAVDARVNELEELLPLLMKDKL
MTALTPFSAAPTGPPSPAPRSKPCPSTLIAAWVRKMRVSWLESKCDTPFANNLSFISSGSSSSSSFTLASTACRNSCLCS
SSIFFQVLRRNCSSNCCSISNVDISLSAFSFNRFETSSKMARYNLPCPRSLLAILSPPKCCNSPAISCQLRRCCSGCPSI
MKSVFTISASLAISLMLCCTAQANDHKLLGAIAMPRNETNDLALKLPVCRIVKRIQLSADHGDLQLSGASVYFKAARSAS
MGKIIGIDLGTTNSCVAIMDGTTPRVLENAEGDRTTPSIIAYTQDGETLVGQPAKRQAVTNPQNTLFAIKRLIGRRFQDE
EVQRDVSIMPFKIIAADNGDAWVEVKGQKMAPPQISAEVLKKMKKTAEDYLGEPVTEAVITVPAYFNDAQRQATKDAGRI
AGLEVKRIINEPTAAALAYGLDKGTGNRTIAVYDLGGGTFDISIIEIDEVDGEKTFEVLATNGDTHLGGEDFDSRLINYL
VEEFKKDQGIDLRNDPLAMQRLKEAAEKAKIELSSAQQTDVNLPYITADATGPKHMNIKVTRAKLESLVEDLVNRSIEPL
KVALQDAGLSVSDIDDVILVGGQTRMPMVQKKVAEFFGKEPRKDVNPDEAVAIGAAVQGGVLTGDVKDVLLLDVTPLSLG
IETMGGVMTTLIAKNTTIPTKHSQVFSTAEDNQSAVTIHVLQGERKRAADNKSLGQFNLDGINPAPRGMPQIEVTFDIDA
DGILHVSAKDKNSGKEQKITIKASSGLNEDEIQKMVRDAEANAEADRKFEELVQTRNQGDHLLHSTRKQVEEAGDKLPAD
MAKQDYYEILGVSKTAEEREIRKAYKRLAMKYHPDRNQGDKEAEAKFKEIKEAYEVLTDSQKRAAYDQYGHAAFEQGGMG
GGGFGGGADFSDIFGDVFGDIFGGGRGRQRAARGADLRYNMELTLEEAVRGVTKEIRIPTLEECDVCHGSGAKPGTQPQT
CPTCHGSGQVQMRQGFFAVQQTCPHCQGRGTLIKDPCNKCHGHGRVERSKTLSVKIPAGVDTGDRIRLAGEGEAGEHGAP
AGDLYVQVQVKQHPIFEREGNNLYCEVPINFAMAALGGEIEVPTLDGRVKLKVPGETQTGKLFRMRGKGVKSVRGGAQGD
MNYSHDNWSAILAHIGKPEELDTSARNAGALTRRREIRDAATLLRLGLAYGPGGMSLREVTAWAQLHDVATLSDVALLKR
LRNAADWFGILAAQTLAVRAAVTGCTSGKRLRLVDGTAISAPGGGSAEWRLHMGYDPHTCQFTDFELTDSRDAERLDRFA
QTADEIRIADRGFGSRPECIRSLAFGEADYIVRVHWRGLRWLTAEGMRFDMMGFLRGLDCGKNGETTVMIGNSGNKKAGA
PFPARLIAVSLPPEKALISKTRLLSENRRKGRVVQAETLEAAGHVLLLTSLPEDEYSAEQVADCYRLRWQIELAFKRLKS
MPERELRLFYYLNCLSLQWFHRSYRNPARAENPSCQSAFLLQLTSAILASEPGRYNQLLQKQVSGYIRDANRIPGQQCVS
MKHLHRFFSSDASGGIILIIAAILAMIMANSGATSGWYHDFLETPVQLRVGSLEINKNMLLWINDALMAVFFLLVGLEVK
RELMQGSLASLRQAAFPVIAAIGGMIVPALLYLAFNYADPITREGWAIPAATDIAFALGVLALLGSRVPLALKIFLMALA
IIDDLGAIIIIALFYTNDLSMASLGVAAVAIAVLAVLNLCGARRTGVYILVGVVLWTAVLKSGVHATLAGVIVGFFIPLK
EKHGRSPAKRLEHVLHPWVAYLILPLFAFANAGVSLQGVTLDGLTSILPLGIIAGLLIGKPLGISLFCWLALRLKLAHLP
MSMSHINYNHLYYFWHVYKEGSVVGAAEALYLTPQTITGQIRALEERLQGKLFKRKGRGLEPSELGELVYRYADKMFTLS
QEMLDIVNYRKESNLLFDVGVADALSKRLVSSVLNAAVVEGEPIHLRCFESTHEMLLEQLSQHKLDMIISDCPIDSTQQE
GLFSVRIGECGVSFWCTNPPPEKPFPACLEERRLLIPGRRSMLGRKLLNWFNSQGLNVEILGEFDDAALMKAFGAMHNAI
MPGNSPHYGRWPQHDFTSLKKLRPQSVTSRIQPGSDVIVCAEMDEQWGYVGAKSRQRWLFYAYDSLRKTVVAHVFGERTM
ATLGRLMSLLSPFDVVIWMTDGWPLYESRLKGKLHVISKRYTQRIERHNLNLRQHLARLGRKSLSFSKSVELHDKVIGHY
MASVSISCPSCSATDGVVRNGKSTAGHQRYLCSHCRKTWQLQFTYTASQPGTHQKIIDMAMNGVGCRATARIMGVGLNTI
MANIKSAKKRAIQSEKARKHNASRRSMMRTFIKKVYAAIEAGDKAAAQKAFNEMQPIVDRQAAKGLIHKNKAARHKANLT
MKLIRGIHNLSQAPQEGCVLTIGNFDGVHRGHRALLQGLQEEGRKRNLPVMVMLFEPQPLELFATDKAPARLTRLREKLR
YLAECGVDYVLCVRFDRRFAALTAQNFISDLLVKHLRVKFLAVGDDFRFGAGREGDFLLLQKAGMEYGFDITSTQTFCEG
GVRISSTAVRQALADDNLALAESLLGHPFAISGRVVHGDELGRTIGFPTANVPLRRQVSPVKGVYAVEVLG
neobio-0.0.20030929/data/prot07b.txt 0000644 0002656 0002032 00000001604 07710227274 015637 0 ustar tillea admin IRNLACAZNPLKSTQNHXYHCCYFNHNFNINVNSTQLKVBERGRTRWWBYHLLLYXWKAYZRPQLRHLQDYIGEXXZBNIVTCNVKAMMXIABEQXHKBBWSGKWMECGVMKCPFAIXZFRKVNFGFTVEVXWBCBYCETFLXRIYRHFKALMRPBWLMCBVFXTIPZKFMEDRZNTZWNLYILXWKCPNDTZRZHYNGXYBYGLZYIEYQLGTPCWVQVRDZANNEFFEWPGQRDSXNFXRFTXCTQCNXAMMMPNNHTWFAKRGKIEEMEXDLCBFQTIGCYAGKBNIBXRTTRGNDZHCPMEWPSCCEPMQFCXLLVAAXWFVXNCPKKVMNVPXBWDNPXDMPBDLHRXADSITVVXHGEAAHVGLYYTQHIAGTRBWDTZTKARPNYZKXDLCRVDCNBHKPRWIMKLVFZBTYIBNRPLVVHRNQAEZQALMSKQKFYZNDMVCLWXHTLETBYQYHLWKBYHIRCXAVQVGWYMSREZGRQAXWBTVXXRWCCEWQZSKAGTGZPZVWRKVXGZWWCDSCIAMVHXZGWCEYNDPXAISLFMBVPDZMNIRZCWZSEAFDBYNGIAZVIYXPVHFBPFEKZPRYAQWHXDFIELIRLTNMXXVVNHYFXZLZXAKVYTGHLBXHVMFZSDBTHPFEBIMRXNPDZMZDNTFESLEKMVKHXIXFENAYZCQHSHCWBRGSLXCQBWAMHFIQTQVVRSPYVLKGRWMFNSKTCAQSDRPYFBXEWDQCMNIYFQXNIKIKDCMQLKYIAGGTILSLBLWSCHSVHBPTAWGMFAPLIGDWWGMITKEAGZYVFIDSXNANDYGIFCVNYLBRIMLRCZWESGFKWSIKAZRDCQWNVYKHPFKKFVWBFPQQYIIHIHFPFKANNMWXVKWLCLCXXVSVEGMWIXMIYHCBG neobio-0.0.20030929/data/dna07b.txt 0000644 0002656 0002032 00000000136 07705454336 015421 0 ustar tillea admin >gi|1786181|gb|AE000111.1|AE000111 Escherichia coli K-12 MG1655
AAGCCCTAAACCGCAAGTTTAATAAAAATA neobio-0.0.20030929/data/dna11a.txt 0000644 0002656 0002032 00000004221 07705606310 015401 0 ustar tillea admin >gi|1786181|gb|AE000111.1|AE000111 Escherichia coli K-12 MG1655
ACCCATAACGGGCAATGATAAAAGGAGTAACCTGTGAAAAAGATGCAATCTATCGTACTCGCACTTTCCCTGGTTCTGGT
CGCTCCCATGGCAGCACAGGCTGCGGAAATTACGTTAGTCCCGTCAGTAAAATTACAGATAGGCGATCGTGATAATCGTG
GCTATTACTGGGATGGAGGTCACTGGCGCGACCACGGCTGGTGGAAACAACATTATGAATGGCGAGGCAATCGCTGGCAC
CTACACGGACCGCCGCCACCGCCGCGCCACCATAAGAAAGCTCCTCATGATCATCACGGCGGTCATGGTCCAGGCAAACA
TCACCGCTAAATGACAAATGCCGGGTAACAATCCGGCATTCAGCGCCTGATGCGACGCTGGCGCGTCTTATCAGGCCTAC
GTTAATTCTGCAATATATTGAATCTGCATGCTTTTGTAGGCAGGATAAGGCGTTCACGCCGCATCCGGCATTGACTGCAA
ACTTAACGCTGCTCGTAGCGTTTAAACACCAGTTCGCCATTGCTGGAGGAATCTTCATCAAAGAAGTAACCTTCGCTATT
AAAACCAGTCAGTTGCTCTGGTTTGGTCAGCCGATTTTCAATAATGAAACGACTCATCAGACCGCGTGCTTTCTTAGCGT
AGAAGCTGATGATCTTAAATTTGCCGTTCTTCTCATCGAGGAACACCGGCTTGATAATCTCGGCATTCAATTTCTTCGGC
TTCACCGATTTAAAATACTCATCTGACGCCAGATTAATCACCACATTATCGCCTTGTGCTGCGAGCGCCTCGTTCAGCTT
GTTGGTGATGATATCTCCCCAGAATTGATACAGATCTTTCCCTCGGGCATTCTCAAGACGGATCCCCATTTCCAGACGAT
AAGGCTGCATTAAATCGAGCGGGCGGAGTACGCCATACAAGCCGGAAAGCATTCGCAAATGCTGTTGGGCAAAATCGAAA
TCGTCTTCGCTGAAGGTTTCGGCCTGCAAGCCGGTGTAGACATCACCTTTAAACGCCAGAATCGCCTGGCGGGCATTCGC
CGGCGTGAAATCTGGCTGCCAGTCATGAAAGCGAGCGGCGTTGATACCCGCCAGTTTGTCGCTGATGCGCATCAGCGTGC
TAATCTGCGGAGGCGTCAGTTTCCGCGCCTCATGGATCAACTGCTGGGAATTGTCTAACAGCTCCGGCAGCGTATAGCGC
GTGGTGGTCAACGGGCTTTGGTAATCAAGCGTTTTCGCAGGTGAAATAAGAATCAGCATATCCAGTCCTTGCAGGAAATT
TATGCCGACTTTAGCAAAAAATGAGAATGAGTTGATCGATAGTTGTGATTACTCCTGCGAAACATCATCCCACGCGTCCG
GAGAAAGCTGGCGACCGATATCCGGATAACGCAATGGATCAAACACCGGGCGCACGCCGAGTTTACGCTGGCGTAGATAA
TCACTGGCAATGGTATGAACCACAGGCGAGAGCAGTAAAATGGCGGTCAAATTGGTAATAGCCATGCAGGCCATTATGAT
ATCTGCCAGTTGCCACATCAGCGGAAGGCTTAGCAAGGTGCCGCCGATGACCGTTGCGAAGGTGCAGATCCGCAAACACC
AGATCGCTTTAGGGTTGTTCAGGCGTAAAAAGAAGAGATTGTTTTCGGCATAAATGTAGTTGGCAACGATGGAGCTGAAG
GCAAACAGAATAACCACAAGGGTAACAAACTCAGCACCCCAGGAACCCATTAGCACCCGCATCGCCTTCTGGATAAGCTG
AATACCTTCCAGCGGCATGTAGGTTGTGCCGTTACCCGCCAGTAATATCAGCATGGCGCTTGCCGTACAGATGACCAGGG
TGTCGATAAAAATGCCAATCATCTGGACAATCCCTTGCGCTGCCGGATGCGGAGGCCAGGACGCCGCTGCCGCTGCCGCG
TTTGGCGTCGAACCCATTCCCGCCTCATTGGAAAACATACTGCGCTGAAAACCGTTAGTAATCGCCTGGCTTAAGGTATA
TCCCGCCGCGCCGCCTGCCGCTTCCTGCCAGCCAAAAGCACTCTCAAAAATAGACCAAATGACGTGGGGAAGTTGCCC neobio-0.0.20030929/data/dna29b.txt 0000644 0002656 0002032 00000000012 07714521152 015405 0 ustar tillea admin TTAGCGTTTA neobio-0.0.20030929/data/dna01a.txt 0000644 0002656 0002032 00000000114 07716574564 015416 0 ustar tillea admin >gi|1786181|gb|AE000111.1|AE000111 Escherichia coli K-12 MG1655
ACAAACACG
neobio-0.0.20030929/data/dna09a.txt 0000644 0002656 0002032 00000000603 07705577334 015425 0 ustar tillea admin >gi|1786181|gb|AE000111.1|AE000111 Escherichia coli K-12 MG1655
ACCCATAACGGGCAATGATAAAAGGAGTAACCTGTGAGAAAAGATGCAATCTATCGTTTCGCACTTTCCCTGGTTCTGGT
CGCTCCCATGCAGCACAGGCTGCGGAATTACGTTAGGTCCCGTCAGTAAAATTACAGATAGGCGATCGTGATAATCGTGG
CTATTACTGGGATGGAGGTCACTGGCGCGACCACGGCTGGTGGAAACAACATTATGAATGGCGAGGCAATCGCTGGCACC
TACACAGGACCGCCGCCACCGCCGCGCCACCATAGAAAGCTCCTCATGATCATCACGGCGGTCATGGTCCAGGCAAAAC
neobio-0.0.20030929/data/prot09b.txt 0000644 0002656 0002032 00000007020 07710227362 015635 0 ustar tillea admin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neobio-0.0.20030929/data/dna18a.txt 0000644 0002656 0002032 00000025121 07702377366 015427 0 ustar tillea admin >gi|1786181|gb|AE000111.1|AE000111 Escherichia coli K-12 MG1655 section 1 of 400 of the complete genome
AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGCTTCTGAACTG
GTTACCTGCCGTGAGTAAATTAAAATTTTATTGACTTAGGTCACTAAATACTTTAACCAATATAGGCATAGCGCACAGAC
AGATAAAAATTACAGAGTACACAACATCCATGAAACGCATTAGCACCACCATTACCACCACCATCACCATTACCACAGGT
AACGGTGCGGGCTGACGCGTACAGGAAACACAGAAAAAAGCCCGCACCTGACAGTGCGGGCTTTTTTTTTCGACCAAAGG
TAACGAGGTAACAACCATGCGAGTGTTGAAGTTCGGCGGTACATCAGTGGCAAATGCAGAACGTTTTCTGCGTGTTGCCG
ATATTCTGGAAAGCAATGCCAGGCAGGGGCAGGTGGCCACCGTCCTCTCTGCCCCCGCCAAAATCACCAACCACCTGGTG
GCGATGATTGAAAAAACCATTAGCGGCCAGGATGCTTTACCCAATATCAGCGATGCCGAACGTATTTTTGCCGAACTTTT
GACGGGACTCGCCGCCGCCCAGCCGGGGTTCCCGCTGGCGCAATTGAAAACTTTCGTCGATCAGGAATTTGCCCAAATAA
AACATGTCCTGCATGGCATTAGTTTGTTGGGGCAGTGCCCGGATAGCATCAACGCTGCGCTGATTTGCCGTGGCGAGAAA
ATGTCGATCGCCATTATGGCCGGCGTATTAGAAGCGCGCGGTCACAACGTTACTGTTATCGATCCGGTCGAAAAACTGCT
GGCAGTGGGGCATTACCTCGAATCTACCGTCGATATTGCTGAGTCCACCCGCCGTATTGCGGCAAGCCGCATTCCGGCTG
ATCACATGGTGCTGATGGCAGGTTTCACCGCCGGTAATGAAAAAGGCGAACTGGTGGTGCTTGGACGCAACGGTTCCGAC
TACTCTGCTGCGGTGCTGGCTGCCTGTTTACGCGCCGATTGTTGCGAGATTTGGACGGACGTTGACGGGGTCTATACCTG
CGACCCGCGTCAGGTGCCCGATGCGAGGTTGTTGAAGTCGATGTCCTACCAGGAAGCGATGGAGCTTTCCTACTTCGGCG
CTAAAGTTCTTCACCCCCGCACCATTACCCCCATCGCCCAGTTCCAGATCCCTTGCCTGATTAAAAATACCGGAAATCCT
CAAGCACCAGGTACGCTCATTGGTGCCAGCCGTGATGAAGACGAATTACCGGTCAAGGGCATTTCCAATCTGAATAACAT
GGCAATGTTCAGCGTTTCTGGTCCGGGGATGAAAGGGATGGTCGGCATGGCGGCGCGCGTCTTTGCAGCGATGTCACGCG
CCCGTATTTCCGTGGTGCTGATTACGCAATCATCTTCCGAATACAGCATCAGTTTCTGCGTTCCACAAAGCGACTGTGTG
CGAGCTGAACGGGCAATGCAGGAAGAGTTCTACCTGGAACTGAAAGAAGGCTTACTGGAGCCGCTGGCAGTGACGGAACG
GCTGGCCATTATCTCGGTGGTAGGTGATGGTATGCGCACCTTGCGTGGGATCTCGGCGAAATTCTTTGCCGCACTGGCCC
GCGCCAATATCAACATTGTCGCCATTGCTCAGGGATCTTCTGAACGCTCAATCTCTGTCGTGGTAAATAACGATGATGCG
ACCACTGGCGTGCGCGTTACTCATCAGATGCTGTTCAATACCGATCAGGTTATCGAAGTGTTTGTGATTGGCGTCGGTGG
CGTTGGCGGTGCGCTGCTGGAGCAACTGAAGCGTCAGCAAAGCTGGCTGAAGAATAAACATATCGACTTACGTGTCTGCG
GTGTTGCCAACTCGAAGGCTCTGCTCACCAATGTACATGGCCTTAATCTGGAAAACTGGCAGGAAGAACTGGCGCAAGCC
AAAGAGCCGTTTAATCTCGGGCGCTTAATTCGCCTCGTGAAAGAATATCATCTGCTGAACCCGGTCATTGTTGACTGCAC
TTCCAGCCAGGCAGTGGCGGATCAATATGCCGACTTCCTGCGCGAAGGTTTCCACGTTGTCACGCCGAACAAAAAGGCCA
ACACCTCGTCGATGGATTACTACCATCAGTTGCGTTATGCGGCGGAAAAATCGCGGCGTAAATTCCTCTATGACACCAAC
GTTGGGGCTGGATTACCGGTTATTGAGAACCTGCAAAATCTGCTCAATGCAGGTGATGAATTGATGAAGTTCTCCGGCAT
TCTTTCTGGTTCGCTTTCTTATATCTTCGGCAAGTTAGACGAAGGCATGAGTTTCTCCGAGGCGACCACGCTGGCGCGGG
AAATGGGTTATACCGAACCGGACCCGCGAGATGATCTTTCTGGTATGGATGTGGCGCGTAAACTATTGATTCTCGCTCGT
GAAACGGGACGTGAACTGGAGCTGGCGGATATTGAAATTGAACCTGTGCTGCCCGCAGAGTTTAACGCCGAGGGTGATGT
TGCCGCTTTTATGGCGAATCTGTCACAACTCGACGATCTCTTTGCCGCGCGCGTGGCGAAGGCCCGTGATGAAGGAAAAG
TTTTGCGCTATGTTGGCAATATTGATGAAGATGGCGTCTGCCGCGTGAAGATTGCCGAAGTGGATGGTAATGATCCGCTG
TTCAAAGTGAAAAATGGCGAAAACGCCCTGGCCTTCTATAGCCACTATTATCAGCCGCTGCCGTTGGTACTGCGCGGATA
TGGTGCGGGCAATGACGTTACAGCTGCCGGTGTCTTTGCTGATCTGCTACGTACCCTCTCATGGAAGTTAGGAGTCTGAC
ATGGTTAAAGTTTATGCCCCGGCTTCCAGTGCCAATATGAGCGTCGGGTTTGATGTGCTCGGGGCGGCGGTGACACCTGT
TGATGGTGCATTGCTCGGAGATGTAGTCACGGTTGAGGCGGCAGAGACATTCAGTCTCAACAACCTCGGACGCTTTGCCG
ATAAGCTGCCGTCAGAACCACGGGAAAATATCGTTTATCAGTGCTGGGAGCGTTTTTGCCAGGAACTGGGTAAGCAAATT
CCAGTGGCGATGACCCTGGAAAAGAATATGCCGATCGGTTCGGGCTTAGGCTCCAGTGCCTGTTCGGTGGTCGCGGCGCT
GATGGCGATGAATGAACACTGCGGCAAGCCGCTTAATGACACTCGTTTGCTGGCTTTGATGGGCGAGCTGGAAGGCCGTA
TCTCCGGCAGCATTCATTACGACAACGTGGCACCGTGTTTTCTCGGTGGTATGCAGTTGATGATCGAAGAAAACGACATC
ATCAGCCAGCAAGTGCCAGGGTTTGATGAGTGGCTGTGGGTGCTGGCGTATCCGGGGATTAAAGTCTCGACGGCAGAAGC
CAGGGCTATTTTACCGGCGCAGTATCGCCGCCAGGATTGCATTGCGCACGGGCGACATCTGGCAGGCTTCATTCACGCCT
GCTATTCCCGTCAGCCTGAGCTTGCCGCGAAGCTGATGAAAGATGTTATCGCTGAACCCTACCGTGAACGGTTACTGCCA
GGCTTCCGGCAGGCGCGGCAGGCGGTCGCGGAAATCGGCGCGGTAGCGAGCGGTATCTCCGGCTCCGGCCCGACCTTGTT
CGCTCTGTGTGACAAGCCGGAAACCGCCCAGCGCGTTGCCGACTGGTTGGGTAAGAACTACCTGCAAAATCAGGAAGGTT
TTGTTCATATTTGCCGGCTGGATACGGCGGGCGCACGAGTACTGGAAAACTAAATGAAACTCTACAATCTGAAAGATCAC
AACGAGCAGGTCAGCTTTGCGCAAGCCGTAACCCAGGGGTTGGGCAAAAATCAGGGGCTGTTTTTTCCGCACGACCTGCC
GGAATTCAGCCTGACTGAAATTGATGAGATGCTGAAGCTGGATTTTGTCACCCGCAGTGCGAAGATCCTCTCGGCGTTTA
TTGGTGATGAAATCCCACAGGAAATCCTGGAAGAGCGCGTGCGCGCGGCGTTTGCCTTCCCGGCTCCGGTCGCCAATGTT
GAAAGCGATGTCGGTTGTCTGGAATTGTTCCACGGGCCAACGCTGGCATTTAAAGATTTCGGCGGTCGCTTTATGGCACA
AATGCTGACCCATATTGCGGGTGATAAGCCAGTGACCATTCTGACCGCGACCTCCGGTGATACCGGAGCGGCAGTGGCTC
ATGCTTTCTACGGTTTACCGAATGTGAAAGTGGTTATCCTCTATCCACGAGGCAAAATCAGTCCACTGCAAGAAAAACTG
TTCTGTACATTGGGCGGCAATATCGAAACTGTTGCCATCGACGGCGATTTCGATGCCTGTCAGGCGCTGGTGAAGCAGGC
GTTTGATGATGAAGAACTGAAAGTGGCGCTAGGGTTAAACTCGGCTAACTCGATTAACATCAGCCGTTTGCTGGCGCAGA
TTTGCTACTACTTTGAAGCTGTTGCGCAGCTGCCGCAGGAGACGCGCAACCAGCTGGTTGTCTCGGTGCCAAGCGGAAAC
TTCGGCGATTTGACGGCGGGTCTGCTGGCGAAGTCACTCGGTCTGCCGGTGAAACGTTTTATTGCTGCGACCAACGTGAA
CGATACCGTGCCACGTTTCCTGCACGACGGTCAGTGGTCACCCAAAGCGACTCAGGCGACGTTATCCAACGCGATGGACG
TGAGTCAGCCGAACAACTGGCCGCGTGTGGAAGAGTTGTTCCGCCGCAAAATCTGGCAACTGAAAGAGCTGGGTTATGCA
GCCGTGGATGATGAAACCACGCAACAGACAATGCGTGAGTTAAAAGAACTGGGCTACACTTCGGAGCCGCACGCTGCCGT
AGCTTATCGTGCGCTGCGTGATCAGTTGAATCCAGGCGAATATGGCTTGTTCCTCGGCACCGCGCATCCGGCGAAATTTA
AAGAGAGCGTGGAAGCGATTCTCGGTGAAACGTTGGATCTGCCAAAAGAGCTGGCAGAACGTGCTGATTTACCCTTGCTT
TCACATAATCTGCCCGCCGATTTTGCTGCGTTGCGTAAATTGATGATGAATCATCAGTAAAATCTATTCATTATCTCAAT
CAGGCCGGGTTTGCTTTTATGCAGCCCGGCTTTTTTATGAAGAAATTATGGAGAAAAATGACAGGGAAAAAGGAGAAATT
CTCAATAAATGCGGTAACTTAGAGATTAGGATTGCGGAGAATAACAACCGCCGTTCTCATCGAGTAATCTCCGGATATCG
ACCCATAACGGGCAATGATAAAAGGAGTAACCTGTGAAAAAGATGCAATCTATCGTACTCGCACTTTCCCTGGTTCTGGT
CGCTCCCATGGCAGCACAGGCTGCGGAAATTACGTTAGTCCCGTCAGTAAAATTACAGATAGGCGATCGTGATAATCGTG
GCTATTACTGGGATGGAGGTCACTGGCGCGACCACGGCTGGTGGAAACAACATTATGAATGGCGAGGCAATCGCTGGCAC
CTACACGGACCGCCGCCACCGCCGCGCCACCATAAGAAAGCTCCTCATGATCATCACGGCGGTCATGGTCCAGGCAAACA
TCACCGCTAAATGACAAATGCCGGGTAACAATCCGGCATTCAGCGCCTGATGCGACGCTGGCGCGTCTTATCAGGCCTAC
GTTAATTCTGCAATATATTGAATCTGCATGCTTTTGTAGGCAGGATAAGGCGTTCACGCCGCATCCGGCATTGACTGCAA
ACTTAACGCTGCTCGTAGCGTTTAAACACCAGTTCGCCATTGCTGGAGGAATCTTCATCAAAGAAGTAACCTTCGCTATT
AAAACCAGTCAGTTGCTCTGGTTTGGTCAGCCGATTTTCAATAATGAAACGACTCATCAGACCGCGTGCTTTCTTAGCGT
AGAAGCTGATGATCTTAAATTTGCCGTTCTTCTCATCGAGGAACACCGGCTTGATAATCTCGGCATTCAATTTCTTCGGC
TTCACCGATTTAAAATACTCATCTGACGCCAGATTAATCACCACATTATCGCCTTGTGCTGCGAGCGCCTCGTTCAGCTT
GTTGGTGATGATATCTCCCCAGAATTGATACAGATCTTTCCCTCGGGCATTCTCAAGACGGATCCCCATTTCCAGACGAT
AAGGCTGCATTAAATCGAGCGGGCGGAGTACGCCATACAAGCCGGAAAGCATTCGCAAATGCTGTTGGGCAAAATCGAAA
TCGTCTTCGCTGAAGGTTTCGGCCTGCAAGCCGGTGTAGACATCACCTTTAAACGCCAGAATCGCCTGGCGGGCATTCGC
CGGCGTGAAATCTGGCTGCCAGTCATGAAAGCGAGCGGCGTTGATACCCGCCAGTTTGTCGCTGATGCGCATCAGCGTGC
TAATCTGCGGAGGCGTCAGTTTCCGCGCCTCATGGATCAACTGCTGGGAATTGTCTAACAGCTCCGGCAGCGTATAGCGC
GTGGTGGTCAACGGGCTTTGGTAATCAAGCGTTTTCGCAGGTGAAATAAGAATCAGCATATCCAGTCCTTGCAGGAAATT
TATGCCGACTTTAGCAAAAAATGAGAATGAGTTGATCGATAGTTGTGATTACTCCTGCGAAACATCATCCCACGCGTCCG
GAGAAAGCTGGCGACCGATATCCGGATAACGCAATGGATCAAACACCGGGCGCACGCCGAGTTTACGCTGGCGTAGATAA
TCACTGGCAATGGTATGAACCACAGGCGAGAGCAGTAAAATGGCGGTCAAATTGGTAATAGCCATGCAGGCCATTATGAT
ATCTGCCAGTTGCCACATCAGCGGAAGGCTTAGCAAGGTGCCGCCGATGACCGTTGCGAAGGTGCAGATCCGCAAACACC
AGATCGCTTTAGGGTTGTTCAGGCGTAAAAAGAAGAGATTGTTTTCGGCATAAATGTAGTTGGCAACGATGGAGCTGAAG
GCAAACAGAATAACCACAAGGGTAACAAACTCAGCACCCCAGGAACCCATTAGCACCCGCATCGCCTTCTGGATAAGCTG
AATACCTTCCAGCGGCATGTAGGTTGTGCCGTTACCCGCCAGTAATATCAGCATGGCGCTTGCCGTACAGATGACCAGGG
TGTCGATAAAAATGCCAATCATCTGGACAATCCCTTGCGCTGCCGGATGCGGAGGCCAGGACGCCGCTGCCGCTGCCGCG
TTTGGCGTCGAACCCATTCCCGCCTCATTGGAAAACATACTGCGCTGAAAACCGTTAGTAATCGCCTGGCTTAAGGTATA
TCCCGCCGCGCCGCCTGCCGCTTCCTGCCAGCCAAAAGCACTCTCAAAAATAGACCAAATGACGTGGGGAAGTTGCCCGA
TATTCATTACGCAAATTACCAGGCTGGTCAGTACCCAGATTATCGCCATCAACGGGACAAAGCCCTGCATGAGCCGGGCG
ACGCCATGAAGACCGCGAGTGATTGCCAGCAGAGTAAAGACAGCGAGAATAATGCCTGTCACCAGCGGGGGAAAATCAAA
AGAAAAACTCAGGGCGCGGGCAACGGCGTTCGCTTGAACTCCGCTGAAAATTATGCCATAGGCGATGAGCAAAAAGACGG
CGAACAGAACGCCCATCCAGCGCATCCCCAGCCCGCGCGCCATATACCATGCCGGTCCGCCACGAAACTGCCCATTGACG
TCACGTTCTTTATAAAGTTGTGCCAGAGAACATTCGGCAAACGAGGTCGCCATGCCGATAAACGCGGCAACCCACATCCA
AAAGACGGCTCCAGGTCCACCGGCGGTAATAGCCAGCGCAACGCCGGCCAGGTTGCCGCTACCCACGCGCGCCGCAAGAC
TGGTACACAATGACTGAAATGAGGTTAAACCGCCTGGCTGTGGATGAATGCTATTTTTAAGACTTTTGCCAAACTGGCGG
ATGTAGCGAAACTGCACAAATCCGGTGCGAAAAGTGAACCAACAACCTGCGCCGAAGAGCAGGTAAATCATTACCGATCC
CCAAAGGACGCTGTTAATGAAGGAGAAAAAATCTGGCATGCATATCCCTCTTATTGCCGGTCGCGATGACTTTCCTGTGT
AAACGTTACCAATTGTTTAAGAAGTATATACGCTACGAGGTACTTGATAACTTCTGCGTAGCATACATGAGGTTTTGTAT
AAAAATGGCGGGCGATATCAACGCAGTGTCAGAAATCCGAAACAGTCTCGCCTGGCGATAACCGTCTTGTCGGCGGTTGC
GCTGACGTTGCGTCGTGATATCATCAGGGCAGACCGGTTACATCCCCCTAACAAGCTGTTTAAAGAGAAATACTATCATG
ACGGACAAATTGACCTCCCTTCGTCAGTACACCACCGTAGTGGCCGACACTGGGGACATCGCGGCAATGAAGCTGTATCA
ACCGCAGGATGCCACAACCAACCCTTCTCTCATTCTTAACGCAGCGCAGATTCCGGAATACCGTAAGTTGATTGATGATG
CTGTCGCCTGGGCGAAACAGCAGAGCAACGATCGCGCGCAGCAGATCGTGGACGCGACCGACAAACTGGCAGTAAATATT
GGTCTGGAAATCCTGAAACTGGTTCCGGGCCGTATCTCAACTGAAGTTGATGCGCGTCTTTCCTATGACACCGAAGCGTC
AATTGCGAAAGCAAAACGCCTGATCAAACTCTACAACGATGCTGGTATTAGCAACGATCGTATTCTGATCAAACTGGCTT
CTACCTGGCAGGGTATCCGTGCTGCAGAACAGCTGGAAAAAGAAGGCATCAACTGTAACCTGACCCTGCTGTTCTCCTTC
GCTCAGGCTCGTGCTTGTGCGGAAGCGGGCGTGTTCCTGATCTCGCCGTTTGTTGGCCGTATTCTTGACTGGTACAAAGC
GAATACCGATAAGAAAGAGTACGCTCCGGCAGAAGATCCGGGCGTGGTTTCTGTATCTGAAATCTACCAGTACTACAAAG
AGCACGGTTATGAAACCGTGGTTATGGGCGCAAGCTTCCGTAACATCGGCGAAATTCTGGAACTGGCAGGCTGCGACCGT
CTGACCATCGCACCGGCACTGCTGAAAGAGCTGGCGGAGAGCGAAGGGGCTATCGAACGTAAACTGTCTTACACCGGCGA
AGTGAAAGCGCGTCCGGCGCGTATCACTGAGTCCGAGTTCCTGTGGCAGCACAACCAGGATCCAATGGCAGTAGATAAAC
TGGCGGAAGGTATCCGTAAGTTTGCTATTGACCAGGAAAAACTGGAAAAAATGATCGGCGATCTGCTGTAATCATTCTTA
GCGTGACCGGGAAGTCGGTCACGCTACCTCTTCTGAAGCCTGTCTGTCACTCCCTTCGCAGTGTATCATTCTGTTTAACG
AGACTGTTTAAACGGAAAAATCTTGATGAATACTTTACGTATTGGCTTAGTTTCCATCTCTGATCGCGCATCCAGCGGCG
TTTATCAGGATAAAGGCATCCCTGCGCTGGAAGAATGGCTGACATCGGCGCTAACCACGCCGTTTGAACTGGAAACCCGC
TTAATCCCCGATGAGCAGGCGATCATCGAGCAAACGTTGTGTGAGCTGGTGGATGAAATGAGTTGCCATCTGGTGCTCAC
CACGGGCGGAACTGGCCCGGCGCGTCGTGACGTAACGCCCGATGCGACGCTGGCAGTAGCGGACCGCGAGATGCCTGGCT
TTGGTGAACAGATGCGCCAGATCAGCCTGCATTTTGTACCAACTGCGATCCTTTCGCGTCAGGTGGGCGTGATTCGCAAA
CAGGCGCTGATCCTTAACTTACCCGGTCAGCCGAAGTCTATTAAAGAGACGCTGGAAGGTGTGAAGGACGCTGAGGGTAA
CGTTGTGGTACACGGTATTTTTGCCAGCGTACCGTACTGCATTCAGTTGCTGGAAGGGCCATACGTTGAAACGGCACCGG
AAGTGGTTGCAGCATTCAGACCGAAGAGTGCAAGACGCGACGTTAGCGAATAAAAAAATCCCCCCGAGCGGGGGGATCTC
AAAACAATTAGTGGGATTCACCAATCGGCAGAACGGTGCGACCAAACTGCTCGTTCAGTACTTCACCCATCGCCAGATAG
ATTGCGCTGGCACCGCAGATCAGCCCAATCCAGCCGGCAAAGTGGATGATTGCGGCGTTACCGGCAATGTTACCGATCGC
CAGCAGGGCAAACAGCACGGTCAGGCTAAAGAAAACGAATTGCAGAACGCGTGCGCCTTTCAGCGTGCCGAAGAACATAA
ACAGCGTAAATACGCCCCACAGACCCAGGTAGACACCAAGGAACTGTGCATTTGGCGCATCGGTCAGACCCAGTTTCGGC
ATCAGCAGAATCGCAACCAGCGTCAGCCAGAAAGAACCGTAAGAGGTGAATGCGGTTAAACCGAAAGTGTTGCCTTTTTT
GTACTCCAGCAGACCAGCAAAAATTTGCGCGATGCCGCCGTAGAAAATGCCCATGGCAAGAATAATACCGTCCAGAGCGA
AATAACCCACGTTGTGCAGGTTAAGCAGAATGGTGGTCATGCCGAAGCCCATCAGGCCCAGCGGTGCCGGATTAGCCAAC
TTAGTGTTGCCCATAATTCCTCAAAAATCATCATCGAATGAATGGTGAAATAATTTCCCTGAATAACTGTAGTGTTTTCA
GGGCGCGGCATAATAATCAGCCAGTGGGGCAGTGTC
neobio-0.0.20030929/data/prot13a.txt 0000644 0002656 0002032 00000023420 07720273340 015627 0 ustar tillea admin QQXQXFQXFDQXFDWQXFDWLQXFDWLTQXFDWLTTQXFDWLTTIQXFDWLTTIIQXFDWLTTIINQXFDWLTTIINSQXFDWLTTIINSXQXFDWLTTIINSXAQXFDWLTTIINSXAYQXFDWLTTIINSXAYBQXFDWLTTIINSXAYBKQXFDWLTTIINSXAYBKQQXFDWLTTIINSXAYBKQQQXFDWLTTIINSXAYBKQQMQXFDWLTTIINSXAYBKQQMHQXFDWLTTIINSXAYBKQQMHYQXFDWLTTIINSXAYBKQQMHYFQXFDWLTTIINSXAYBKQQMHYFBQXFDWLTTIINSXAYBKQQMHYFBQQXFDWLTTIINSXAYBKQQMHYFBQEQXFDWLTTIINSXAYBKQQMHYFBQEKQXFDWLTTIINSXAYBKQQMHYFBQEKBQXFDWLTTIINSXAYBKQQMHYFBQEKBAQXFDWLTTIINSXAYBKQQMHYFBQEKBAZQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZAQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEKQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEKLQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEKLQQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEKLQCQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEKLQCKQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEKLQCKFQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEKLQCKFLQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEKLQCKFLLQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEKLQCKFLLPQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEKLQCKFLLPFQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEKLQCKFLLPFVQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEKLQCKFLLPFVDQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEKLQCKFLLPFVDHQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEKLQCKFLLPFVDHAQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEKLQCKFLLPFVDHARQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEKLQCKFLLPFVDHARYQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEKLQCKFLLPFVDHARYVQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEKLQCKFLLPFVDHARYVVQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEKLQCKFLLPFVDHARYVVAQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEKLQCKFLLPFVDHARYVVANQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEKLQCKFLLPFVDHARYVVANKQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEKLQCKFLLPFVDHARYVVANKLQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEKLQCKFLLPFVDHARYVVANKLSQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEKLQCKFLLPFVDHARYVVANKLSPQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEKLQCKFLLPFVDHARYVVANKLSPMQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEKLQCKFLLPFVDHARYVVANKLSPMHQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEKLQCKFLLPFVDHARYVVANKLSPMHQQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEKLQCKFLLPFVDHARYVVANKLSPMHQHQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEKLQCKFLLPFVDHARYVVANKLSPMHQHHQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEKLQCKFLLPFVDHARYVVANKLSPMHQHHQQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEKLQCKFLLPFVDHARYVVANKLSPMHQHHQLQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEKLQCKFLLPFVDHARYVVANKLSPMHQHHQLWQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEKLQCKFLLPFVDHARYVVANKLSPMHQHHQLWSQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEKLQCKFLLPFVDHARYVVANKLSPMHQHHQLWSAQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEKLQCKFLLPFVDHARYVVANKLSPMHQHHQLWSAWQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEKLQCKFLLPFVDHARYVVANKLSPMHQHHQLWSAWTQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEKLQCKFLLPFVDHARYVVANKLSPMHQHHQLWSAWTDQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEKLQCKFLLPFVDHARYVVANKLSPMHQHHQLWSAWTDCQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEKLQCKFLLPFVDHARYVVANKLSPMHQHHQLWSAWTDCXQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEKLQCKFLLPFVDHARYVVANKLSPMHQHHQLWSAWTDCXHQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEKLQCKFLLPFVDHARYVVANKLSPMHQHHQLWSAWTDCXHQQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEKLQCKFLLPFVDHARYVVANKLSPMHQHHQLWSAWTDCXHQCQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEKLQCKFLLPFVDHARYVVANKLSPMHQHHQLWSAWTDCXHQCZQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEKLQCKFLLPFVDHARYVVANKLSPMHQHHQLWSAWTDCXHQCZWQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEKLQCKFLLPFVDHARYVVANKLSPMHQHHQLWSAWTDCXHQCZWEQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEKLQCKFLLPFVDHARYVVANKLSPMHQHHQLWSAWTDCXHQCZWECQXFDWLTTIINSXAYBKQQMHYFBQEKBAZDDTZSBPLPZBXYWBYHFXMFZYYWMFKHPMGNZLDPGAIDFGKEVHZASKWYCNHNAXSDHKEKLQCKFLLPFVDHARYVVANKLSPMHQHHQLWSAWT neobio-0.0.20030929/data/dna20a.txt 0000644 0002656 0002032 00000011610 07713633570 015410 0 ustar tillea admin AAGTGTTTAGTGAGTCGGTTGGAAAATGTCGTCTACGTTCGCTCTAGGTGAATACCTCGAAAATTAGGGTAAAAATCCCACGCCGCTGTTCGGGCTTGTCGAATCGCGCAGCCCCGTTAACAAACCTGTACTACGTTGTATACCCCAATATCCACACTACTTTGAAAGTGATAGAGTAAGATCGATTGAGATGCCGGCCTCCTCTTCTAACGGATTCTGAACGGAGGGATCCTGGAGGCTGGTCATAGTGATGGCGCCAAAACCCTTATGCAAGAGCGCGAATGCGGTGTCTGCCTATGATATGATAACTAGTTTGGGTCAAAGGTGGGATCACTGGAGATGTATTCTTCTGACGAGAGGTATTTTTTCGATATGGAGTCTCGAACACGCAATCGAGGACGAACGCGCCATTTTAATGAGCGTCCCTAGGCGCTCGTTGGCTCCAAGAAAGAGGTTAGGACTTGTACTTGTGTGGACCTCTCTTTCTGCAGCCGCCTGTAGGGCTAATGAGGATGGGCCGCCCGTCGGGAGAGGGCCCTATCGTAATTAGCGCACAAAGACGACTGGATTACATAGTAGCTCTGGCGGCCGGTTAGCCCCACGAACATCGTGATTTATTCTAAGGGAGTTTAAGCAGAAGATCAGCATCGTAGTTTGCCTTCTCAGAGAGCGCCCCTCATGCGCCATAATTCGCTCTTCTCAATACGGCGTCCGCTTCAGCGGGACGTGCTTTAAAAGGGACCACCTCTTGGCTATGGCACTACTGGACGCGTCTAACGTTATCGATTGGTTTGTCCAACGACTCCATCTGCAATAGCACGCCCCCATGTACGGGTTGTGTTGACAGCTTATCTTAGCGCCTTCGTCCCTCTTTAAATATAACCCACTAATTCAACGCGAGCTCATCAAACCAAATTACGGCGCAGCTTTCAGTCAGACAATTTTACGGTTCTTGAAGCGTCTATCTACTATCCCAGTTACAGCACTCAGTATGCCAAACAACCCTTTTACAGGGGCAAGCCGTGACAATCCTTGTTTTTGTAGTGCTGGGGAAGAGGAAACGAGATCGGCACCTCTATATAAGGCTACAGCGGATAAGGAGTTTCCTATTCGCGTTGAATCCTATCCATCTCCAAGCTGCCTAGATCAACGTATGCTATTTGGGACCTCGGACAGAGGCGCTAATTCAGATAGACGGTGCCGGATGTAATGTGGGCAACTAGTTTTAAAGCTCGACAATTCGCCGCAAGGACAGAAAAGCCCGCCAACTATTTGAAGTCTAATTGACGTCTAGAAGGTTGCGCCTCTTCGATAGGTAATGTGTCTGAACGTCTGTTCGTTCCGACCTCTATTTTACCTCTAAGTTCACCCGGCGGCAGTAGAGGCCGTTTCCAACGTGGTACTTAAGGGCGTTGAGCACCTTTTCTAGGTATGAAAGTTAGCTAAGAGTAAGACCAGACCTTTAATCGAAACGGCCAATCTCCGTGGGTCTGCTTCCGCTCGCCCATAGCCGCTCATTCGACGATTGGGTGGTTACCGTTTTCTGTTGAGATGGATGTTCTCGGAAGGTCCTAACCTTGTGATATAATTAGGCTCCAGTTTGTACTTGTCACACCGTCCACATCACGTGGCGTGACGTGCTACAAGAGTCATCGCACTATGTATCTCAGCGGGGCGCACCTTCTTATTCACCCGTCACAATATCAGCCGTCCTCCCTTACCATGTCTCTCATGAGATAGAATGTGAGGATTATTCACATGTCATGGACCAAGAGCCGTCGGGTATTGAAACCTAGCCAAGAACAGAGCATCCTACGTGCATTCGCTTAGATATCTATCTCATCGTTTCGTATCGGGATTTGCAGGCTATAGGTGAATCAGCAGTAGAGCGTACGTGTACGTAAAGATTAACTGCTACTGAATCTCGACCGTCTACATTGGTCAGTGGTTAATATTTATGCTATGTGTGAAGTTCAGCACTGGCCAACCTTGGGCGAATACGTGCAGGACTGTCTATATCAAGAATAGTGATGCATGCGTTGGTGGGTCGGCCTAACCAGTATGTCCTGCAGAATTAGATTAAAATAATAACTCGTGATCGCATGATTCGCACAGGTTCTTCCCGCGTAACTGCATAAGTAGCAAGGATCTGGAGGCTAACAACACGACGCATCGTAATCGGAGCAGAAACGTGACTATGAGGTGGTACAAAAATAATCTATATTATGATAATGGGAGAACTTCTATAAACGCAAAGAGATTCAGGCATGTTAGCTGATTTAAATGGACCTCTTAAGAGTTATCAACTTAGGCTGAATTTATTTGACATTTCTCGCCCGGCCACAGGCCCACACATTCGGTCAATCGCCAGAGATAACAGGCGGGACATATCTAAGCGTTACGAACGAAAAGGCGCGGAACATCCGTCCCTTATACAGGTTACCAGGACTCCAGTTTCCTCGCGGTTAGGTAACATTCTAACACCTCCATTACCCATTCCATAAATCATACCTTCAGTATTAACGGCCCACCGTCTAGCGCTGCGCTGTCCGGATTCCAAGTAGAAATAGGAGGGTTGGAGGGCTAAAAAACCGCAGGCCAAGCTAGGTTTCCGTGGGCCCTTAAAATAATTGGCAGGTCCTGAGTTTCGATATGTCCACTCGCACGACGTAAGAATCAAGATCTCCTTTGGCCCGGCGACTCACATTGCATTCACGTAGGACCTGAACAAGCGTTGCCGGGGAAGTTATCCGTCGTCAAACCTTACATAAATACAAGGCACCCGTTCAATGACAGAACCGCCCAATCAGTCCCAGCTCGACCAAGAATTCTTATGAGCAGCGCTGTAGCACGGATAGCAAGCATACTTGCCGAATGGATCGTCTTGCTTCACTGGCTGCCAAATTTCTAGCTGCTGTCTATAACATCATAGTTCGTGTGTTTGTTCTCGCGGGGATGACCTCACCCAGACTATCCATGGAGTCCGGTTCGGACTTAGACCCTATCACATACTTGAGTGTTTAGAGTCGTGATTCGCAGACGTTTCCGGACCGACCCCCCCCCAAAGGGTAGGCGCATCGTAATAAAGCTGGAGTATTCGTCGTAGGGTCCCTATGTTCCGAACAGTTGCGATATGTACGCTAAACATCCCTGGTGTGACCATCTACTCGCCAGAAGGGCCCATCTGAAGTCATTGTAATCCTGCGTGGTGTGGGTGTTGCCAAAGTGAGGCCCCTCCCTGTGATGTCCCGGGCACGTCGCTAGCAACGTATGGCACAGGCCCCGAAGGAAGTAGTCAGGCCTTATCTCGGAAACTAAGTTGAGTCATGTAATCCCCGTATAGTCTCGACGGAGGTCTACGAGTCAAGTTACATACCGGGTGGCAGATAAATTGCGAGGCCCGCTTCAAACCTCAGTCTGCGGGATCTAGCCGGCAAGAGCCTTAACATTGTAGGTCATACGAATAGTGTAGCTGGCTGCCTTAGTTCCTTCCTACAGCTGGATTCGGGAACCGGTGCGCATGTGCATCGCGCTCACCCGGGAATGGCTGCAGACTGCTTTGCACCGGCGGGTGGATCAACGATTTACACCGGTGAAGGGTTACACACGGGTAACGCTGCTTTTCGAGCGTAACTACGTCCCCACAAATTATCAAGATTAAAAACCGCCGGCCGTGCCTGTTCATCCGAGCGTAGGATAGTCCAGCCGGCCGGCAGGATCGACGTTGATACTCGCCTTAGCCTCAGTGGTTCTCTGCATGCGACCGTTGCGAAACCCTAACAATTTATTTGCATAACGTCTGTAGTCATTGATGGGATACGTCGAATGGTCTCCACCGTATATACGTAGGACTAAGATATTGGGGGACGCACCACGCTCGCGTGTTGCTACATAAGGAACTTTCCCGTAAGCTTTGCAGGGGATAACGAGGCTATGTTGGGTCCTCCAGAAAACGCTGCCGTCGCGGCATAACCGCGACCTCGGAGGTGCTATTTCACGTTAATGTGACAAGTAGAAAGTTGCTTTTGTCTCTTGGGGAATGATCGTGCCGTTAAAGTGAGATCGGTCCTGCAATTCGCTTTGCGCCCTGAACAGCTTGAGACGCGTTAACATGCACGCGGACGTTTGCTTCTATACTAATATGGACGTAATTTAGAACCTTCGTGATGCTTGGGTTAGCTGAACCTCGTAAGCCCCATCAAGGCAAGCCCAACCGGACCCTACCCTTCTGTGACCGTGGCTGCAGACGTTGTGGAATTGTCTTATCGGACCGTTTTTACTCCATACCTGGAGTACCTCACATAGGTTTTCTGCGACTGTCGACTTTCGATCCGCTAGACTACCTTATCAACGTGGAACCGGTCGTTTGCTCCCACCCCTAAGGACACGTATACAGCTTGTTTACATTGCCATCTGAGCGAGGCATAAGTTTGAGAAAACGTAACACAGTCTACATGATTCTAAGTAGTAGGAAACCACCGCGCCTCACAAATGGTAGCATGGATAACCCCCGGGGTCCAGCAAGGAATACCTAGTATCATAATTCAGGGGCTTGAGCGAGTCTGCAGGTGACCGGGTTCACTCTGTTCCAGGTTGTGCATGCTCGTATTATATTTACTACCAGATAGAAGTTATTCTTGGCAAACGGGGCGGACACCCGTCGTCTCTGCCTTTCTAAATAGAAGGAGGACCCACTTCCGAATCATGCGATGGGATGGGCACCCCAGGGACTAGTGAGATCAAAGAGGTGGAACCGGGTCGCACTGAATACGGCGTAAGACAAATAAGTCTAAATTAGGAACCGCCACATGGCATTTATTATTCGTGCATTATTCCCTGACTTCTAAAATGATTAGAATATGGCTTCCGTGTATATCTCGAATGGCCACCAATGGTTAATCGGCCTAACTGCGCCCGTTTCAACGTTTCGCCAGCGAAGAGTTTTCTGTGTGGGTGAAGTTGGGAAATCGCCCTATCTGCATGTCAATCAAGGATCCACC neobio-0.0.20030929/data/dna16a.txt 0000644 0002656 0002032 00000006034 07710231112 015400 0 ustar tillea admin CTCCTATAGCCTATTGCCCGTGATTGGAGGCATTCTTCATGATCGCTAGCGTTCTGCTCCGAGCGTTGAACTCTGTCGGGGGATATACGAAGTAGTCTGACAGCCTCCAGCCATTACGTCACATAGAGGGGAAGTCTACAGCCTCGCGGTAGGAGACGCTCTAATCGCCGAGTTCAAAAGGGTATCAGATTTTCACGTAACCAAGTTCATTGTGCACTGTACTGATGCCGAGTCAAAACTCCACCACCGCATCAACAGACGTTCCTCCACCCAAATGTTGTCCGTACGGGGTGTACCTTACCCTCATTCAGGATACCTGATGTTCAATCAATACGGAGCTGGTTACAGATTGACGGATCAAGTGTGAATTTACGACACTGAAATGCAACGGATATGTTACGATATCTGGACCTGTACACGGCGAAAAGCGGCGACTGGACTGTGTGCACGGCACAGCTCATCCCGGACTCAATCAGCGACAGAGCGGTATACGCATCATCAGCGTTAAGTCAGGCTCGTTCTTCATCTACGTTCGTATTATAGGCCCTGTGTAAGAATTTCGGAGAACGGCGTCGTGAGCGCACGGGCCAGCCCTCGATCTTGATCTACTGGGGAACGACGGGAGAGAACCCGGCGTCGCATTCAGGCTCCTAGCTCCCGATATTGAATCGTGTGGACAGTCTGCACCGCATGGTACCACGCCCTGGTCCTATAATAAGAGCTAACCCACCAATCGTTTGGATATGGGGGCACGGGACGTCTCAAGGATGCTGCTATTGGTCTGGCACGGCTGGCGCTGGGAGAAATTCGTCGACATCTTGTGGTGCTCATTATCGGTTGGGTTCGCTACCAAAGGTCAAGTCCCACTTATACTCCAAGTATTTACAACTACGGATGCCCCTCGAATCATCTCTGTCCCCTCACTGGCGTAAACCCGCACGTACAAGGAACCCAGTACAAACAAACATGACATATACGCCTCTGACGTGAACTAGCATTGGCACGGAGGGTCTAGGTTCGATTTGTGACTATTCATATCCGCAGAGACCGCCGCGCTCATGGCTCAAGGCGGGGGGTGCCGCATGCTGTACCATGCAATCTAGCATTCGTGGTAATCCGATGTCCGTTAGCCCTTCTAATGACCTGAAACAGTGTCGCGAAGCACGCCCTGTGGACTCAAACCCCTTCGGAACTCAGTTTGATGAGCAGCATCATTAGTACACCGTCTCCGTTAAGTCGAACTGAGCCGTATGCGCATTTCTCCGGCAGCGTCTCTGGACGTTGAGATGAGTCTACGGACTTTTTGCAAAGGTTTCATGATAATTGGCTTGGCCCTTTGGTGAAGCAAGGAAACGGGTTGCTCACCCCGTCCGGTCGATGTCATTCTCGTGTCACGTCTAAGTCAAAATCGTGGCAGCACTTAGAACCTATGCCGTCGAGGAACGCTGACACGCATCAACCAGTGCGCTCGGTCGGTTCGTAAGATAACCCGCCTCGCGTAGCTGTTATTGGATAGGCTTCGTTCGAGGGTAAGGCGCTAACTATATAAGGAGAGCACTTTTTGTTGCCGTAAGAAAACACCGCTACTAGGGGGTTCCAAGGAGCTGTTTTAGGACTACGCCCGGGCTTACTGGGTGGTGCGTGTCTATGTCCGCCTTGGCGTTTTCGTCCTGAGGACGCCTGATTATAGTGAAGCTTACCACTGTAGACCGCACCCAAACGTTAATGTCGACTCTTTCCGTAGCGTTCGTGGAACGGTATTTCCTTCGACCTGAGTAGTCTTACACCAGCCTTCAAAGAAAACGTGATCCGACTAATCCACTACACGCTCGGCCCACGTATCCTGAAAATAAAGACGCAAAGTAAACACGGAGATGAGGAATGGGCACCAGCATGACTTAATAGAGTGGCGCCCAGGCTTTGATCTTCGAACTTGTCTCACGAGAAGCCAGTATACTCCGAGGTCTTACGGAGCTTTGCGACTCGTGCCTAATGCGCCTTTACACTGTCACCAAGGTCACCACTGGCACCGAGCGGCTTTTGGCTTGACCGGAAAGGGGCCGATTACAGTCCTTCAGTGAACCGATACTGTTATAAACCCATCTCATTAAGTCCAACCGATTAACTTGCCCCCACGGCTCATTTAGTGGGCACTTAAAGACCTCACTATTTCGCCCACTTGAGGGTCAGTACACCACCCAGACAATTATGTAAGGGCCTTCATTTACTTATTAGTGTACAGTCATCCACACCTGTCAAAGTATAATAAACGGCAGCCACGTATTTGTATCGCACAATGGTCTCAACGCACACTGGTTGCAATATTTGATATCTACCCATATGTTGGAGAACCTAACGGACATGCCACAACAAGCCGAAATGCGCACCGCTGTAGATTCTAATACTCGCTAACGTGTGCGGCTGGCAAAATGCTGAGAAAGCCGGTCTTCCTAACATGGCCGGCTAAGGGAATACCCGATAACTTAAGGGCTACCATATATATAATTCTTGTGACGGTATCACCCACATCCACGGCTGACAGAGTTGCCAACGGAGTAGATATTACTGGCGCCGGTCGAATACCGATAATCAATCTCGTTCACTTTTAGCATGCTCGGTGTGGACATCGTGAATGAGGTGATAGAATTGATACAGATCACCTTATTCGGGGCGTCTTAGCGGCATGAGTTCCGACGCCGTCTACCGGCTGGCAGCATGAACTCGATTATCCGGAAGTACGCCTAGGCGGTCTCACAAACGCTAAGCACACGAGTGATACCTTAATGTCGCTCAAGTGTAGCGGTTGGAACATGCAGAGTGTATACTGATAGGTTGTACACGTGATGACAGACCCCTAATATGGTGGGAACGGGGGCAGCGCAGAGTCAGAGTGACTATACTCTCTTCCGTAAAGTACCTGTTCATTGGCCACAAGCACGGCCCGGTAGGAAGCCTTGGGGGGTACTCAGCAATCTTCTACCCCACACCCCGTGACTTTTGAGCACTAAATTGACGATGAGTACACCCGCTTGGGATCCTTGCGTTATCACCACTCGACCCCGGCGCCGTCATTAGAATTGTATGCATCGTGTTCATGGCA neobio-0.0.20030929/data/dna27a.txt 0000644 0002656 0002032 00000000012 07714520440 015401 0 ustar tillea admin AGGTCATTAG neobio-0.0.20030929/data/dna30b.txt 0000644 0002656 0002032 00000000012 07714575644 015414 0 ustar tillea admin AABAAAABBA neobio-0.0.20030929/data/blosum80.txt 0000644 0002656 0002032 00000004153 06671724252 016020 0 ustar tillea admin # Matrix made by matblas from blosum80.iij
# * column uses minimum score
# BLOSUM Clustered Scoring Matrix in 1/2 Bit Units
# Blocks Database = /data/blocks_5.0/blocks.dat
# Cluster Percentage: >= 80
# Entropy = 0.9868, Expected = -0.7442
A R N D C Q E G H I L K M F P S T W Y V B Z X *
A 5 -2 -2 -2 -1 -1 -1 0 -2 -2 -2 -1 -1 -3 -1 1 0 -3 -2 0 -2 -1 -1 -6
R -2 6 -1 -2 -4 1 -1 -3 0 -3 -3 2 -2 -4 -2 -1 -1 -4 -3 -3 -2 0 -1 -6
N -2 -1 6 1 -3 0 -1 -1 0 -4 -4 0 -3 -4 -3 0 0 -4 -3 -4 4 0 -1 -6
D -2 -2 1 6 -4 -1 1 -2 -2 -4 -5 -1 -4 -4 -2 -1 -1 -6 -4 -4 4 1 -2 -6
C -1 -4 -3 -4 9 -4 -5 -4 -4 -2 -2 -4 -2 -3 -4 -2 -1 -3 -3 -1 -4 -4 -3 -6
Q -1 1 0 -1 -4 6 2 -2 1 -3 -3 1 0 -4 -2 0 -1 -3 -2 -3 0 3 -1 -6
E -1 -1 -1 1 -5 2 6 -3 0 -4 -4 1 -2 -4 -2 0 -1 -4 -3 -3 1 4 -1 -6
G 0 -3 -1 -2 -4 -2 -3 6 -3 -5 -4 -2 -4 -4 -3 -1 -2 -4 -4 -4 -1 -3 -2 -6
H -2 0 0 -2 -4 1 0 -3 8 -4 -3 -1 -2 -2 -3 -1 -2 -3 2 -4 -1 0 -2 -6
I -2 -3 -4 -4 -2 -3 -4 -5 -4 5 1 -3 1 -1 -4 -3 -1 -3 -2 3 -4 -4 -2 -6
L -2 -3 -4 -5 -2 -3 -4 -4 -3 1 4 -3 2 0 -3 -3 -2 -2 -2 1 -4 -3 -2 -6
K -1 2 0 -1 -4 1 1 -2 -1 -3 -3 5 -2 -4 -1 -1 -1 -4 -3 -3 -1 1 -1 -6
M -1 -2 -3 -4 -2 0 -2 -4 -2 1 2 -2 6 0 -3 -2 -1 -2 -2 1 -3 -2 -1 -6
F -3 -4 -4 -4 -3 -4 -4 -4 -2 -1 0 -4 0 6 -4 -3 -2 0 3 -1 -4 -4 -2 -6
P -1 -2 -3 -2 -4 -2 -2 -3 -3 -4 -3 -1 -3 -4 8 -1 -2 -5 -4 -3 -2 -2 -2 -6
S 1 -1 0 -1 -2 0 0 -1 -1 -3 -3 -1 -2 -3 -1 5 1 -4 -2 -2 0 0 -1 -6
T 0 -1 0 -1 -1 -1 -1 -2 -2 -1 -2 -1 -1 -2 -2 1 5 -4 -2 0 -1 -1 -1 -6
W -3 -4 -4 -6 -3 -3 -4 -4 -3 -3 -2 -4 -2 0 -5 -4 -4 11 2 -3 -5 -4 -3 -6
Y -2 -3 -3 -4 -3 -2 -3 -4 2 -2 -2 -3 -2 3 -4 -2 -2 2 7 -2 -3 -3 -2 -6
V 0 -3 -4 -4 -1 -3 -3 -4 -4 3 1 -3 1 -1 -3 -2 0 -3 -2 4 -4 -3 -1 -6
B -2 -2 4 4 -4 0 1 -1 -1 -4 -4 -1 -3 -4 -2 0 -1 -5 -3 -4 4 0 -2 -6
Z -1 0 0 1 -4 3 4 -3 0 -4 -3 1 -2 -4 -2 0 -1 -4 -3 -3 0 4 -1 -6
X -1 -1 -1 -2 -3 -1 -1 -2 -2 -2 -2 -1 -1 -2 -2 -1 -1 -3 -2 -1 -2 -1 -1 -6
* -6 -6 -6 -6 -6 -6 -6 -6 -6 -6 -6 -6 -6 -6 -6 -6 -6 -6 -6 -6 -6 -6 -6 1
neobio-0.0.20030929/data/dna10b.txt 0000644 0002656 0002032 00000003366 07705606712 015420 0 ustar tillea admin >gi|1786181|gb|AE000111.1|AE000111 Escherichia coli K-12 MG1655
ACCCATAACGGGCAATGATAAAAGGAGTAACCTGTGAAAAAGATGCAATCTATCGTACTCGCACTTTCCCTGGTTCTGGT
CGCTCCCATGGCAGCAGAGGCTGCGGAAATTACGTTAGTCCCGTCAGTAAAATTACAGATAGGCGATCGTGATAATCGTG
GCTATTACTGGGATGGAGGTCACTGGCGCGACCACGGCTGGTGGAAACAACATTATGAATGGCGAGGCAATCGCTGGCAC
CTACACGGACCGCCGCCACCGCCGCGCCACCATAAGAAAGCTCCTCATGATCATCACGGCGGTCATGGTCCAGGCAAACA
TCACCGCTAAATGACAAATGCCGGGTAACAATCCGGCATTCAGCGCCTGATGCGACGCTGGCGCGTCTTATCAGGCCTAC
GTTAATTCTGCAATATATTGAATCTGCATGCTTTTGTAGGCAGGATAAGGCGTTCACGCCGCATCCGGCATTGACTGCAA
ACTTAACGCTGCTCGTAGCGTTTAAACACCAGTTCGCCATTGCTGGAGGAATCTTCATCAAAGAAGTAACCTTCGCTATT
AAAACCAGTCAGTTGCTCTGGTTTGGTCAGCCGATTTTCAATAATGAAACGACTCATCAGACCGCGTGCTTTCTTAGCGT
AGAAGCTGATGATCTTAAATTTGCCGTTCTTCTCATCGAGGAACACCGGCTTGATAATCTCGGCATTCAATTTCTTCGGC
TTCACCGATTTAAAATACTCATCTGACGCCAGATTAATCACCACATTATCGCCTTGTGCTGCGAGCGCCTCGTTCAGCTT
GTTGGTGATGATATCTCCCCAGAATTGATACAGATCTTTCCCTCGGGCATTCTCAAGACGGATCCCCATTTCCAGACGAT
AAGGCTGCATTAAATCGAGCGGGCGGAGTACGCCATACAAGCCGGAAAGCATTCGCAAATGCTGTTGGGCAAAATCGAAA
TCGTCTTCGCTGAAGGTTTCGGCCTGCAAGCCGGTGTAGACATCACCTTTAAACGCCAGAATCGCCTGGCGGGCATTCGC
CGGCGTGAAATCTGGCTGCCAGTCATGAAAGCGGGCGGCGTTGATACCCGCCAGTTTGTCGCTGATGCGCATCAGCGTGC
TAATCTGCGGAGGCGTCAGTTTCCGCGCCTCATGGATCAACTGCTGGGAATTGTCTAACAGCTCCGGCAGCGTATAGCGC
GATCGCTTTAGGGTTGTTCAGGCGTAAAAAGAAGAGATTGTTTTCGGCATAAATGTAGTTGGCAACGATGGAGCTGAAGG
CAAACAGAATAACCACAAGGGTAACAAACTCAGCACCCCAGGAACCCATTAGCACCCGCATCGCCTTCTGGATAAGCTGA
ATACCTTCCAGCGGCATGTAGGTTGTGCCGTTACCCGCCAGTAATATCAGCATGGCGCTTGCCGTACAGATGACCAGGGT
GTCGATAAAAATGCCAATCATCTGGACAATCCCTTGCGCTGCCGGATGCGGAGGCCAGGACGCCGCTGCCGCTGCCGCGT
TTGGCGTCGAACCCATTCCCGCCTCATTGGAAACATACTGCGCTGAATTTTAACCGTTAGTAATCGCCTGGCTTAAGGTA
TATCCCGCCGCGCCGCCTGCCGCTTCCTGCCAGCCAAAAGCACTCTCAAAAATGACCAAATGACGTGGGGAAGTTGC neobio-0.0.20030929/data/dna07a.txt 0000644 0002656 0002032 00000000127 07705454342 015415 0 ustar tillea admin >gi|1786181|gb|AE000111.1|AE000111 Escherichia coli K-12 MG1655
ACTAAACCGCATTAATAATAAAA neobio-0.0.20030929/data/dna38a.txt 0000644 0002656 0002032 00000000014 07720657662 015423 0 ustar tillea admin ACAAGACAGCGA neobio-0.0.20030929/data/prot05a.txt 0000644 0002656 0002032 00000001051 07701155554 015631 0 ustar tillea admin >HXKA_YEAST STANDARD; PRT; 485 AA., 485 bases, 8BF84D98 checksum.
MVHLGPKKPQARKGSMADVPKELMDEIHQLEDMFTVDSETLRKVVKHFID
ELNKGLTKKGGNIPMIPGWVMEFPTGKESGNYLAIDLGGTNLRVVLVKLS
GNHTFDTTQSKYKLPHDMRTTKHQEELWSFIADSLKDFMVEQELLNTKDT
LPLGFTFSYPASQNKINEGILQRWTKGFDIPNVEGHDVVPLLQNEISKRE
LPIEIVALINDTVGTLIASYYTDPETKMGVIFGTGVNGAFYDVVSDIEKL
EGKLADDIPSNSPMAINCEYGSFDNEHLVLPRTKYDVAVDEQSPRPGQQA
FEKMTSGYYVLLELNEKLMLKDQDLSKLKQPYIMDTSYPARIED
DPFENLEDTDDIFQKDFGVKTTLPERKLIRRLCELIGTRAARLAVCGIAA
ICQKRGYKTGHIAADGSVYNKYPGFKEAAAKGLRDIYGWTGDASKDPITI
VPAEDGSGAGAAVIAALSEKRIAEGKSLGIIGA
neobio-0.0.20030929/data/dna13b.txt 0000644 0002656 0002032 00000001604 07710231010 015371 0 ustar tillea admin GCCTATTCGGATGTACTCTCTCCGCCCAGAAGTGAAGGAGTCAGATAGGTCCTTGCTATAACAGCCGCAACACTCATCGTGCCGGCAGCCTAGCAGTTACCTGGATCCCAGATCTACCTTACCATTTCAGGCTAAATTTAGGCTCGGGTACAAAAAACATCGCCGGGCTTCAACCTTGCCGCCCTTAACACACGGTGTGACTTTATACAGGGAGATGGAGCATGGGCTGGCCTAGTGGGGTGTGGCGCTAATTTCCTCGCTAATGCTATGCGGAGCCCTGAAAGCTGACTGGAGGAGGCCGAGCCGACAATGTCTCGTGAGTGGCATTGCGTTTAAGGAAGACTTTTGTCCGATCTACACCTTCCTCGAGTCTCCGCAGGGTTGTGCATAGTGGCTGTAGACAGAATCCAGCTGACAGGTCTGCATTTAGAAATAGCTTAGCGTCCGCCGGACCACTGTCAACTTTACTGTGGCTCTCGTCTGCTGACTTTGATTATCTGAATGTGAGTCTCAGTAACTGACCTGGGCGTCTTCGGCGAAGGATCAATGAACGAATCAAAGAGGTGAAGGGGCTTTCCTGCTAAGACCGTGCATCAGTACTAGCCGGTCGAGTCCTTTGCACGTCCGCCGCAGCCGTACAGTCGATTGATATAGTCTACCCTCGATCCTTTAGCAAGTGCATATGCAGCCGACCAACCTTGCGGCATACTCCAATCAACACTACCCAGATCCTAAGGTGACGGTTTCAGAGGATATACGAAGCGTATTGCACCGCGTATGTATTTAAGAACGGTGGGTGTTATGTCAGACGCGTCCGGTTTTAACCCTTTATACAAATCGTCTCGACACACTACATCAATATATTACATGAAGGTGCATCACAGCCGGTCCACACCGGTT neobio-0.0.20030929/data/dna19b.txt 0000644 0002656 0002032 00000001602 07714345466 015426 0 ustar tillea admin A
AC
ACG
ACGT
ACGTA
ACGTAC
ACGTACG
ACGTACGT
ACGTACGTA
ACGTACGTAC
ACGTACGTACG
ACGTACGTACGT
ACGTACGTACGTA
ACGTACGTACGTAC
ACGTACGTACGTACG
ACGTACGTACGTACGT
ACGTACGTACGTACGTA
ACGTACGTACGTACGTAC
ACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT neobio-0.0.20030929/data/dna24a.txt 0000644 0002656 0002032 00000000111 07714347500 015402 0 ustar tillea admin A
T
TT
AA
TTT
AAA
TTTT
AAAA
TTTTT
AAAAA
TTTTTT
AAAAAA
TTTTTTT neobio-0.0.20030929/data/prot02b.txt 0000644 0002656 0002032 00000000027 07700137524 015625 0 ustar tillea admin >YEAST B
MVHKKPQGSMADVP neobio-0.0.20030929/data/dna10a.txt 0000644 0002656 0002032 00000003365 07705606716 015422 0 ustar tillea admin >gi|1786181|gb|AE000111.1|AE000111 Escherichia coli K-12 MG1655
ACCCATAACGGGCAATGATAAAAGGAGTAACCTGTGAAAAAGATGCAATCTATCGTACTCGCACTTTCCCTGGTTCTGGT
CGCTCCCATGGCAGCACAGGCTGCGGAAATTACGTTAGTCCCGTCAGTAAAATTACAGATAGGCGATCGTGATAATCGTG
GCTATTACTGGGATGGAGGTCACTGGCGCGACCACGGCTGGTGGAAACAACATTATGAATGGCGAGGCAATCGCTGGCAC
CTACACGGACCGCCGCCACCGCCGCGCCACCATAAGAAAGCTCCTCATGATCATCACGGCGGTCATGGTCCAGGCAAACA
TCACCGCTAAATGACAAATGCCGGGTAACAATCCGGCATTCAGCGCCTGATGCGACGCTGGCGCGTCTTATCAGGCCTAC
GTTAATTCTGCAATATATTGAATCTGCATGCTTTTGTAGGCAGGATAAGGCGTTCACGCCGCATCCGGCATTGACTGCAA
ACTTAACGCTGCTCGTAGCGTTTAAACACCAGTTCGCCATTGCTGGAGGAATCTTCATCAAAGAAGTAACCTTCGCTATT
AAAACCAGTCAGTTGCTCTGGTTTGGTCAGCCGATTTTCAATAATGAAACGACTCATCAGACCGCGTGCTTTCTTAGCGT
AGAAGCTGATGATCTTAAATTTGCCGTTCTTCTCATCGAGGAACACCGGCTTGATAATCTCGGCATTCAATTTCTTCGGC
TTCACCGATTTAAAATACTCATCTGACGCCAGATTAATCACCACATTATCGCCTTGTGCTGCGAGCGCCTCGTTCAGCTT
GTTGGTGATGATATCTCCCCAGAATTGATACAGATCTTTCCCTCGGGCATTCTCAAGACGGATCCCCATTTCCAGACGAT
AAGGCTGCATTAAATCGAGCGGGCGGAGTACGCCATACAAGCCGGAAAGCATTCGCAAATGCTGTTGGGCAAAATCGAAA
TCGTCTTCGCTGAAGGTTTCGGCCTGCAAGCCGGTGTAGACATCACCTTTAAACGCCAGAATCGCCTGGCGGGCATTCGC
CGGCGTGAAATCTGGCTGCCAGTCATGAAAGCGAGCGGCGTTGATACCCGCCAGTTTGTCGCTGATGCGCATCAGCGTGC
TAATCTGCGGAGGCGTCAGTTTCCGCGCCTCATGGATCAACTGCTGGGAATTGTCTAACAGCTCCGGCAGCGTATAGCGC
AGATCGCTTTAGGGTTGTTCAGGCGTAAAAAGAAGAGATTGTTTTCGGCATAAATGTAGTTGGCAACGATGGAGCTGAAG
GCAAACAGAATAACCACAAGGGTAACAAACTCAGCACCCCAGGAACCCATTAGCACCCGCATCGCCTTCTGGATAAGCTG
AATACCTTCCAGCGGCATGTAGGTTGTGCCGTTACCCGCCAGTAATATCAGCATGGCGCTTGCCGTACAGATGACCAGGG
TGTCGATAAAAATGCCAATCATCTGGACAATCCCTTGCGCTGCCGGATGCGGAGGCCAGGACGCCGCTGCCGCTGCCGCG
TTTGGCGTCGAACCCATTCCCGCCTCATTGGAAAACATACTGCGCTGAAAACCGTTAGTAATCGCCTGGCTTAAGGTATA
TCCCGCCGCGCCGCCTGCCGCTTCCTGCCAGCCAAAAGCACTCTCAAAAATAGACCAAATGACGTGGGGAAGTTGC neobio-0.0.20030929/data/dna21b.txt 0000644 0002656 0002032 00000000303 07714101734 015400 0 ustar tillea admin >gi|1786181|gb|AE000111.1|AE000111 Escherichia coli K-12 MG1655
G
GG
GGG
GGGG
GGGGG
GGGGGG
GGGGGGG
GGGGGGGA
T
GGGGGGGAA
TT
GGGGGGGAAA
TTT
GGGGGGGAAAA
TTTT
GGGGGGGAAAAA
TTTTT
GGGGGGGAAAAAA
TTTTTT
neobio-0.0.20030929/data/dna21a.txt 0000644 0002656 0002032 00000000254 07714103226 015402 0 ustar tillea admin >gi|1786181|gb|AE000111.1|AE000111 Escherichia coli K-12 MG1655
C
CC
CCC
CCCC
CCCCC
CCCCCC
CCCCCCC
CCCCCCCA
CCCCCCCAA
CCCCCCCAAA
CCCCCCCAAAA
CCCCCCCAAAAA
CCCCCCCAAAAAA
CCC
neobio-0.0.20030929/data/dna18b.txt 0000644 0002656 0002032 00000025121 07702377366 015430 0 ustar tillea admin >gi|1786181|gb|AE000111.1|AE000111 Escherichia coli K-12 MG1655 section 1 of 400 of the complete genome
AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGCTTCTGAACTG
GTTACCTGCCGTGAGTAAATTAAAATTTTATTGACTTAGGTCACTAAATACTTTAACCAATATAGGCATAGCGCACAGAC
AGATAAAAATTACAGAGTACACAACATCCATGAAACGCATTAGCACCACCATTACCACCACCATCACCATTACCACAGGT
AACGGTGCGGGCTGACGCGTACAGGAAACACAGAAAAAAGCCCGCACCTGACAGTGCGGGCTTTTTTTTTCGACCAAAGG
TAACGAGGTAACAACCATGCGAGTGTTGAAGTTCGGCGGTACATCAGTGGCAAATGCAGAACGTTTTCTGCGTGTTGCCG
ATATTCTGGAAAGCAATGCCAGGCAGGGGCAGGTGGCCACCGTCCTCTCTGCCCCCGCCAAAATCACCAACCACCTGGTG
GCGATGATTGAAAAAACCATTAGCGGCCAGGATGCTTTACCCAATATCAGCGATGCCGAACGTATTTTTGCCGAACTTTT
GACGGGACTCGCCGCCGCCCAGCCGGGGTTCCCGCTGGCGCAATTGAAAACTTTCGTCGATCAGGAATTTGCCCAAATAA
AACATGTCCTGCATGGCATTAGTTTGTTGGGGCAGTGCCCGGATAGCATCAACGCTGCGCTGATTTGCCGTGGCGAGAAA
ATGTCGATCGCCATTATGGCCGGCGTATTAGAAGCGCGCGGTCACAACGTTACTGTTATCGATCCGGTCGAAAAACTGCT
GGCAGTGGGGCATTACCTCGAATCTACCGTCGATATTGCTGAGTCCACCCGCCGTATTGCGGCAAGCCGCATTCCGGCTG
ATCACATGGTGCTGATGGCAGGTTTCACCGCCGGTAATGAAAAAGGCGAACTGGTGGTGCTTGGACGCAACGGTTCCGAC
TACTCTGCTGCGGTGCTGGCTGCCTGTTTACGCGCCGATTGTTGCGAGATTTGGACGGACGTTGACGGGGTCTATACCTG
CGACCCGCGTCAGGTGCCCGATGCGAGGTTGTTGAAGTCGATGTCCTACCAGGAAGCGATGGAGCTTTCCTACTTCGGCG
CTAAAGTTCTTCACCCCCGCACCATTACCCCCATCGCCCAGTTCCAGATCCCTTGCCTGATTAAAAATACCGGAAATCCT
CAAGCACCAGGTACGCTCATTGGTGCCAGCCGTGATGAAGACGAATTACCGGTCAAGGGCATTTCCAATCTGAATAACAT
GGCAATGTTCAGCGTTTCTGGTCCGGGGATGAAAGGGATGGTCGGCATGGCGGCGCGCGTCTTTGCAGCGATGTCACGCG
CCCGTATTTCCGTGGTGCTGATTACGCAATCATCTTCCGAATACAGCATCAGTTTCTGCGTTCCACAAAGCGACTGTGTG
CGAGCTGAACGGGCAATGCAGGAAGAGTTCTACCTGGAACTGAAAGAAGGCTTACTGGAGCCGCTGGCAGTGACGGAACG
GCTGGCCATTATCTCGGTGGTAGGTGATGGTATGCGCACCTTGCGTGGGATCTCGGCGAAATTCTTTGCCGCACTGGCCC
GCGCCAATATCAACATTGTCGCCATTGCTCAGGGATCTTCTGAACGCTCAATCTCTGTCGTGGTAAATAACGATGATGCG
ACCACTGGCGTGCGCGTTACTCATCAGATGCTGTTCAATACCGATCAGGTTATCGAAGTGTTTGTGATTGGCGTCGGTGG
CGTTGGCGGTGCGCTGCTGGAGCAACTGAAGCGTCAGCAAAGCTGGCTGAAGAATAAACATATCGACTTACGTGTCTGCG
GTGTTGCCAACTCGAAGGCTCTGCTCACCAATGTACATGGCCTTAATCTGGAAAACTGGCAGGAAGAACTGGCGCAAGCC
AAAGAGCCGTTTAATCTCGGGCGCTTAATTCGCCTCGTGAAAGAATATCATCTGCTGAACCCGGTCATTGTTGACTGCAC
TTCCAGCCAGGCAGTGGCGGATCAATATGCCGACTTCCTGCGCGAAGGTTTCCACGTTGTCACGCCGAACAAAAAGGCCA
ACACCTCGTCGATGGATTACTACCATCAGTTGCGTTATGCGGCGGAAAAATCGCGGCGTAAATTCCTCTATGACACCAAC
GTTGGGGCTGGATTACCGGTTATTGAGAACCTGCAAAATCTGCTCAATGCAGGTGATGAATTGATGAAGTTCTCCGGCAT
TCTTTCTGGTTCGCTTTCTTATATCTTCGGCAAGTTAGACGAAGGCATGAGTTTCTCCGAGGCGACCACGCTGGCGCGGG
AAATGGGTTATACCGAACCGGACCCGCGAGATGATCTTTCTGGTATGGATGTGGCGCGTAAACTATTGATTCTCGCTCGT
GAAACGGGACGTGAACTGGAGCTGGCGGATATTGAAATTGAACCTGTGCTGCCCGCAGAGTTTAACGCCGAGGGTGATGT
TGCCGCTTTTATGGCGAATCTGTCACAACTCGACGATCTCTTTGCCGCGCGCGTGGCGAAGGCCCGTGATGAAGGAAAAG
TTTTGCGCTATGTTGGCAATATTGATGAAGATGGCGTCTGCCGCGTGAAGATTGCCGAAGTGGATGGTAATGATCCGCTG
TTCAAAGTGAAAAATGGCGAAAACGCCCTGGCCTTCTATAGCCACTATTATCAGCCGCTGCCGTTGGTACTGCGCGGATA
TGGTGCGGGCAATGACGTTACAGCTGCCGGTGTCTTTGCTGATCTGCTACGTACCCTCTCATGGAAGTTAGGAGTCTGAC
ATGGTTAAAGTTTATGCCCCGGCTTCCAGTGCCAATATGAGCGTCGGGTTTGATGTGCTCGGGGCGGCGGTGACACCTGT
TGATGGTGCATTGCTCGGAGATGTAGTCACGGTTGAGGCGGCAGAGACATTCAGTCTCAACAACCTCGGACGCTTTGCCG
ATAAGCTGCCGTCAGAACCACGGGAAAATATCGTTTATCAGTGCTGGGAGCGTTTTTGCCAGGAACTGGGTAAGCAAATT
CCAGTGGCGATGACCCTGGAAAAGAATATGCCGATCGGTTCGGGCTTAGGCTCCAGTGCCTGTTCGGTGGTCGCGGCGCT
GATGGCGATGAATGAACACTGCGGCAAGCCGCTTAATGACACTCGTTTGCTGGCTTTGATGGGCGAGCTGGAAGGCCGTA
TCTCCGGCAGCATTCATTACGACAACGTGGCACCGTGTTTTCTCGGTGGTATGCAGTTGATGATCGAAGAAAACGACATC
ATCAGCCAGCAAGTGCCAGGGTTTGATGAGTGGCTGTGGGTGCTGGCGTATCCGGGGATTAAAGTCTCGACGGCAGAAGC
CAGGGCTATTTTACCGGCGCAGTATCGCCGCCAGGATTGCATTGCGCACGGGCGACATCTGGCAGGCTTCATTCACGCCT
GCTATTCCCGTCAGCCTGAGCTTGCCGCGAAGCTGATGAAAGATGTTATCGCTGAACCCTACCGTGAACGGTTACTGCCA
GGCTTCCGGCAGGCGCGGCAGGCGGTCGCGGAAATCGGCGCGGTAGCGAGCGGTATCTCCGGCTCCGGCCCGACCTTGTT
CGCTCTGTGTGACAAGCCGGAAACCGCCCAGCGCGTTGCCGACTGGTTGGGTAAGAACTACCTGCAAAATCAGGAAGGTT
TTGTTCATATTTGCCGGCTGGATACGGCGGGCGCACGAGTACTGGAAAACTAAATGAAACTCTACAATCTGAAAGATCAC
AACGAGCAGGTCAGCTTTGCGCAAGCCGTAACCCAGGGGTTGGGCAAAAATCAGGGGCTGTTTTTTCCGCACGACCTGCC
GGAATTCAGCCTGACTGAAATTGATGAGATGCTGAAGCTGGATTTTGTCACCCGCAGTGCGAAGATCCTCTCGGCGTTTA
TTGGTGATGAAATCCCACAGGAAATCCTGGAAGAGCGCGTGCGCGCGGCGTTTGCCTTCCCGGCTCCGGTCGCCAATGTT
GAAAGCGATGTCGGTTGTCTGGAATTGTTCCACGGGCCAACGCTGGCATTTAAAGATTTCGGCGGTCGCTTTATGGCACA
AATGCTGACCCATATTGCGGGTGATAAGCCAGTGACCATTCTGACCGCGACCTCCGGTGATACCGGAGCGGCAGTGGCTC
ATGCTTTCTACGGTTTACCGAATGTGAAAGTGGTTATCCTCTATCCACGAGGCAAAATCAGTCCACTGCAAGAAAAACTG
TTCTGTACATTGGGCGGCAATATCGAAACTGTTGCCATCGACGGCGATTTCGATGCCTGTCAGGCGCTGGTGAAGCAGGC
GTTTGATGATGAAGAACTGAAAGTGGCGCTAGGGTTAAACTCGGCTAACTCGATTAACATCAGCCGTTTGCTGGCGCAGA
TTTGCTACTACTTTGAAGCTGTTGCGCAGCTGCCGCAGGAGACGCGCAACCAGCTGGTTGTCTCGGTGCCAAGCGGAAAC
TTCGGCGATTTGACGGCGGGTCTGCTGGCGAAGTCACTCGGTCTGCCGGTGAAACGTTTTATTGCTGCGACCAACGTGAA
CGATACCGTGCCACGTTTCCTGCACGACGGTCAGTGGTCACCCAAAGCGACTCAGGCGACGTTATCCAACGCGATGGACG
TGAGTCAGCCGAACAACTGGCCGCGTGTGGAAGAGTTGTTCCGCCGCAAAATCTGGCAACTGAAAGAGCTGGGTTATGCA
GCCGTGGATGATGAAACCACGCAACAGACAATGCGTGAGTTAAAAGAACTGGGCTACACTTCGGAGCCGCACGCTGCCGT
AGCTTATCGTGCGCTGCGTGATCAGTTGAATCCAGGCGAATATGGCTTGTTCCTCGGCACCGCGCATCCGGCGAAATTTA
AAGAGAGCGTGGAAGCGATTCTCGGTGAAACGTTGGATCTGCCAAAAGAGCTGGCAGAACGTGCTGATTTACCCTTGCTT
TCACATAATCTGCCCGCCGATTTTGCTGCGTTGCGTAAATTGATGATGAATCATCAGTAAAATCTATTCATTATCTCAAT
CAGGCCGGGTTTGCTTTTATGCAGCCCGGCTTTTTTATGAAGAAATTATGGAGAAAAATGACAGGGAAAAAGGAGAAATT
CTCAATAAATGCGGTAACTTAGAGATTAGGATTGCGGAGAATAACAACCGCCGTTCTCATCGAGTAATCTCCGGATATCG
ACCCATAACGGGCAATGATAAAAGGAGTAACCTGTGAAAAAGATGCAATCTATCGTACTCGCACTTTCCCTGGTTCTGGT
CGCTCCCATGGCAGCACAGGCTGCGGAAATTACGTTAGTCCCGTCAGTAAAATTACAGATAGGCGATCGTGATAATCGTG
GCTATTACTGGGATGGAGGTCACTGGCGCGACCACGGCTGGTGGAAACAACATTATGAATGGCGAGGCAATCGCTGGCAC
CTACACGGACCGCCGCCACCGCCGCGCCACCATAAGAAAGCTCCTCATGATCATCACGGCGGTCATGGTCCAGGCAAACA
TCACCGCTAAATGACAAATGCCGGGTAACAATCCGGCATTCAGCGCCTGATGCGACGCTGGCGCGTCTTATCAGGCCTAC
GTTAATTCTGCAATATATTGAATCTGCATGCTTTTGTAGGCAGGATAAGGCGTTCACGCCGCATCCGGCATTGACTGCAA
ACTTAACGCTGCTCGTAGCGTTTAAACACCAGTTCGCCATTGCTGGAGGAATCTTCATCAAAGAAGTAACCTTCGCTATT
AAAACCAGTCAGTTGCTCTGGTTTGGTCAGCCGATTTTCAATAATGAAACGACTCATCAGACCGCGTGCTTTCTTAGCGT
AGAAGCTGATGATCTTAAATTTGCCGTTCTTCTCATCGAGGAACACCGGCTTGATAATCTCGGCATTCAATTTCTTCGGC
TTCACCGATTTAAAATACTCATCTGACGCCAGATTAATCACCACATTATCGCCTTGTGCTGCGAGCGCCTCGTTCAGCTT
GTTGGTGATGATATCTCCCCAGAATTGATACAGATCTTTCCCTCGGGCATTCTCAAGACGGATCCCCATTTCCAGACGAT
AAGGCTGCATTAAATCGAGCGGGCGGAGTACGCCATACAAGCCGGAAAGCATTCGCAAATGCTGTTGGGCAAAATCGAAA
TCGTCTTCGCTGAAGGTTTCGGCCTGCAAGCCGGTGTAGACATCACCTTTAAACGCCAGAATCGCCTGGCGGGCATTCGC
CGGCGTGAAATCTGGCTGCCAGTCATGAAAGCGAGCGGCGTTGATACCCGCCAGTTTGTCGCTGATGCGCATCAGCGTGC
TAATCTGCGGAGGCGTCAGTTTCCGCGCCTCATGGATCAACTGCTGGGAATTGTCTAACAGCTCCGGCAGCGTATAGCGC
GTGGTGGTCAACGGGCTTTGGTAATCAAGCGTTTTCGCAGGTGAAATAAGAATCAGCATATCCAGTCCTTGCAGGAAATT
TATGCCGACTTTAGCAAAAAATGAGAATGAGTTGATCGATAGTTGTGATTACTCCTGCGAAACATCATCCCACGCGTCCG
GAGAAAGCTGGCGACCGATATCCGGATAACGCAATGGATCAAACACCGGGCGCACGCCGAGTTTACGCTGGCGTAGATAA
TCACTGGCAATGGTATGAACCACAGGCGAGAGCAGTAAAATGGCGGTCAAATTGGTAATAGCCATGCAGGCCATTATGAT
ATCTGCCAGTTGCCACATCAGCGGAAGGCTTAGCAAGGTGCCGCCGATGACCGTTGCGAAGGTGCAGATCCGCAAACACC
AGATCGCTTTAGGGTTGTTCAGGCGTAAAAAGAAGAGATTGTTTTCGGCATAAATGTAGTTGGCAACGATGGAGCTGAAG
GCAAACAGAATAACCACAAGGGTAACAAACTCAGCACCCCAGGAACCCATTAGCACCCGCATCGCCTTCTGGATAAGCTG
AATACCTTCCAGCGGCATGTAGGTTGTGCCGTTACCCGCCAGTAATATCAGCATGGCGCTTGCCGTACAGATGACCAGGG
TGTCGATAAAAATGCCAATCATCTGGACAATCCCTTGCGCTGCCGGATGCGGAGGCCAGGACGCCGCTGCCGCTGCCGCG
TTTGGCGTCGAACCCATTCCCGCCTCATTGGAAAACATACTGCGCTGAAAACCGTTAGTAATCGCCTGGCTTAAGGTATA
TCCCGCCGCGCCGCCTGCCGCTTCCTGCCAGCCAAAAGCACTCTCAAAAATAGACCAAATGACGTGGGGAAGTTGCCCGA
TATTCATTACGCAAATTACCAGGCTGGTCAGTACCCAGATTATCGCCATCAACGGGACAAAGCCCTGCATGAGCCGGGCG
ACGCCATGAAGACCGCGAGTGATTGCCAGCAGAGTAAAGACAGCGAGAATAATGCCTGTCACCAGCGGGGGAAAATCAAA
AGAAAAACTCAGGGCGCGGGCAACGGCGTTCGCTTGAACTCCGCTGAAAATTATGCCATAGGCGATGAGCAAAAAGACGG
CGAACAGAACGCCCATCCAGCGCATCCCCAGCCCGCGCGCCATATACCATGCCGGTCCGCCACGAAACTGCCCATTGACG
TCACGTTCTTTATAAAGTTGTGCCAGAGAACATTCGGCAAACGAGGTCGCCATGCCGATAAACGCGGCAACCCACATCCA
AAAGACGGCTCCAGGTCCACCGGCGGTAATAGCCAGCGCAACGCCGGCCAGGTTGCCGCTACCCACGCGCGCCGCAAGAC
TGGTACACAATGACTGAAATGAGGTTAAACCGCCTGGCTGTGGATGAATGCTATTTTTAAGACTTTTGCCAAACTGGCGG
ATGTAGCGAAACTGCACAAATCCGGTGCGAAAAGTGAACCAACAACCTGCGCCGAAGAGCAGGTAAATCATTACCGATCC
CCAAAGGACGCTGTTAATGAAGGAGAAAAAATCTGGCATGCATATCCCTCTTATTGCCGGTCGCGATGACTTTCCTGTGT
AAACGTTACCAATTGTTTAAGAAGTATATACGCTACGAGGTACTTGATAACTTCTGCGTAGCATACATGAGGTTTTGTAT
AAAAATGGCGGGCGATATCAACGCAGTGTCAGAAATCCGAAACAGTCTCGCCTGGCGATAACCGTCTTGTCGGCGGTTGC
GCTGACGTTGCGTCGTGATATCATCAGGGCAGACCGGTTACATCCCCCTAACAAGCTGTTTAAAGAGAAATACTATCATG
ACGGACAAATTGACCTCCCTTCGTCAGTACACCACCGTAGTGGCCGACACTGGGGACATCGCGGCAATGAAGCTGTATCA
ACCGCAGGATGCCACAACCAACCCTTCTCTCATTCTTAACGCAGCGCAGATTCCGGAATACCGTAAGTTGATTGATGATG
CTGTCGCCTGGGCGAAACAGCAGAGCAACGATCGCGCGCAGCAGATCGTGGACGCGACCGACAAACTGGCAGTAAATATT
GGTCTGGAAATCCTGAAACTGGTTCCGGGCCGTATCTCAACTGAAGTTGATGCGCGTCTTTCCTATGACACCGAAGCGTC
AATTGCGAAAGCAAAACGCCTGATCAAACTCTACAACGATGCTGGTATTAGCAACGATCGTATTCTGATCAAACTGGCTT
CTACCTGGCAGGGTATCCGTGCTGCAGAACAGCTGGAAAAAGAAGGCATCAACTGTAACCTGACCCTGCTGTTCTCCTTC
GCTCAGGCTCGTGCTTGTGCGGAAGCGGGCGTGTTCCTGATCTCGCCGTTTGTTGGCCGTATTCTTGACTGGTACAAAGC
GAATACCGATAAGAAAGAGTACGCTCCGGCAGAAGATCCGGGCGTGGTTTCTGTATCTGAAATCTACCAGTACTACAAAG
AGCACGGTTATGAAACCGTGGTTATGGGCGCAAGCTTCCGTAACATCGGCGAAATTCTGGAACTGGCAGGCTGCGACCGT
CTGACCATCGCACCGGCACTGCTGAAAGAGCTGGCGGAGAGCGAAGGGGCTATCGAACGTAAACTGTCTTACACCGGCGA
AGTGAAAGCGCGTCCGGCGCGTATCACTGAGTCCGAGTTCCTGTGGCAGCACAACCAGGATCCAATGGCAGTAGATAAAC
TGGCGGAAGGTATCCGTAAGTTTGCTATTGACCAGGAAAAACTGGAAAAAATGATCGGCGATCTGCTGTAATCATTCTTA
GCGTGACCGGGAAGTCGGTCACGCTACCTCTTCTGAAGCCTGTCTGTCACTCCCTTCGCAGTGTATCATTCTGTTTAACG
AGACTGTTTAAACGGAAAAATCTTGATGAATACTTTACGTATTGGCTTAGTTTCCATCTCTGATCGCGCATCCAGCGGCG
TTTATCAGGATAAAGGCATCCCTGCGCTGGAAGAATGGCTGACATCGGCGCTAACCACGCCGTTTGAACTGGAAACCCGC
TTAATCCCCGATGAGCAGGCGATCATCGAGCAAACGTTGTGTGAGCTGGTGGATGAAATGAGTTGCCATCTGGTGCTCAC
CACGGGCGGAACTGGCCCGGCGCGTCGTGACGTAACGCCCGATGCGACGCTGGCAGTAGCGGACCGCGAGATGCCTGGCT
TTGGTGAACAGATGCGCCAGATCAGCCTGCATTTTGTACCAACTGCGATCCTTTCGCGTCAGGTGGGCGTGATTCGCAAA
CAGGCGCTGATCCTTAACTTACCCGGTCAGCCGAAGTCTATTAAAGAGACGCTGGAAGGTGTGAAGGACGCTGAGGGTAA
CGTTGTGGTACACGGTATTTTTGCCAGCGTACCGTACTGCATTCAGTTGCTGGAAGGGCCATACGTTGAAACGGCACCGG
AAGTGGTTGCAGCATTCAGACCGAAGAGTGCAAGACGCGACGTTAGCGAATAAAAAAATCCCCCCGAGCGGGGGGATCTC
AAAACAATTAGTGGGATTCACCAATCGGCAGAACGGTGCGACCAAACTGCTCGTTCAGTACTTCACCCATCGCCAGATAG
ATTGCGCTGGCACCGCAGATCAGCCCAATCCAGCCGGCAAAGTGGATGATTGCGGCGTTACCGGCAATGTTACCGATCGC
CAGCAGGGCAAACAGCACGGTCAGGCTAAAGAAAACGAATTGCAGAACGCGTGCGCCTTTCAGCGTGCCGAAGAACATAA
ACAGCGTAAATACGCCCCACAGACCCAGGTAGACACCAAGGAACTGTGCATTTGGCGCATCGGTCAGACCCAGTTTCGGC
ATCAGCAGAATCGCAACCAGCGTCAGCCAGAAAGAACCGTAAGAGGTGAATGCGGTTAAACCGAAAGTGTTGCCTTTTTT
GTACTCCAGCAGACCAGCAAAAATTTGCGCGATGCCGCCGTAGAAAATGCCCATGGCAAGAATAATACCGTCCAGAGCGA
AATAACCCACGTTGTGCAGGTTAAGCAGAATGGTGGTCATGCCGAAGCCCATCAGGCCCAGCGGTGCCGGATTAGCCAAC
TTAGTGTTGCCCATAATTCCTCAAAAATCATCATCGAATGAATGGTGAAATAATTTCCCTGAATAACTGTAGTGTTTTCA
GGGCGCGGCATAATAATCAGCCAGTGGGGCAGTGTC
neobio-0.0.20030929/data/prot07a.txt 0000644 0002656 0002032 00000001750 07710227264 015637 0 ustar tillea admin ECGVZVSLLXVHTZYGVXLTKTWHRYFEMIXLXNTLQBZPCRTQRQBHNIVVHECXZBVSQFFXKARRVANLIYTXEZDIBAKEMGKRDVYBSAKHZRPDNFFECQPSMWVGKSIEXASTMFNKRHRGZCYEDBIPIBXFHYLSEYTTPWMEQMTQMNNDNCGGWKEYBPQBYRENKYXHWHLCCYNHQNCCSQHLHAYNGPXNIRQYTEIYRECAQBYSMPCIDKDTWVDTZPTHYNCQRNMLDDQSWKVLYITCWAMLISTGZCLILQZNHGEBLSBGESRNRNIYKBEFPLDVYSAGMXQBFLSHNTHBBAXGDSRIATRIMTVGXNRRDBCAPXWMGKCEDMLINPAXGNQGMYQNVHXMBTVVHEWTZQXSARQRSWAABYGCXYWHVTLYIPNPVLEAAXQCQXXRCVRWCSCYRCWYZLSPKFTTTTEVNFKMXWMGTDTFRQEEBGZKEZFACESCNAMBGNZEHIDKCDFWVCACRFTQCWPPGZVMMFCZAIYNZFLICXRAGIYWRHDXEGQIQWYTDCWLITIEKQDZYKCANNWQHYXIVHQSSEXHCGNVTNIPAKHNMRXPGNDLMXWXTCZERCBKBTXIKHNSHYNMWKXLKYVBPLSCAPBEVHVBEDFHBXXTEAYAGXWXLTNBTBXXIPKIHZVMKMLQTMAPPIKEEPNLNYLZRXHEKAGDVNLSGNMNEDIPQNTENXCHMXDGZWREMLCCEMKEZXTVVKQQGLGGZXXCHMFEQYIHLKBMHTHZWZETBPNVVEWBQRXCMGRBNDTSWEAKWBXBBKXANMARTIILFMGMBPSTVDCVECBTIWZNLCXLHHKWEPKLSNZTMWYGBPHBSSNNKDWXKRLAXWDBQWTYBAZCRPKGKELHLPYSDRPRWLXZDERAFZYLPYHHGYDKDMGAXBYNYVNRNXPNVGNZRQMEGAIMRLWDMGLQNYKPFYGNXAZLBQTQMMRDLSEKGYYVYHCEYECMQVGDNZHXXIMTXPXCBRBXKZDLWMID neobio-0.0.20030929/data/prot10a.txt 0000644 0002656 0002032 00000006034 07710227442 015627 0 ustar tillea admin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neobio-0.0.20030929/data/prot02a.txt 0000644 0002656 0002032 00000000030 07700137530 015613 0 ustar tillea admin >YEAST A
MVVHKPQSMDVPPME neobio-0.0.20030929/data/dna26b.txt 0000644 0002656 0002032 00000000012 07714476456 015422 0 ustar tillea admin PTXYLSHDQB neobio-0.0.20030929/data/dna22a.txt 0000644 0002656 0002032 00000000163 07714106474 015412 0 ustar tillea admin >gi|1786181|gb|AE000111.1|AE000111 Escherichia coli K-12 MG1655
GLDZRXRLWZVZVHHDMXRISLBMLTGCKFLWKTITVPABXRPQPVZRKE
neobio-0.0.20030929/data/dna29a.txt 0000644 0002656 0002032 00000000014 07714521130 015402 0 ustar tillea admin GTGTTGCCGA
neobio-0.0.20030929/data/blosum62.txt 0000644 0002656 0002032 00000004151 06400302772 016003 0 ustar tillea admin # Matrix made by matblas from blosum62.iij
# * column uses minimum score
# BLOSUM Clustered Scoring Matrix in 1/2 Bit Units
# Blocks Database = /data/blocks_5.0/blocks.dat
# Cluster Percentage: >= 62
# Entropy = 0.6979, Expected = -0.5209
A R N D C Q E G H I L K M F P S T W Y V B Z X *
A 4 -1 -2 -2 0 -1 -1 0 -2 -1 -1 -1 -1 -2 -1 1 0 -3 -2 0 -2 -1 0 -4
R -1 5 0 -2 -3 1 0 -2 0 -3 -2 2 -1 -3 -2 -1 -1 -3 -2 -3 -1 0 -1 -4
N -2 0 6 1 -3 0 0 0 1 -3 -3 0 -2 -3 -2 1 0 -4 -2 -3 3 0 -1 -4
D -2 -2 1 6 -3 0 2 -1 -1 -3 -4 -1 -3 -3 -1 0 -1 -4 -3 -3 4 1 -1 -4
C 0 -3 -3 -3 9 -3 -4 -3 -3 -1 -1 -3 -1 -2 -3 -1 -1 -2 -2 -1 -3 -3 -2 -4
Q -1 1 0 0 -3 5 2 -2 0 -3 -2 1 0 -3 -1 0 -1 -2 -1 -2 0 3 -1 -4
E -1 0 0 2 -4 2 5 -2 0 -3 -3 1 -2 -3 -1 0 -1 -3 -2 -2 1 4 -1 -4
G 0 -2 0 -1 -3 -2 -2 6 -2 -4 -4 -2 -3 -3 -2 0 -2 -2 -3 -3 -1 -2 -1 -4
H -2 0 1 -1 -3 0 0 -2 8 -3 -3 -1 -2 -1 -2 -1 -2 -2 2 -3 0 0 -1 -4
I -1 -3 -3 -3 -1 -3 -3 -4 -3 4 2 -3 1 0 -3 -2 -1 -3 -1 3 -3 -3 -1 -4
L -1 -2 -3 -4 -1 -2 -3 -4 -3 2 4 -2 2 0 -3 -2 -1 -2 -1 1 -4 -3 -1 -4
K -1 2 0 -1 -3 1 1 -2 -1 -3 -2 5 -1 -3 -1 0 -1 -3 -2 -2 0 1 -1 -4
M -1 -1 -2 -3 -1 0 -2 -3 -2 1 2 -1 5 0 -2 -1 -1 -1 -1 1 -3 -1 -1 -4
F -2 -3 -3 -3 -2 -3 -3 -3 -1 0 0 -3 0 6 -4 -2 -2 1 3 -1 -3 -3 -1 -4
P -1 -2 -2 -1 -3 -1 -1 -2 -2 -3 -3 -1 -2 -4 7 -1 -1 -4 -3 -2 -2 -1 -2 -4
S 1 -1 1 0 -1 0 0 0 -1 -2 -2 0 -1 -2 -1 4 1 -3 -2 -2 0 0 0 -4
T 0 -1 0 -1 -1 -1 -1 -2 -2 -1 -1 -1 -1 -2 -1 1 5 -2 -2 0 -1 -1 0 -4
W -3 -3 -4 -4 -2 -2 -3 -2 -2 -3 -2 -3 -1 1 -4 -3 -2 11 2 -3 -4 -3 -2 -4
Y -2 -2 -2 -3 -2 -1 -2 -3 2 -1 -1 -2 -1 3 -3 -2 -2 2 7 -1 -3 -2 -1 -4
V 0 -3 -3 -3 -1 -2 -2 -3 -3 3 1 -2 1 -1 -2 -2 0 -3 -1 4 -3 -2 -1 -4
B -2 -1 3 4 -3 0 1 -1 0 -3 -4 0 -3 -3 -2 0 -1 -4 -3 -3 4 1 -1 -4
Z -1 0 0 1 -3 3 4 -2 0 -3 -3 1 -1 -3 -1 0 -1 -3 -2 -2 1 4 -1 -4
X 0 -1 -1 -1 -2 -1 -1 -1 -1 -1 -1 -1 -1 -1 -2 0 0 -2 -1 -1 -1 -1 -1 -4
* -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 1
neobio-0.0.20030929/data/dna17b.txt 0000644 0002656 0002032 00000010131 07710120360 015375 0 ustar tillea admin >gi|1786181|gb|AE000111.1|AE000111 Escherichia coli K-12 MG1655
ACACCTCGTCGATGGATTACTACCATCAGTTGCGTTATGCGGCGGAAAAATCGCGGCGTAAATTCCTCTATGACACCAAC
GTTGGGGCTGGATTACCGGTTATTGAGAACCTGCAAAATCTGCTCAATGCAGGTGATGAATTGATGAAGTTCTCCGGCAT
TCTTTCTGGTTCGCTTTCTTATATCTTCGGCAAGTTAGACGAAGGCATGAGTTTCTCCGAGGCGACCACGCTGGCGCGGG
AAATGGGTTATACCGAACCGGACCCGCGAGATGATCTTTCTGGTATGGATGTGGCGCGTAAACTATTGATTCTCGCTCGT
GAAACGGGACGTGAACAGGAGCTGGCGGATATTGAAATTGAACCTGTGCTGCCCGCAGAGTTTAACGCCGAGGGTGATGT
TGCCGCTTTTATGGCGAATCTGTCACAACTCGACGATCTCTTTGCCGCGCGCGTGGCGAAGGCCCGTGATGAAGGAAAAG
TTTTGCGCTATGTTGGCAATATTGATGAAGATGGCGTCTGCCGCGTGAAGATTGCCGAAGTGGATGGTAATGATCCGCTG
TTCAAAGTGAAAAATGGCGAAAACGCCCTGGCCTTCTATAGCCACTATTATCAGCCGCTGCCGTTGGTACTGCGCGGATA
TGGTGCGGGCAATGACGTTACAGCTGCCGGTGTCTTTGCTGATCTGCTACGTACCCTCTCATGGAAGTTAGGAGTCTGAC
ATGGTTAAAGTTTATGCCCCGGCTTCCAGTGCCAATATGAGCGTCGGGTTTGATGTGCTCGGGGCGGCGGTGACACCTGT
TGATGGTGCATTGCTCGGAGATGTAGTCACGGTTGAGGCGGCAGAGACATTCAGTCTCAACAACCTCGGACGCTTTGCCG
ATAAGCTGCCGTCAGAACCACGGGAAAATATCGTTTATCAGTGCTGGGAGCGTTTTTGCCAGGAACTGGGTAAGCAAATT
CCAGTGGCGATGACCCTGGAAAAGAATATGCCGATCGGTTCGGGCTTAGGCTCCAGTGCCTGTTCGGTGGTCGCGGCGCT
GATGGCGATGAATGAACACTGCGGCAAGCCGCTTAATGACACTCGTTTGCTGGCTTTGATGGGCGAGCTGGAAGGCCGTA
TCTCCGGCAGCATTCATTACGACAACGTGGCACCGTGTTTTCTCGGTGGTATGCAGTTGATGATCGAAGAAAACGACATC
ATCAGCCAGCAAGTGCCGGGGTTTGATGAGTGGCTGTGGGTGCTGGCGTATCCGGGGATTAAAGTCTCGACGGCAGAAGC
CAGGGCTATTTTACCGGCGCAGTATCGCCGCCAGGATTGCATTGCGCACGGGCGACATCTGGCAGGCTTCATTCACGCCT
GCTATTCCCGTCAGCCTGAGCTTGCCGCGAAGCTGATGAAAGATGTTATCGCTGAACCCTACCGTGAACGGTTACTGCCA
GGCTTCCGGCAGGCGCGGCAGGCGGTCGCGGAAATCGGCGCGGTAGCGAGCGGTATCTCCGGCTCCGGCCCGACCTTGTT
CGCTCTGTGTGACAAGCCGGAAACCGCCCAGCGCGTTGCCGACTGGTTGGGTAAGAACTACCTGCAAAATCAGGAAGGTT
TTGTTCATATTTGCCGGCTGGATACGGCGGGCGCACGAGTACTGGAAAACTAAATGAAACTCTACAATCTGAAAGATCAC
AACGAGCAGGTCAGCTTTGCGCAAGCCGTAACCCAGGGGTTGGGCAAAAATCAGGGGCTGTTTTTTCCGCACGACCTGCC
GGAATTCAGCCTGACTGAAATTGATGAGATGCTGAAGCTGGATTTTGTCACCCGCAGTGCGAAGATCCTCTCGGCGTTTA
TTGGTGATGAAATCCCACAGGAAATCCTGGAAGAGCGCGTGCGCGCGGCGTTTGCCTTCCCGGCTCCGGTCGCCAATGTT
GAAAGCGATGTCGGTTGTCTGGAATTGTTCCACGGGCCAACGCTGGCATTTAAAGATTTCGGCGGTCGCTTTATGGCACA
AATGCTGACCCATATTGCGGGTGATAAGCCAGTGACCATTCTGACCGCGACCTCCGGTGATACCGGAGCGGCAGTGGCTC
ATGCTTTCTACGGTTTACCGAATGTGAAAGTGGTTATCCTCTATCCACGAGGCAAAATCAGTCCACTGCAAGAAAAACTG
TTCTGTACATTGGGCGGCAATATCGAAACTGTTGCCATCGACGGCGATTTCGATGCCTGTCAGGCGCTGGTGAAGCAGGC
GTTTGATGATGAAGAACTGAAAGTGGCGCTAGGGTTAAACTCGGCTAACTCGATTAACATCAGCCGTTTGCTGGCGCAGA
TTTGCTACTACTTTGAAGCTGTTGCGCAGCTGCCGCAGGAGACGCGCAACCAGCTGGTTGTCTCGGTGCCAAGCGGAAAC
TTCGGCGATTTGACGGCGGGTCTGCTGGCGAAGTCACTCGGTCTGCCGGTGAAACGTTTTATTGCTGCGACCAACGTGAA
CGATACCGTGCCACGTTTCCTGCACGACGGTCAGTGGTCACCCAAAGCGACTCAGGCGACGTTATCCAACGCGATGGACG
TGAGTCAGCCGAACAACGGGCCGCGTGTGGAAGAGTTGTTCCGCCGCAAAATCTGGCAACTGAAAGAGCTGGGTTATGCA
GCCGTGGATGATGAAACCACGCAACAGACAATGCGTGAGTTAAAAGAACTGGGCTACACTTCGGAGCCGCACGCTGCCGT
AGCTTATCGTGCGCTGCGTGATCAGTTGAATCCAGGCGAATATGGCTTGTTCCTCGGCACCGCGCATCCGGCGAAATTTA
AAGAGAGCGTGGAAGCGATTCTCGGTGAAACGTTGGATCTGCCAAAAGAGCTGGCAGAACGTGCTGATTTACCCTTGCTT
TCACATAATCTGCCCGCCGATTTTGCTGCGTTGCGTAAATTGATGATGAATCATCAGTAAAATCTATTCATTATCTCAAT
CAGGCCGGGTTTGCTTTTATGCAGCCCGGCTTTTTTATGAAGAAATTATGGAGAAAAATGACAGGGAAAAAGGAGAAATT
CTCAATAAATGCGGTAACTTAGAGATTAGGATTGCGGAGAATAACAACCGCCGTTCTCATCGAGTAATCTCCGGATATCG
ACCCATAACGGGCAATGATAAAAGGAGTAACCTGTGAAAAAGATGCAATCTATCGTACTCGCACTTTCCCTGGTTCTGGT
CGCTCCCATGGCAGCAGAGGCTGCGGAAATTACGTTAGTCCCGTCAGTAAAATTACAGATAGGCGATCGTGATAATCGTG
GCTATTACTGGGATGGAGGTCACTGGCGCGACCACGGCTGGTGGAAACAACATTATGAATGGCGAGGCAATCGCTGGCAC
CTACACGGACCGCCGCCACCGCCGCGCCACCATAAGAAAGCTCCTCATGATCATCACGGCGGTCATGGTCCAGGCAAACA
TCACCGCTAAATGACAAATGCCGGGTAACAATCCGGCATTCAGCGCCTGATGCGACGCTGGCGCGTCTTATCAGGCCTAC
GTTAATTCTGCAATATATTGAATCTGCATGCTTTTGTAGGCAGGATAAGGCGTTCACGCCGCATCCGGCATTGACTGCAA
ACTTAACGCTGCTCGTAGCGTTTAAACACCAGTTCGCCATTGCTGGAGGAATCTTCATCAAAGAAGTAACCTTCGCTATT
AAAACCAGTCAGTTGCTCTGGTTTGGTCAGCCGATTTTCAATAATGAAACGACTCATCAGACCGCGTGCTTTCTTAGCGT
ACTTAACGCTGCTCGTAGCGTTTAAACACCAGTTCGCCATTGCTGGAGGAATCTTCATCAAAGAAGTAACCTTCGCTATT
AGAAGCTGATGATCTTAAATTTGCCGTTCTTCTCATCGAGGAACACCGGCTTGATAATCTCGGCATTCAATTTCTTCGGC
TATCCCGCCGCGCCGCCTGCCGCTTCCTGCCAGCCAAAAGCACTCTCAAAAATGACCAAATGACGTGGGGAAGTTGCCCG
AACTCAAAAATGACCAAATGACGTGGGGAAGTTGCCCGAAACGTGGGGAAGTTGCCCGAAGTTGCCCGAAC neobio-0.0.20030929/data/dna22b.txt 0000644 0002656 0002032 00000000163 07714106464 015412 0 ustar tillea admin >gi|1786181|gb|AE000111.1|AE000111 Escherichia coli K-12 MG1655
NSSNHBBCFZMZQWASMBSRLQVPYQSVYSSSPAGHPARNSAHIARPMTP
neobio-0.0.20030929/data/dna09b.txt 0000644 0002656 0002032 00000000603 07705576556 015433 0 ustar tillea admin >gi|1786181|gb|AE000111.1|AE000111 Escherichia coli K-12 MG1655
ACCCATAACGGGCAATGATAAAAGGAGTAACCTGTGAAAAAGATGCAATCTATCGTACTCGCACTTTCCCTGGTTCTGGT
CGCTCCCATGGCAGCAGAGGCTGCGGAAATTACGTTAGTCCCGTCAGTAAAATTACAGATAGGCGATCGTGATAATCGTG
GCTATTACTGGGATGGAGGTCACTGGCGCGACCACGGCTGGTGGAAACAACATTATGAATGGCGAGGCAATCGCTGGCAC
CTACACGGACCGCCGCCACCGCCGCGCCACCATAAGAAAGCTCCTCATGATCATCACGGCGGTCATGGTCCAGGCAAAC
neobio-0.0.20030929/data/dna25b.txt 0000644 0002656 0002032 00000000106 07714350432 015406 0 ustar tillea admin G
GG
GA
GGG
GAA
GGGG
GAAA
GGGGG
GAAAA
GGGGGG
GAAAAA
GGGGGGG neobio-0.0.20030929/data/prot14b.txt 0000644 0002656 0002032 00000000174 07724425656 015647 0 ustar tillea admin >HXKB_YEAST STANDARD; PRT; 486 AA., 486 bases, B05F4DF9 checksum.
MVHLGQARKGSMVPKELMQQIENFEKIFTVPTETLQAVTKHFISELEKGLSKKGGNIP neobio-0.0.20030929/data/dna38b.txt 0000644 0002656 0002032 00000000014 07720660024 015406 0 ustar tillea admin AGAACAAGGCGA neobio-0.0.20030929/data/dna28a.txt 0000644 0002656 0002032 00000000012 07714520714 015406 0 ustar tillea admin AGGTCATTAG neobio-0.0.20030929/data/hepatitis_a.txt 0000644 0002656 0002032 00000016742 07721476376 016660 0 ustar tillea admin >gi|9626732|ref|NC_001489.1| Hepatitis A virus, complete genome
TTCAAGAGGGGTCTCCGGGAATTTCCGGAGTCCCTCTTGGAAGTCCATGGTGAGGGGACTTGATACCTCA
CCGCCGTTTGCCTAGGCTATAGGCTAAATTTTCCCTTTCCCTTTTCCCTTTCCTATTCCCTTTGTTTTGC
TTGTAAATATTAATTCCTGCAGGTTCAGGGTTCTTAAATCTGTTTCTCTATAAGAACACTCATTTTTCAC
GCTTTCTGTCTTCTTTCTTCCAGGGCTCTCCCCTTGCCCTAGGCTCTGGCCGTTGCGCCCGGCGGGGTCA
ACTCCATGATTAGCATGGAGCTGTAGGAGTCTAAATTGGGGACACAGATGTTTGGAACGTCACCTTGCAG
TGTTAACTTGGCTTTCATGAATCTCTTTGATCTTCCACAAGGGGTAGGCTACGGGTGAAACCTCTTAGGC
TAATACTTCTATGAAGAGATGCCTTGGATAGGGTAACAGCGGCGGATATTGGTGAGTTGTTAAGACAAAA
ACCATTCAACGCCGGAGGACTGACTCTCATCCAGTGGATGCATTGAGTGGATTGACTGTCAGGGCTGTCT
TTAGGCTTAATTCCAGACCTCTCTGTGCTTAGGGCAAACATCATTTGGCCTTAAATGGGATTCTGTGAGA
GGGGATCCCTCCATTGACAGCTGGACTGTTCTTTGGGGCCTTATGTGGTGTTTGCCTCTGAGGTACTCAG
GGGCATTTAGGTTTTTCCTCATTCTTAAATAATAATGAACATGTCTAGACAAGGTATTTTCCAGACTGTT
GGGAGTGGTCTTGACCACATCCTGTCTTTGGCAGACATTGAGGAAGAGCAAATGATTCAATCAGTTGATA
GGACTGCAGTGACTGGTGCTTCTTATTTTACTTCTGTGGATCAATCTTCAGTTCATACAGCTGAGGTTGG
ATCACACCAGGTTGAACCTTTGAGAACCTCTGTTGATAAACCCGGTTCAAAGAAGACTCAGGGAGAGAAA
TTTTTCTTGATTCATTCTGCAGATTGGCTTACTACACATGCTCTTTTCCATGAAGTTGCAAAATTGGATG
TGGTGAAATTATTATACAATGAGCAGTTTGCTGTTCAAGGGTTGTTGAGATACCATACATATGCAAGATT
TGGCATTGAAATTCAAGTTCAGATAAACCCTACACCTTTCCAACAGGGGGGATTGATCTGTGCTATGGTT
CCTGGTGACCAGAGCTATGGTTCTATAGCATCATTGACTGTTTATCCTCATGGTTTGTTAAATTGCAATA
TTAACAATGTGGTTAGAATAAAGGTTCCATTTATTTACACAAGAGGTGCTTACCACTTTAAAGATCCACA
ATACCCAGTTTGGGAATTGACAATTAGAGTTTGGTCAGAATTAAATATTGGGACAGGAACTTCAGCTTAT
ACTTCACTCAATGTTTTAGCTAGATTTACAGATTTGGAGTTGCATGGATTAACTCCTCTTTCTACACAAA
TGATGAGAAATGAATTTAGGGTCAGTACTACTGAGAATGTGGTGAATCTGTCAAATTATGAAGATGCAAG
AGCAAAGATGTCTTTTGCTTTGGATCAGGAAGATTGGAAATCTGATCCGTCCCAGGGTGGTGGGATCAAA
ATTACTCATTTTACTACTTGGACATCTATTCCAACTTTGGCTGCTCAGTTTCCATTTAATGCTTCAGACT
CAGTTGGTCAACAAATTAAAGTTATTCCAGTTGACCCATATTTTTTCCAAATGACAAATACGAATCCTGA
CCAAAAATGTATAACTGCTTTGGCTTCTATTTGTCAGATGTTTTGTTTTTGGAGAGGAGATCTTGTCTTT
GATTTTCAAGTTTTTCCCACCAAATATCATTCAGGTAGATTACTGTTTTGTTTTGTTCCTGGCAATGAGC
TAATAGATGTTTCTGGAATCACATTAAAGCAAGCAACTACTGCTCCTTGTGCAGTAATGGATATTACAGG
AGTGCAGTCAACTTTGAGATTTCGTGTTCCCTGGATTTCTGACACTCCTTACAGAGTGAACAGGTATACA
AAGTCAGCACATCAGAAAGGTGAGTACACTGCCATTGGGAAGCTTATTGTGTATTGTTATAACAGATTGA
CCTCTCCTTCTAACGTTGCTTCCCATGTCAGAGTGAATGTTTATCTTTCAGCAATTAACTTGGAATGTTT
TGCTCCTCTTTATCATGCTATGGATGTTACTACACAAGTTGGAGATGATTCTGGAGGTTTTTCAACAACA
GTTTCTACAGAACAGAATGTTCCAGATCCCCAAGTTGGTATAACAACCATGAAAGATTTGAAAGGAAAAG
CTAACAGAGGGAAAATGGATGTTTCAGGAGTACAAGCACCTGTGGGAGCTATCACAACAATTGAGGATCC
AGTTTTAGCAAAGAAAGTACCTGAGACATTTCCTGAATTGAAACCTGGAGAATCCAGACATACATCAGAT
CATATGTCCATCTACAAGTTTATGGGAAGGTCTCATTTCTTGTGCACTTTTACATTCAATTCAAATAATA
AAGAGTACACATTTCCTATAACCTTGTCTTCAACCTCTAATCCTCCTCATGGTTTGCCATCAACACTGAG
GTGGTTTTTCAACTTGTTTCAGTTGTATAGAGGGCCTTTAGATCTGACAATTATTATTACAGGAGCAACT
GATGTAGATGGCATGGCCTGGTTCACTCCAGTAGGTCTTGCCGTTGATACTCCTTGGGTAGAGAAGGAGT
CAGCTTTGTCTATTGACTACAAAACTGCTCTTGGAGCTGTCAGATTTAACACAAGGAGAACAGGGAACAT
TCAGATTAGATTACCATGGTATTCTTATTTATATGCTGTGTCTGGAGCACTGGATGGTTTGGGTGACAAG
ACAGATTCTACATTTGGATTGGTTTCTATTCAGATTGCAAATTACAATCATTCTGATGAATACTTGTCTT
TTAGTTGTTATTTGTCTGTCACAGAACAATCAGAGTTTTATTTTCCCAGAGCTCCATTGAACTCAAATGC
CATGTTATCCACTGAATCAATGATGAGCAGAATTGCAGCTGGAGACTTGGAGTCATCAGTGGATGATCCT
AGATCAGAGGAAGATAAAAGATTTGAGAGTCATATAGAATGCAGGAAGCCATATAAAGAACTGAGATTAG
AAGTTGGGAAACAAAGACTCAAGTATGCTCAGGAAGAATTGTCAAATGAAGTACTTCCACCCCCTAGGAA
AATGAAGGGACTGTTTTCACAAGCCAAAATTTCTCTTTTTTATACTGAGGAGCATGAAATAATGAAGTTT
TCCTGGAGAGGTGTGACTGCTGATACTAGAGCTTTAAGGAGGTTTGGATTCTCTTTGGCCGCAGGCAGAA
GTGTGTGGACTCTTGAAATGGATGCTGGGGTTCTTACTGGGAGACTGATTAGATTGAATGATGAGAAATG
GACAGAAATGAAGGATGACAAGATTGTTTCATTGATTGAAAAGTTTACAAGTAACAAATATTGGTCCAAA
GTGAATTTCCCACATGGGATGTTGGATCTTGAAGAAATTGCTGCCAATTCTAAGGATTTTCCTAACATGT
CTGAAACGGATTTGTGTTTCTTGCTGCATTGGTTAAATCCAAAGAAAATTAATTTAGCAGATAGAATGCT
TGGATTGTCTGGAGTTCAGGAAATTAAAGAACAAGGTGTTGGATTAATAGCAGAGTGTAGAACTTTCTTA
GATTCTATTGCTGGAACTTTAAAATCTATGATGTTTGGATTTCATCATTCTGTGACTGTTGAAATTATAA
ACACTGTGCTCTGTTTTGTTAAGAGTGGAATTTTGCTTTATGTAATACAACAATTGAATCAGGATGAACA
TTCTCACATAATTGGTTTGTTGAGAGTCATGAATTATGCAGATATTGGTTGTTCAGTTATTTCATGTGGC
AAAGTTTTTTCCAAAATGCTGGAAACAGTCTTTAATTGGCAAATGGACTCCAGAATGATGGAGTTAAGGA
CTCAGAGTTTTTCCAACTGGTTAAGAGATATTTGTTCTGGGATCACCATTTTTAAAAACTTCAAGGATGC
AATTTATTGGCTTTATACAAAATTAAAGGACTTTTATGAAGTGAATTATGGCAAGAAGAAGGACATTTTA
AATATTCTTAAAGATAACCAACAAAAAATAGAGAAAGCCATTGAGGAAGCCGATGAATTTTGCATTTTGC
AAATCCAAGATGTGGAAAAATTTGAACAGTATCAGAAAGGGGTTGACTTGATACAAAAATTGAGAACTGT
TCATTCAATGGCTCAGGTTGATCCAAATTTAATGGTTCATTTGTCACCTTTGAGAGATTGTATAGCAAGA
GTTCATCAGAAACTTAAAAACCTTGGATCTATAAATCAGGCAATGGTAACGAGATGTGAGCCAGTTGTTT
GTTATTTATATGGCAAAAGAGGGGGAGGAAAGAGCTTAACATCAATTGCATTGGCAACCAAAATTTGTAA
ACATTATGGTGTTGAGCCTGAAAAGAATATCTATACTAAACCTGTGGCTTCAGATTACTGGGATGGATAT
AGTGGACAATTAGTTTGCATCATTGATGATATTGGCCAAAACACAACAGATGAGGATTGGTCAGATTTTT
GTCAGTTAGTGTCAGGATGTCCAATGAGATTAAACATGGCCTCTCTTGAGGAGAAGGGTAGGCATTTTTC
TTCTCCTTTTATAATAGCAACTTCAAATTGGTCAAATCCAAGTCCAAAAACAGTTTATGTTAAGGAAGCA
ATTGACCGCAGACTCCATTTCAAGGTTGAAGTTAAACCTGCTTCATTTTTCAAAAATCCTCACAATGATA
TGTTGAATGTTAATTTAGCTAAAACAAATGATGCAATCAAAGATATGTCTTGTGTTGATTTGATAATGGA
TGGACATAATGTTTCATTGATGGATTTGCTCAGTTCTTTAGTCATGACAGTTGAAATTAGAAAACAAAAC
ATGACTGAATTCATGGAGTTGTGGTCTCAGGGAATTTCAGATGATGATAATGATAGTGCAGTAGCTGAGT
TTTTCCAGTCTTTTCCATCTGGTGAACCATCGAACTCTAAATTATCTGGCTTTTTCCAATCTGTTACTAA
TCACAAGTGGGTTGCTGTGGGAGCTGCAGTTGGCATTCTTGGAGTGCTCGTTGGAGGATGGTTTGTGTAT
AAGCATTTCTCCCGCAAAGAGGAGGAACCAATCCCAGCTGAAGGGGTATATCATGGTGTAACTAAGCCCA
AGCAAGTGATTAAATTAGATGCAGATCCAGTAGAATCTCAGTCAACTTTGGAAATAGCAGGACTGGTTAG
GAAGAACTTGGTTCAGTTTGGAGTTGGAGAGAAGAATGGATGTGTGAGATGGGTTATGAATGCCTTGGGA
GTGAAAGATGATTGGCTGCTTGTGCCTTCCCATGCTTATAAATTTGAGAAAGATTATGAAATGATGGAGT
TTTATTTTAATAGAGGTGGAACTTACTATTCAATTTCAGCTGGTAATGTTGTTATTCAATCTTTGGATGT
GGGATTCCAGGATGTTGTTCTGATGAAGGTTCCTACAATTCCTAAGTTTAGAGATATTACTCAGCATTTT
ATTAAGAAAGGGGATGTGCCTAGAGCTTTGAATCGCCTGGCAACATTAGTGACAACTGTAAATGGAACCC
CTATGTTAATTTCTGAGGGCCCACTAAAGATGGAAGAGAAAGCTACTTATGTTCATAAGAAAAATGATGG
TACAACAGTTGATTTAACTGTGGATCAGGCATGGAGAGGAAAAGGCGAAGGTCTTCCTGGAATGTGTGGT
GGGGCCTTGGTTTCATCGAATCAATCTATACAGAATGCAATCTTGGGCATCCATGTTGCTGGAGGAAATT
CAATTCTTGTTGCAAAATTGGTTACTCAAGAAATGTTCCAAAATATTGATAAGAAAATTGAAAGTCAGAG
AATTATGAAAGTGGAGTTTACTCAGTGTTCAATGAATGTGGTCTCCAAAACGCTTTTTAGAAAGAGTCCC
ATTTATCATCACATTGATAAAACCATGATTAATTTTCCTGCAGCTATGCCCTTTTCTAAAGCTGAAATTG
ATCCAATGGCTGTGATGTTATCTAAGTATTCATTACCTATTGTAGAAGAACCAGAGGATTATAAAGAGGC
TTCAATTTTTTATCAAAATAAAATAGTGGGTAAGACTCAGTTAGTTGATGATTTTTTAGATCTTGATATG
GCCATTACAGGGGCCCCAGGAATTGATGCTATCAACATGGATTCATCTCCTGGATTTCCTTATGTCCAGG
AGAAGTTGACCAAAAGAGATTTAATTTGGTTGGATGAAAATGGTTTATTGCTGGGAGTTCATCCAAGATT
GGCTCAGAGAATCTTATTCAATACTGTCATGATGGAAAATTGTTCTGATTTGGATGTTGTTTTTACAACC
TGTCCAAAAGATGAATTGAGACCATTAGAGAAAGTGTTGGAATCAAAAACAAGAGCTATTGATGCTTGTC
CTCTGGATTACTCAATTTTGTGCCGAATGTATTGGGGTCCAGCTATTAGTTATTTTCATTTGAATCCAGG
TTTCCATACAGGTGTTGCTATTGGCATAGATCCTGATAGACAGTGGGATGAATTATTTAAAACAATGATA
AGATTCGGAGATGTTGGTCTTGATTTAGATTTCTCTGCTTTTGATGCTAGTCTTAGTCCATTTATGATTA
GAGAAGCAGGTAGAATCATGAGTGAACTATCTGGAACTCCATCCCATTTTGGCACAGCTCTTATCAATAC
TATCATTTATTCCAAGCATTTGCTGTATAACTGTTGTTACCATGTCTGTGGTTCAATGCCCTCTGGGTCT
CCTTGTACAGCTTTGCTAAATTCAATTATTAATAATGTCAATTTGTATTATGTGTTTTCCAAGATATTTG
GAAAGTCTCCAGTTTTCTTTTGTCAGGCTTTGAAGATTCTCTGTTATGGAGATGATGTTTTAATAGTTTT
CTCTCGAGATGTTCAGATTGATAATCTTGATTTGATTGGACAAAAAATTGTAGATGAGTTTAAGAAACTT
GGCATGACAGCTACTTCTGCTGACAAGAATGTACCTCAGCTGAAACCAGTTTCGGAATTGACTTTTCTCA
AAAGATCTTTCAATTTGGTAGAGGATAGAATTAGACCTGCAATTTCGGAAAAAACAATTTGGTCTTTAAT
AGCATGGCAGAGAAGTAACGCTGAGTTTGAGCAGAATTTAGAAAATGCTCAGTGGTTTGCTTTTATGCAT
GGCTATGAGTTTTATCAGAAATTTTATTATTTTGTTCAGTCCTGTTTGGAGAAAGAGATGATAGAATACA
GACTTAAATCTTATGATTGGTGGAGAATGAGATTTTATGACCAGTGTTTCATTTGTGACCTTTCATGATT
TGTTTAAACAAATTTTCTTAAAATTTCTGAGGTTTGTTTATTTCTTTTATCAGTAAAT
neobio-0.0.20030929/data/hepatitis_b.txt 0000644 0002656 0002032 00000006377 07721476520 016653 0 ustar tillea admin >gi|21326584|ref|NC_003977.1| Hepatitis B virus, complete genome
CTCCACAACATTCCACCAAGCTCTGCTAGATCCCAGAGTGAGGGGCCTATATTTTCCTGCTGGTGGCTCC
AGTTCCGGAACAGTAAACCCTGTTCCGACTACTGCCTCACCCATATCGTCAATCTTCTCGAGGACTGGGG
ACCCTGCACCGAACATGGAGAGCACAACATCAGGATTCCTAGGACCCCTGCTCGTGTTACAGGCGGGGTT
TTTCTTGTTGACAAGAATCCTCACAATACCACAGAGTCTAGACTCGTGGTGGACTTCTCTCAATTTTCTA
GGGGGAGCACCCACGTGTCCTGGCCAAAATTCGCAGTCCCCAACCTCCAATCACTCACCAACCTCTTGTC
CTCCAACTTGTCCTGGCTATCGCTGGATGTGTCTGCGGCGTTTTATCATATTCCTCTTCATCCTGCTGCT
ATGCCTCATCTTCTTGTTGGTTCTTCTGGACTACCAAGGTATGTTGCCCGTTTGTCCTCTACTTCCAGGA
ACATCAACTACCAGCACGGGACCATGCAGAACCTGCACGATTCCTGCTCAAGGAACCTCTATGTTTCCCT
CTTGTTGCTGTACAAAACCTTCGGACGGAAACTGCACTTGTATTCCCATCCCATCATCCTGGGCTTTCGC
AAGATTCCTATGGGAGTGGGCCTCAGTCCGTTTCTCCTGGCTCAGTTTACTAGTGCCATTTGTTCAGTGG
TTCGTAGGGCTTTCCCCCACTGTTTGGCTTTCAGCTATATGGATGATGTGGTATTGGGGGCCAAGTCTGT
ACAACATCTTGAGTCCCTTTTTACCTCTATTACCAATTTTCTTTTGTCTTTGGGTATACATTTGAACCCT
AATAAAACCAAACGTTGGGGCTACTCCCTTAACTTCATGGGATATGTAATTGGAAGTTGGGGTACTTTAC
CGCAGGAACATATTGTACAAAAACTCAAGCAATGTTTTCGAAAATTGCCTGTAAATAGACCTATTGATTG
GAAAGTATGTCAAAGAATTGTGGGTCTTTTGGGCTTTGCTGCCCCTTTTACACAATGTGGCTATCCTGCC
TTGATGCCTTTATATGCATGTATACAATCTAAGCAGGCTTTCACTTTCTCGCCAACTTACAAGGCCTTTC
TGTGTAAACAATATCTAAACCTTTACCCCGTTGCCCGGCAACGGTCAGGTCTCTGCCAAGTGTTTGCTGA
CGCAACCCCCACGGGTTGGGGCTTGGCCATAGGCCATCGGCGCATGCGTGGAACCTTTGTGGCTCCTCTG
CCGATCCATACTGCGGAACTCCTAGCAGCTTGTTTTGCTCGCAGCCGGTCTGGAGCGAAACTTATCGGAA
CCGACAACTCAGTTGTCCTCTCTCGGAAATACACCTCCTTTCCATGGCTGCTAGGCTGTGCTGCCAACTG
GATCCTGCGCGGGACGTCCTTTGTCTACGTCCCGTCGGCGCTGAATCCCGCGGACGACCCGTCTCGGGGC
CGTTTGGGCCTCTACCGTCCCCTTCTTCATCTGCCGTTCCGGCCGACCACGGGGCGCACCTCTCTTTACG
CGGTCTCCCCGTCTGTGCCTTCTCATCTGCCGGACCGTGTGCACTTCGCTTCACCTCTGCACGTAGCATG
GAGACCACCGTGAACGCCCACCAGGTCTTGCCCAAGGTCTTACACAAGAGGACTCTTGGACTCTCAGCAA
TGTCAACGACCGACCTTGAGGCATACTTCAAAGACTGTTTGTTTAAAGACTGGGAGGAGTTGGGGGAGGA
GATTAGGTTAAAGGTCTTTGTACTAGGAGGCTGTAGGCATAAATTGGTCTGTTCACCAGCACCATGCAAC
TTTTTCCCCTCTGCCTAATCATCTCATGTTCATGTCCTACTGTTCAAGCCTCCAAGCTGTGCCTTGGGTG
GCTTTGGGGCATGGACATTGACCCGTATAAAGAATTTGGAGCTTCTGTGGAGTTACTCTCTTTTTTGCCT
TCTGACTTCTTTCCTTCTATTCGAGATCTCCTCGACACCGCCTCTGCTCTGTATCGGGAGGCCTTAGAGT
CTCCGGAACATTGTTCACCTCACCATACAGCACTCAGGCAAGCTATTCTGTGTTGGGGTGAGTTGATGAA
TCTGGCCACCTGGGTGGGAAGTAATTTGGAAGACCCAGCATCCAGGGAATTAGTAGTCAGCTATGTCAAT
GTTAATATGGGCCTAAAAATTAGACAACTATTGTGGTTTCACATTTCCTGCCTTACTTTTGGAAGAGAAA
CTGTCCTTGAGTATTTGGTGTCTTTTGGAGTGTGGATTCGCACTCCTCCCGCTTACAGACCACCAAATGC
CCCTATCTTATCAACACTTCCGGAAACTACTGTTGTTAGACGACGAGGCAGGTCCCCTAGAAGAAGAACT
CCCTCGCCTCGCAGACGAAGGTCTCAATCGCCGCGTCGCAGAAGATCTCAATCTCGGGAATCTCAATGTT
AGTATCCCTTGGACTCATAAGGTGGGAAACTTTACTGGGCTTTATTCTTCTACTGTACCTGTCTTTAATC
CTGATTGGAAAACTCCCTCCTTTCCTCACATTCATTTACAGGAGGACATTATTAATAGATGTCAACAATA
TGTGGGCCCTCTGACAGTTAATGAAAAAAGGAGATTAAAATTAATTATGCCTGCTAGGTTCTATCCTAAC
CTTACCAAATATTTGCCCTTGGACAAAGGCATTAAACCGTATTATCCTGAATATGCAGTTAATCATTACT
TCAAAACTAGGCATTATTTACATACTCTGTGGAAGGCTGGCATTCTATATAAGAGAGAAACTACACGCAG
CGCCTCATTTTGTGGGTCACCATATTCTTGGGAACAAGAGCTACAGCATGGGAGGTTGGTCTTCCAAACC
TCGACAAGGCATGGGGACGAATCTTTCTGTTCCCAATCCTCTGGGATTCTTTCCCGATCACCAGTTGGAC
CCTGCGTTCGGAGCCAACTCAAACAATCCAGATTGGGACTTCAACCCCAACAAGGATCACTGGCCAGAGG
CAAATCAGGTAGGAGCGGGAGCATTTGGTCCAGGGTTCACCCCACCACACGGAGGCCTTTTGGGGTGGAG
CCCTCAGGCTCAGGGCATATTGACAACACTGCCAGCAGCACCTCCTCCTGCCTCCACCAATCGGCAGTCA
GGAAGACAGCCTACTCCCATCTCTCCACCTCTAAGAGACAGTCATCCTCAGGCCATGCAGTGGAA
neobio-0.0.20030929/data/hep.html 0000644 0002656 0002032 00000003461 07727275244 015256 0 ustar tillea admin Query= gi|9626732|ref|NC_001489.1| Hepatitis A virus, complete
genome
(7478 letters)
>gi|21326584|ref|NC_003977.1| Hepatitis B virus, complete genome
Length = 3215
Score = 23.8 bits (14), Expect = 1.7
Identities = 15/16 (93%)
Strand = Plus / Plus
Query: 4811 caaaaatcctcacaat 4826
||| ||||||||||||
Sbjct: 222 caagaatcctcacaat 237
Score = 23.8 bits (14), Expect = 1.7
Identities = 15/16 (93%)
Strand = Plus / Plus
Query: 6939 ccagttttcttttgtc 6954
||| ||||||||||||
Sbjct: 803 ccaattttcttttgtc 818
Score = 22.2 bits (13), Expect = 5.0
Identities = 13/13 (100%)
Strand = Plus / Minus
Query: 6887 tattaataatgtc 6899
|||||||||||||
Sbjct: 2577 tattaataatgtc 2565
Lambda K H
1.10 0.333 0.549
Gapped
Lambda K H
1.10 0.333 0.549
Matrix: blastn matrix:1 -1
Gap Penalties: Existence: 5, Extension: 1
Number of Hits to DB: 13
Number of Sequences: 0
Number of extensions: 13
Number of successful extensions: 3
Number of sequences better than 10.0: 1
Number of HSP's better than 10.0 without gapping: 1
Number of HSP's successfully gapped in prelim test: 0
Number of HSP's that attempted gapping in prelim test: 0
Number of HSP's gapped (non-prelim): 3
length of query: 3215
length of database: 7478
effective HSP length: 27
effective length of query: 3188
effective length of database: 7451
effective search space: 23753788
effective search space used: 23753788
T: 0
A: 0
X1: 7 (11.1 bits)
X2: 18 (28.5 bits)
S1: 14 (23.8 bits)
S2: 13 (22.2 bits)
neobio-0.0.20030929/data/prot01a.txt 0000644 0002656 0002032 00000000020 07705611724 015620 0 ustar tillea admin >YEAST A
MVPHKPM neobio-0.0.20030929/data/dna39a.txt 0000644 0002656 0002032 00000000014 07723264610 015412 0 ustar tillea admin ACAAGACAGCGT neobio-0.0.20030929/data/pam250.txt 0000644 0002656 0002032 00000005214 06671724252 015352 0 ustar tillea admin #
# This matrix was produced by "pam" Version 1.0.6 [28-Jul-93]
#
# PAM 70 substitution matrix, scale = ln(2)/2 = 0.346574
#
# Expected score = -2.77, Entropy = 1.60 bits
#
# Lowest score = -11, Highest score = 13
#
A R N D C Q E G H I L K M F P S T W Y V B Z X *
A 5 -4 -2 -1 -4 -2 -1 0 -4 -2 -4 -4 -3 -6 0 1 1 -9 -5 -1 -1 -1 -2 -11
R -4 8 -3 -6 -5 0 -5 -6 0 -3 -6 2 -2 -7 -2 -1 -4 0 -7 -5 -4 -2 -3 -11
N -2 -3 6 3 -7 -1 0 -1 1 -3 -5 0 -5 -6 -3 1 0 -6 -3 -5 5 -1 -2 -11
D -1 -6 3 6 -9 0 3 -1 -1 -5 -8 -2 -7 -10 -4 -1 -2 -10 -7 -5 5 2 -3 -11
C -4 -5 -7 -9 9 -9 -9 -6 -5 -4 -10 -9 -9 -8 -5 -1 -5 -11 -2 -4 -8 -9 -6 -11
Q -2 0 -1 0 -9 7 2 -4 2 -5 -3 -1 -2 -9 -1 -3 -3 -8 -8 -4 -1 5 -2 -11
E -1 -5 0 3 -9 2 6 -2 -2 -4 -6 -2 -4 -9 -3 -2 -3 -11 -6 -4 2 5 -3 -11
G 0 -6 -1 -1 -6 -4 -2 6 -6 -6 -7 -5 -6 -7 -3 0 -3 -10 -9 -3 -1 -3 -3 -11
H -4 0 1 -1 -5 2 -2 -6 8 -6 -4 -3 -6 -4 -2 -3 -4 -5 -1 -4 0 1 -3 -11
I -2 -3 -3 -5 -4 -5 -4 -6 -6 7 1 -4 1 0 -5 -4 -1 -9 -4 3 -4 -4 -3 -11
L -4 -6 -5 -8 -10 -3 -6 -7 -4 1 6 -5 2 -1 -5 -6 -4 -4 -4 0 -6 -4 -4 -11
K -4 2 0 -2 -9 -1 -2 -5 -3 -4 -5 6 0 -9 -4 -2 -1 -7 -7 -6 -1 -2 -3 -11
M -3 -2 -5 -7 -9 -2 -4 -6 -6 1 2 0 10 -2 -5 -3 -2 -8 -7 0 -6 -3 -3 -11
F -6 -7 -6 -10 -8 -9 -9 -7 -4 0 -1 -9 -2 8 -7 -4 -6 -2 4 -5 -7 -9 -5 -11
P 0 -2 -3 -4 -5 -1 -3 -3 -2 -5 -5 -4 -5 -7 7 0 -2 -9 -9 -3 -4 -2 -3 -11
S 1 -1 1 -1 -1 -3 -2 0 -3 -4 -6 -2 -3 -4 0 5 2 -3 -5 -3 0 -2 -1 -11
T 1 -4 0 -2 -5 -3 -3 -3 -4 -1 -4 -1 -2 -6 -2 2 6 -8 -4 -1 -1 -3 -2 -11
W -9 0 -6 -10 -11 -8 -11 -10 -5 -9 -4 -7 -8 -2 -9 -3 -8 13 -3 -10 -7 -10 -7 -11
Y -5 -7 -3 -7 -2 -8 -6 -9 -1 -4 -4 -7 -7 4 -9 -5 -4 -3 9 -5 -4 -7 -5 -11
V -1 -5 -5 -5 -4 -4 -4 -3 -4 3 0 -6 0 -5 -3 -3 -1 -10 -5 6 -5 -4 -2 -11
B -1 -4 5 5 -8 -1 2 -1 0 -4 -6 -1 -6 -7 -4 0 -1 -7 -4 -5 5 1 -2 -11
Z -1 -2 -1 2 -9 5 5 -3 1 -4 -4 -2 -3 -9 -2 -2 -3 -10 -7 -4 1 5 -3 -11
X -2 -3 -2 -3 -6 -2 -3 -3 -3 -3 -4 -3 -3 -5 -3 -1 -2 -7 -5 -2 -2 -3 -3 -11
* -11 -11 -11 -11 -11 -11 -11 -11 -11 -11 -11 -11 -11 -11 -11 -11 -11 -11 -11 -11 -11 -11 -11 1
neobio-0.0.20030929/data/dna02b.txt 0000644 0002656 0002032 00000000110 07706116656 015405 0 ustar tillea admin >gi|1786181|gb|AE000111.1|AE000111 Escherichia coli K-12 MG1655
AGAAAGGC neobio-0.0.20030929/data/dna23a.txt 0000644 0002656 0002032 00000024303 07712133662 015412 0 ustar tillea admin G
GA
GAC
GACT
GACTA
GACTAC
GACTACG
GACTACGT
GACTACGTA
GACTACGTAC
GACTACGTACG
GACTACGTACGT
GACTACGTACGTA
GACTACGTACGTAC
GACTACGTACGTACG
GACTACGTACGTACGT
GACTACGTACGTACGTA
GACTACGTACGTACGTAC
GACTACGTACGTACGTACG
GACTACGTACGTACGTACGT
GACTACGTACGTACGTACGTA
GACTACGTACGTACGTACGTAC
GACTACGTACGTACGTACGTACG
GACTACGTACGTACGTACGTACGT
GACTACGTACGTACGTACGTACGTA
GACTACGTACGTACGTACGTACGTAC
GACTACGTACGTACGTACGTACGTACG
GACTACGTACGTACGTACGTACGTACGT
GACTACGTACGTACGTACGTACGTACGTA
GACTACGTACGTACGTACGTACGTACGTAC
GACTACGTACGTACGTACGTACGTACGTACG
GACTACGTACGTACGTACGTACGTACGTACGT
GACTACGTACGTACGTACGTACGTACGTACGTA
GACTACGTACGTACGTACGTACGTACGTACGTAC
GACTACGTACGTACGTACGTACGTACGTACGTACG
GACTACGTACGTACGTACGTACGTACGTACGTACGT
GACTACGTACGTACGTACGTACGTACGTACGTACGTA
GACTACGTACGTACGTACGTACGTACGTACGTACGTAC
GACTACGTACGTACGTACGTACGTACGTACGTACGTACG
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGT
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
GACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC neobio-0.0.20030929/data/prot13b.txt 0000644 0002656 0002032 00000023420 07720273346 015636 0 ustar tillea admin YYEYECYECEYECEBYECEBHYECEBHQYECEBHQQYECEBHQQTYECEBHQQTEYECEBHQQTEKYECEBHQQTEKZYECEBHQQTEKZMYECEBHQQTEKZMSYECEBHQQTEKZMSRYECEBHQQTEKZMSREYECEBHQQTEKZMSRESYECEBHQQTEKZMSRESGYECEBHQQTEKZMSRESGVYECEBHQQTEKZMSRESGVTYECEBHQQTEKZMSRESGVTPYECEBHQQTEKZMSRESGVTPKYECEBHQQTEKZMSRESGVTPKQYECEBHQQTEKZMSRESGVTPKQDYECEBHQQTEKZMSRESGVTPKQDBYECEBHQQTEKZMSRESGVTPKQDBGYECEBHQQTEKZMSRESGVTPKQDBGAYECEBHQQTEKZMSRESGVTPKQDBGAVYECEBHQQTEKZMSRESGVTPKQDBGAVWYECEBHQQTEKZMSRESGVTPKQDBGAVWPYECEBHQQTEKZMSRESGVTPKQDBGAVWPYYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTAYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBAYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBAYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAAYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEAYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZTYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZTIYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZTIBYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZTIBRYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZTIBRWYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZTIBRWLYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZTIBRWLFYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZTIBRWLFWYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZTIBRWLFWAYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZTIBRWLFWARYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZTIBRWLFWAREYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZTIBRWLFWAREFYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZTIBRWLFWAREFHYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZTIBRWLFWAREFHQYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZTIBRWLFWAREFHQFYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZTIBRWLFWAREFHQFGYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZTIBRWLFWAREFHQFGXYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZTIBRWLFWAREFHQFGXNYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZTIBRWLFWAREFHQFGXNLYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZTIBRWLFWAREFHQFGXNLGYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZTIBRWLFWAREFHQFGXNLGWYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZTIBRWLFWAREFHQFGXNLGWCYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZTIBRWLFWAREFHQFGXNLGWCCYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZTIBRWLFWAREFHQFGXNLGWCCGYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZTIBRWLFWAREFHQFGXNLGWCCGXYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZTIBRWLFWAREFHQFGXNLGWCCGXLYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZTIBRWLFWAREFHQFGXNLGWCCGXLRYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZTIBRWLFWAREFHQFGXNLGWCCGXLRNYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZTIBRWLFWAREFHQFGXNLGWCCGXLRNFYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZTIBRWLFWAREFHQFGXNLGWCCGXLRNFSYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZTIBRWLFWAREFHQFGXNLGWCCGXLRNFSNYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZTIBRWLFWAREFHQFGXNLGWCCGXLRNFSNDYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZTIBRWLFWAREFHQFGXNLGWCCGXLRNFSNDIYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZTIBRWLFWAREFHQFGXNLGWCCGXLRNFSNDIXYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZTIBRWLFWAREFHQFGXNLGWCCGXLRNFSNDIXDYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZTIBRWLFWAREFHQFGXNLGWCCGXLRNFSNDIXDLYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZTIBRWLFWAREFHQFGXNLGWCCGXLRNFSNDIXDLLYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZTIBRWLFWAREFHQFGXNLGWCCGXLRNFSNDIXDLLVYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZTIBRWLFWAREFHQFGXNLGWCCGXLRNFSNDIXDLLVKYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZTIBRWLFWAREFHQFGXNLGWCCGXLRNFSNDIXDLLVKGYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZTIBRWLFWAREFHQFGXNLGWCCGXLRNFSNDIXDLLVKGFYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZTIBRWLFWAREFHQFGXNLGWCCGXLRNFSNDIXDLLVKGFRYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZTIBRWLFWAREFHQFGXNLGWCCGXLRNFSNDIXDLLVKGFRPYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZTIBRWLFWAREFHQFGXNLGWCCGXLRNFSNDIXDLLVKGFRPIYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZTIBRWLFWAREFHQFGXNLGWCCGXLRNFSNDIXDLLVKGFRPIKYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZTIBRWLFWAREFHQFGXNLGWCCGXLRNFSNDIXDLLVKGFRPIKXYECEBHQQTEKZMSRESGVTPKQDBGAVWPYSQDGQFMNLDMCZLMTADAXDSTMCVVWPBASVBACXSPIMCSYMQBMTLXZAASEANHMPSZTIBRWLFWAREFHQFGXNLGWCCGXLRNFSNDIXDL neobio-0.0.20030929/data/prot03b.txt 0000644 0002656 0002032 00000000203 07701073462 015623 0 ustar tillea admin >HXKB_YEAST STANDARD; PRT; 486 AA., 486 bases, B05F4DF9 checksum.
MVHLGPKKPQARKGSMADVPKELMQQIENFEKIFTVPTETLQAVTKHFIS
ELEKGLSKKGGNIP neobio-0.0.20030929/data/prot04b.txt 0000644 0002656 0002032 00000000333 07701073134 015624 0 ustar tillea admin >HXKB_YEAST STANDARD; PRT; 486 AA., 486 bases, B05F4DF9 checksum.
MVHLGPKKPQARKGSMADVPKELMQQIENFEKIFTVPTETLQAVTKHFIS
ELEKGLSKKGGNIPMIPGWVMDFPTGKESGDFLAIDLGGTNLRVVLVKLG
GDRTFDTTQSKYRLPDAMRTTQNPDELWEFIADSLKAFIDEQFPQGISEP
neobio-0.0.20030929/data/dna32b.txt 0000644 0002656 0002032 00000007640 07720032544 015414 0 ustar tillea admin A
AC
ACG
ACGT
ACGTA
ACGTAC
ACGTACG
ACGTACGT
ACGTACGTA
ACGTACGTAC
ACGTACGTACG
ACGTACGTACGT
ACGTACGTACGTA
ACGTACGTACGTAC
ACGTACGTACGTACG
ACGTACGTACGTACGT
ACGTACGTACGTACGTA
ACGTACGTACGTACGTAC
ACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTA neobio-0.0.20030929/data/dna03b.txt 0000644 0002656 0002032 00000000016 07714355020 015400 0 ustar tillea admin A
G
AA
AG
GG
A neobio-0.0.20030929/data/dna05b.txt 0000644 0002656 0002032 00000000127 07707061670 015414 0 ustar tillea admin >gi|1786181|gb|AE000111.1|AE000111 Escherichia coli K-12 MG1655
AAGTAAACAGTTTAATAAAAATA neobio-0.0.20030929/data/dna16b.txt 0000644 0002656 0002032 00000007640 07710231124 015410 0 ustar tillea admin TTTGCCGAGTACATGAGAAGGTAACTGTGAGCCTGACCACCGCAACGGGGAATCCTCGGTGAAATCAGAGACGCCAGACAAGGTGACTGTACTAGGCGTTGAACCGGTTTTAGGTGCTCTCCGTATCTTAGTTTCACGTACGGGGAACACACCTAGATGTGGACCACTATTTAGATAACCCCCGGACCGTTTAACATTCAACGTACAGCGCGGTGGAGGAATCGAGGTACGACACCCAGGGGTAATCGCTACTCCTATTGGGCGCTACATTCTGGATAAGAGGCCAGTACCATGGCCCTGCTCGGCCTCATTACTACGTGGCGAGTAACAAAGAGACGAGGCAGGAAAATACTCGGGCGGCCGCGTTGATCGAAGTGAACCATATTAAGATAGAAACGGGGTGCACTGCACCATTCTATAGGTTTTCCTACATGAACACTCAATCACCCTCGATCATTTAGTACAGAGATACTGTGCTGTCTAGTCGGAAAGTGGTCGAGTACCATAAAGCCATATCATCAGAATCGGGAGACTCTGGCGAACCGCTCAGCTTTAGTTCTAGGCTCATGTGGCATTCCGGGGGAAGCATATTGTAGGAGGATACGCTTATATCGACGTCGTTGAACTAGGACGTCCGATGAGACTTAGGGAAGTTCCCAATACGACATCCTACGACGGAAATGTCGTCGGATATTTCGGTACGGTTACACACTTTGTCTTTAGGGAGTTGCTGTCCCCCCGAGCGCGGTAACTACAAGAGTGGGTATTAGAGCAGGTGGTAGGAAGGACTTTTTGCTGCAGTCGGACATAATGGTAAATGGCCAGTCGAAAGTTACACCTAGGAGCAGGTACAAGGCGATGCCTCCTGAGCGCATACACTGACAATGGATTACTGGACGCTGGCCTGCCCCGTGCCTGGTTCCTGCTCTTGACGGCCAAAACGTGGTCTACGGGATGTGATCTTTTGGTCCGATTGGAGGAAAGAGAGTCTTGGGTTCATAGGGTCGACTACGGCAAAAACTCCGGCTGTTCAGGGAGAACTCGGAATTTCCCAGGTAATTAGTGGAGGTGAACATCTGAACTGGCCTTTAACATGGTTCGAGTGGCAACTTCCCCGGTCACTCAGCATAACCTGCCACTACTCTGATGTGACTGAGTTGGGCGCGGCAGAAGATGAAATCCCCGCGTATCTGCAGAATGGAAGGTAAGAAGGAATTAGAATTGGAAACTATAATAGAACGTATCGAGGCGCCGCAAGAGTTTTTCCAGGCAGCTGATTCACTAAGGCATAAAACTCTCGCAATAACGAGGCTAGGTGGGGCATAATACAATAGGAAATGCACCACTCCTTCGTCGGCGAGTTGTCCCGCGCCAGAGACTTATACGCGAGCGGTTACAGTTTCTAACCATGAGGAATAGAGGAAAGGAGAATCTATCCTAGCCAGATGCGATGGTTATAATCGCGAAGATACCCCGACACGTCATGGCGTATTCAACGCAACAAGATGCTAGCGTCGTGCATAACGTGATGGCTCCAGGACCACCTGTCAGATTTTGGTCATTTAGACATGAAGTTCTTATCCCTGTCTCAAGCGGTAGGGGACCGGGTTTCCAGAACACGGAGCCGCTGTCTAATACATCTCATGTTGAGACCGCAGACACGAATCTCATTTCACTCAACGATCTTAGCGTCCGAAACGGTAGTGCCATGTGTGCATGTTATGATGTAGTCACGCAGTAACGTTCGCCACGCCCAACGTACTTTAGCCGGATCAACTCCTCTACCAGAACTCTACACACTTCACGAGAACGGCATGAAACAATCAATTGACCAAGTCCCGAGTGAATAACTTTGTTCGTTACTACGGTGTCTCAAGTTGAGTTAGCTACCACTTACCTACGTAGAGGAGCTACATTATTGTAGGAAACGTCTTAGCAAGAGGTTGGTGTCCTTGTGAAACAGTTCGGCGAGCCCAGTAGAAATGCTAGCATCGTTTAGTGTAGCAGCCCTGACACGATGCCGAAGGTTCGCTTACTGTCGTTGGGGTAAATAAGAAATCGGGCCTTAACAAAGACGACAAAATGAGCTTCCAAAGCACTCAGCCAATAATTGAAGAACCTGTACGAGTTCAGCTCCTAGTTCTAGCCGGCATACTAACTAATGGCATTCAATGTATGCATTGGTTGCCCAATGGTTTCAAATGACCAATTCCGCAATAGAGCTCGCCTTTATGGAGGAGGTGGCAGCAAAATGTTAGAAACCTCGCGGACTCAACACTATCGCATTATTGTGTGTACGCGCGCCGCTTGCCCTTCCCAAAAGTCCTGTGAACTTTTCGCCTCTAATACGTAAGAGTGGTCTGAATCCCCTTTTTCATTCCTGCAATGACTAGTTGGTCTAAACTTAAAGTCCACGCAGGTCCACAAGCTCTAACGCGTGCTTACACAAGCCAGTCGTTTAGCGTACACGGTATCAGCAGATGATGGGCTATTAACTCAGGGATCTCTTAGGTCCAAACAGGCTGGACCCGTTCGGCAGTGGACTTTAATCGTCCTCAGGCCGGGGACTAGCTGATATAGTTCCCGCTTAGCGCGGATTATATACATTCACACCTCCGAAAAAGACCGTCGATCCGTAACTCCGAGTAAGCATTAGTGATCATATGACGCTACGGCGATATTTAAGAGTTCGTGCGGTATTAGTGGGCATGCTCTTATGCTTCGATCCTGGGTTCAAAAACCCTGTGTGACTTTCGCTTCCAAATAGTGGACGTGGCTTCTCCTGTGCCAATCAACAGATGGTCCTTTTTCTAGGTAGCCGGACCACTTAGCTGGTATATGGACTGGTTGCAGAACACTGCTGAACATTTAGAGACCCGAAGCAAGGGCAGGACCAGACAGAAGAGTCAGCCCGTTCGTACCTTCTAGGCAATCATCGAATGATATCTTTTTAGTTGGTGAGACGTTGACATTGACCGTGAGTGTGATGGTGTAGAGCCACAGCAGCCGTAGTGTGGCCCAGAAGCGTAGACATACTAGCCCGTGGAGAATTAGGCGGGTAGGTCGACACCAGTAATCTTAAGTTTGGCTGATGCAACACCCTATTTGTGCGAGCGCAAAGCTGGAAAGCACCGGAACCAGAGGAAAGAGTGAGCGCGCGACGATACAGGAACAAGTTTCCCAATGGTGAATTGGCTACGGTAGCCTAGGAACGGATAAAAAGACTGATGTAACCGAGGCATGTAATCCATAACTGCCATTATCATTAACAGTATTAATAAAGAGAGGAAACCCTATCGCCCACATGGTCATATGCCATGCAGCTGGTCCCTACGGTAACTCCGCCACGGACACCATAAGTTATGGCACGACAGACTGCAATAGATATCAGAGCAGGACTCCTCCCAAGACATACGGGCGAGGTGGACTTCGAAATGCCCTACGAAATCCGTTCCAAAGCATCAATGGATTGTCGATGGGATCTAGATTGCGTCCAACATCGATAGACCAACGGAGAAACCGAGAGCCTCCGTGCGTGGTCAGGCTAACGAATGAATGGCCACGTACGAGTTTTTTGGCTCCATATATGTTGTAGATCCACGAAGTATGATTACTGTCCAATCTTACCGTCACCCCACGTTATAGCGGCCAGCCTTGTAAGCTGATAGAGGTCGATGTAGTCTCGGCATGACAATTGTAGGTGTACGGCTGCATCGGCAAATTTGCGGCAATCGCGCGGCCAGTGAAAGATCTGGCCGTCGCTTGTCTCAAGCCGGGCGCTAGCTACCCTCACATCGGGGTCTCGATCGTTACTCGTGCTCAGGGGGATATCCATCTATGGTTCATACGTGATCAGCTCGTTGTTGCTTTGGACTCTGGAAACCACTGACTGTATTCGCTCTCCCTGCAACTTATTTAAGCCCGCTACATGCGCCTGGACGCGGTGAGTTAGTGCATGGCCCAAGGCACGCCTGGTGAATCTGGAGGACGGACCCATCTG neobio-0.0.20030929/data/dna12a.txt 0000644 0002656 0002032 00000001130 07710230756 015401 0 ustar tillea admin AGGCTATACTTAAGTGGTCGTTATGGCCGTACACCGACCAGCGAGGAACGCATAACAGCGACCTACATAAGTTTGTGGTGCATCAAGCTACCGCTTTGCTGATGGCGGACGAAACGCAATTGTTAGAAAGGGGGCGGCACAGTACCGAACACGCGTTTCCACGGTCATATTCAGAGGTGCTGTTTTTCTCGTGTAACGCGGCACCTTCCATGTCGCCGTTAGTGCGATGAGACTCCAGACCGTGCCCACACTTTGCTCATCGCGCACCAAGAGGAGACCCCTGTTATCAGGCGTCGCAGTTCCTAGGGGCGCTATCCCACCGTCGCATAACGCCCGACCAAAGGACCACCAATCGTTCCGGCGCTGATTTGTCTGGCTCGAGGCGAGTGTCTGATCTGCACTGAGTAGCGGTCCCACTTGGTGCGCTATTACGGGACGCATGAGCCCTGCGTTTTCTCTCTAATAGTTAGAGAGTATCCTTCTATGCGTCATGCGAGAGGTTTCGCCTTAGACTAGGTTTTCGAGCTGCCCAGGGTTCCAGTGTGCTTAAGCCGCCATTTATGGTTTACTCAAGGGTAAAGGTGATCCCATGATTTGATA neobio-0.0.20030929/data/prot10b.txt 0000644 0002656 0002032 00000007640 07710227450 015633 0 ustar tillea admin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neobio-0.0.20030929/data/dna02a.txt 0000644 0002656 0002032 00000000111 07706116524 015377 0 ustar tillea admin >gi|1786181|gb|AE000111.1|AE000111 Escherichia coli K-12 MG1655
ACAAACACG neobio-0.0.20030929/data/prot03a.txt 0000644 0002656 0002032 00000000201 07701073456 015623 0 ustar tillea admin >HXKA_YEAST STANDARD; PRT; 485 AA., 485 bases, 8BF84D98 checksum.
MVHLGPKKPQARKGSMADVPKELMDEIHQLEDMFTVDSETLRKVVKHFID
ELNKGLTKKGGN neobio-0.0.20030929/data/dna12b.txt 0000644 0002656 0002032 00000001130 07710230762 015377 0 ustar tillea admin ACTCCCACACCACTACTACTAGCCGTTCTTTGCTGTAGAATTCGAAACACCTTTCAGACTGTACCCTGCCTGCAACTTATAGGGTGCTCATACCGACTCCTAGCCTGAGTCTGACTTGTCGGAAAAATACTGCGCTCGTATGGAAAAGTACACCGAGATGCTGAGCCTGAGTTACAAATCAGGCAGTTTTTGGGTCTTATTACTAGGCCCACGCTATCTTTGAACATATACTTCTCAGATAACGAGATTTATGTGCTAAGCGATACGTGGCTCAATCCCCGCTAGGATCTGCCACAACACCACGACTGTCACTCCTTATCAATGACACTCAGTTTTCCAAACGCGGCTGTAGGTGGTTATTGGTTACGAACGCGACGAACTTACTGTCTTACCTATTGTCAAAGGCCTATAATGCCACACTCTAAAGCGAGCGGACAACTACCGTTTAAAGCGAATAATGTACCGACCCAAAAAGAACATTTCCCGGTCCCGTCAGTAGAGCTGGTCAAGAAGGTAGTCTGAATAACTCACGGAGGTATCTTTAGGCTAGGAGCTGAACAAACTTCAGAAATATAACGCCCCGCCGCCTGCACATGCGCA neobio-0.0.20030929/data/dna05a.txt 0000644 0002656 0002032 00000000122 07707061714 015405 0 ustar tillea admin >gi|1786181|gb|AE000111.1|AE000111 Escherichia coli K-12 MG1655
ATAAACTTAATAATAAAA neobio-0.0.20030929/data/pam30.txt 0000644 0002656 0002032 00000005214 06671724252 015266 0 ustar tillea admin #
# This matrix was produced by "pam" Version 1.0.6 [28-Jul-93]
#
# PAM 30 substitution matrix, scale = ln(2)/2 = 0.346574
#
# Expected score = -5.06, Entropy = 2.57 bits
#
# Lowest score = -17, Highest score = 13
#
A R N D C Q E G H I L K M F P S T W Y V B Z X *
A 6 -7 -4 -3 -6 -4 -2 -2 -7 -5 -6 -7 -5 -8 -2 0 -1 -13 -8 -2 -3 -3 -3 -17
R -7 8 -6 -10 -8 -2 -9 -9 -2 -5 -8 0 -4 -9 -4 -3 -6 -2 -10 -8 -7 -4 -6 -17
N -4 -6 8 2 -11 -3 -2 -3 0 -5 -7 -1 -9 -9 -6 0 -2 -8 -4 -8 6 -3 -3 -17
D -3 -10 2 8 -14 -2 2 -3 -4 -7 -12 -4 -11 -15 -8 -4 -5 -15 -11 -8 6 1 -5 -17
C -6 -8 -11 -14 10 -14 -14 -9 -7 -6 -15 -14 -13 -13 -8 -3 -8 -15 -4 -6 -12 -14 -9 -17
Q -4 -2 -3 -2 -14 8 1 -7 1 -8 -5 -3 -4 -13 -3 -5 -5 -13 -12 -7 -3 6 -5 -17
E -2 -9 -2 2 -14 1 8 -4 -5 -5 -9 -4 -7 -14 -5 -4 -6 -17 -8 -6 1 6 -5 -17
G -2 -9 -3 -3 -9 -7 -4 6 -9 -11 -10 -7 -8 -9 -6 -2 -6 -15 -14 -5 -3 -5 -5 -17
H -7 -2 0 -4 -7 1 -5 -9 9 -9 -6 -6 -10 -6 -4 -6 -7 -7 -3 -6 -1 -1 -5 -17
I -5 -5 -5 -7 -6 -8 -5 -11 -9 8 -1 -6 -1 -2 -8 -7 -2 -14 -6 2 -6 -6 -5 -17
L -6 -8 -7 -12 -15 -5 -9 -10 -6 -1 7 -8 1 -3 -7 -8 -7 -6 -7 -2 -9 -7 -6 -17
K -7 0 -1 -4 -14 -3 -4 -7 -6 -6 -8 7 -2 -14 -6 -4 -3 -12 -9 -9 -2 -4 -5 -17
M -5 -4 -9 -11 -13 -4 -7 -8 -10 -1 1 -2 11 -4 -8 -5 -4 -13 -11 -1 -10 -5 -5 -17
F -8 -9 -9 -15 -13 -13 -14 -9 -6 -2 -3 -14 -4 9 -10 -6 -9 -4 2 -8 -10 -13 -8 -17
P -2 -4 -6 -8 -8 -3 -5 -6 -4 -8 -7 -6 -8 -10 8 -2 -4 -14 -13 -6 -7 -4 -5 -17
S 0 -3 0 -4 -3 -5 -4 -2 -6 -7 -8 -4 -5 -6 -2 6 0 -5 -7 -6 -1 -5 -3 -17
T -1 -6 -2 -5 -8 -5 -6 -6 -7 -2 -7 -3 -4 -9 -4 0 7 -13 -6 -3 -3 -6 -4 -17
W -13 -2 -8 -15 -15 -13 -17 -15 -7 -14 -6 -12 -13 -4 -14 -5 -13 13 -5 -15 -10 -14 -11 -17
Y -8 -10 -4 -11 -4 -12 -8 -14 -3 -6 -7 -9 -11 2 -13 -7 -6 -5 10 -7 -6 -9 -7 -17
V -2 -8 -8 -8 -6 -7 -6 -5 -6 2 -2 -9 -1 -8 -6 -6 -3 -15 -7 7 -8 -6 -5 -17
B -3 -7 6 6 -12 -3 1 -3 -1 -6 -9 -2 -10 -10 -7 -1 -3 -10 -6 -8 6 0 -5 -17
Z -3 -4 -3 1 -14 6 6 -5 -1 -6 -7 -4 -5 -13 -4 -5 -6 -14 -9 -6 0 6 -5 -17
X -3 -6 -3 -5 -9 -5 -5 -5 -5 -5 -6 -5 -5 -8 -5 -3 -4 -11 -7 -5 -5 -5 -5 -17
* -17 -17 -17 -17 -17 -17 -17 -17 -17 -17 -17 -17 -17 -17 -17 -17 -17 -17 -17 -17 -17 -17 -17 1
neobio-0.0.20030929/data/dna24b.txt 0000644 0002656 0002032 00000000111 07714347504 015407 0 ustar tillea admin A
G
GG
AA
GGG
AAA
GGGG
AAAA
GGGGG
AAAAA
GGGGGG
AAAAAA
GGGGGGG neobio-0.0.20030929/data/dna23b.txt 0000644 0002656 0002032 00000024303 07712133672 015414 0 ustar tillea admin A
AC
ACG
ACGT
ACGTA
ACGTAC
ACGTACG
ACGTACGT
ACGTACGTA
ACGTACGTAC
ACGTACGTACG
ACGTACGTACGT
ACGTACGTACGTA
ACGTACGTACGTAC
ACGTACGTACGTACG
ACGTACGTACGTACGT
ACGTACGTACGTACGTA
ACGTACGTACGTACGTAC
ACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT neobio-0.0.20030929/data/dna17a.txt 0000644 0002656 0002032 00000010131 07710120364 015400 0 ustar tillea admin >gi|1786181|gb|AE000111.1|AE000111 Escherichia coli K-12 MG1655
ACACCTCGTCGATGGATTACTACCATCAGTTGCGTTATGCGGCGGAAAAATCGCGGCGTAAATTCCTCTATGACACCAAC
GTTGGGGCTGGATTACCGGTTATTGAGAACCTGCAAAATCTGCTCAATGCAGGTGATGAATTGATGAAGTTCTCCGGCAT
TCTTTCTGGTTCGCTTTCTTATATCTTCGGCAAGTTAGACGAAGGCATGAGTTTCTCCGAGGCGACCACGCTGGCGCGGG
AAATGGGTTATACCGAACCGGACCCGCGAGATGATCTTTCTGGTATGGATGTGGCGCGTAAACTATTGATTCTCGCTCGT
GAAACGGGACGTGAACTGGAGCTGGCGGATATTGAAATTGAACCTGTGCTGCCCGCAGAGTTTAACGCCGAGGGTGATGT
TGCCGCTTTTATGGCGAATCTGTCACAACTCGACGATCTCTTTGCCGCGCGCGTGGCGAAGGCCCGTGATGAAGGAAAAG
TTTTGCGCTATGTTGGCAATATTGATGAAGATGGCGTCTGCCGCGTGAAGATTGCCGAAGTGGATGGTAATGATCCGCTG
TTCAAAGTGAAAAATGGCGAAAACGCCCTGGCCTTCTATAGCCACTATTATCAGCCGCTGCCGTTGGTACTGCGCGGATA
TGGTGCGGGCAATGACGTTACAGCTGCCGGTGTCTTTGCTGATCTGCTACGTACCCTCTCATGGAAGTTAGGAGTCTGAC
ATGGTTAAAGTTTATGCCCCGGCTTCCAGTGCCAATATGAGCGTCGGGTTTGATGTGCTCGGGGCGGCGGTGACACCTGT
TGATGGTGCATTGCTCGGAGATGTAGTCACGGTTGAGGCGGCAGAGACATTCAGTCTCAACAACCTCGGACGCTTTGCCG
ATAAGCTGCCGTCAGAACCACGGGAAAATATCGTTTATCAGTGCTGGGAGCGTTTTTGCCAGGAACTGGGTAAGCAAATT
CCAGTGGCGATGACCCTGGAAAAGAATATGCCGATCGGTTCGGGCTTAGGCTCCAGTGCCTGTTCGGTGGTCGCGGCGCT
GATGGCGATGAATGAACACTGCGGCAAGCCGCTTAATGACACTCGTTTGCTGGCTTTGATGGGCGAGCTGGAAGGCCGTA
TCTCCGGCAGCATTCATTACGACAACGTGGCACCGTGTTTTCTCGGTGGTATGCAGTTGATGATCGAAGAAAACGACATC
ATCAGCCAGCAAGTGCCAGGGTTTGATGAGTGGCTGTGGGTGCTGGCGTATCCGGGGATTAAAGTCTCGACGGCAGAAGC
CAGGGCTATTTTACCGGCGCAGTATCGCCGCCAGGATTGCATTGCGCACGGGCGACATCTGGCAGGCTTCATTCACGCCT
GCTATTCCCGTCAGCCTGAGCTTGCCGCGAAGCTGATGAAAGATGTTATCGCTGAACCCTACCGTGAACGGTTACTGCCA
GGCTTCCGGCAGGCGCGGCAGGCGGTCGCGGAAATCGGCGCGGTAGCGAGCGGTATCTCCGGCTCCGGCCCGACCTTGTT
CGCTCTGTGTGACAAGCCGGAAACCGCCCAGCGCGTTGCCGACTGGTTGGGTAAGAACTACCTGCAAAATCAGGAAGGTT
TTGTTCATATTTGCCGGCTGGATACGGCGGGCGCACGAGTACTGGAAAACTAAATGAAACTCTACAATCTGAAAGATCAC
AACGAGCAGGTCAGCTTTGCGCAAGCCGTAACCCAGGGGTTGGGCAAAAATCAGGGGCTGTTTTTTCCGCACGACCTGCC
GGAATTCAGCCTGACTGAAATTGATGAGATGCTGAAGCTGGATTTTGTCACCCGCAGTGCGAAGATCCTCTCGGCGTTTA
TTGGTGATGAAATCCCACAGGAAATCCTGGAAGAGCGCGTGCGCGCGGCGTTTGCCTTCCCGGCTCCGGTCGCCAATGTT
GAAAGCGATGTCGGTTGTCTGGAATTGTTCCACGGGCCAACGCTGGCATTTAAAGATTTCGGCGGTCGCTTTATGGCACA
AATGCTGACCCATATTGCGGGTGATAAGCCAGTGACCATTCTGACCGCGACCTCCGGTGATACCGGAGCGGCAGTGGCTC
ATGCTTTCTACGGTTTACCGAATGTGAAAGTGGTTATCCTCTATCCACGAGGCAAAATCAGTCCACTGCAAGAAAAACTG
TTCTGTACATTGGGCGGCAATATCGAAACTGTTGCCATCGACGGCGATTTCGATGCCTGTCAGGCGCTGGTGAAGCAGGC
GTTTGATGATGAAGAACTGAAAGTGGCGCTAGGGTTAAACTCGGCTAACTCGATTAACATCAGCCGTTTGCTGGCGCAGA
TTTGCTACTACTTTGAAGCTGTTGCGCAGCTGCCGCAGGAGACGCGCAACCAGCTGGTTGTCTCGGTGCCAAGCGGAAAC
TTCGGCGATTTGACGGCGGGTCTGCTGGCGAAGTCACTCGGTCTGCCGGTGAAACGTTTTATTGCTGCGACCAACGTGAA
CGATACCGTGCCACGTTTCCTGCACGACGGTCAGTGGTCACCCAAAGCGACTCAGGCGACGTTATCCAACGCGATGGACG
TGAGTCAGCCGAACAACTGGCCGCGTGTGGAAGAGTTGTTCCGCCGCAAAATCTGGCAACTGAAAGAGCTGGGTTATGCA
GCCGTGGATGATGAAACCACGCAACAGACAATGCGTGAGTTAAAAGAACTGGGCTACACTTCGGAGCCGCACGCTGCCGT
AGCTTATCGTGCGCTGCGTGATCAGTTGAATCCAGGCGAATATGGCTTGTTCCTCGGCACCGCGCATCCGGCGAAATTTA
AAGAGAGCGTGGAAGCGATTCTCGGTGAAACGTTGGATCTGCCAAAAGAGCTGGCAGAACGTGCTGATTTACCCTTGCTT
TCACATAATCTGCCCGCCGATTTTGCTGCGTTGCGTAAATTGATGATGAATCATCAGTAAAATCTATTCATTATCTCAAT
CAGGCCGGGTTTGCTTTTATGCAGCCCGGCTTTTTTATGAAGAAATTATGGAGAAAAATGACAGGGAAAAAGGAGAAATT
CTCAATAAATGCGGTAACTTAGAGATTAGGATTGCGGAGAATAACAACCGCCGTTCTCATCGAGTAATCTCCGGATATCG
ACCCATAACGGGCAATGATAAAAGGAGTAACCTGTGAAAAAGATGCAATCTATCGTACTCGCACTTTCCCTGGTTCTGGT
CGCTCCCATGGCAGCACAGGCTGCGGAAATTACGTTAGTCCCGTCAGTAAAATTACAGATAGGCGATCGTGATAATCGTG
GCTATTACTGGGATGGAGGTCACTGGCGCGACCACGGCTGGTGGAAACAACATTATGAATGGCGAGGCAATCGCTGGCAC
CTACACGGACCGCCGCCACCGCCGCGCCACCATAAGAAAGCTCCTCATGATCATCACGGCGGTCATGGTCCAGGCAAACA
TCACCGCTAAATGACAAATGCCGGGTAACAATCCGGCATTCAGCGCCTGATGCGACGCTGGCGCGTCTTATCAGGCCTAC
GTTAATTCTGCAATATATTGAATCTGCATGCTTTTGTAGGCAGGATAAGGCGTTCACGCCGCATCCGGCATTGACTGCAA
ACTTAACGCTGCTCGTAGCGTTTAAACACCAGTTCGCCATTGCTGGAGGAATCTTCATCAAAGAAGTAACCTTCGCTATT
AAAACCAGTCAGTTGCTCTGGTTTGGTCAGCCGATTTTCAATAATGAAACGACTCATCAGACCGCGTGCTTTCTTAGCGT
ACTTAACGCTGCTCGTAGCGTTTAAACACCAGTTCGCCATTGCTGGAGGAATCTTCATCAAAGAAGTAACCTTCGCTATT
AGAAGCTGATGATCTTAAATTTGCCGTTCTTCTCATCGAGGAACACCGGCTTGATAATCTCGGCATTCAATTTCTTCGGC
TCCCGCCGCGCCGCCTGCCGCTTCCTGCCAGCCAAAAGCACTCTCAAAAATAGACCAAATGACGTGGGGAAGTTGCCCGA
CTCTCAAAAATAGACCAAATGACGTGGGGAAGTTGCCCGAGACGTGGGGAAGTTGCCCGAAGTTGCCCGAC neobio-0.0.20030929/data/dna30a.txt 0000644 0002656 0002032 00000000014 07714575640 015411 0 ustar tillea admin BABABABBAB
neobio-0.0.20030929/data/dna39b.txt 0000644 0002656 0002032 00000000014 07723264626 015422 0 ustar tillea admin AGAACAAGGCGT neobio-0.0.20030929/data/dna20b.txt 0000644 0002656 0002032 00000011610 07713633576 015417 0 ustar tillea admin CTCTCAGTCGATATTCATTGACGGATAGTTACTGAAAGCCATCTATCTAAAGTTGGCTAAGACGGCAGGGGAGCAGGCGGATGCGGGCCGCCATTCGGGCTTCGCACTCACTGCAGTAGCGCACTTTCATCACGACGGCATCCTACTACCATTGCATTATCATGCTCGCCCCAATGACGTAGCCAGTTGTGTTGGTCGTACATAGTGTACCGAAAGCCATGACCTAAATTTGGTTGAAACAGTAGTTAGCACACTCCATCAGAGATAGTAAGGCTCGTGAAGCCGAGACTGGGTCTGGATGAACGCATCAGAACTGGAATTGCATATCCCAGGTTGTAACGTGAGTTGCGTAGATGCCGGACCTGGACTAAAAAAGACTTCTGGAAGTTTTTGTATGTTCATAATTTAAAAAATTGTAGTTGAACCCCTAAAGCCATTTGTATGGCCTGGAACCTTTATTTATTCACACGTTAGTACGAGCGAGTGCTGATGCCCGATTGTGGCCCCGAGATAATAAGGACTTCGTCATCTGGGAGCATGTAGTCTATCAGCGGCCGTCGACTATCCACCAGACGAGGGCTCCCAAATAAGAAAGCGGTTCCGAATAGAGATCGCGGCGTCACTCGGTTCTAACGCGCAAATCAGGTCTATGAAAAAAGCTCGCTAACGGCGCGTAAGGTTTGCCGACATCGAAGGGTTCAGTGGGTGCAAAATGAAAGCTGCTCTGCGACTACTTACCTGTCGGCTTCACGCGAGGTTGTAAAAGTGTGCTGGATAGGTTGCCAGAGTAACGAGTGGTTACACATCATGGCAACATCCTCCCCTTTGTGAGTCGAGACTCCTATTCGTCCATCCTCTAAATCACCTTACCCGCGATATCGTCGGAAGCCATGGCCATCTTCAGCTCCCATTTACGCTCTAATACTGTTCCATTGAAAAGACGAAGGAGCGAACAGGAGGACCCGGTTCACTAGCAGGCTCGGAGTATGATTTTAAGATATATCCCCGTTTATCGACGCTGACGTCGTTGCTTCCGCCGCACGAGGACGGCCTCAGGCGATAGGTGAGTTGTTATGCCTTACAAATCGGTCGTCTTACTAAGTTTTAACACAATACCTGCGCGGAAAGACGGTACATTCTGACTCGACAGTGAAGGCCTGACCAACGAGTAGTGTGAAACCCACATATGTATGAGGGCTCTTGGCACCCTTTGAAAGCGGTTGACAAGGACCCGGGGCTAACAAACCGCGCAGCTAAAGTTGATATTGAGCACAGGACGGTCTCTAGATGTGATGAACACCGCTATATTCCATGCCTAGTCATCCACGACAGGTTAGTCTAGAGGTTTCCTGGAATCGTCCGTTACGTTGTGCGTACACGCCAGCCCATATAGCTCACACGCGGGGCGGTTTGACCGTAGAGAATGACTGACTCGCTCTGCAAAGAGACGGAATACACGCCTCCTCTGAAAATCACCGGACTTCTTTACAGTGTGCTCGCGGAGGCGGACTCTGGCACCCGTAAATTATTCTTTTCTGGGAATAGTATTCCCCGGCCGTAGAAACCCAAGCTCACCTAACAGCGTGCCTCAAGTCAGTGGCCCCGGGACGGTCTACACCGAGGTTCATCGGTCAGGTTACGTTGCCGCCCGAGACAGCTACCTGGACCGTTGGAACGCACTTTTAGATGGCTTTCCCCGCGCCGCGAGAACATCGTCAGCCGTTCAAAGTTCACGCCCAAGCGGTGAGCCCGTCTTCGGCAGAGGCCTTAAGTTGATCGGTTCTTTTGTGTAATGACGAGAACTTGCGGCGCGACAGCAACGCTCAGGCCCAAGCAATTCTGTGGGATAATGGAGCCTTCTTCATATAAGATGAACAAAATGGCGGGAAATCAGTTAAATCTGTAGTAACCGTACTGCTCGCAATGTCGTCGTGGGACGTCCAGCATATGGTGTATTAGGGACCCGGACAGACCGAGACGCTGGACTCAGAATAGGCATTAGTTTAATTGAGAGTACGAACAATATAGGTCTCGGGCCTCGGGCCCACACGTTCGTGTCGCACCGTGTTAAATCGGCAAGCGTCAGTGTGCACTGCATACGTTTCGATTACGCACGCACTCAAGAAATAAGTCGCGGCTCCCATGCCATACGGCCGGCATCCTGACTGGCGGATAGTGCTCGCGTAATTCGAGTGGGATTCACTGTCTACATGACCCAGCTTCAATTATAGACAACAACACTTTTAGACGCAACTTGTTTCTCCGCAGTGTACATCCACCAACCCAATAGGTCGTGAGATCATTGATGGGTGTCATTGGATTAGATGCTAGTGAACAACCGCTAAACTGTTAGTAAAGAAAACATTGCGGCTAGTCCGCGAACGGTCCAGCGTCGTTGGCAATATGCCGCAACTGAAACACTAGCACGGTACCCTCTGTTCAAACGTTGTCCCGGGATGGCTTTTAGCAATACGCAACTCATCTTCGAACACCTGACAGTGTGGATCCGCGGCTCTACGCTCATGGAATCATGCTAGGAGCTCTACATAGCGAACTGGTTTTGACGCCCACGCTGTCGCCGGAGTCCAGTGCCCAAGTAGGGACTCGGTGGGTAGTAGACCAGCCACAAGCGACCCCCCCCAAGGATTATAAAGTCTAGTCTACTCCAAGCTGTTATGCTATTTCTCTAACCATGGTTCACCTAATACCAATTTGTGCCGGTGAGGCTGCGTTAACGTAAAAGACAACCCCACGCGTACTACCCACACCTAGCTTAATTGAATAACAACACCGACAACATCCAAAGATATGTCTTTACGCACTAACCAAAACCTATAAGAAGTTATGTCTATGCTCCTCGTATGTTATTGCAGCGTCGCAGACCCCGGATCGGTCTTGCGCGGGAGAGATTCCTCTGACGATCCCCCATATCATGCGGACATGGAGCGCTCCTCCGAACGGGGCTTCGCCCCTACCAGGTCTGGTATCCCTAGTGATGCTGCTTTGTACATCGGTGCAGATGCGTGTGACATATGGATACCTCTATACACTAACGTGGTTTCTAAGATCTAGAGAGGGTGTATTCGGCTTTGCGTCCGTGGCTGCTGCTACACTAATTAGGTTCTACACGCATAAGCTCATGGCAGCAGAGAGCCAACCGTCAAAGCCGGGGCCAGGATTACATAGATGGGCGGGTATGTGTGCGTCGGCTAAGGTTGACTAGCCGTAGGTAACGACAGTTGTCGCACAAACACTCAACAGCAACCCGAGCAACGGTGGCTAAACAGCCTCTCTGGGTGTAAATCCACTATTTGGAGCCGGTGACCTGTGCCTCAGCGAATAATTAACGGAAGTAATTCAAACCTCCCACGAAAGGCTCTATAGGCTGACCGGAGGCATGCCCCCGAAAGCGGGTATTTTTAGATTAATACTCGTGGAAATGATTTCACTTTACGACTCCTCCATTATACCTTGGAGACCGAAAATGGGCAATTCGTACTGGCACGGTCCCCGTTACACTATATCTACAATCGCATCAACGATTAGAGGATTGTTCCACGAACACAGCTTGGTTTCGCCTATGTGACTCCCTATCGAAGGGTTTCTACCGCCGTTGGGCCTTATGCGCGGAAGTCCTCCGCTTATGGAAGCGAAATCTTGGCTTGCTCACATTTCCCGGACTAATGTACGTATGGTATCTAAGGACAAATTGCATGCGGATCCGCTGCGGTGGCGAAATGCGTCGATAGTTTTCCTCCACATCGTGATAACATTATTTGTTAGTATGAATGCCAACATACCAATCATGTCCTCTTCCGAACTCAGGTCATTCCCTAACGCTTTTTTTGCGGGCCGCTCCTAAGGCAGAACATAGAGATCGGCCGAACTTATAATGCGTGTTCTCTACGCTCTTATCCCTAACCGCTATAACGCCGCACTGAACTCCGACCCAGCTAGCTCTGTCCATAACAATGTGGTAGTGCTAGAGTGCGCGAAATTCCCATAGTAATCCGTTACTCGCATGAATCGTCGAAGCAGAAGTCACGTAGATTATGGACGAGGACAACAGTACACCTGCAACTTTGCTTCGTAGGGCCCTGCAAGATGGGTAACACTAAAGCATCTTGTGCAATTCTAAAGTGGTGCCACATCAGTAGTAGTAGAGAACTTAAATATCCCGTTTATTTCTGTTGTTAGACGTTAACTGTAGCGTCCTCATAGTGGATAGTAGGTCTCTTCAAGTGCAATTTTACCCAATACTTATAAGCCGTCGAAAATCGGGAGGGGCTGCATTTGTTTTAGATAGGTTGCCTATACGCACGGCTATACTCTTATTCTAAGGCTATGAGTTCCGCCAAGTAGAAGTGGAGATAGCGTAGTCCTCAGTAAGAGGTCGGGACTCTCGCGGCGCAGCGCCATCTCTTCAGCCGTCAGGTACTGTATGTATGACGGACCATAAGCTTCGCCCACCTAGAAGTTGGCGATCTTCGTTTTGACGTACGTGATAAATAGACAATCCTACTCCCTAACGTACAGATTTAAACTGAGAACAGTTGAATCGTTGGCGATTCAGATATGTTGTGCGTGCTATAAGTAATTCCTAAAATTCGATTATCTGCCATAGTTGCTTGTCCCATCATGGGTCATGAAAAAGACCCCAAGTCCTCGGTTGGGCACCCTCTCCTAATCGCACAGCTACGGCGTACGGGCTTGCGAGGTCTAATCTCGCCGAGTGGCTTGCATTCTTCCGAGATGGTTTCACATGTATCTCGTACTAATGCAGAGTCCGGTGGGGCTGCCGCCTGAAGAATTGAGGTCACCAGTCGGCGGGAGATCCTGATTAAAATTGACTGGTTAAGCTGCATTGCAGATCCCTCCGGCCCGTGTAGTCCAAGGAACTCTGGCCAACATGTGCACAGCGGCCCTGTTGTACTACTGGGATAAGCCTTTAATTGAAGAGCTACCATCGTGTTAACTCATAGAGGCTCTACTAAGTAAGA neobio-0.0.20030929/data/dna28b.txt 0000644 0002656 0002032 00000000012 07714520452 015406 0 ustar tillea admin CAATTCTTTG neobio-0.0.20030929/data/prot06b.txt 0000644 0002656 0002032 00000001130 07710227246 015627 0 ustar tillea admin RVERWDQGTFKZGKSQLDZGTKGHDXAYZZINBLELNWHLQHBWKGQBMPNSGLZNBLBKZWIWNRCBFKKDWIPHKHMRTAWVTGVNNIPENVFGZPGSFDFNVNRILGMGSBHNIBAFBCSICBKZFCYKSFVVCHKNEQWFECAVQAIXXTTCCHBMNSTTPZDILYLEQKNRYQFWWTPWZGKKXLPXEZHWWIMIEKVRSYALWDNMHGMLNISQKMAAXCTXGXZGSWWYEWVXMBLSQQQIDMCKWPEBLPDFMTHXLPXVGMEGYKRFAINXVSMFLGQNMCFVGXAKDYIRIVMEPTHNRLHYBYPPSWGCAWPTVEXZDYDHXCCYCEVBZXTTXMFZSAZCLLQIBBARYIEIWNPKWPXKYXCEFPREISPVECEKPGMLDHGWXRSXSQZHTTHIELSZWFDLBSWDYCZLTCXQZHKXYBYQHFBCXIWAHZGZEIXFZFDELLFQWQKQDZBYBKXCBRDEKSCTSXXBSNINQAMYYLRXWLMLNEIPRTMAKXSMSYKZZYLTEXKFFVWETGVMVPWEDRBEZCRXGZVMSVMQAHXNTHKCWABSYYTDDLCCMSQLYACEDVCDDERGSEIPPVNHRQZW neobio-0.0.20030929/data/dna03a.txt 0000644 0002656 0002032 00000000015 07714355054 015405 0 ustar tillea admin A
C
AA
AC
ACG neobio-0.0.20030929/data/prot08a.txt 0000644 0002656 0002032 00000003244 07710227326 015637 0 ustar tillea admin MWYDGEDIVCHTAQLIFBRVLNFVDLTXTPKAGFAFPBHDVFNELBYKIXLBTMZYYTXNSXNDZQSFKLNTGYRZMTHLNFKWNYGVHGANATGNGWEQZSYEWQYKPRLQGYBQGNISQBXFPYFPWYHLNNGWGXDPPWQMETMFAMWLMTGTAHHSPPVQPCLGZZNISDZXEZLQHISZBENRIVVPHSPXNZVEWFRLSAMEXRCVWWRNMXDSDBGQHHLCEFEERFCZFCDHKLRKZLVRFYWLCGDXMXCDZKATZXHXASHABFCCCDLSTYLFRDYKZZRQMTIDKGTKPBEENQGSXTWGSGAHYDIVICGCPCAYKHGRYLAWPAHCFXXAYFZHIPNXARGYNWKYVTQXKTKMAKKAEIZKVZBFKCATEEHPZZHMPRKZZNHXLBEVMLYXRPSCRALWWBHHBEGFGDVLHEHZDBKLFWWFIIDDLHNAANCBDAKANTDZLTFGTZPYDBAXEGTGZQTHPVZQAFGESXSVSFLTDRXDMQCYDGTBEDRNWWWDGWEZDWBDDWKIMEBSBNBXWTLWHTVLFGIKSZCYDVIBLCYFSFIQWAHXHHDHKTETQMTDQFKMKINGXMESNVVQWMPCIMEXWXMTXFYILXCAPXYVCVMGHLZBVAYWRSEPGQPAKPBZLEIKSEPPTFVAMMAVGWTWTFDZYKMMSHYSDVXKFFECZQHSBGPWKHICVXWVWQTHQDTMEKHKSHNHHSKWZPEKMKMTVXZSMGLVRZZWBMZGDZLMCVZCYVGNIFMHBNHHFYVZMGAXVTQDCFFBVCHQMBIKDNRFSLNDHCXYNFQRAEWWNWMGDWWYBWVCHBBKNRBQLVCPCDCBDYBWTWCCESZTKXMCEWXHSSEXZYWWGFYLLPXGAIASFCEWZLWIHKWLCLHRZMFBMEDGRNBAGCLZZPTCESWBBVSRNIMQIQFBBVQNEYMDDINRZTVHVAVVIZBTMFSZLGYGLMIKHZZBZVBBNCPAGQFIKALWAZGHGRCXKXEEQNEDMLICGFBVWMKDVQFRGAEZHMHPSNXTVKHGQKSNKGKYEMFCIWCNEGFTSWTQTMHCHAIFAWDYFZFXVPKGNQPGKFIQNEYELVWANSTNWDZLBBVQNMWWMHBHKKMMBVACSLZPEFCVELNGGNKBSGGLXBPCZWBMXDIIYMAXXYGKBHKHHQDTYHQSTFNZQBQPAHPEEECZASGIVYWWVBXAZTYMKSMNGAKQICPKFQAKCGTQYIGVEEHEWTTEIMFHBGVCPZBSQEFFGGSHEHRHGZFSPXPEZMQZGRMVVQPDGLLSKVENTMXXIYWESQZMNCWXYPKPYEPDANQDHYLLVMATWWAXRBBTRKNSKRKZVEBALKRIBKSVWLHXTBNQMKLTZSQWQSMCGQVVXFPVNCDFZMBXRLNMZYLCVVHIGXGANWPIQYDGIEIBAHXWWXIFPFYNNILRMVQZMHZAQIXSXLYZZZDQXKBGQQVDYEZXIVQNLWINWRRFEEKCMHSYEQILTCHNPMXLZDEHFYLTBEZYCYPGDTSVCHPGLXIWYHPYQNXPXETQNSWIZVTVMVRZTAXKZATPKNGGYSQGDAFWARZFSZLIRYIFITWLIHRSCTVFMTFEZFGAQXIQXNLDCLNDWVVFBXCDTIQZMTQTVTTIKEVHAHKQNNXAGMCELTTRBHDEZFVPYKZKRHSCHAXRYTSCTVRPSLLIECIRTNQQVGWCGQKR neobio-0.0.20030929/data/dna31b.txt 0000644 0002656 0002032 00000013546 07720032452 015413 0 ustar tillea admin A
AC
ACG
ACGT
ACGTA
ACGTAC
ACGTACG
ACGTACGT
ACGTACGTA
ACGTACGTAC
ACGTACGTACG
ACGTACGTACGT
ACGTACGTACGTA
ACGTACGTACGTAC
ACGTACGTACGTACG
ACGTACGTACGTACGT
ACGTACGTACGTACGTA
ACGTACGTACGTACGTAC
ACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAC
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTA neobio-0.0.20030929/doc/ 0002755 0002656 0002032 00000000000 11662262520 013430 5 ustar tillea admin neobio-0.0.20030929/doc/neobio/ 0002755 0002656 0002032 00000000000 07727746554 014730 5 ustar tillea admin neobio-0.0.20030929/doc/neobio/gui/ 0002755 0002656 0002032 00000000000 07727746554 015514 5 ustar tillea admin neobio-0.0.20030929/doc/neobio/gui/PairwiseAlignmentFrame.html 0000644 0002656 0002032 00000154621 07727746676 023013 0 ustar tillea admin
Overview
Package
Class
Tree
Index
Help
NeoBio API
PREV CLASS
NEXT CLASS
FRAMES
NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD
DETAIL: FIELD | CONSTR | METHOD
neobio.gui
Class PairwiseAlignmentFrame
java.lang.Object
|
+--java.awt.Component
|
+--java.awt.Container
|
+--javax.swing.JComponent
|
+--javax.swing.JInternalFrame
|
+--neobio.gui.PairwiseAlignmentFrame
Nested Class Summary
Nested classes inherited from class javax.swing.JInternalFrame
javax.swing.JInternalFrame.AccessibleJInternalFrame, javax.swing.JInternalFrame.JDesktopIcon
Nested classes inherited from class javax.swing.JComponent
javax.swing.JComponent.AccessibleJComponent
Nested classes inherited from class java.awt.Container
java.awt.Container.AccessibleAWTContainer
Nested classes inherited from class java.awt.Component
java.awt.Component.AccessibleAWTComponent, java.awt.Component.BltBufferStrategy, java.awt.Component.FlipBufferStrategy
Field Summary
private PairwiseAlignmentAlgorithm[]algorithm
private javax.swing.JComboBoxalgorithm_combo
private java.lang.String[]algorithm_name
private javax.swing.JPanelalgorithm_panel
private javax.swing.JRadioButtonbasic_button
private booleanbasic_scheme
private javax.swing.JRadioButtonfile_button
private javax.swing.JFileChooserfind_dialog
private javax.swing.JButtonfind_matrix_button
private javax.swing.JButtonfind_output_button
private javax.swing.JButtonfind_seq1_button
private javax.swing.JButtonfind_seq2_button
private javax.swing.JTextFieldgap_field
private javax.swing.JLabelgap_label
private javax.swing.JPanelinput_panel
private javax.swing.JTextFieldmatch_field
private javax.swing.JLabelmatch_label
private javax.swing.JRadioButtonmatrix_button
private javax.swing.JTextFieldmatrix_field
private javax.swing.JTextFieldmismatch_field
private javax.swing.JLabelmismatch_label
private javax.swing.JTextAreaoutput_area
private javax.swing.JTextFieldoutput_field
private javax.swing.ButtonGroupoutput_group
private javax.swing.JPaneloutput_panel
private javax.swing.JTabbedPaneoutput_tab
private javax.swing.JPaneloutput_tab_panel
private booleanoutput_to_file
private java.awt.Frameparent_frame
private javax.swing.JTextAreaprogress_area
private javax.swing.JPanelprogress_tab_panel
private javax.swing.JButtonrun_button
private javax.swing.ButtonGroupscoring_group
private javax.swing.JPanelscoring_panel
private javax.swing.JRadioButtonscreen_button
private javax.swing.JTextFieldseq1_field
private javax.swing.JLabelseq1_label
private javax.swing.JTextFieldseq2_field
private javax.swing.JLabelseq2_label
private static intwindow_number
Fields inherited from class javax.swing.JInternalFrame
closable, CONTENT_PANE_PROPERTY, desktopIcon, FRAME_ICON_PROPERTY, frameIcon, GLASS_PANE_PROPERTY, iconable, IS_CLOSED_PROPERTY, IS_ICON_PROPERTY, IS_MAXIMUM_PROPERTY, IS_SELECTED_PROPERTY, isClosed, isIcon, isMaximum, isSelected, LAYERED_PANE_PROPERTY, maximizable, MENU_BAR_PROPERTY, resizable, ROOT_PANE_PROPERTY, rootPane, rootPaneCheckingEnabled, title, TITLE_PROPERTY
Fields inherited from class javax.swing.JComponent
accessibleContext, listenerList, TOOL_TIP_TEXT_KEY, ui, UNDEFINED_CONDITION, WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, WHEN_FOCUSED, WHEN_IN_FOCUSED_WINDOW
Fields inherited from class java.awt.Container
Fields inherited from class java.awt.Component
BOTTOM_ALIGNMENT, CENTER_ALIGNMENT, LEFT_ALIGNMENT, RIGHT_ALIGNMENT, TOP_ALIGNMENT
Fields inherited from interface javax.swing.WindowConstants
DISPOSE_ON_CLOSE, DO_NOTHING_ON_CLOSE, EXIT_ON_CLOSE, HIDE_ON_CLOSE
Fields inherited from interface java.awt.image.ImageObserver
ABORT, ALLBITS, ERROR, FRAMEBITS, HEIGHT, PROPERTIES, SOMEBITS, WIDTH
Constructor Summary
PairwiseAlignmentFrame(java.awt.Frame parent_frame)
Creates a new instance of the internal frame.
Method Summary
private voidadd(javax.swing.JComponent a,
javax.swing.JComponent b,
java.awt.GridBagConstraints c,
int x,
int y)
private voidcheckRunButtonStatus()
private voidfindMatrixButtonActionPerformed()
private voidfindOutputButtonActionPerformed()
private voidfindSeq1ButtonActionPerformed()
private voidfindSeq2ButtonActionPerformed()
private voidinitComponents()
private voidoutputOptionStateChanged()
private voidrunButtonActionPerformed()
private voidschemeOptionStateChanged()
private voidshowError(java.lang.String message)
Methods inherited from class javax.swing.JInternalFrame
addImpl, addInternalFrameListener, createRootPane, dispose, doDefaultCloseAction, fireInternalFrameEvent, getAccessibleContext, getContentPane, getDefaultCloseOperation, getDesktopIcon, getDesktopPane, getFocusCycleRootAncestor, getFocusOwner, getFrameIcon, getGlassPane, getInternalFrameListeners, getJMenuBar, getLayer, getLayeredPane, getMenuBar, getMostRecentFocusOwner, getNormalBounds, getRootPane, getTitle, getUI, getUIClassID, getWarningString, isClosable, isClosed, isFocusCycleRoot, isIcon, isIconifiable, isMaximizable, isMaximum, isResizable, isRootPaneCheckingEnabled, isSelected, moveToBack, moveToFront, pack, paintComponent, paramString, remove, removeInternalFrameListener, reshape, restoreSubcomponentFocus, setClosable, setClosed, setContentPane, setDefaultCloseOperation, setDesktopIcon, setFocusCycleRoot, setFrameIcon, setGlassPane, setIcon, setIconifiable, setJMenuBar, setLayer, setLayer, setLayeredPane, setLayout, setMaximizable, setMaximum, setMenuBar, setNormalBounds, setResizable, setRootPane, setRootPaneCheckingEnabled, setSelected, setTitle, setUI, show, toBack, toFront, updateUI
Methods inherited from class javax.swing.JComponent
addAncestorListener, addNotify, addPropertyChangeListener, addPropertyChangeListener, addVetoableChangeListener, computeVisibleRect, contains, createToolTip, disable, enable, firePropertyChange, firePropertyChange, firePropertyChange, firePropertyChange, firePropertyChange, firePropertyChange, firePropertyChange, firePropertyChange, firePropertyChange, fireVetoableChange, getActionForKeyStroke, getActionMap, getAlignmentX, getAlignmentY, getAncestorListeners, getAutoscrolls, getBorder, getBounds, getClientProperty, getComponentGraphics, getConditionForKeyStroke, getDebugGraphicsOptions, getDefaultLocale, getGraphics, getHeight, getInputMap, getInputMap, getInputVerifier, getInsets, getInsets, getListeners, getLocation, getMaximumSize, getMinimumSize, getNextFocusableComponent, getPreferredSize, getPropertyChangeListeners, getPropertyChangeListeners, getRegisteredKeyStrokes, getSize, getToolTipLocation, getToolTipText, getToolTipText, getTopLevelAncestor, getTransferHandler, getVerifyInputWhenFocusTarget, getVetoableChangeListeners, getVisibleRect, getWidth, getX, getY, grabFocus, isDoubleBuffered, isLightweightComponent, isManagingFocus, isMaximumSizeSet, isMinimumSizeSet, isOpaque, isOptimizedDrawingEnabled, isPaintingTile, isPreferredSizeSet, isRequestFocusEnabled, isValidateRoot, paint, paintBorder, paintChildren, paintImmediately, paintImmediately, print, printAll, printBorder, printChildren, printComponent, processComponentKeyEvent, processKeyBinding, processKeyEvent, processMouseMotionEvent, putClientProperty, registerKeyboardAction, registerKeyboardAction, removeAncestorListener, removeNotify, removePropertyChangeListener, removePropertyChangeListener, removeVetoableChangeListener, repaint, repaint, requestDefaultFocus, requestFocus, requestFocus, requestFocusInWindow, requestFocusInWindow, resetKeyboardActions, revalidate, scrollRectToVisible, setActionMap, setAlignmentX, setAlignmentY, setAutoscrolls, setBackground, setBorder, setDebugGraphicsOptions, setDefaultLocale, setDoubleBuffered, setEnabled, setFont, setForeground, setInputMap, setInputVerifier, setMaximumSize, setMinimumSize, setNextFocusableComponent, setOpaque, setPreferredSize, setRequestFocusEnabled, setToolTipText, setTransferHandler, setUI, setVerifyInputWhenFocusTarget, setVisible, unregisterKeyboardAction, update
Methods inherited from class java.awt.Container
add, add, add, add, add, addContainerListener, applyComponentOrientation, areFocusTraversalKeysSet, countComponents, deliverEvent, doLayout, findComponentAt, findComponentAt, getComponent, getComponentAt, getComponentAt, getComponentCount, getComponents, getContainerListeners, getFocusTraversalKeys, getFocusTraversalPolicy, getLayout, insets, invalidate, isAncestorOf, isFocusCycleRoot, isFocusTraversalPolicySet, layout, list, list, locate, minimumSize, paintComponents, preferredSize, printComponents, processContainerEvent, processEvent, remove, removeAll, removeContainerListener, setFocusTraversalKeys, setFocusTraversalPolicy, transferFocusBackward, transferFocusDownCycle, validate, validateTree
Methods inherited from class java.awt.Component
action, add, addComponentListener, addFocusListener, addHierarchyBoundsListener, addHierarchyListener, addInputMethodListener, addKeyListener, addMouseListener, addMouseMotionListener, addMouseWheelListener, bounds, checkImage, checkImage, coalesceEvents, contains, createImage, createImage, createVolatileImage, createVolatileImage, disableEvents, dispatchEvent, enable, enableEvents, enableInputMethods, getBackground, getBounds, getColorModel, getComponentListeners, getComponentOrientation, getCursor, getDropTarget, getFocusListeners, getFocusTraversalKeysEnabled, getFont, getFontMetrics, getForeground, getGraphicsConfiguration, getHierarchyBoundsListeners, getHierarchyListeners, getIgnoreRepaint, getInputContext, getInputMethodListeners, getInputMethodRequests, getKeyListeners, getLocale, getLocation, getLocationOnScreen, getMouseListeners, getMouseMotionListeners, getMouseWheelListeners, getName, getParent, getPeer, getSize, getToolkit, getTreeLock, gotFocus, handleEvent, hasFocus, hide, imageUpdate, inside, isBackgroundSet, isCursorSet, isDisplayable, isEnabled, isFocusable, isFocusOwner, isFocusTraversable, isFontSet, isForegroundSet, isLightweight, isShowing, isValid, isVisible, keyDown, keyUp, list, list, list, location, lostFocus, mouseDown, mouseDrag, mouseEnter, mouseExit, mouseMove, mouseUp, move, nextFocus, paintAll, postEvent, prepareImage, prepareImage, processComponentEvent, processFocusEvent, processHierarchyBoundsEvent, processHierarchyEvent, processInputMethodEvent, processMouseEvent, processMouseWheelEvent, remove, removeComponentListener, removeFocusListener, removeHierarchyBoundsListener, removeHierarchyListener, removeInputMethodListener, removeKeyListener, removeMouseListener, removeMouseMotionListener, removeMouseWheelListener, repaint, repaint, repaint, resize, resize, setBounds, setBounds, setComponentOrientation, setCursor, setDropTarget, setFocusable, setFocusTraversalKeysEnabled, setIgnoreRepaint, setLocale, setLocation, setLocation, setName, setSize, setSize, show, size, toString, transferFocus, transferFocusUpCycle
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
Field Detail
window_number
private static int window_number
parent_frame
private java.awt.Frame parent_frame
input_panel
private javax.swing.JPanel input_panel
scoring_panel
private javax.swing.JPanel scoring_panel
algorithm_panel
private javax.swing.JPanel algorithm_panel
output_panel
private javax.swing.JPanel output_panel
progress_tab_panel
private javax.swing.JPanel progress_tab_panel
output_tab_panel
private javax.swing.JPanel output_tab_panel
seq1_field
private javax.swing.JTextField seq1_field
seq2_field
private javax.swing.JTextField seq2_field
matrix_field
private javax.swing.JTextField matrix_field
output_field
private javax.swing.JTextField output_field
match_field
private javax.swing.JTextField match_field
mismatch_field
private javax.swing.JTextField mismatch_field
gap_field
private javax.swing.JTextField gap_field
progress_area
private javax.swing.JTextArea progress_area
output_area
private javax.swing.JTextArea output_area
find_seq1_button
private javax.swing.JButton find_seq1_button
find_seq2_button
private javax.swing.JButton find_seq2_button
find_output_button
private javax.swing.JButton find_output_button
find_matrix_button
private javax.swing.JButton find_matrix_button
run_button
private javax.swing.JButton run_button
algorithm_combo
private javax.swing.JComboBox algorithm_combo
output_tab
private javax.swing.JTabbedPane output_tab
screen_button
private javax.swing.JRadioButton screen_button
file_button
private javax.swing.JRadioButton file_button
basic_button
private javax.swing.JRadioButton basic_button
matrix_button
private javax.swing.JRadioButton matrix_button
scoring_group
private javax.swing.ButtonGroup scoring_group
output_group
private javax.swing.ButtonGroup output_group
seq1_label
private javax.swing.JLabel seq1_label
seq2_label
private javax.swing.JLabel seq2_label
match_label
private javax.swing.JLabel match_label
mismatch_label
private javax.swing.JLabel mismatch_label
gap_label
private javax.swing.JLabel gap_label
find_dialog
private javax.swing.JFileChooser find_dialog
output_to_file
private boolean output_to_file
basic_scheme
private boolean basic_scheme
algorithm_name
private java.lang.String[] algorithm_name
algorithm
private PairwiseAlignmentAlgorithm[] algorithm
Constructor Detail
PairwiseAlignmentFrame
public PairwiseAlignmentFrame(java.awt.Frame parent_frame)
parent_frame - the parent frame
Method Detail
initComponents
private void initComponents()
add
private void add(javax.swing.JComponent a,
javax.swing.JComponent b,
java.awt.GridBagConstraints c,
int x,
int y)
findSeq1ButtonActionPerformed
private void findSeq1ButtonActionPerformed()
findSeq2ButtonActionPerformed
private void findSeq2ButtonActionPerformed()
findMatrixButtonActionPerformed
private void findMatrixButtonActionPerformed()
findOutputButtonActionPerformed
private void findOutputButtonActionPerformed()
schemeOptionStateChanged
private void schemeOptionStateChanged()
outputOptionStateChanged
private void outputOptionStateChanged()
checkRunButtonStatus
private void checkRunButtonStatus()
runButtonActionPerformed
private void runButtonActionPerformed()
showError
private void showError(java.lang.String message)
Overview
Package
Class
Tree
Index
Help
PREV CLASS
NEXT CLASS
FRAMES
NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD
DETAIL: FIELD | CONSTR | METHOD
http://neobio.sourceforge.net
NeoBio is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with NeoBio; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
neobio-0.0.20030929/doc/neobio/gui/package-tree.html 0000644 0002656 0002032 00000016735 07727746670 020743 0 ustar tillea admin
Overview
Package
Class
Tree
Index
Help
NeoBio API
PREV
NEXT
FRAMES
NO FRAMES
Hierarchy For Package neobio.gui
Class Hierarchy
Overview
Package
Class
Tree
Index
Help
PREV
NEXT
FRAMES
NO FRAMES
http://neobio.sourceforge.net
NeoBio is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with NeoBio; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
neobio-0.0.20030929/doc/neobio/gui/AboutDialog.html 0000644 0002656 0002032 00000057611 07727746674 020607 0 ustar tillea admin
Overview
Package
Class
Tree
Index
Help
NeoBio API
PREV CLASS
NEXT CLASS
FRAMES
NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD
DETAIL: FIELD | CONSTR | METHOD
neobio.gui
Class AboutDialog
java.lang.Object
|
+--java.awt.Component
|
+--java.awt.Container
|
+--java.awt.Window
|
+--java.awt.Dialog
|
+--javax.swing.JDialog
|
+--neobio.gui.AboutDialog
Nested Class Summary
Nested classes inherited from class javax.swing.JDialog
javax.swing.JDialog.AccessibleJDialog
Nested classes inherited from class java.awt.Dialog
java.awt.Dialog.AccessibleAWTDialog
Nested classes inherited from class java.awt.Window
java.awt.Window.AccessibleAWTWindow
Nested classes inherited from class java.awt.Container
java.awt.Container.AccessibleAWTContainer
Nested classes inherited from class java.awt.Component
java.awt.Component.AccessibleAWTComponent, java.awt.Component.BltBufferStrategy, java.awt.Component.FlipBufferStrategy
Field Summary
private javax.swing.JLabelimage_label
Fields inherited from class javax.swing.JDialog
accessibleContext, rootPane, rootPaneCheckingEnabled
Fields inherited from class java.awt.Dialog
Fields inherited from class java.awt.Window
Fields inherited from class java.awt.Container
Fields inherited from class java.awt.Component
BOTTOM_ALIGNMENT, CENTER_ALIGNMENT, LEFT_ALIGNMENT, RIGHT_ALIGNMENT, TOP_ALIGNMENT
Fields inherited from interface javax.swing.WindowConstants
DISPOSE_ON_CLOSE, DO_NOTHING_ON_CLOSE, EXIT_ON_CLOSE, HIDE_ON_CLOSE
Fields inherited from interface java.awt.image.ImageObserver
ABORT, ALLBITS, ERROR, FRAMEBITS, HEIGHT, PROPERTIES, SOMEBITS, WIDTH
Constructor Summary
AboutDialog(java.awt.Frame parent)
Creates a new instance of the About screen.
Method Summary
private voidcloseDialog(java.awt.event.WindowEvent e)
private voidinitComponents()
Methods inherited from class javax.swing.JDialog
addImpl, createRootPane, dialogInit, getAccessibleContext, getContentPane, getDefaultCloseOperation, getGlassPane, getJMenuBar, getLayeredPane, getRootPane, isDefaultLookAndFeelDecorated, isRootPaneCheckingEnabled, paramString, processWindowEvent, remove, setContentPane, setDefaultCloseOperation, setDefaultLookAndFeelDecorated, setGlassPane, setJMenuBar, setLayeredPane, setLayout, setRootPane, setRootPaneCheckingEnabled, update
Methods inherited from class java.awt.Dialog
addNotify, dispose, getTitle, hide, isModal, isResizable, isUndecorated, setModal, setResizable, setTitle, setUndecorated, show
Methods inherited from class java.awt.Window
addPropertyChangeListener, addPropertyChangeListener, addWindowFocusListener, addWindowListener, addWindowStateListener, applyResourceBundle, applyResourceBundle, createBufferStrategy, createBufferStrategy, finalize, getBufferStrategy, getFocusableWindowState, getFocusCycleRootAncestor, getFocusOwner, getFocusTraversalKeys, getGraphicsConfiguration, getInputContext, getListeners, getLocale, getMostRecentFocusOwner, getOwnedWindows, getOwner, getToolkit, getWarningString, getWindowFocusListeners, getWindowListeners, getWindowStateListeners, isActive, isFocusableWindow, isFocusCycleRoot, isFocused, isShowing, pack, postEvent, processEvent, processWindowFocusEvent, processWindowStateEvent, removeWindowFocusListener, removeWindowListener, removeWindowStateListener, setCursor, setFocusableWindowState, setFocusCycleRoot, setLocationRelativeTo, toBack, toFront
Methods inherited from class java.awt.Container
add, add, add, add, add, addContainerListener, applyComponentOrientation, areFocusTraversalKeysSet, countComponents, deliverEvent, doLayout, findComponentAt, findComponentAt, getAlignmentX, getAlignmentY, getComponent, getComponentAt, getComponentAt, getComponentCount, getComponents, getContainerListeners, getFocusTraversalPolicy, getInsets, getLayout, getMaximumSize, getMinimumSize, getPreferredSize, insets, invalidate, isAncestorOf, isFocusCycleRoot, isFocusTraversalPolicySet, layout, list, list, locate, minimumSize, paint, paintComponents, preferredSize, print, printComponents, processContainerEvent, remove, removeAll, removeContainerListener, removeNotify, setFocusTraversalKeys, setFocusTraversalPolicy, setFont, transferFocusBackward, transferFocusDownCycle, validate, validateTree
Methods inherited from class java.awt.Component
action, add, addComponentListener, addFocusListener, addHierarchyBoundsListener, addHierarchyListener, addInputMethodListener, addKeyListener, addMouseListener, addMouseMotionListener, addMouseWheelListener, bounds, checkImage, checkImage, coalesceEvents, contains, contains, createImage, createImage, createVolatileImage, createVolatileImage, disable, disableEvents, dispatchEvent, enable, enable, enableEvents, enableInputMethods, firePropertyChange, firePropertyChange, firePropertyChange, getBackground, getBounds, getBounds, getColorModel, getComponentListeners, getComponentOrientation, getCursor, getDropTarget, getFocusListeners, getFocusTraversalKeysEnabled, getFont, getFontMetrics, getForeground, getGraphics, getHeight, getHierarchyBoundsListeners, getHierarchyListeners, getIgnoreRepaint, getInputMethodListeners, getInputMethodRequests, getKeyListeners, getLocation, getLocation, getLocationOnScreen, getMouseListeners, getMouseMotionListeners, getMouseWheelListeners, getName, getParent, getPeer, getPropertyChangeListeners, getPropertyChangeListeners, getSize, getSize, getTreeLock, getWidth, getX, getY, gotFocus, handleEvent, hasFocus, imageUpdate, inside, isBackgroundSet, isCursorSet, isDisplayable, isDoubleBuffered, isEnabled, isFocusable, isFocusOwner, isFocusTraversable, isFontSet, isForegroundSet, isLightweight, isOpaque, isValid, isVisible, keyDown, keyUp, list, list, list, location, lostFocus, mouseDown, mouseDrag, mouseEnter, mouseExit, mouseMove, mouseUp, move, nextFocus, paintAll, prepareImage, prepareImage, printAll, processComponentEvent, processFocusEvent, processHierarchyBoundsEvent, processHierarchyEvent, processInputMethodEvent, processKeyEvent, processMouseEvent, processMouseMotionEvent, processMouseWheelEvent, remove, removeComponentListener, removeFocusListener, removeHierarchyBoundsListener, removeHierarchyListener, removeInputMethodListener, removeKeyListener, removeMouseListener, removeMouseMotionListener, removeMouseWheelListener, removePropertyChangeListener, removePropertyChangeListener, repaint, repaint, repaint, repaint, requestFocus, requestFocus, requestFocusInWindow, requestFocusInWindow, reshape, resize, resize, setBackground, setBounds, setBounds, setComponentOrientation, setDropTarget, setEnabled, setFocusable, setFocusTraversalKeysEnabled, setForeground, setIgnoreRepaint, setLocale, setLocation, setLocation, setName, setSize, setSize, setVisible, show, size, toString, transferFocus, transferFocusUpCycle
Methods inherited from class java.lang.Object
clone, equals, getClass, hashCode, notify, notifyAll, wait, wait, wait
Field Detail
image_label
private javax.swing.JLabel image_label
Constructor Detail
AboutDialog
public AboutDialog(java.awt.Frame parent)
parent - the parent frame
Method Detail
initComponents
private void initComponents()
closeDialog
private void closeDialog(java.awt.event.WindowEvent e)
Overview
Package
Class
Tree
Index
Help
PREV CLASS
NEXT CLASS
FRAMES
NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD
DETAIL: FIELD | CONSTR | METHOD
http://neobio.sourceforge.net
NeoBio is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with NeoBio; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
neobio-0.0.20030929/doc/neobio/gui/package-summary.html 0000644 0002656 0002032 00000016650 07727746670 021475 0 ustar tillea admin
Overview
Package
Class
Tree
Index
Help
NeoBio API
PREV PACKAGE
NEXT PACKAGE
FRAMES
NO FRAMES
Package neobio.gui
Graphical user interface tools to run the algorithms provided by other packages.
Description
Class Summary
AboutDialog
About screen.
NeoBio
This class is a simple GUI utility for computing pairwise sequence alignments using one
of the the algorithms provided in the neobio.alignment package.
PairwiseAlignmentFrame
This class is the internal frame of NeoBio's graphical interface for computing pairwise
sequence alignments using one of the the algorithms provided in the neobio.alignment package.
Package neobio.gui Description
Overview
Package
Class
Tree
Index
Help
PREV PACKAGE
NEXT PACKAGE
FRAMES
NO FRAMES
http://neobio.sourceforge.net
NeoBio is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with NeoBio; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
neobio-0.0.20030929/doc/neobio/gui/package-frame.html 0000644 0002656 0002032 00000001773 07727746670 021072 0 ustar tillea admin
neobio-0.0.20030929/doc/neobio/gui/NeoBio.html 0000644 0002656 0002032 00000103346 07727746674 017565 0 ustar tillea admin
Classes
AboutDialog
NeoBio
PairwiseAlignmentFrame
Overview
Package
Class
Tree
Index
Help
NeoBio API
PREV CLASS
NEXT CLASS
FRAMES
NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD
DETAIL: FIELD | CONSTR | METHOD
neobio.gui
Class NeoBio
java.lang.Object
|
+--java.awt.Component
|
+--java.awt.Container
|
+--java.awt.Window
|
+--java.awt.Frame
|
+--javax.swing.JFrame
|
+--neobio.gui.NeoBio
Nested Class Summary
Nested classes inherited from class javax.swing.JFrame
javax.swing.JFrame.AccessibleJFrame
Nested classes inherited from class java.awt.Frame
java.awt.Frame.AccessibleAWTFrame
Nested classes inherited from class java.awt.Window
java.awt.Window.AccessibleAWTWindow
Nested classes inherited from class java.awt.Container
java.awt.Container.AccessibleAWTContainer
Nested classes inherited from class java.awt.Component
java.awt.Component.AccessibleAWTComponent, java.awt.Component.BltBufferStrategy, java.awt.Component.FlipBufferStrategy
Field Summary
private javax.swing.JMenuItemabout_menuitem
private javax.swing.JButtonalignment_button
private javax.swing.JDesktopPanedesktop_pane
private javax.swing.JMenuItemexit_menuitem
private javax.swing.JMenufile_menu
private javax.swing.JToolBarfile_toolbar
private javax.swing.JMenuhelp_menu
private javax.swing.JMenuBarmenu_bar
private javax.swing.JSeparatormid_separator
private javax.swing.JMenuItemnew_alignment_item
private javax.swing.JPaneltoolbar_panel
Fields inherited from class javax.swing.JFrame
accessibleContext, EXIT_ON_CLOSE, rootPane, rootPaneCheckingEnabled
Fields inherited from class java.awt.Frame
CROSSHAIR_CURSOR, DEFAULT_CURSOR, E_RESIZE_CURSOR, HAND_CURSOR, ICONIFIED, MAXIMIZED_BOTH, MAXIMIZED_HORIZ, MAXIMIZED_VERT, MOVE_CURSOR, N_RESIZE_CURSOR, NE_RESIZE_CURSOR, NORMAL, NW_RESIZE_CURSOR, S_RESIZE_CURSOR, SE_RESIZE_CURSOR, SW_RESIZE_CURSOR, TEXT_CURSOR, W_RESIZE_CURSOR, WAIT_CURSOR
Fields inherited from class java.awt.Window
Fields inherited from class java.awt.Container
Fields inherited from class java.awt.Component
BOTTOM_ALIGNMENT, CENTER_ALIGNMENT, LEFT_ALIGNMENT, RIGHT_ALIGNMENT, TOP_ALIGNMENT
Fields inherited from interface javax.swing.WindowConstants
DISPOSE_ON_CLOSE, DO_NOTHING_ON_CLOSE, HIDE_ON_CLOSE
Fields inherited from interface java.awt.image.ImageObserver
ABORT, ALLBITS, ERROR, FRAMEBITS, HEIGHT, PROPERTIES, SOMEBITS, WIDTH
Constructor Summary
NeoBio()
Creates a new instance of a graphical interface.
Method Summary
private voidaboutMenuItemActionPerformed(java.awt.event.ActionEvent e)
private voidexitForm()
private voidexitMenuItemActionPerformed(java.awt.event.ActionEvent e)
private voidinitComponents()
static voidmain(java.lang.String[] args)
Create and run a new interface.
private voidnewAlignmentActionPerformed(java.awt.event.ActionEvent e)
private voidpairwiseAlignment()
Methods inherited from class javax.swing.JFrame
addImpl, createRootPane, frameInit, getAccessibleContext, getContentPane, getDefaultCloseOperation, getGlassPane, getJMenuBar, getLayeredPane, getRootPane, isDefaultLookAndFeelDecorated, isRootPaneCheckingEnabled, paramString, processWindowEvent, remove, setContentPane, setDefaultCloseOperation, setDefaultLookAndFeelDecorated, setGlassPane, setJMenuBar, setLayeredPane, setLayout, setRootPane, setRootPaneCheckingEnabled, update
Methods inherited from class java.awt.Frame
addNotify, finalize, getCursorType, getExtendedState, getFrames, getIconImage, getMaximizedBounds, getMenuBar, getState, getTitle, isResizable, isUndecorated, remove, removeNotify, setCursor, setExtendedState, setIconImage, setMaximizedBounds, setMenuBar, setResizable, setState, setTitle, setUndecorated
Methods inherited from class java.awt.Window
addPropertyChangeListener, addPropertyChangeListener, addWindowFocusListener, addWindowListener, addWindowStateListener, applyResourceBundle, applyResourceBundle, createBufferStrategy, createBufferStrategy, dispose, getBufferStrategy, getFocusableWindowState, getFocusCycleRootAncestor, getFocusOwner, getFocusTraversalKeys, getGraphicsConfiguration, getInputContext, getListeners, getLocale, getMostRecentFocusOwner, getOwnedWindows, getOwner, getToolkit, getWarningString, getWindowFocusListeners, getWindowListeners, getWindowStateListeners, hide, isActive, isFocusableWindow, isFocusCycleRoot, isFocused, isShowing, pack, postEvent, processEvent, processWindowFocusEvent, processWindowStateEvent, removeWindowFocusListener, removeWindowListener, removeWindowStateListener, setCursor, setFocusableWindowState, setFocusCycleRoot, setLocationRelativeTo, show, toBack, toFront
Methods inherited from class java.awt.Container
add, add, add, add, add, addContainerListener, applyComponentOrientation, areFocusTraversalKeysSet, countComponents, deliverEvent, doLayout, findComponentAt, findComponentAt, getAlignmentX, getAlignmentY, getComponent, getComponentAt, getComponentAt, getComponentCount, getComponents, getContainerListeners, getFocusTraversalPolicy, getInsets, getLayout, getMaximumSize, getMinimumSize, getPreferredSize, insets, invalidate, isAncestorOf, isFocusCycleRoot, isFocusTraversalPolicySet, layout, list, list, locate, minimumSize, paint, paintComponents, preferredSize, print, printComponents, processContainerEvent, remove, removeAll, removeContainerListener, setFocusTraversalKeys, setFocusTraversalPolicy, setFont, transferFocusBackward, transferFocusDownCycle, validate, validateTree
Methods inherited from class java.awt.Component
action, add, addComponentListener, addFocusListener, addHierarchyBoundsListener, addHierarchyListener, addInputMethodListener, addKeyListener, addMouseListener, addMouseMotionListener, addMouseWheelListener, bounds, checkImage, checkImage, coalesceEvents, contains, contains, createImage, createImage, createVolatileImage, createVolatileImage, disable, disableEvents, dispatchEvent, enable, enable, enableEvents, enableInputMethods, firePropertyChange, firePropertyChange, firePropertyChange, getBackground, getBounds, getBounds, getColorModel, getComponentListeners, getComponentOrientation, getCursor, getDropTarget, getFocusListeners, getFocusTraversalKeysEnabled, getFont, getFontMetrics, getForeground, getGraphics, getHeight, getHierarchyBoundsListeners, getHierarchyListeners, getIgnoreRepaint, getInputMethodListeners, getInputMethodRequests, getKeyListeners, getLocation, getLocation, getLocationOnScreen, getMouseListeners, getMouseMotionListeners, getMouseWheelListeners, getName, getParent, getPeer, getPropertyChangeListeners, getPropertyChangeListeners, getSize, getSize, getTreeLock, getWidth, getX, getY, gotFocus, handleEvent, hasFocus, imageUpdate, inside, isBackgroundSet, isCursorSet, isDisplayable, isDoubleBuffered, isEnabled, isFocusable, isFocusOwner, isFocusTraversable, isFontSet, isForegroundSet, isLightweight, isOpaque, isValid, isVisible, keyDown, keyUp, list, list, list, location, lostFocus, mouseDown, mouseDrag, mouseEnter, mouseExit, mouseMove, mouseUp, move, nextFocus, paintAll, prepareImage, prepareImage, printAll, processComponentEvent, processFocusEvent, processHierarchyBoundsEvent, processHierarchyEvent, processInputMethodEvent, processKeyEvent, processMouseEvent, processMouseMotionEvent, processMouseWheelEvent, removeComponentListener, removeFocusListener, removeHierarchyBoundsListener, removeHierarchyListener, removeInputMethodListener, removeKeyListener, removeMouseListener, removeMouseMotionListener, removeMouseWheelListener, removePropertyChangeListener, removePropertyChangeListener, repaint, repaint, repaint, repaint, requestFocus, requestFocus, requestFocusInWindow, requestFocusInWindow, reshape, resize, resize, setBackground, setBounds, setBounds, setComponentOrientation, setDropTarget, setEnabled, setFocusable, setFocusTraversalKeysEnabled, setForeground, setIgnoreRepaint, setLocale, setLocation, setLocation, setName, setSize, setSize, setVisible, show, size, toString, transferFocus, transferFocusUpCycle
Methods inherited from class java.lang.Object
clone, equals, getClass, hashCode, notify, notifyAll, wait, wait, wait
Methods inherited from interface java.awt.MenuContainer
getFont, postEvent
Field Detail
file_menu
private javax.swing.JMenu file_menu
help_menu
private javax.swing.JMenu help_menu
menu_bar
private javax.swing.JMenuBar menu_bar
new_alignment_item
private javax.swing.JMenuItem new_alignment_item
exit_menuitem
private javax.swing.JMenuItem exit_menuitem
about_menuitem
private javax.swing.JMenuItem about_menuitem
mid_separator
private javax.swing.JSeparator mid_separator
file_toolbar
private javax.swing.JToolBar file_toolbar
toolbar_panel
private javax.swing.JPanel toolbar_panel
alignment_button
private javax.swing.JButton alignment_button
desktop_pane
private javax.swing.JDesktopPane desktop_pane
Constructor Detail
NeoBio
public NeoBio()
Method Detail
initComponents
private void initComponents()
aboutMenuItemActionPerformed
private void aboutMenuItemActionPerformed(java.awt.event.ActionEvent e)
exitMenuItemActionPerformed
private void exitMenuItemActionPerformed(java.awt.event.ActionEvent e)
exitForm
private void exitForm()
newAlignmentActionPerformed
private void newAlignmentActionPerformed(java.awt.event.ActionEvent e)
pairwiseAlignment
private void pairwiseAlignment()
main
public static void main(java.lang.String[] args)
args - command line arguments
Overview
Package
Class
Tree
Index
Help
PREV CLASS
NEXT CLASS
FRAMES
NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD
DETAIL: FIELD | CONSTR | METHOD
http://neobio.sourceforge.net
NeoBio is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with NeoBio; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
neobio-0.0.20030929/doc/neobio/textui/ 0002755 0002656 0002032 00000000000 07727746554 016252 5 ustar tillea admin neobio-0.0.20030929/doc/neobio/textui/RandomFactorSequenceGenerator.html 0000644 0002656 0002032 00000033131 07727746672 025057 0 ustar tillea admin
Overview
Package
Class
Tree
Index
Help
NeoBio API
PREV CLASS
NEXT CLASS
FRAMES
NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD
DETAIL: FIELD | CONSTR | METHOD
neobio.textui
Class RandomFactorSequenceGenerator
java.lang.Object
|
+--neobio.textui.RandomFactorSequenceGenerator
type, size and file, where:
type is either DNA for DNA sequences or
PROT for protein sequences.
size is the number os characters.
file (optional) is the name of a file (if ommited, sequence
is written to standard output).
- Author:
- Sergio A. de Carvalho Jr.
| Field Summary | |
private static char[] |
DNA_CHARS
Character set for DNA sequences. |
private static char[] |
PROT_CHARS
Character set for protein sequences. |
| Constructor Summary | |
RandomFactorSequenceGenerator()
|
|
| Method Summary | |
static void |
main(java.lang.String[] args)
The main method takes three parameters from the command line to generate a sequence. |
private static void |
usage()
Prints command line usage. |
| Methods inherited from class java.lang.Object |
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Field Detail |
DNA_CHARS
private static final char[] DNA_CHARS
- Character set for DNA sequences.
PROT_CHARS
private static final char[] PROT_CHARS
- Character set for protein sequences.
| Constructor Detail |
RandomFactorSequenceGenerator
public RandomFactorSequenceGenerator()
| Method Detail |
main
public static void main(java.lang.String[] args)
- The main method takes three parameters from the command line to generate a
sequence. See the class description for details.
- Parameters:
args- command line arguments
usage
private static void usage()
- Prints command line usage.
|
|
||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
NeoBio is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with NeoBio; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
neobio-0.0.20030929/doc/neobio/textui/RandomSequenceGenerator.html 0000644 0002656 0002032 00000032526 07727746672 023727 0 ustar tillea admin
|
NeoBio API | ||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
neobio.textui
Class RandomSequenceGenerator
java.lang.Object | +--neobio.textui.RandomSequenceGenerator
- public class RandomSequenceGenerator
- extends java.lang.Object
This class is a simple command line based utility for generating random sequences.
The main method takes three parameters from the command line to generate a
sequence: type, size and file, where:
typeis eitherDNAfor DNA sequences orPROTfor protein sequences.sizeis the number os characters.file(optional) is the name of a file (if ommited, sequence is written to standard output).
- Author:
- Sergio A. de Carvalho Jr.
| Field Summary | |
private static char[] |
DNA_CHARS
Character set for DNA sequences. |
private static char[] |
PROT_CHARS
Character set for protein sequences. |
| Constructor Summary | |
RandomSequenceGenerator()
|
|
| Method Summary | |
static void |
main(java.lang.String[] args)
The main method takes three parameters from the command line to generate a sequence. |
private static void |
usage()
Prints command line usage. |
| Methods inherited from class java.lang.Object |
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Field Detail |
DNA_CHARS
private static final char[] DNA_CHARS
- Character set for DNA sequences.
PROT_CHARS
private static final char[] PROT_CHARS
- Character set for protein sequences.
| Constructor Detail |
RandomSequenceGenerator
public RandomSequenceGenerator()
| Method Detail |
main
public static void main(java.lang.String[] args)
- The main method takes three parameters from the command line to generate a
sequence. See the class description for details.
- Parameters:
args- command line arguments
usage
private static void usage()
- Prints command line usage.
|
|
||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
NeoBio is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with NeoBio; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
neobio-0.0.20030929/doc/neobio/textui/package-tree.html 0000644 0002656 0002032 00000014632 07727746670 021473 0 ustar tillea admin
|
NeoBio API | ||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||
Hierarchy For Package neobio.textui
- Package Hierarchies:
- All Packages
Class Hierarchy
- class java.lang.Object
- class neobio.textui.NeoBio
- class neobio.textui.RandomFactorSequenceGenerator
- class neobio.textui.RandomSequenceGenerator
|
|
||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||
NeoBio is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with NeoBio; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
neobio-0.0.20030929/doc/neobio/textui/package-summary.html 0000644 0002656 0002032 00000016447 07727746670 022237 0 ustar tillea admin
|
NeoBio API | ||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES | ||||||||
Package neobio.textui
Command line based tools to run the algorithms provided by other packages.
See:
Description
| Class Summary | |
| NeoBio | This class is a simple command line based utility for computing pairwise sequence alignments using one of the the algorithms provided in the neobio.alignment package. |
| RandomFactorSequenceGenerator | This class is a simple command line based utility for generating random sequences with optimal LZ78 factorisation. |
| RandomSequenceGenerator | This class is a simple command line based utility for generating random sequences. |
Package neobio.textui Description
Command line based tools to run the algorithms provided by other packages.
|
|
||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES | ||||||||
NeoBio is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with NeoBio; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
neobio-0.0.20030929/doc/neobio/textui/package-frame.html 0000644 0002656 0002032 00000002055 07727746670 021622 0 ustar tillea admin
|
Classes
NeoBio RandomFactorSequenceGenerator RandomSequenceGenerator |
|
NeoBio API | ||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
neobio.textui
Class NeoBio
java.lang.Object | +--neobio.textui.NeoBio
- public class NeoBio
- extends java.lang.Object
This class is a simple command line based utility for computing pairwise sequence alignments using one of the the algorithms provided in the neobio.alignment package.
The main method takes the follwing parameters from the command line:
NeoBio <alg> <S1> <S2> [M <matrix> | S <match>
<mismatch> <gap>]
<alg>is eitherNWfor Needleman & Wunsch (global alignment),SWfor Smith & Waterman (local alignment),CLZGfor Crochemore, Landau & Ziv-Ukelson global alignment orCLZLfor Crochemore, Landau & Ziv-Ukelson local alignment;<S1>is the first sequence file;<S2>is the second sequence file;M <matrix>is for using a scoring matrix file;S <match> <mismatch> <gap>is for using a simple scoring scheme, where<match>is the match reward value,<mismatch>is the mismatch penalty value and<gap>is the cost of a gap (linear gap cost function).
- Author:
- Sergio A. de Carvalho Jr.
| Constructor Summary | |
NeoBio()
|
|
| Method Summary | |
static void |
main(java.lang.String[] args)
The main method takes parameters from the command line to compute a pairwise sequence alignment. |
static void |
usage()
Prints command line usage. |
| Methods inherited from class java.lang.Object |
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Constructor Detail |
NeoBio
public NeoBio()
| Method Detail |
main
public static void main(java.lang.String[] args)
- The main method takes parameters from the command line to compute a pairwise
sequence alignment. See the class description for details.
- Parameters:
args- command line arguments
usage
public static void usage()
- Prints command line usage.
|
|
||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
NeoBio is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with NeoBio; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
neobio-0.0.20030929/doc/neobio/alignment/ 0002755 0002656 0002032 00000000000 11662262520 016661 5 ustar tillea admin neobio-0.0.20030929/doc/neobio/alignment/LocalAlignmentBlock.html 0000644 0002656 0002032 00000045427 07727746672 023453 0 ustar tillea admin
|
NeoBio API | ||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
neobio.alignment
Class LocalAlignmentBlock
java.lang.Object | +--neobio.alignment.AlignmentBlock | +--neobio.alignment.LocalAlignmentBlock
- public class LocalAlignmentBlock
- extends AlignmentBlock
This class is used by the CrochemoreLandauZivUkelsonLocalAlignment algorithm to store the information of an alignment block. All fields are public (but final) in order to simplify the access to the data.
For more information on how this class is used, please refer to the specification
of the CrochemoreLandauZivUkelsonLocalAlignment class.
- Author:
- Sergio A. de Carvalho Jr.
- See Also:
CrochemoreLandauZivUkelsonLocalAlignment
| Field Summary | |
int |
C
The value of the highest scoring path contained in this block, called C-path. |
LocalAlignmentBlock[] |
E_path_ancestor
An array of pointers to blocks that are source of E-paths. |
int[] |
E_path_ancestor_index
Indexes of of the entry in the ancestor block that is the source of the E-path. |
int[] |
E_path_score
The value of the highest scoring path which starts at the input border of this block and ends inside it, called E-path. |
byte[] |
path_type
The type of the highest scoring path ending at a given position of the output border of a block. |
byte |
S_direction
The direction to the source of the S-path of the new vertex of this block. |
int[] |
S_path_score
The value of the highest scoring path which starts inside the block and ends at its output border. |
| Fields inherited from class neobio.alignment.AlignmentBlock |
ancestor, direction, dist_column, factor1, factor2, output_border, source_path |
| Constructor Summary | |
(package private) |
LocalAlignmentBlock(Factor factor1,
Factor factor2)
Creates a new root block. |
(package private) |
LocalAlignmentBlock(Factor factor1,
Factor factor2,
int size)
Creates a new alignment block, with all arrays created with the specified size. |
| Methods inherited from class java.lang.Object |
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Field Detail |
E_path_score
public int[] E_path_score
- The value of the highest scoring path which starts at the input border of this
block and ends inside it, called E-path.
E_path_ancestor
public LocalAlignmentBlock[] E_path_ancestor
- An array of pointers to blocks that are source of E-paths.
E_path_ancestor_index
public int[] E_path_ancestor_index
- Indexes of of the entry in the ancestor block that is the source of the E-path.
S_path_score
public int[] S_path_score
- The value of the highest scoring path which starts inside the block and ends at its
output border.
path_type
public byte[] path_type
- The type of the highest scoring path ending at a given position of the output
border of a block.
S_direction
public byte S_direction
- The direction to the source of the S-path of the new vertex of this block.
C
public int C
- The value of the highest scoring path contained in this block, called C-path.
| Constructor Detail |
LocalAlignmentBlock
LocalAlignmentBlock(Factor factor1, Factor factor2)
- Creates a new root block.
- Parameters:
factor1- factor of the first sequence being alignedfactor2- factor of the second sequence being aligned
LocalAlignmentBlock
LocalAlignmentBlock(Factor factor1, Factor factor2, int size)
- Creates a new alignment block, with all arrays created with the specified size.
- Parameters:
factor1- factor of the first sequence being alignedfactor2- factor of the second sequence being alignedsize- size of the arrays to be created
|
|
||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
NeoBio is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with NeoBio; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
neobio-0.0.20030929/doc/neobio/alignment/ScoringMatrix.html 0000644 0002656 0002032 00000071550 07727746672 022374 0 ustar tillea admin
|
NeoBio API | ||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
neobio.alignment
Class ScoringMatrix
java.lang.Object | +--neobio.alignment.ScoringScheme | +--neobio.alignment.ScoringMatrix
- public class ScoringMatrix
- extends ScoringScheme
This class implements a scoring scheme based on a substitution matrix. It is useful
to represent PAM and BLOSUM family of amino acids scoring matrices. Its constructor
loads such matrices from a file (or any other character stream). The following is an
extract of a BLOSUM62 scoring matrix file:
A R N D C Q E G H I L K M F P S T W Y V B Z X *
A 4 -1 -2 -2 0 -1 -1 0 -2 -1 -1 -1 -1 -2 -1 1 0 -3 -2 0 -2 -1 0 -4
R -1 5 0 -2 -3 1 0 -2 0 -3 -2 2 -1 -3 -2 -1 -1 -3 -2 -3 -1 0 -1 -4
...
B -2 -1 3 4 -3 0 1 -1 0 -3 -4 0 -3 -3 -2 0 -1 -4 -3 -3 4 1 -1 -4
Z -1 0 0 1 -3 3 4 -2 0 -3 -3 1 -1 -3 -1 0 -1 -3 -2 -2 1 4 -1 -4
X 0 -1 -1 -1 -2 -1 -1 -1 -1 -1 -1 -1 -1 -1 -2 0 0 -2 -1 -1 -1 -1 -1 -4
* -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 1
Matrices are expected to follow this format. They must have one row an one column for each defined character (not necessarily in the same order). Each row and column must start with a distinct character (no repetition) and all row characters must have a correspondent column, and vice versa.
Value at position (i,j) represent the score of substituting character of row i for
character of column j. Insertion penalties are specified by the last row while deletion
penalties must be located at the last column (both represented by the special character
defined by the INDEL_CHAR constant). Note that it only supports an
additive gap cost function. In case any of this rules are not followed, an
InvalidScoringMatrixException exception is raised by the constructor.
If a scoring operation (substitution, insertion or deletion) involves a character not found in the matrix, an exception is raised.
- Author:
- Sergio A. de Carvalho Jr.
- See Also:
InvalidScoringMatrixException
| Field Summary | |
protected java.lang.String |
col_codes
Stores matrix column headers in the order they were found. |
protected static char |
COMMENT_CHAR
The character used to start a comment line in the scoring matrix file. |
protected int |
dimension
Dimension of the (squared) matrix. |
protected static char |
INDEL_CHAR
The character that indicates the row and column for insertion and deletion penalties in the matrix. |
protected int[][] |
matrix
Stores values for each operation (substitution, insertion or deletion) defined by this matrix. |
protected int |
max_absolute_score
The maximum absolute score that this matrix can return for any substitution, deletion or insertion. |
protected java.lang.String |
row_codes
Stores matrix row headers in the order they were found. |
| Fields inherited from class neobio.alignment.ScoringScheme |
case_sensitive |
| Constructor Summary | |
ScoringMatrix(java.io.Reader input)
Creates a new instance of a substitution matrix loaded from the character stream. |
|
ScoringMatrix(java.io.Reader input,
boolean case_sensitive)
Creates a new instance of a substitution matrix loaded from the character stream. |
|
| Method Summary | |
boolean |
isPartialMatchSupported()
Tells whether this scoring scheme supports partial matches, which it does, although a particular scoring matrix loaded by this instace might not. |
int |
maxAbsoluteScore()
Returns the maximum absolute score that this scoring scheme can return for any substitution, deletion or insertion. |
int |
scoreDeletion(char a)
Returns the score of a deletion of character a according to this
scoring matrix. |
int |
scoreInsertion(char a)
Returns the score of an insertion of character a according to this
scoring matrix. |
int |
scoreSubstitution(char a,
char b)
Returns the score of a substitution of character a for character
b according to this scoring matrix. |
java.lang.String |
toString()
Returns a String representation of this scoring matrix. |
| Methods inherited from class neobio.alignment.ScoringScheme |
isCaseSensitive |
| Methods inherited from class java.lang.Object |
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait |
| Field Detail |
INDEL_CHAR
protected static final char INDEL_CHAR
- The character that indicates the row and column for insertion and deletion
penalties in the matrix.
- See Also:
- Constant Field Values
COMMENT_CHAR
protected static final char COMMENT_CHAR
- The character used to start a comment line in the scoring matrix file.
- See Also:
- Constant Field Values
col_codes
protected java.lang.String col_codes
- Stores matrix column headers in the order they were found.
row_codes
protected java.lang.String row_codes
- Stores matrix row headers in the order they were found.
matrix
protected int[][] matrix
- Stores values for each operation (substitution, insertion or deletion) defined by
this matrix.
dimension
protected int dimension
- Dimension of the (squared) matrix.
max_absolute_score
protected int max_absolute_score
- The maximum absolute score that this matrix can return for any substitution,
deletion or insertion.
| Constructor Detail |
ScoringMatrix
public ScoringMatrix(java.io.Reader input) throws java.io.IOException, InvalidScoringMatrixException
- Creates a new instance of a substitution matrix loaded from the character stream.
The case of characters is significant when subsequently computing their score.
- Parameters:
input- character stream from where the matrix is read- Throws:
java.io.IOException- if an I/O operation fails when reading from inputInvalidScoringMatrixException- if the matrix does not comply with the specification
ScoringMatrix
public ScoringMatrix(java.io.Reader input, boolean case_sensitive) throws java.io.IOException, InvalidScoringMatrixException
- Creates a new instance of a substitution matrix loaded from the character stream.
If
case_sensitiveistrue, the case of characters is significant when subsequently computing their score; otherwise the case is ignored. - Parameters:
input- character stream from where the matrix is readcase_sensitive-trueif the case of characters must be- Throws:
java.io.IOException- if an I/O operation fails when reading from inputInvalidScoringMatrixException- if the matrix does not comply with the specification
| Method Detail |
scoreSubstitution
public int scoreSubstitution(char a, char b) throws IncompatibleScoringSchemeException
- Returns the score of a substitution of character
afor characterbaccording to this scoring matrix.- Specified by:
scoreSubstitutionin classScoringScheme
- Parameters:
a- first characterb- second character- Returns:
- score of a substitution of character
aforb - Throws:
IncompatibleScoringSchemeException- if this substitution is not defined
scoreInsertion
public int scoreInsertion(char a) throws IncompatibleScoringSchemeException
- Returns the score of an insertion of character
aaccording to this scoring matrix.- Specified by:
scoreInsertionin classScoringScheme
- Parameters:
a- character to be inserted- Returns:
- score of insertion of
a - Throws:
IncompatibleScoringSchemeException- if this character is not recognised
scoreDeletion
public int scoreDeletion(char a) throws IncompatibleScoringSchemeException
- Returns the score of a deletion of character
aaccording to this scoring matrix.- Specified by:
scoreDeletionin classScoringScheme
- Parameters:
a- character to be deleted- Returns:
- score of deletion of
a - Throws:
IncompatibleScoringSchemeException- if this character is not recognised
isPartialMatchSupported
public boolean isPartialMatchSupported()
- Tells whether this scoring scheme supports partial matches, which it does, although
a particular scoring matrix loaded by this instace might not. A partial match is
a situation when two characters are not equal but, for any reason, are regarded
as similar by this scoring scheme, which then returns a positive score value. This
is common for amino acid scoring matrices.
- Specified by:
isPartialMatchSupportedin classScoringScheme
- Returns:
- always return
true
maxAbsoluteScore
public int maxAbsoluteScore()
- Returns the maximum absolute score that this scoring scheme can return for any
substitution, deletion or insertion.
- Specified by:
maxAbsoluteScorein classScoringScheme
- Returns:
- maximum absolute score that can be returned
toString
public java.lang.String toString()
- Returns a String representation of this scoring matrix.
- Overrides:
toStringin classjava.lang.Object
- Returns:
- a String representation of this scoring matrix
|
|
||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
NeoBio is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with NeoBio; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
neobio-0.0.20030929/doc/neobio/alignment/SmithWaterman.html 0000644 0002656 0002032 00000073623 07727746672 022371 0 ustar tillea admin
|
NeoBio API | ||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
neobio.alignment
Class SmithWaterman
java.lang.Object | +--neobio.alignment.PairwiseAlignmentAlgorithm | +--neobio.alignment.SmithWaterman
- public class SmithWaterman
- extends PairwiseAlignmentAlgorithm
This class implement the classic local alignment algorithm (with linear gap penalty function) due to T.F.Smith and M.S.Waterman (1981).
This algorithm is very similar to the NeedlemanWunsch algorithm for global alignment. The idea here also consists of building an (n+1 x m+1) matrix M given two sequences A and B of sizes n and m, respectively. However, unlike in the global alignment case, every position M[i,j] in the matrix contains the similarity score of suffixes of A[1..i] and B[1..j].
Starting from row 0, column 0, the computeMatrix method
computes each position M[i,j] with the following recurrence:
M[0,0] = M[0,j] = M[i,0] = 0
M[i,j] = max { M[i,j-1] + scoreInsertion (B[j]),
M[i-1,j-1] + scoreSubstitution (A[i], B[j]),
M[i-1,j] + scoreDeletion(A[i]) }
Note that, here, all cells in the first row and column are set to zero. The best local alignment score is the highest value found anywhere in the matrix.
Just like in global alignment case, this algorithm has quadratic space complexity because it needs to keep an (n+1 x m+1) matrix in memory. And since the work of computing each cell is constant, it also has quadratic time complexity.
After the matrix has been computed, the alignment can be retrieved by tracing a path
back in the matrix from the position of the highest score until a cell of value zero is
reached. This step is performed by the buildOptimalAlignment method, and its time complexity is linear on the size of the
alignment.
If the similarity value only is needed (and not the alignment itself), it is easy to
reduce the space requirement to O(n) by keeping just the last row or column in memory.
This is precisely what is done by the computeScore method. Note
that it still requires O(n2) time.
For a more efficient approach to the local alignment problem, see the CrochemoreLandauZivUkelson algorithm. For global alignment, see the NeedlemanWunsch algorithm.
- Author:
- Sergio A. de Carvalho Jr.
- See Also:
NeedlemanWunsch,CrochemoreLandauZivUkelson,CrochemoreLandauZivUkelsonLocalAlignment,CrochemoreLandauZivUkelsonGlobalAlignment
| Field Summary | |
protected int[][] |
matrix
The dynamic programming matrix. |
protected int |
max_col
Indicate the column of where an optimal local alignment can be found in the matrix. |
protected int |
max_row
Indicate the row of where an optimal local alignment can be found in the matrix.. |
protected CharSequence |
seq1
The first sequence of an alignment. |
protected CharSequence |
seq2
The second sequence of an alignment. |
| Fields inherited from class neobio.alignment.PairwiseAlignmentAlgorithm |
alignment, APPROXIMATE_MATCH_TAG, GAP_CHARACTER, GAP_TAG, MATCH_TAG, MISMATCH_TAG, score, score_computed, scoring, sequences_loaded, use_match_tag |
| Constructor Summary | |
SmithWaterman()
|
|
| Method Summary | |
protected PairwiseAlignment |
buildOptimalAlignment()
Builds an optimal local alignment between the loaded sequences. |
protected void |
computeMatrix()
Computes the dynamic programming matrix. |
protected PairwiseAlignment |
computePairwiseAlignment()
Builds an optimal local alignment between the loaded sequences after computing the dynamic programming matrix. |
protected int |
computeScore()
Computes the score of the best local alignment between the two sequences using the scoring scheme previously set. |
protected void |
loadSequencesInternal(java.io.Reader input1,
java.io.Reader input2)
Loads sequences into CharSequence instances. |
protected void |
unloadSequencesInternal()
Frees pointers to loaded sequences and the dynamic programming matrix so that their data can be garbage collected. |
| Methods inherited from class neobio.alignment.PairwiseAlignmentAlgorithm |
getPairwiseAlignment, getScore, loadSequences, max, max, max, scoreDeletion, scoreInsertion, scoreSubstitution, setScoringScheme, unloadSequences, useMatchTag |
| Methods inherited from class java.lang.Object |
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Field Detail |
seq1
protected CharSequence seq1
- The first sequence of an alignment.
seq2
protected CharSequence seq2
- The second sequence of an alignment.
matrix
protected int[][] matrix
- The dynamic programming matrix. Each position (i, j) represents the best score
between a suffic of the firsts i characters of
seq1and a suffix of the first j characters ofseq2.
max_row
protected int max_row
- Indicate the row of where an optimal local alignment can be found in the matrix..
max_col
protected int max_col
- Indicate the column of where an optimal local alignment can be found in the matrix.
| Constructor Detail |
SmithWaterman
public SmithWaterman()
| Method Detail |
loadSequencesInternal
protected void loadSequencesInternal(java.io.Reader input1, java.io.Reader input2) throws java.io.IOException, InvalidSequenceException
- Loads sequences into CharSequence instances. In case of any error, an
exception is raised by the constructor of
CharSequence(please check the specification of that class for specific requirements).- Specified by:
loadSequencesInternalin classPairwiseAlignmentAlgorithm
- Parameters:
input1- Input for first sequenceinput2- Input for second sequence- Throws:
java.io.IOException- If an I/O error occurs when reading the sequencesInvalidSequenceException- If the sequences are not valid- See Also:
CharSequence
unloadSequencesInternal
protected void unloadSequencesInternal()
- Frees pointers to loaded sequences and the dynamic programming matrix so that their
data can be garbage collected.
- Specified by:
unloadSequencesInternalin classPairwiseAlignmentAlgorithm
computePairwiseAlignment
protected PairwiseAlignment computePairwiseAlignment() throws IncompatibleScoringSchemeException
- Builds an optimal local alignment between the loaded sequences after computing the
dynamic programming matrix. It calls the
buildOptimalAlignmentmethod after thecomputeMatrixmethod computes the dynamic programming matrix.- Specified by:
computePairwiseAlignmentin classPairwiseAlignmentAlgorithm
- Returns:
- an optimal pairwise alignment between the loaded sequences
- Throws:
IncompatibleScoringSchemeException- If the scoring scheme is not compatible with the loaded sequences.- See Also:
computeMatrix(),buildOptimalAlignment()
computeMatrix
protected void computeMatrix() throws IncompatibleScoringSchemeException
- Computes the dynamic programming matrix.
- Throws:
IncompatibleScoringSchemeException- If the scoring scheme is not compatible with the loaded sequences.
buildOptimalAlignment
protected PairwiseAlignment buildOptimalAlignment() throws IncompatibleScoringSchemeException
- Builds an optimal local alignment between the loaded sequences. Before it is
executed, the dynamic programming matrix must already have been computed by
the
computeMatrixmethod.- Returns:
- an optimal local alignment between the loaded sequences
- Throws:
IncompatibleScoringSchemeException- If the scoring scheme is not compatible with the loaded sequences.- See Also:
computeMatrix()
computeScore
protected int computeScore() throws IncompatibleScoringSchemeException
- Computes the score of the best local alignment between the two sequences using the
scoring scheme previously set. This method calculates the similarity value only
(doesn't build the whole matrix so the alignment cannot be recovered, however it
has the advantage of requiring O(n) space only).
- Specified by:
computeScorein classPairwiseAlignmentAlgorithm
- Returns:
- the score of the best local alignment between the loaded sequences
- Throws:
IncompatibleScoringSchemeException- If the scoring scheme is not compatible with the loaded sequences.- See Also:
PairwiseAlignmentAlgorithm.getScore()
|
|
||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
NeoBio is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with NeoBio; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
neobio-0.0.20030929/doc/neobio/alignment/InvalidScoringMatrixException.html 0000644 0002656 0002032 00000035220 07727746672 025554 0 ustar tillea admin
|
NeoBio API | ||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
neobio.alignment
Class InvalidScoringMatrixException
java.lang.Object
|
+--java.lang.Throwable
|
+--java.lang.Exception
|
+--neobio.alignment.InvalidScoringMatrixException
- All Implemented Interfaces:
- java.io.Serializable
- public class InvalidScoringMatrixException
- extends java.lang.Exception
Signals that the substitution matrix does not comply with the specification (see ScoringMatrix for details).
- Author:
- Sergio A. de Carvalho Jr.
- See Also:
ScoringMatrix, Serialized Form
| Field Summary |
| Fields inherited from class java.lang.Exception |
|
| Fields inherited from class java.lang.Throwable |
|
| Constructor Summary | |
InvalidScoringMatrixException()
Constructs an InvalidScoringMatrixException with null as its error
detail message. |
|
InvalidScoringMatrixException(java.lang.String message)
Constructs an InvalidScoringMatrixException with the specified detail
message. |
|
InvalidScoringMatrixException(java.lang.String message,
java.lang.Throwable cause)
Constructs an InvalidScoringMatrixException with the specified detail
message and cause. |
|
InvalidScoringMatrixException(java.lang.Throwable cause)
Constructs an InvalidScoringMatrixException with the specified cause
(and a detail message that typically contains the class and detail message of
cause). |
|
| Methods inherited from class java.lang.Throwable |
fillInStackTrace, getCause, getLocalizedMessage, getMessage, getStackTrace, initCause, printStackTrace, printStackTrace, printStackTrace, setStackTrace, toString |
| Methods inherited from class java.lang.Object |
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait |
| Constructor Detail |
InvalidScoringMatrixException
public InvalidScoringMatrixException()
- Constructs an
InvalidScoringMatrixExceptionwith null as its error detail message.
InvalidScoringMatrixException
public InvalidScoringMatrixException(java.lang.String message)
- Constructs an
InvalidScoringMatrixExceptionwith the specified detail message. - Parameters:
message- an error message
InvalidScoringMatrixException
public InvalidScoringMatrixException(java.lang.Throwable cause)
- Constructs an
InvalidScoringMatrixExceptionwith the specified cause (and a detail message that typically contains the class and detail message of cause). - Parameters:
cause- a cause
InvalidScoringMatrixException
public InvalidScoringMatrixException(java.lang.String message, java.lang.Throwable cause)
- Constructs an
InvalidScoringMatrixExceptionwith the specified detail message and cause. - Parameters:
message- an error messagecause- a cause
|
|
||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
NeoBio is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with NeoBio; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
neobio-0.0.20030929/doc/neobio/alignment/IncompatibleScoringSchemeException.html 0000644 0002656 0002032 00000035376 07727746672 026550 0 ustar tillea admin
|
NeoBio API | ||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
neobio.alignment
Class IncompatibleScoringSchemeException
java.lang.Object
|
+--java.lang.Throwable
|
+--java.lang.Exception
|
+--neobio.alignment.IncompatibleScoringSchemeException
- All Implemented Interfaces:
- java.io.Serializable
- public class IncompatibleScoringSchemeException
- extends java.lang.Exception
Signals that an scoring scheme is not compatible with the sequences being aligned.
- Author:
- Sergio A. de Carvalho Jr.
- See Also:
ScoringScheme,PairwiseAlignmentAlgorithm, Serialized Form
| Field Summary |
| Fields inherited from class java.lang.Exception |
|
| Fields inherited from class java.lang.Throwable |
|
| Constructor Summary | |
IncompatibleScoringSchemeException()
Constructs an IncompatibleScoringSchemeException with null as its
error detail message. |
|
IncompatibleScoringSchemeException(java.lang.String message)
Constructs an IncompatibleScoringSchemeException with the specified
detail message. |
|
IncompatibleScoringSchemeException(java.lang.String message,
java.lang.Throwable cause)
Constructs an IncompatibleScoringSchemeException with the specified
detail message and cause. |
|
IncompatibleScoringSchemeException(java.lang.Throwable cause)
Constructs an IncompatibleScoringSchemeException with the specified
cause (and a detail message that typically contains the class and detail message
of cause). |
|
| Methods inherited from class java.lang.Throwable |
fillInStackTrace, getCause, getLocalizedMessage, getMessage, getStackTrace, initCause, printStackTrace, printStackTrace, printStackTrace, setStackTrace, toString |
| Methods inherited from class java.lang.Object |
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait |
| Constructor Detail |
IncompatibleScoringSchemeException
public IncompatibleScoringSchemeException()
- Constructs an
IncompatibleScoringSchemeExceptionwith null as its error detail message.
IncompatibleScoringSchemeException
public IncompatibleScoringSchemeException(java.lang.String message)
- Constructs an
IncompatibleScoringSchemeExceptionwith the specified detail message. - Parameters:
message- an error message
IncompatibleScoringSchemeException
public IncompatibleScoringSchemeException(java.lang.Throwable cause)
- Constructs an
IncompatibleScoringSchemeExceptionwith the specified cause (and a detail message that typically contains the class and detail message of cause). - Parameters:
cause- a cause
IncompatibleScoringSchemeException
public IncompatibleScoringSchemeException(java.lang.String message, java.lang.Throwable cause)
- Constructs an
IncompatibleScoringSchemeExceptionwith the specified detail message and cause. - Parameters:
message- an error messagecause- a cause
|
|
||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
NeoBio is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with NeoBio; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
neobio-0.0.20030929/doc/neobio/alignment/CharSequence.html 0000644 0002656 0002032 00000040344 07727746670 022144 0 ustar tillea admin
|
NeoBio API | ||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
neobio.alignment
Class CharSequence
java.lang.Object | +--neobio.alignment.CharSequence
- public class CharSequence
- extends java.lang.Object
This class implements a sequence of characters stored as an array that provides random access to any position in constant time.
The input can come from any source, provided it is encapsulated in a proper
Reader instance. The stream is expected to be ready (i.e. the next
read operation must return the first character of the sequence) and it is
not closed when its end is reached, so the client is allowed to reset it and maybe use
it for another purpose.
Sequences can contain letters only although lines started with the
COMMENT_CHAR character ('>') are regarded as comments and are completely
skipped. White spaces (including tabs, line feeds and carriage returns) are also
ignored throughout.
This class is used by two sequence alignment algorithms: SmithWaterman and NeedlemanWunsch.
- Author:
- Sergio A. de Carvalho Jr.
- See Also:
SmithWaterman,NeedlemanWunsch
| Field Summary | |
protected static char |
COMMENT_CHAR
The character used to start a comment line in a sequence file. |
protected char[] |
sequence
Stores the sequence as an array of characters. |
| Constructor Summary | |
CharSequence(java.io.Reader reader)
Creates a new instance of a CharSequence, loading the sequence data
from the Reader input stream. |
|
| Method Summary | |
char |
charAt(int pos)
Returns the character at a given position. |
int |
length()
Returns the number of characters of this sequence. |
java.lang.String |
toString()
Returns a string representation of the sequence. |
| Methods inherited from class java.lang.Object |
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait |
| Field Detail |
COMMENT_CHAR
protected static final char COMMENT_CHAR
- The character used to start a comment line in a sequence file. When this character
is found, the rest of the line is ignored.
- See Also:
- Constant Field Values
sequence
protected char[] sequence
- Stores the sequence as an array of characters.
| Constructor Detail |
CharSequence
public CharSequence(java.io.Reader reader) throws java.io.IOException, InvalidSequenceException
- Creates a new instance of a
CharSequence, loading the sequence data from theReaderinput stream. - Parameters:
reader- source of characters for this sequence- Throws:
java.io.IOException- if an I/O exception occurs when reading the inputInvalidSequenceException- if the input does not contain a valid sequence
| Method Detail |
length
public int length()
- Returns the number of characters of this sequence.
- Returns:
- int number of characters of this sequence
charAt
public char charAt(int pos)
- Returns the character at a given position. For the client, the first character is
at position 1, while the last character is at position
length(). This is convinient for sequence alignment algorithms based on a classic dynamic programming matrix since the sequences usually start at row/column 1. This method does not check boundaries, therefore anArrayIndexOutOfBoundsExceptionmay be raised ifposis out of bounds.- Parameters:
pos- position of character (from 1 tolength()inclusive)- Returns:
- the character
toString
public java.lang.String toString()
- Returns a string representation of the sequence.
- Overrides:
toStringin classjava.lang.Object
- Returns:
- a string representation of the sequence
|
|
||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
NeoBio is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with NeoBio; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
neobio-0.0.20030929/doc/neobio/alignment/AlignmentBlock.html 0000644 0002656 0002032 00000043677 07727746670 022503 0 ustar tillea admin
|
NeoBio API | ||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
neobio.alignment
Class AlignmentBlock
java.lang.Object | +--neobio.alignment.AlignmentBlock
- Direct Known Subclasses:
- LocalAlignmentBlock
- public class AlignmentBlock
- extends java.lang.Object
This class is used by the CrochemoreLandauZivUkelson algorithm to store the information of an alignment block. All fields are public (but final) in order to simplify the access to the data.
For more information on how this class is used, please refer to the specification
of the CrochemoreLandauZivUkelson class and it subclasses.
- Author:
- Sergio A. de Carvalho Jr.
- See Also:
CrochemoreLandauZivUkelson
| Field Summary | |
AlignmentBlock[] |
ancestor
An array of pointers to prefix blocks of this block. |
byte[] |
direction
An array of directions that must be followed to reach the source of the highest scoring path for each entry in the output border. |
int[] |
dist_column
The DIST column of this block. |
Factor |
factor1
A pointer to the factor of the first sequence being aligned. |
Factor |
factor2
A pointer to the factor of the second sequence being aligned. |
int[] |
output_border
This block's output border. |
int[] |
source_path
An array of indexes to the source of the highest scoring path for each entry in the output border. |
| Constructor Summary | |
AlignmentBlock(Factor factor1,
Factor factor2)
Creates a new root block. |
|
AlignmentBlock(Factor factor1,
Factor factor2,
int size)
Creates a new alignment block, with all arrays created with the specified size. |
|
| Methods inherited from class java.lang.Object |
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Field Detail |
factor1
public final Factor factor1
- A pointer to the factor of the first sequence being aligned.
factor2
public final Factor factor2
- A pointer to the factor of the second sequence being aligned.
dist_column
public final int[] dist_column
- The DIST column of this block.
ancestor
public final AlignmentBlock[] ancestor
- An array of pointers to prefix blocks of this block.
output_border
public final int[] output_border
- This block's output border.
source_path
public final int[] source_path
- An array of indexes to the source of the highest scoring path for each entry in
the output border.
direction
public final byte[] direction
- An array of directions that must be followed to reach the source of the highest
scoring path for each entry in the output border.
| Constructor Detail |
AlignmentBlock
public AlignmentBlock(Factor factor1, Factor factor2)
- Creates a new root block. A root block does not have
source_pathandancestorarrays. Moreover, itsdist_columnandoutput_borderarrays are set to zero, and thedirectionarray is set to contain anSTOP_DIRECTION. - Parameters:
factor1- factor of the first sequence being alignedfactor2- factor of the second sequence being aligned
AlignmentBlock
public AlignmentBlock(Factor factor1, Factor factor2, int size)
- Creates a new alignment block, with all arrays created with the specified size.
- Parameters:
factor1- factor of the first sequence being alignedfactor2- factor of the second sequence being alignedsize- size of the arrays to be created
|
|
||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
NeoBio is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with NeoBio; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
neobio-0.0.20030929/doc/neobio/alignment/PairwiseAlignmentAlgorithm.html 0000644 0002656 0002032 00000135123 07727746672 025071 0 ustar tillea admin
|
NeoBio API | ||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
neobio.alignment
Class PairwiseAlignmentAlgorithm
java.lang.Object | +--neobio.alignment.PairwiseAlignmentAlgorithm
- Direct Known Subclasses:
- CrochemoreLandauZivUkelson, NeedlemanWunsch, SmithWaterman
- public abstract class PairwiseAlignmentAlgorithm
- extends java.lang.Object
This abstract class is the superclass of all classes implementing pairwise sequence alignment algorithms. Subclasses are required to provide methods to build a high scoring alignment between two sequences and compute its score with a given scoring scheme.
Clients are required to set a scoring scheme and load two sequences before requesting an alignment or the computation of its score. They typically make the following sequence of method calls:
// prepare
PairwiseAlignmentAlgorithm algorithm = new SomePairwiseAlignmentAlgorith ();
algorithm.setScoringScheme (some_scoring_scheme);
algorithm.loadSequences (sequence1, sequence2);
// now compute the alignment
PairwiseAlignment alignment = algorithm.getPairwiseAlignment();
int score = algorithm.getScore();
- Author:
- Sergio A. de Carvalho Jr.
- See Also:
PairwiseAlignment
| Field Summary | |
protected PairwiseAlignment |
alignment
Stores the product of the last pairwise alignment performed. |
protected static char |
APPROXIMATE_MATCH_TAG
Tag character that signals an approximate match in the score tag line of an alignment. |
protected static char |
GAP_CHARACTER
Character that signals a gap in sequence. |
protected static char |
GAP_TAG
Character that signals a gap in the score tag line of an alignment. |
protected static char |
MATCH_TAG
Tag character that signals a match in the score tag line of an alignment. |
protected static char |
MISMATCH_TAG
Character that signals a mismatch in the score tag line of an alignment. |
protected int |
score
This field stores just the score of the last pairwise alignment performed (if the score_computed flag is set to true). |
protected boolean |
score_computed
Flags whether the score of the alignment between the last two loaded sequences has already been computed. |
protected ScoringScheme |
scoring
The scoring scheme used to compute a pairwise sequence alignment. |
protected boolean |
sequences_loaded
Flags whether sequences have been loaded. |
protected boolean |
use_match_tag
Indicates if the MATCH_TAG tag should be used or not. |
| Constructor Summary | |
PairwiseAlignmentAlgorithm()
|
|
| Method Summary | |
protected abstract PairwiseAlignment |
computePairwiseAlignment()
Subclasses must implement this method to compute an alignment between the loaded sequences using the scoring scheme previously set. |
protected abstract int |
computeScore()
Subclasses must implement this method to compute the score of the alignment between the loaded sequences using the scoring scheme previously set. |
PairwiseAlignment |
getPairwiseAlignment()
Return the last pairwise alignment computed (if any) or request subclasses to compute one and return the result by calling the computePairwiseAlignment method. |
int |
getScore()
Returns the score of the last alignment computed (if any) or request subclasses to compute one and return the result by calling the computeScore method.
|
void |
loadSequences(java.io.Reader input1,
java.io.Reader input2)
Request subclasses to load the sequences according to their own needs. |
protected abstract void |
loadSequencesInternal(java.io.Reader input1,
java.io.Reader input2)
Subclasses must implement this method to load sequences according to their own needs and throw an exception in case of any failure. |
protected int |
max(int v1,
int v2)
Helper method to compute the the greater of two values. |
protected int |
max(int v1,
int v2,
int v3)
Helper method to compute the the greater of three values. |
protected int |
max(int v1,
int v2,
int v3,
int v4)
Helper method to compute the the greater of four values. |
protected int |
scoreDeletion(char a)
Helper method to invoke the scoreDeletion method of the scoring scheme
set to this algorithm. |
protected int |
scoreInsertion(char a)
Helper method to invoke the scoreInsertion method of the scoring
scheme set to this algorithm. |
protected int |
scoreSubstitution(char a,
char b)
Helper method to invoke the scoreSubstitution method of the scoring
scheme set to this algorithm. |
void |
setScoringScheme(ScoringScheme scoring)
Sets the scoring scheme to be used for the next alignments. |
void |
unloadSequences()
Frees pointer to loaded sequences and computed alignments (if any) so that their data can be garbage collected. |
protected abstract void |
unloadSequencesInternal()
Subclasses must implement this method to unload sequences according to their own storage, freeing pointers to sequences and any intermediate data so that they can be garbage collected. |
protected boolean |
useMatchTag()
Tells wether the MATCH_TAG tag should be used or not. |
| Methods inherited from class java.lang.Object |
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Field Detail |
MATCH_TAG
protected static final char MATCH_TAG
- Tag character that signals a match in the score tag line of an alignment. Its use
is conditioned by the
use_match_tagflag.- See Also:
use_match_tag,useMatchTag(), Constant Field Values
APPROXIMATE_MATCH_TAG
protected static final char APPROXIMATE_MATCH_TAG
- Tag character that signals an approximate match in the score tag line of an
alignment.
- See Also:
- Constant Field Values
MISMATCH_TAG
protected static final char MISMATCH_TAG
- Character that signals a mismatch in the score tag line of an alignment.
- See Also:
- Constant Field Values
GAP_TAG
protected static final char GAP_TAG
- Character that signals a gap in the score tag line of an alignment.
- See Also:
- Constant Field Values
GAP_CHARACTER
protected static final char GAP_CHARACTER
- Character that signals a gap in sequence.
- See Also:
- Constant Field Values
use_match_tag
protected boolean use_match_tag
- Indicates if the
MATCH_TAGtag should be used or not. If it istrue, the alignment algorithm should write theMATCH_TAGtag in the score tag line of the alignment whenever a match occurs between characters of the two sequences. If it isfalsethe matching character should be written instead. This flag is updated whenever a scoring scheme is set to thisPairwiseAlignmentAlgorithmby thesetScoringSchememethod.
scoring
protected ScoringScheme scoring
- The scoring scheme used to compute a pairwise sequence alignment. It must be set
before performing the alignment, and if a new scoring scheme is set, any alignment
or score already computed is lost.
alignment
protected PairwiseAlignment alignment
- Stores the product of the last pairwise alignment performed. It contains a string
representation of a highest scoring alignment between the two sequences and its
score. It is set after a successful execution of the
computePairwiseAlignmentmethod that subclasses must implement. It is set to null if new sequences are loaded or a new scoring scheme is set.
score
protected int score
- This field stores just the score of the last pairwise alignment performed (if the
score_computed flagis set to true). It is useful when just the score is needed (and not the alignment itselft). Its value is set after a successful execution of bothcomputePairwiseAlignmentorcomputeScoremethods that subclasses must implement. If new sequences are loaded or a new scoring scheme is set, thescore_computedflag is set to false, and this field's value becomes undefined.
score_computed
protected boolean score_computed
- Flags whether the score of the alignment between the last two loaded sequences has
already been computed. It is set to true after a successful execution of both
computePairwiseAlignmentorcomputeScoremethods that subclasses must implement. It is set to falsef if new sequences are loaded or a new scoring scheme is set.
sequences_loaded
protected boolean sequences_loaded
- Flags whether sequences have been loaded. It is set to true after subclasses
successfully load two sequences.
| Constructor Detail |
PairwiseAlignmentAlgorithm
public PairwiseAlignmentAlgorithm()
| Method Detail |
setScoringScheme
public void setScoringScheme(ScoringScheme scoring)
- Sets the scoring scheme to be used for the next alignments. Any alignment or score
already computed is lost. If the scoring scheme supports partial matches, this
PairwiseAlignmentAlgorithmis set not to use theMATCH_TAGtag because in this case the score tag line be confusing. If the scoring scheme does not support partial matches, then the use of theMATCH_TAGtag is enabled.- Parameters:
scoring- Scoring scheme to be used- See Also:
MATCH_TAG,ScoringScheme.isPartialMatchSupported()
useMatchTag
protected boolean useMatchTag()
- Tells wether the
MATCH_TAGtag should be used or not. If it returnstrue, the alignment algorithm should write theMATCH_TAGtag in the score tag line of the alignment produced whenever a match occurs between characters of the two sequences. If it returnsfalsethe matching character should be written instead. The value returned is conditioned by theuse_match_tagflag, which is updated whenever a scoring scheme is set to thisPairwiseAlignmentAlgorithmby thesetScoringSchememethod.- Returns:
trueMATCH_TAG tag should be used,falseotherwise- See Also:
MATCH_TAG,use_match_tag,setScoringScheme(neobio.alignment.ScoringScheme)
loadSequences
public void loadSequences(java.io.Reader input1, java.io.Reader input2) throws java.io.IOException, InvalidSequenceException
- Request subclasses to load the sequences according to their own needs. Any
alignment and score already computed is lost. If no exception is raised, the loaded
flag is set to true. Subclasses typically store the sequences in instances of an
appropiate class and each can have its own contract, so check each algorithm to see
what kind of sequences it produces. Input can come from any source provided they
are encapsulated with a proper Reader. They must be ready to be read, i.e. the next
read operation must return the sequence's first character.
- Parameters:
input1- First sequenceinput2- Second sequence- Throws:
java.io.IOException- If an I/O error occurs when reading the sequencesInvalidSequenceException- If the sequences are not valid
unloadSequences
public void unloadSequences()
- Frees pointer to loaded sequences and computed alignments (if any) so that their
data can be garbage collected.
getPairwiseAlignment
public PairwiseAlignment getPairwiseAlignment() throws IncompatibleScoringSchemeException
- Return the last pairwise alignment computed (if any) or request subclasses to
compute one and return the result by calling the
computePairwiseAlignmentmethod. The sequences must already be loaded and a scoring scheme must already be set.- Returns:
- a pairwise alignment between the loaded sequences
- Throws:
IncompatibleScoringSchemeException- If the scoring scheme is not compatible with the loaded sequences- See Also:
computePairwiseAlignment()
getScore
public int getScore() throws IncompatibleScoringSchemeException
- Returns the score of the last alignment computed (if any) or request subclasses to
compute one and return the result by calling the
computeScoremethod. The sequences must already be loaded and a scoring scheme must already be set.- Returns:
- the score of the alignment between the loaded sequences
- Throws:
IncompatibleScoringSchemeException- If the scoring scheme is not compatible with the loaded sequences- See Also:
computeScore()
loadSequencesInternal
protected abstract void loadSequencesInternal(java.io.Reader input1, java.io.Reader input2) throws java.io.IOException, InvalidSequenceException
- Subclasses must implement this method to load sequences according to their own
needs and throw an exception in case of any failure. If no exception is raised, the
loaded flag is set to true by the public method and the sequences are believed to
be loaded (so an alignment or score can be requested).
- Parameters:
input1- First sequenceinput2- Second sequence- Throws:
java.io.IOException- If an I/O error occurs when reading the sequencesInvalidSequenceException- If the sequences are not valid- See Also:
loadSequences(java.io.Reader, java.io.Reader),CharSequence,FactorSequence
unloadSequencesInternal
protected abstract void unloadSequencesInternal()
- Subclasses must implement this method to unload sequences according to their own
storage, freeing pointers to sequences and any intermediate data so that they can
be garbage collected. This methid is called by the public
unloadSequencesmethod.- See Also:
unloadSequences()
computePairwiseAlignment
protected abstract PairwiseAlignment computePairwiseAlignment() throws IncompatibleScoringSchemeException
- Subclasses must implement this method to compute an alignment between the loaded
sequences using the scoring scheme previously set. This methid is called by the
getPairwiseAlignmentmethod when needed.- Returns:
- a pairwise alignment between the loaded sequences
- Throws:
IncompatibleScoringSchemeException- If the scoring scheme is not compatible with the loaded sequences- See Also:
getPairwiseAlignment()
computeScore
protected abstract int computeScore() throws IncompatibleScoringSchemeException
- Subclasses must implement this method to compute the score of the alignment between
the loaded sequences using the scoring scheme previously set. This methid is called
by the
getScoremethod when needed.- Returns:
- the score of the alignment between the loaded sequences
- Throws:
IncompatibleScoringSchemeException- If the scoring scheme is not compatible with the loaded sequences- See Also:
getScore()
scoreSubstitution
protected final int scoreSubstitution(char a, char b) throws IncompatibleScoringSchemeException
- Helper method to invoke the
scoreSubstitutionmethod of the scoring scheme set to this algorithm.- Parameters:
a- first characterb- second character- Returns:
- score of substitution of
aforb - Throws:
IncompatibleScoringSchemeException- if the scoring scheme is not compatible with the sequences being aligned- See Also:
ScoringScheme.scoreSubstitution(char, char)
scoreInsertion
protected final int scoreInsertion(char a) throws IncompatibleScoringSchemeException
- Helper method to invoke the
scoreInsertionmethod of the scoring scheme set to this algorithm.- Parameters:
a- the character to be inserted- Returns:
- score of insertion of
a - Throws:
IncompatibleScoringSchemeException- if the scoring scheme is not compatible with the sequences being aligned- See Also:
ScoringScheme.scoreInsertion(char)
scoreDeletion
protected final int scoreDeletion(char a) throws IncompatibleScoringSchemeException
- Helper method to invoke the
scoreDeletionmethod of the scoring scheme set to this algorithm.- Parameters:
a- the character to be deleted- Returns:
- score of deletion of
a - Throws:
IncompatibleScoringSchemeException- if the scoring scheme is not compatible with the sequences being aligned- See Also:
ScoringScheme.scoreDeletion(char)
max
protected final int max(int v1, int v2)
- Helper method to compute the the greater of two values.
- Parameters:
v1- first valuev2- second value- Returns:
- the larger of
v1andv2
max
protected final int max(int v1, int v2, int v3)
- Helper method to compute the the greater of three values.
- Parameters:
v1- first valuev2- second valuev3- third value- Returns:
- the larger of
v1,v2andv3
max
protected final int max(int v1, int v2, int v3, int v4)
- Helper method to compute the the greater of four values.
- Parameters:
v1- first valuev2- second valuev3- third valuev4- fourth value- Returns:
- the larger of
v1,v2v3andv4
|
|
||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
NeoBio is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with NeoBio; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
neobio-0.0.20030929/doc/neobio/alignment/NeedlemanWunsch.html 0000644 0002656 0002032 00000070744 07727746672 022667 0 ustar tillea admin
|
NeoBio API | ||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
neobio.alignment
Class NeedlemanWunsch
java.lang.Object | +--neobio.alignment.PairwiseAlignmentAlgorithm | +--neobio.alignment.NeedlemanWunsch
- public class NeedlemanWunsch
- extends PairwiseAlignmentAlgorithm
This class implements the classic global alignment algorithm (with linear gap penalty function) due to S.B.Needleman and C.D.Wunsch (1970).
It is based on a dynamic programming approach. The idea consists of, given two sequences A and B of sizes n and m, respectively, building an (n+1 x m+1) matrix M that contains the similarity of prefixes of A and B. Every position M[i,j] in the matrix holds the score between the subsequences A[1..i] and B[1..j]. The first row and column represent alignments with spaces.
Starting from row 0, column 0, the algorithm computes each position M[i,j] with the following recurrence:
M[0,0] = 0
M[i,j] = max { M[i,j-1] + scoreInsertion (B[j]),
M[i-1,j-1] + scoreSubstitution (A[i], B[j]),
M[i-1,j] + scoreDeletion(A[i]) }
In the end, the value at the last position (last row, last column) will contain
the similarity between the two sequences. This part of the algorithm is accomplished
by the computeMatrix method. It has quadratic space complexity
since it needs to keep an (n+1 x m+1) matrix in memory. And since the work of computing
each cell is constant, it also has quadratic time complexity.
After the matrix has been computed, the alignment can be retrieved by tracing a path
back in the matrix from the last position to the first. This step is performed by
the buildOptimalAlignment method, and since the path can
be roughly as long as (m + n), this method has O(n) time complexity.
If the similarity value only is needed (and not the alignment itself), it is easy to
reduce the space requirement to O(n) by keeping just the last row or column in memory.
This is precisely what is done by the computeScore method. Note
that it still requires O(n2) time.
For a more efficient approach to the global alignment problem, see the CrochemoreLandauZivUkelson algorithm. For local alignment, see the SmithWaterman algorithm.
- Author:
- Sergio A. de Carvalho Jr.
- See Also:
SmithWaterman,CrochemoreLandauZivUkelson,CrochemoreLandauZivUkelsonLocalAlignment,CrochemoreLandauZivUkelsonGlobalAlignment
| Field Summary | |
protected int[][] |
matrix
The dynamic programming matrix. |
protected CharSequence |
seq1
The first sequence of an alignment. |
protected CharSequence |
seq2
The second sequence of an alignment. |
| Fields inherited from class neobio.alignment.PairwiseAlignmentAlgorithm |
alignment, APPROXIMATE_MATCH_TAG, GAP_CHARACTER, GAP_TAG, MATCH_TAG, MISMATCH_TAG, score, score_computed, scoring, sequences_loaded, use_match_tag |
| Constructor Summary | |
NeedlemanWunsch()
|
|
| Method Summary | |
protected PairwiseAlignment |
buildOptimalAlignment()
Builds an optimal global alignment between the loaded sequences. |
protected void |
computeMatrix()
Computes the dynamic programming matrix. |
protected PairwiseAlignment |
computePairwiseAlignment()
Builds an optimal global alignment between the loaded sequences after computing the dynamic programming matrix. |
protected int |
computeScore()
Computes the score of the best global alignment between the two sequences using the scoring scheme previously set. |
protected void |
loadSequencesInternal(java.io.Reader input1,
java.io.Reader input2)
Loads sequences into CharSequence instances. |
protected void |
unloadSequencesInternal()
Frees pointers to loaded sequences and the dynamic programming matrix so that their data can be garbage collected. |
| Methods inherited from class neobio.alignment.PairwiseAlignmentAlgorithm |
getPairwiseAlignment, getScore, loadSequences, max, max, max, scoreDeletion, scoreInsertion, scoreSubstitution, setScoringScheme, unloadSequences, useMatchTag |
| Methods inherited from class java.lang.Object |
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Field Detail |
seq1
protected CharSequence seq1
- The first sequence of an alignment.
seq2
protected CharSequence seq2
- The second sequence of an alignment.
matrix
protected int[][] matrix
- The dynamic programming matrix. Each position (i, j) represents the best score
between the firsts i characters of
seq1and j characters ofseq2.
| Constructor Detail |
NeedlemanWunsch
public NeedlemanWunsch()
| Method Detail |
loadSequencesInternal
protected void loadSequencesInternal(java.io.Reader input1, java.io.Reader input2) throws java.io.IOException, InvalidSequenceException
- Loads sequences into CharSequence instances. In case of any error,
an exception is raised by the constructor of
CharSequence(please check the specification of that class for specific requirements).- Specified by:
loadSequencesInternalin classPairwiseAlignmentAlgorithm
- Parameters:
input1- Input for first sequenceinput2- Input for second sequence- Throws:
java.io.IOException- If an I/O error occurs when reading the sequencesInvalidSequenceException- If the sequences are not valid- See Also:
CharSequence
unloadSequencesInternal
protected void unloadSequencesInternal()
- Frees pointers to loaded sequences and the dynamic programming matrix so that their
data can be garbage collected.
- Specified by:
unloadSequencesInternalin classPairwiseAlignmentAlgorithm
computePairwiseAlignment
protected PairwiseAlignment computePairwiseAlignment() throws IncompatibleScoringSchemeException
- Builds an optimal global alignment between the loaded sequences after computing the
dynamic programming matrix. It calls the
buildOptimalAlignmentmethod after thecomputeMatrixmethod computes the dynamic programming matrix.- Specified by:
computePairwiseAlignmentin classPairwiseAlignmentAlgorithm
- Returns:
- an optimal global alignment between the loaded sequences
- Throws:
IncompatibleScoringSchemeException- If the scoring scheme is not compatible with the loaded sequences.- See Also:
computeMatrix(),buildOptimalAlignment()
computeMatrix
protected void computeMatrix() throws IncompatibleScoringSchemeException
- Computes the dynamic programming matrix.
- Throws:
IncompatibleScoringSchemeException- If the scoring scheme is not compatible with the loaded sequences.
buildOptimalAlignment
protected PairwiseAlignment buildOptimalAlignment() throws IncompatibleScoringSchemeException
- Builds an optimal global alignment between the loaded sequences. Before it is
executed, the dynamic programming matrix must already have been computed by
the
computeMatrixmethod.- Returns:
- an optimal global alignment between the loaded sequences
- Throws:
IncompatibleScoringSchemeException- If the scoring scheme is not compatible with the loaded sequences.- See Also:
computeMatrix()
computeScore
protected int computeScore() throws IncompatibleScoringSchemeException
- Computes the score of the best global alignment between the two sequences using the
scoring scheme previously set. This method calculates the similarity value only
(doesn't build the whole matrix so the alignment cannot be recovered, however it
has the advantage of requiring O(n) space only).
- Specified by:
computeScorein classPairwiseAlignmentAlgorithm
- Returns:
- score of the best global alignment between the loaded sequences
- Throws:
IncompatibleScoringSchemeException- If the scoring scheme is not compatible with the loaded sequences.- See Also:
PairwiseAlignmentAlgorithm.getScore()
|
|
||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
NeoBio is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with NeoBio; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
neobio-0.0.20030929/doc/neobio/alignment/Matrix.html 0000644 0002656 0002032 00000024472 07727746670 021046 0 ustar tillea admin
|
NeoBio API | ||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
neobio.alignment
Interface Matrix
- All Known Implementing Classes:
- OutMatrix
- public interface Matrix
This interface defines a minimal set of operations that a matrix must implement. This interface is used by the Smawk class to provide a general services regardless of how the matrix is actually stored.
- Author:
- Sergio A. de Carvalho Jr.
- See Also:
Smawk
| Method Summary | |
int |
numColumns()
Returns the number of columns that this matrix has. |
int |
numRows()
Returns the number of rows that this matrix has. |
int |
valueAt(int row,
int col)
Returns the value at an specified row and column. |
| Method Detail |
valueAt
public int valueAt(int row, int col)
- Returns the value at an specified row and column.
- Parameters:
row- row number of element to be retrievedcol- column number of element to be retrieved- Returns:
- value at row
rowcolumncol
numRows
public int numRows()
- Returns the number of rows that this matrix has.
- Returns:
- number of rows
numColumns
public int numColumns()
- Returns the number of columns that this matrix has.
- Returns:
- number of columns
|
|
||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
NeoBio is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with NeoBio; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
neobio-0.0.20030929/doc/neobio/alignment/package-tree.html 0000644 0002656 0002032 00000022225 07727746670 022124 0 ustar tillea admin
|
NeoBio API | ||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||
Hierarchy For Package neobio.alignment
- Package Hierarchies:
- All Packages
Class Hierarchy
- class java.lang.Object
- class neobio.alignment.AlignmentBlock
- class neobio.alignment.LocalAlignmentBlock
- class neobio.alignment.CharSequence
- class neobio.alignment.Factor
- class neobio.alignment.FactorSequence
- class neobio.alignment.OutMatrix (implements neobio.alignment.Matrix)
- class neobio.alignment.PairwiseAlignment (implements java.io.Serializable)
- class neobio.alignment.PairwiseAlignmentAlgorithm
- class neobio.alignment.CrochemoreLandauZivUkelson
- class neobio.alignment.CrochemoreLandauZivUkelsonGlobalAlignment
- class neobio.alignment.CrochemoreLandauZivUkelsonLocalAlignment
- class neobio.alignment.NeedlemanWunsch
- class neobio.alignment.SmithWaterman
- class neobio.alignment.CrochemoreLandauZivUkelson
- class neobio.alignment.ScoringScheme
- class neobio.alignment.BasicScoringScheme
- class neobio.alignment.ScoringMatrix
- class neobio.alignment.Smawk
- class java.lang.Throwable (implements java.io.Serializable)
- class java.lang.Exception
- class neobio.alignment.IncompatibleScoringSchemeException
- class neobio.alignment.InvalidScoringMatrixException
- class neobio.alignment.InvalidSequenceException
- class java.lang.Exception
- class neobio.alignment.Trie
- class neobio.alignment.AlignmentBlock
Interface Hierarchy
- interface neobio.alignment.Matrix
|
|
||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||
NeoBio is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with NeoBio; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
neobio-0.0.20030929/doc/neobio/alignment/Factor.html 0000644 0002656 0002032 00000056170 07727746672 021022 0 ustar tillea admin
|
NeoBio API | ||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
neobio.alignment
Class Factor
java.lang.Object | +--neobio.alignment.Factor
- public class Factor
- extends java.lang.Object
This class is used by FactorSequence to create a linked list of factors of a text as induced by its Lempel-Ziv (LZ78) factorisation.
Each instance of this class represent a string composed of its an ancestor factor's string plus one character, and contains:
- a pointer to its ancestor factor (the longest factor previously seen in the text during its LZ78 factorisation);
- the new character;
- a serial number (which represents its order in the text)
- a pointer to the next factor of the text
- its length (number of characters, which is equal to its ancestor's length plus one)
- Author:
- Sergio A. de Carvalho Jr.
- See Also:
FactorSequence
| Field Summary | |
protected Factor |
ancestor
A pointer to this factor's ancestor, which represents a prefix of this factor's text. |
protected int |
length
The number of characters of the text represented by this factor. |
protected char |
new_char
The new character of this factor. |
protected Factor |
next
A pointer to the next factor. |
protected int |
serial_number
This factor's serial number, which indicates the order of this factor inside the linked list of factors of a text. |
| Constructor Summary | |
Factor()
Creates a new empty Factor. |
|
Factor(Factor ancestor,
int serial_number,
char new_char)
Creates a new Factor instance with the specified serial number and
new character, and pointing to the given ancestor. |
|
| Method Summary | |
Factor |
getAncestor()
Returns this factor's ancestor factor. |
int |
getAncestorSerialNumber()
This method is a shorthand to return the serial number of this factor's ancestor. |
char |
getNewChar()
Returns this factor's new character. |
Factor |
getNext()
Returns this factor's next factor. |
int |
getSerialNumber()
Returns this factor's serial number. |
int |
length()
Returns this factor's length. |
void |
setNext(Factor next)
Sets this factor's next pointer to point to the specified factor.
|
java.lang.String |
toString()
Returns a string representation of the text represented by this factor. |
| Methods inherited from class java.lang.Object |
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait |
| Field Detail |
ancestor
protected Factor ancestor
- A pointer to this factor's ancestor, which represents a prefix of this factor's
text.
next
protected Factor next
- A pointer to the next factor.
serial_number
protected int serial_number
- This factor's serial number, which indicates the order of this factor inside the
linked list of factors of a text.
length
protected int length
- The number of characters of the text represented by this factor.
new_char
protected char new_char
- The new character of this factor.
| Constructor Detail |
Factor
public Factor()
- Creates a new empty
Factor. It has no ancestor and no character (both are set tonull). Its serial number is set to zero as well as its length.This constructor is used to initiate the a linked list of factors of a text. Its
nextpointer is initiallynull, but it is typically set to point to the first factor afterwards (with thesetNextmethod). - See Also:
setNext(neobio.alignment.Factor)
Factor
public Factor(Factor ancestor, int serial_number, char new_char)
- Creates a new
Factorinstance with the specified serial number and new character, and pointing to the given ancestor. Its length is set to its ancestor's length plus 1.Its
nextpointer is initiallynull, but it is typically set to point to the next factor afterwards (with thesetNextmethod). - Parameters:
ancestor- this factor's ancestorserial_number- this factor's serial numbernew_char- this factor's new character- See Also:
setNext(neobio.alignment.Factor)
| Method Detail |
setNext
public void setNext(Factor next)
- Sets this factor's
nextpointer to point to the specified factor. Although the next factor has typically a serial number equal to this factor's serial number plus 1, no attempt is made to guarantee this rule. This allows special constructs or a different order in the factorisation.- Parameters:
next- the factor that will be pointed to- See Also:
getNext()
getAncestor
public Factor getAncestor()
- Returns this factor's ancestor factor.
- Returns:
- this factor's ancestor factor
getAncestorSerialNumber
public int getAncestorSerialNumber()
- This method is a shorthand to return the serial number of this factor's ancestor.
Note that it does not check if this factor has an ancestor or not, therefore, if
it is called on the root factor, a NullPointerException is raised.
- Returns:
- the serial number of this factor's ancestor
getNext
public Factor getNext()
- Returns this factor's next factor.
- Returns:
- this factor's next factor
- See Also:
setNext(neobio.alignment.Factor)
getSerialNumber
public int getSerialNumber()
- Returns this factor's serial number.
- Returns:
- this factor's serial number
length
public int length()
- Returns this factor's length.
- Returns:
- this factor's length
getNewChar
public char getNewChar()
- Returns this factor's new character.
- Returns:
- this factor's new character
toString
public java.lang.String toString()
- Returns a string representation of the text represented by this factor. It inspects
its chain of ancestors up until as far as the root factor, spelling their new
characters out.
- Overrides:
toStringin classjava.lang.Object
- Returns:
- a string representation of the text denoted by this factor
|
|
||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
NeoBio is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with NeoBio; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
neobio-0.0.20030929/doc/neobio/alignment/Trie.html 0000644 0002656 0002032 00000060546 07727746672 020511 0 ustar tillea admin
|
NeoBio API | ||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
neobio.alignment
Class Trie
java.lang.Object | +--neobio.alignment.Trie
- public class Trie
- extends java.lang.Object
This class implements a trie, or a digital search tree. A trie is a multiway tree (each node can have multiple children) that represents a set of strings.
Each node contains data encapsulated in an object instance. Each edge spells out a character and each path from the root represents a string described by the characters labelling the traversed edges. Moreover, for each string represented, there is a unique path from the root.
The trie of the following example represents the strings 'a', 'd', 'b', 'ac', 'ba', 'be', 'bd', 'bad' and 'bae'.
[0]
--+--
/ | \
a/ d| \b
[1] [2] [4]
| --+--
| / | \
c| a/ e| d\
[3] [5] [6] [9]
--+--
/ \
d/ e\
[7] [8]
It is easy to see that strings with common prefixes will branch off from each other at the first distinguishing character. This feature makes the trie a good data structure to identify and represent phrases of a text such as the ones induced by the Lempel-Ziv familiy of compression algorithms. For instance, the LZ78 version parses the text into phrases, where each phrase is the longest matching phrase seen previously plus one character.
In this implementation, each node is actually an instance of this class. To build a trie, one must first create the root using the public constructor:
Trie root = new Trie (some_object);
Here some_object contains any relevant information encapsulated in an
object instance. Typically, that's the only moment the public constructor is used. From
now on, all new nodes will be added as a new child of one existing node using the
add method:
new_node = any_node.add (some_object, character);
Here character is the character that will label the edge from
any_node to new_node. Note that this transition must not
already exist, otherwise an exception is raised.
To find the longest prefix of a given string, we follow a path from the root down
the tree, character by character, with the spellDown method:
next_node = root;
while (next_node != null)
{
current_node = next_node;
char c = get next character from somewhere
next_node = current_node.spellDown (c);
}
spellDown follows the edge out of current_node labelled by
the character c and returns the next node. If there is no such a path, it
returns null.
To retrieve the information stored at any node, simply use the getData
method.
In fact, there are many ways to implement a trie. To avoid wasting space with multiple pointers at each node, this implementation uses an approach with a linked list of siblings. Each node actually contains a pointer to one of its children and a pointer to one of its siblings only. Together with the pointers, each node also stores the character that labels the edge to the pointed node.
[0]
|
a| d b
[1]---[2]---[4]
| |
c| a| e d
[3] [5]---[6]---[9]
|
d| e
[7]---[8]
In this way, a trie is similar to a binary tree. Although this implementation is
more efficient in terms of space, the search for a label with a given character leaving
a node n is no more constant but proportional to the number of children of
n. In the previous example, it is necessary to traverse three edges to
reach node 9 from node 4 with character d.
This class is used by the FactorSequence to build a linked list of factors of a sequence in a LZ78 fashion, i.e. where each factor is the longest factor previously seen plus one character.
- Author:
- Sergio A. de Carvalho Jr.
- See Also:
FactorSequence
| Field Summary | |
protected java.lang.Object |
data
This node's stored data. |
protected Trie |
sibling
A pointer to this node's next sibling. |
protected Trie |
son
A pointer to the first of this node's children. |
protected char |
to_sibling
The character that labels the edge from this node to the sibling pointer by sibling. |
protected char |
to_son
The character that labels the edge from this node to the child node pointer by son. |
| Constructor Summary | |
Trie(java.lang.Object data)
Creates a new trie node with the specified data. |
|
| Method Summary | |
Trie |
add(java.lang.Object data,
char c)
Adds a new child to this node. |
protected Trie |
addSibling(java.lang.Object data,
char c)
Adds a sibling to this node. |
java.lang.Object |
getData()
Returns the data associated with this node. |
Trie |
spellDown(char c)
Follows a path from this node to one of its children by spelling the character supplied as an argument. |
protected Trie |
spellRight(char c)
Follows a path from this node to one of its sibling by spelling the character supplied as an argument. |
| Methods inherited from class java.lang.Object |
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Field Detail |
son
protected Trie son
- A pointer to the first of this node's children.
to_son
protected char to_son
- The character that labels the edge from this node to the child node pointer by
son.
sibling
protected Trie sibling
- A pointer to this node's next sibling.
to_sibling
protected char to_sibling
- The character that labels the edge from this node to the sibling pointer by
sibling.
data
protected java.lang.Object data
- This node's stored data.
| Constructor Detail |
Trie
public Trie(java.lang.Object data)
- Creates a new trie node with the specified data. This constructor is typically used
by the client only once to instantiate the root node. After that, all new nodes are
implicitly instantiated by the
addmethod. - Parameters:
data- the data that will be associated with the new node
| Method Detail |
getData
public java.lang.Object getData()
- Returns the data associated with this node.
- Returns:
- data associated with this node
add
public Trie add(java.lang.Object data, char c)
- Adds a new child to this node. The new node will be implicitly instantiated with
the
dataargument, and the edge from this node to the new node will be labelled by the character argument. If this node already have an edge labelled with this character, an exception is raised. Otherwise, the new node created and returned.If this node have no child, a new node is created straight away. Otherwise, the task is assigned to its first child that will add the new node as a sibling.
- Parameters:
data- the data that will be associated with the new nodec- the character that will label the edge from this node to the new node- Returns:
- the added node
- Throws:
java.lang.IllegalStateException- if this node already have an edge labelled byc
addSibling
protected Trie addSibling(java.lang.Object data, char c)
- Adds a sibling to this node. The new node will be implicitly instantiated with
the
dataargument, and the edge from this node to the new node will be labelled by the character argument. If this node already have a sibling with this character, an exception is raised. Otherwise, the new node is created and returned.If this node have no direct sibling, a new node is created straight away. Otherwise, the task is assigned to its next sibling.
- Parameters:
data- the data that will be associated with the new nodec- the character that will label the edge from this node to the new node- Returns:
- the added node
- Throws:
java.lang.IllegalStateException- if this node already have an edge labelled byc
spellDown
public Trie spellDown(char c)
- Follows a path from this node to one of its children by spelling the character
supplied as an argument. If there is no such a path,
nullis returned. Otherwise, the reached child node is returned.If this node's direct child is reached with an edge labelled by the character, it is returned straight away. Otherwise, it is assigned the task of finding another sibling labelled with that character.
- Parameters:
c- the character that labels the path to be followed to this node's child- Returns:
- the child node reached by traversing the edge labelled by
c
spellRight
protected Trie spellRight(char c)
- Follows a path from this node to one of its sibling by spelling the character
supplied as an argument. If there is no such a path,
nullis returned. Otherwise, the reached sibling node is returned.If this node's direct sibling is reached with an edge labelled by the character, it is returned straight away. Otherwise, it is assigned the task of finding another sibling labelled with that character.
- Parameters:
c- the character that labels the path to be followed to the sibling- Returns:
- the sibling node reached by traversing the edge labelled by
c
|
|
||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
NeoBio is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with NeoBio; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
neobio-0.0.20030929/doc/neobio/alignment/BasicScoringScheme.html 0000644 0002656 0002032 00000061005 07727746670 023266 0 ustar tillea admin
|
NeoBio API | ||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
neobio.alignment
Class BasicScoringScheme
java.lang.Object | +--neobio.alignment.ScoringScheme | +--neobio.alignment.BasicScoringScheme
- public class BasicScoringScheme
- extends ScoringScheme
This class implements a basic scoring scheme. At least three parameters must be provided to the constructor: the reward for a match (a substitution of equal characters), the penalty for a mismatch (a substitution of different characters) and the cost of a gap (an insertion or deletion of a character). Note that it only supports an additive gap cost function.
Although the match reward is expected to be a positive value, and the mismatch penalty and the gap cost are expected to be negative, no attempt is made to enforce these behaviour.
- Author:
- Sergio A. de Carvalho Jr.
| Field Summary | |
protected int |
gap_cost
The cost of a gap (an insertion or deletion of a character). |
protected int |
match_reward
The reward for a match (a substitution of equal characters). |
protected int |
max_absolute_score
The maximum absolute score that this scoring scheme can return, which is the maximum absolute value among match_reward,
mismatch_penalty and gap_cost. |
protected int |
mismatch_penalty
The penalty for a mismatch (a substitution of different characters). |
| Fields inherited from class neobio.alignment.ScoringScheme |
case_sensitive |
| Constructor Summary | |
BasicScoringScheme(int match_reward,
int mismatch_penalty,
int gap_cost)
Creates a new instance of a basic scoring scheme with the specified values of match reward, mismatch penalty and gap cost. |
|
BasicScoringScheme(int match_reward,
int mismatch_penalty,
int gap_cost,
boolean case_sensitive)
Creates a new instance of basic scoring scheme with the specified values of match reward, mismatch penalty and gap cost. |
|
| Method Summary | |
boolean |
isPartialMatchSupported()
Tells whether this scoring scheme supports partial matches, which it does not. |
int |
maxAbsoluteScore()
Returns the maximum absolute score that this scoring scheme can return for any substitution, deletion or insertion, which is the maximum absolute value among match_reward, mismatch_penalty and
gap_cost. |
int |
scoreDeletion(char a)
Always returns gap_cost for the deletion of any character. |
int |
scoreInsertion(char a)
Always returns gap_cost for the insertion of any character. |
int |
scoreSubstitution(char a,
char b)
Returns the score of a substitution of character a for character
b according to this scoring scheme. |
java.lang.String |
toString()
Returns a String representation of this scoring scheme. |
| Methods inherited from class neobio.alignment.ScoringScheme |
isCaseSensitive |
| Methods inherited from class java.lang.Object |
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait |
| Field Detail |
match_reward
protected int match_reward
- The reward for a match (a substitution of equal characters).
mismatch_penalty
protected int mismatch_penalty
- The penalty for a mismatch (a substitution of different characters).
gap_cost
protected int gap_cost
- The cost of a gap (an insertion or deletion of a character).
max_absolute_score
protected int max_absolute_score
- The maximum absolute score that this scoring scheme can return, which is the
maximum absolute value among
match_reward,mismatch_penaltyandgap_cost.
| Constructor Detail |
BasicScoringScheme
public BasicScoringScheme(int match_reward, int mismatch_penalty, int gap_cost)
- Creates a new instance of a basic scoring scheme with the specified values of
match reward, mismatch penalty and gap cost. The case of characters is significant
when subsequently computing their score.
- Parameters:
match_reward- reward for a substitution of equal charactersmismatch_penalty- penalty for a substitution of different charactersgap_cost- cost of an insertion or deletion of any character
BasicScoringScheme
public BasicScoringScheme(int match_reward, int mismatch_penalty, int gap_cost, boolean case_sensitive)
- Creates a new instance of basic scoring scheme with the specified values of
match reward, mismatch penalty and gap cost. If
case_sensitiveistrue, the case of characters is significant when subsequently computing their score; otherwise the case is ignored. - Parameters:
match_reward- reward for a substitution of equal charactersmismatch_penalty- penalty for a substitution of different charactersgap_cost- cost of an insertion or deletion of any charactercase_sensitive-trueif the case of characters must be significant,falseotherwise
| Method Detail |
scoreSubstitution
public int scoreSubstitution(char a, char b)
- Returns the score of a substitution of character
afor characterbaccording to this scoring scheme. It ismatch_rewardifaequalsb,mismatch_penaltyotherwise.- Specified by:
scoreSubstitutionin classScoringScheme
- Parameters:
a- first characterb- second character- Returns:
match_rewardifaequalsb,mismatch_penaltyotherwise.
scoreInsertion
public int scoreInsertion(char a)
- Always returns
gap_costfor the insertion of any character.- Specified by:
scoreInsertionin classScoringScheme
- Parameters:
a- the character to be inserted- Returns:
gap_cost
scoreDeletion
public int scoreDeletion(char a)
- Always returns
gap_costfor the deletion of any character.- Specified by:
scoreDeletionin classScoringScheme
- Parameters:
a- the character to be deleted- Returns:
gap_cost
maxAbsoluteScore
public int maxAbsoluteScore()
- Returns the maximum absolute score that this scoring scheme can return for any
substitution, deletion or insertion, which is the maximum absolute value among
match_reward,mismatch_penaltyandgap_cost.- Specified by:
maxAbsoluteScorein classScoringScheme
- Returns:
- the maximum absolute value among
match_reward,mismatch_penaltyandgap_cost.
isPartialMatchSupported
public boolean isPartialMatchSupported()
- Tells whether this scoring scheme supports partial matches, which it does not.
- Specified by:
isPartialMatchSupportedin classScoringScheme
- Returns:
- always return
false
toString
public java.lang.String toString()
- Returns a String representation of this scoring scheme.
- Overrides:
toStringin classjava.lang.Object
- Returns:
- a String representation of this scoring scheme
|
|
||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
NeoBio is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with NeoBio; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
neobio-0.0.20030929/doc/neobio/alignment/CrochemoreLandauZivUkelsonGlobalAlignment.html 0000644 0002656 0002032 00000106023 07727746670 030020 0 ustar tillea admin
|
NeoBio API | ||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
neobio.alignment
Class CrochemoreLandauZivUkelsonGlobalAlignment
java.lang.Object | +--neobio.alignment.PairwiseAlignmentAlgorithm | +--neobio.alignment.CrochemoreLandauZivUkelson | +--neobio.alignment.CrochemoreLandauZivUkelsonGlobalAlignment
- public class CrochemoreLandauZivUkelsonGlobalAlignment
- extends CrochemoreLandauZivUkelson
This class implements the global pairwise sequence alignment algorithm (with linear gap penalty function) due to Maxime Crochemore, Gad Landau and Michal Ziv-Ukelson (2002).
This implementation derives from the paper of M.Crochemore, G.Landau and M.Ziv-Ukelson, A Sub-quadratic Sequence Alignment Algorithm for Unrestricted Scoring Matrices (available here as PDF or Postscript).
For a general description of the algorithm, please refer to the specification of the abstract CrochemoreLandauZivUkelson superclass.
This class consist mainly of methods that:
createBlock
and its variants);
computeOutputBorder;
locateScore;
buildOptimalAlignment.
- Author:
- Sergio A. de Carvalho Jr.
- See Also:
CrochemoreLandauZivUkelson,CrochemoreLandauZivUkelsonLocalAlignment
| Field Summary |
| Fields inherited from class neobio.alignment.CrochemoreLandauZivUkelson |
block_table, DIAGONAL_DIRECTION, LEFT_DIRECTION, num_cols, num_rows, out_matrix, seq1, seq2, smawk, STOP_DIRECTION, TOP_DIRECTION |
| Fields inherited from class neobio.alignment.PairwiseAlignmentAlgorithm |
alignment, APPROXIMATE_MATCH_TAG, GAP_CHARACTER, GAP_TAG, MATCH_TAG, MISMATCH_TAG, score, score_computed, scoring, sequences_loaded, use_match_tag |
| Constructor Summary | |
CrochemoreLandauZivUkelsonGlobalAlignment()
|
|
| Method Summary | |
protected PairwiseAlignment |
buildOptimalAlignment()
Builds an optimal global alignment between the loaded sequences after the block table has been computed. |
protected void |
computeOutputBorder(AlignmentBlock block,
int row,
int col,
int dim,
int lc,
int lr)
Computes the output border of a block. |
protected AlignmentBlock |
createBlock(Factor factor1,
Factor factor2,
int row,
int col)
Creates and computes all information of an alignment block. |
protected AlignmentBlock |
createFirstColumnBlock(Factor factor1,
Factor factor2,
int row)
Creates and computes all information of an alignment block of the first column of the block table. |
protected AlignmentBlock |
createFirstRowBlock(Factor factor1,
Factor factor2,
int col)
Creates and computes all information of an alignment block of the first row of the block table. |
protected AlignmentBlock |
createRootBlock(Factor factor1,
Factor factor2)
Creates the root block. |
protected int |
locateScore()
Locate the score of the highest scoring global alignment in the block table. |
| Methods inherited from class neobio.alignment.CrochemoreLandauZivUkelson |
assembleDistMatrix, assembleInputBorder, computeBlockTable, computePairwiseAlignment, computeScore, getDiagonalPrefix, getLeftPrefix, getTopPrefix, loadSequencesInternal, traverseBlock, unloadSequencesInternal |
| Methods inherited from class neobio.alignment.PairwiseAlignmentAlgorithm |
getPairwiseAlignment, getScore, loadSequences, max, max, max, scoreDeletion, scoreInsertion, scoreSubstitution, setScoringScheme, unloadSequences, useMatchTag |
| Methods inherited from class java.lang.Object |
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Constructor Detail |
CrochemoreLandauZivUkelsonGlobalAlignment
public CrochemoreLandauZivUkelsonGlobalAlignment()
| Method Detail |
createBlock
protected AlignmentBlock createBlock(Factor factor1, Factor factor2, int row, int col) throws IncompatibleScoringSchemeException
- Creates and computes all information of an alignment block. Its main job is to
compute the DIST column for the block. It then request the
computeOutputBordermethod to compute the block's output border.- Specified by:
createBlockin classCrochemoreLandauZivUkelson
- Parameters:
factor1- factor of the first sequencefactor2- factor of the second sequencerow- row index of the block in the block tablecol- column index of the block in the block table- Returns:
- the computed block
- Throws:
IncompatibleScoringSchemeException- if the scoring scheme is not compatible with the sequences being aligned
createRootBlock
protected AlignmentBlock createRootBlock(Factor factor1, Factor factor2)
- Creates the root block. This is a special case of the
createBlockmethod. No information is actually computed.- Specified by:
createRootBlockin classCrochemoreLandauZivUkelson
- Parameters:
factor1- factor of the first sequencefactor2- factor of the second sequence- Returns:
- the root block
createFirstRowBlock
protected AlignmentBlock createFirstRowBlock(Factor factor1, Factor factor2, int col) throws IncompatibleScoringSchemeException
- Creates and computes all information of an alignment block of the first row of the
block table. This is a special case of the
createBlockmethod.- Specified by:
createFirstRowBlockin classCrochemoreLandauZivUkelson
- Parameters:
factor1- factor of the first sequencefactor2- factor of the second sequencecol- column index of the block in the block table- Returns:
- the computed block
- Throws:
IncompatibleScoringSchemeException- if the scoring scheme is not compatible with the sequences being aligned- See Also:
createBlock
createFirstColumnBlock
protected AlignmentBlock createFirstColumnBlock(Factor factor1, Factor factor2, int row) throws IncompatibleScoringSchemeException
- Creates and computes all information of an alignment block of the first column of
the block table. This is a special case of the
createBlockmethod.- Specified by:
createFirstColumnBlockin classCrochemoreLandauZivUkelson
- Parameters:
factor1- factor of the first sequencefactor2- factor of the second sequencerow- row index of the block in the block table- Returns:
- the computed block
- Throws:
IncompatibleScoringSchemeException- if the scoring scheme is not compatible with the sequences being aligned- See Also:
createBlock
computeOutputBorder
protected void computeOutputBorder(AlignmentBlock block, int row, int col, int dim, int lc, int lr)
- Computes the output border of a block. This is performed in five steps:
- Retrieve the block's input border;
- Retrieve the block's complete DIST matrix;
- Create an interface to the OUT matrix from the input border and DIST matrix;
- Use SMAWK to compute all column maxima of the OUT matrix (SMAWK finds the index of the row that contains the maximum value of a column);
- Assemble the output border by extracting the maximum values of each column of the OUT matrix using the information obtained in the previous step.
- Parameters:
block- the block for which the output border is to be computedrow- row index of the block in the block tablecol- column index of the block in the block tabledim- dimension of the output borderlc- number of columns of the blocklr- number of row of the block
buildOptimalAlignment
protected PairwiseAlignment buildOptimalAlignment() throws IncompatibleScoringSchemeException
- Builds an optimal global alignment between the loaded sequences after the block
table has been computed. This method traces a path back in the block table, from
the last block to the first.
- Specified by:
buildOptimalAlignmentin classCrochemoreLandauZivUkelson
- Returns:
- an optimal global alignment
- Throws:
IncompatibleScoringSchemeException- If the scoring scheme is not compatible with the loaded sequences.- See Also:
CrochemoreLandauZivUkelson.traverseBlock(neobio.alignment.AlignmentBlock, int, java.lang.StringBuffer, java.lang.StringBuffer, java.lang.StringBuffer)
locateScore
protected int locateScore()
- Locate the score of the highest scoring global alignment in the block table. This
value is found in the output border of the last block (last row, last column).
- Specified by:
locateScorein classCrochemoreLandauZivUkelson
- Returns:
- the score of the highest scoring global alignment
|
|
||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
NeoBio is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with NeoBio; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
neobio-0.0.20030929/doc/neobio/alignment/CrochemoreLandauZivUkelson.html 0000644 0002656 0002032 00000210075 07727746670 025043 0 ustar tillea admin
|
NeoBio API | ||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
neobio.alignment
Class CrochemoreLandauZivUkelson
java.lang.Object | +--neobio.alignment.PairwiseAlignmentAlgorithm | +--neobio.alignment.CrochemoreLandauZivUkelson
- Direct Known Subclasses:
- CrochemoreLandauZivUkelsonGlobalAlignment, CrochemoreLandauZivUkelsonLocalAlignment
- public abstract class CrochemoreLandauZivUkelson
- extends PairwiseAlignmentAlgorithm
This abstract class is the superclass of both global and local sequence alignment algorithms (with linear gap penalty function) due to Maxime Crochemore, Gad Landau and Michal Ziv-Ukelson (2002).
This implementation derives from the paper of M.Crochemore, G.Landau and M.Ziv-Ukelson, A Sub-quadratic Sequence Alignment Algorithm for Unrestricted Scoring Matrices (available here as PDF or Postscript).
It employs Lempel-Ziv compression techniques to speed up the classic dynamic programmin approach to sequence alignment (see NeedlemanWunsch and SmithWaterman classes). It reduces the time and space complexity from O(n2) to O(n2/log n). In fact, the complexity is actually O(h n2/log n), where 0 <= h <= 1 is a real number denoting the entropy of the text (a measure of how compressible it is). This means that, the more compressible a sequence is, the less memory the algorithm will require, and the faster it will run.
The idea behind this improvement is to identify repetitions in the sequences and reuse the computation of their alignments. The first step is, therefore, to parse the sequences into LZ78-like factors. LZ78 is a popular compression algorithm of the Lempel-Ziv familiy due to J.Ziv and A.Lempel (1978). This factorisation is accomplished by the FactorSequence class (for more information about this factorisation, please refer to the specification of that class) that builds a doubly-linked list of factors. Each factor is an instance of the Factor class (refer to the specification of this class for more information).
Once the sequences have been parsed, the algorithm builds a matrix of blocks, called
block table, that is vaguely similar to the dynamic programming matrix used by both
NeedlemanWunsch and SmithWaterman. Each block contains an
instance of an AlignmentBlock (please refer to its specification for more
information on what information is stored) and represents the alignment beteween one
factor of each sequence. This block table is, in fact, a partition of the alignment
graph.
Consider a block B which corresponds to the alignment of factor F1 = xa from sequence S1 and factor F2 = yb from sequence S2. Here, F1 extends a previous factor of S1 with character a, while F2 extends a previous factor of S2 with character b. We can define the input border of B as the set of values at the left and top borders of block B, and the output border as the set of values at the right and bottom borders of B. Moreover, we can define the following prefix blocks of B:
- Left prefix - is the block that contains the alignment of factor F1 with a factor F2' = y (a prefix of factor F2).
- Diagonal prefix - is the block that contains the alignment of factor F1' = x (a prefix of factor F1) with a factor F2' = y (a prefix of factor F2).
- Top prefix - is the block that contains the alignment of factor F1' = x (a prefix of factor F1) with factor F2.
Note that each factor has a pointer to its prefix factor, called ancestor (see the
specification of the Factor class). This pointer makes it easy to retrieve
any of the three prefix blocks of B in constant time.
Rather than computing each value of the alignment block B, the algorithm will only compute the values on its input and output borders. This is precisely what makes it more efficient.
In this class there is a general specification of how the block table is computed
(see the computeBlockTable method for details). The actual
method depends on the subclasses. In general, there are two phases:
- Encoding - the structure of a block B is studied and represented in an efficient way by computing weights of optimal paths connecting each entry of its input border to each entry of its output border. This information is encoded in a DIST matrix where DIST[i,j] stores the weight of an optimal paths connecting entry i of the input border to entry j the output border of B.
- Propagation - the input border of a block B is retrieved (from the left and top blocks of B) and its output border is computed with the help of the DIST matrix.
In fact, for each block, only one column of the DIST matrix needs to be computed,
all other columns are actually retrieved from its prefix blocks. This is precisely what
is accomplished by the assembleDistMatrix method found in
this class (it is general enough for both global and local alignment versions of the
algorithm.
From the DIST matrix, we obtain the OUT matrix defined as
OUT[i,j] = I[i] + DIST[i,j] where I is the input border array. This means
that the OUT matrix is the DIST matrix updated by the input border of a block. The
output border is then computed from the OUT matrix by taking the maximum value of each
column. This class also have a general method for assembling the input border (see
assembleInputBorder
The OUT matrix is encoded by the OutMatrix class that takes as both a DIST matrix and an input border array. Note that it does not compute the OUT matrix, it just stores the necessary information to retrieve a value at any position of the matrix.
A naive approach to compute the output border of a block from the OUT matrix of size n x n would take a time proportional to n2. However, it happens that, due to the nature of the DIST matrix, both DIST and OUT matrices are Monge arrays, which implies that they are also totally monotone. This property allows the computation of the output border of B in linear time with the SMAWK algorithm (see the specification of the Smawk class for more information on SMAWK).
This class contains a general specification that is pertinent to both global and local versions of the algorithm. For more information on each version of, please refer to the appropriate subclass.
A note about the performance of these algorithms. Although theoretical results suggest that these algorithms are faster and consume less memory than the classical methods, in practice it is hard to realise their performance gains.
These algorithms are extremely complex and require the storage of many extra
pointers and other auxiliary data for each block (see the AlignmentBlock
class for more details). Hence, even though the space requirement is
O(n2/log n), which is less than O(n2), in practice, for most of
the cases these algorithms will take more time and memory space than their clasical
counterparts (we have to keep in mind that the Big Oh notation ignores all constants
involved).
Therefore, in order to realise the full power of these algorithms, they have to be used with extremly large and redundant sequences. This will allow a proper reutilisation of the computations and, maybe, provide an improvement in terms of space and run time. For instance, it is easy to devise such a sequence if we use a one-character alphabet because, in this case, a sequence is factorised into a series of factors that are a prefix of the next.
- Author:
- Sergio A. de Carvalho Jr.
- See Also:
CrochemoreLandauZivUkelsonGlobalAlignment,CrochemoreLandauZivUkelsonLocalAlignment,NeedlemanWunsch,SmithWaterman,FactorSequence,AlignmentBlock,OutMatrix,Smawk,computeBlockTable(),assembleDistMatrix(neobio.alignment.AlignmentBlock, int, int, int, int)
| Field Summary | |
protected AlignmentBlock[][] |
block_table
The block table, which is a matrix of alignment blocks where each block represents the alignment between one factor of each sequence. |
protected static byte |
DIAGONAL_DIRECTION
A constant that indicates that the diagonal direction must be followed to reach the source of an optimal path in a block during the trace back procedure to retrieve a high scoring alignment. |
protected static byte |
LEFT_DIRECTION
A constant that indicates that the left direction must be followed to reach the source of an optimal path in a block during the trace back procedure to retrieve a high scoring alignment. |
protected int |
num_cols
Number of columns of the block table. |
protected int |
num_rows
Number of rows of the block table. |
protected OutMatrix |
out_matrix
An instance of the OutMatrix class that encodes the OUT matrix of a
block when supplied with the DIST matrix and the input border array of a block.
|
protected FactorSequence |
seq1
The first factorised sequence being aligned. |
protected FactorSequence |
seq2
The second factorised sequence being aligned. |
protected Smawk |
smawk
An instance of the Smawk class that implements the SMAWK algorithm to
compute the column maxima of a totally monotone matrix. |
protected static byte |
STOP_DIRECTION
A constant that indicates that the source of an optimal path has been reached in a block and that the trace back procedure to retrieve a high scoring alignment can stop. |
protected static byte |
TOP_DIRECTION
A constant that indicates that the top direction must be followed to reach the source of an optimal path in a block during the trace back procedure to retrieve a high scoring alignment. |
| Fields inherited from class neobio.alignment.PairwiseAlignmentAlgorithm |
alignment, APPROXIMATE_MATCH_TAG, GAP_CHARACTER, GAP_TAG, MATCH_TAG, MISMATCH_TAG, score, score_computed, scoring, sequences_loaded, use_match_tag |
| Constructor Summary | |
CrochemoreLandauZivUkelson()
|
|
| Method Summary | |
protected int[][] |
assembleDistMatrix(AlignmentBlock block,
int dim,
int r,
int c,
int lc)
Assembles the DIST matrix of a block by retrieving the DIST columns of its prefix blocks. |
protected int[] |
assembleInputBorder(int dim,
int r,
int c,
int lr)
Assembles the input border of a block by retrieving the values at the output borders of the left and top blocks. |
protected abstract PairwiseAlignment |
buildOptimalAlignment()
Retrieves an optimal alignment between the loaded sequences. |
protected void |
computeBlockTable()
Computes the block table. |
protected PairwiseAlignment |
computePairwiseAlignment()
Computes the block table (the result depends on subclasses, see computeBlockTable for details) and requests subclasses to retrieve an
optimal alignment between the loaded sequences. |
protected int |
computeScore()
Computes the block table (the result depends on subclasses, see computeBlockTable for details) and requests subclasses to locate the
score of the highest scoring alignment between the two sequences in the block
table. |
protected abstract AlignmentBlock |
createBlock(Factor factor1,
Factor factor2,
int row,
int col)
Computes a block of the block table, which corresponds to an alignment block between one factor of sequence 1 and one factor of sequence 2. |
protected abstract AlignmentBlock |
createFirstColumnBlock(Factor factor1,
Factor factor2,
int row)
Computes a block at the first column (column zero) of the block table, which corresponds to an alignment block between one factor of sequence 1 and an empty string. |
protected abstract AlignmentBlock |
createFirstRowBlock(Factor factor1,
Factor factor2,
int col)
Computes a block at the first row (row zero) of the block table, which corresponds to an alignment block between one factor of sequence 2 and an empty string. |
protected abstract AlignmentBlock |
createRootBlock(Factor factor1,
Factor factor2)
Computes the root block of the block table. |
protected AlignmentBlock |
getDiagonalPrefix(AlignmentBlock block)
This method is a shorthand to retrieve the diagonal prefix of a block from the block table. |
protected AlignmentBlock |
getLeftPrefix(AlignmentBlock block)
This method is a shorthand to retrieve the left prefix of a block from the block table. |
protected AlignmentBlock |
getTopPrefix(AlignmentBlock block)
This method is a shorthand to retrieve the top prefix of a block from the block table. |
protected void |
loadSequencesInternal(java.io.Reader input1,
java.io.Reader input2)
Loads sequences into FactorSequence instances. |
protected abstract int |
locateScore()
Locates the score of the highest scoring alignment between the two sequences in the block table after is thas been computed. |
protected void |
traverseBlock(AlignmentBlock block,
int source,
java.lang.StringBuffer gapped_seq1,
java.lang.StringBuffer tag_line,
java.lang.StringBuffer gapped_seq2)
Traverses a block to retrieve a part of an optimal alignment from the specified source in the output border to an entry in the input border. |
protected void |
unloadSequencesInternal()
Frees pointers to loaded sequences and the the block table so that their data can be garbage collected. |
| Methods inherited from class neobio.alignment.PairwiseAlignmentAlgorithm |
getPairwiseAlignment, getScore, loadSequences, max, max, max, scoreDeletion, scoreInsertion, scoreSubstitution, setScoringScheme, unloadSequences, useMatchTag |
| Methods inherited from class java.lang.Object |
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Field Detail |
STOP_DIRECTION
protected static final byte STOP_DIRECTION
- A constant that indicates that the source of an optimal path has been reached in a
block and that the trace back procedure to retrieve a high scoring alignment can
stop.
- See Also:
- Constant Field Values
LEFT_DIRECTION
protected static final byte LEFT_DIRECTION
- A constant that indicates that the left direction must be followed to reach the
source of an optimal path in a block during the trace back procedure to retrieve a
high scoring alignment.
- See Also:
- Constant Field Values
DIAGONAL_DIRECTION
protected static final byte DIAGONAL_DIRECTION
- A constant that indicates that the diagonal direction must be followed to reach the
source of an optimal path in a block during the trace back procedure to retrieve a
high scoring alignment.
- See Also:
- Constant Field Values
TOP_DIRECTION
protected static final byte TOP_DIRECTION
- A constant that indicates that the top direction must be followed to reach the
source of an optimal path in a block during the trace back procedure to retrieve a
high scoring alignment.
- See Also:
- Constant Field Values
seq1
protected FactorSequence seq1
- The first factorised sequence being aligned.
seq2
protected FactorSequence seq2
- The second factorised sequence being aligned.
block_table
protected AlignmentBlock[][] block_table
- The block table, which is a matrix of alignment blocks where each block represents
the alignment between one factor of each sequence.
num_rows
protected int num_rows
- Number of rows of the block table. It is determined by the number of factors of the
first sequence.
num_cols
protected int num_cols
- Number of columns of the block table. It is determined by the number of factors of
the second sequence.
smawk
protected Smawk smawk
- An instance of the
Smawkclass that implements the SMAWK algorithm to compute the column maxima of a totally monotone matrix. It is used to speed up the computation of the output border of a block.
out_matrix
protected OutMatrix out_matrix
- An instance of the
OutMatrixclass that encodes the OUT matrix of a block when supplied with the DIST matrix and the input border array of a block. Note that it does not compute the OUT matrix itselft, it just stores the necessary information to retrieve a value at any position of the matrix.This object is then used to compute the output border of a block with the
Smawkclass. Note that theOutMatrixclass implements theMatrixinterface as required by theSmawkclass.
| Constructor Detail |
CrochemoreLandauZivUkelson
public CrochemoreLandauZivUkelson()
| Method Detail |
loadSequencesInternal
protected void loadSequencesInternal(java.io.Reader input1, java.io.Reader input2) throws java.io.IOException, InvalidSequenceException
- Loads sequences into
FactorSequenceinstances. In case of any error, an exception is raised by the constructor ofFactorSequence(please check the specification of that class for specific requirements).A
FactorSequenceis an LZ78-like factorisation of the sequences being aligned.- Specified by:
loadSequencesInternalin classPairwiseAlignmentAlgorithm
- Parameters:
input1- Input for first sequenceinput2- Input for second sequence- Throws:
java.io.IOException- If an I/O error occurs when reading the sequencesInvalidSequenceException- If the sequences are not valid- See Also:
FactorSequence
unloadSequencesInternal
protected void unloadSequencesInternal()
- Frees pointers to loaded sequences and the the block table so that their data can
be garbage collected.
- Specified by:
unloadSequencesInternalin classPairwiseAlignmentAlgorithm
computePairwiseAlignment
protected PairwiseAlignment computePairwiseAlignment() throws IncompatibleScoringSchemeException
- Computes the block table (the result depends on subclasses, see
computeBlockTablefor details) and requests subclasses to retrieve an optimal alignment between the loaded sequences. The actual product depends on the subclasses which can produce a global (seeCrochemoreLandauZivUkelsonGlobalAlignment) or local alignment (seeCrochemoreLandauZivUkelsonLocalAlignment).Subclasses are required to implement the
buildOptimalAlignmentabstract method defined by this class according to their own method.- Specified by:
computePairwiseAlignmentin classPairwiseAlignmentAlgorithm
- Returns:
- an optimal alignment between the loaded sequences
- Throws:
IncompatibleScoringSchemeException- If the scoring scheme is not compatible with the loaded sequences.- See Also:
CrochemoreLandauZivUkelsonGlobalAlignment,CrochemoreLandauZivUkelsonLocalAlignment,computeBlockTable(),buildOptimalAlignment()
computeScore
protected int computeScore() throws IncompatibleScoringSchemeException
- Computes the block table (the result depends on subclasses, see
computeBlockTablefor details) and requests subclasses to locate the score of the highest scoring alignment between the two sequences in the block table. The result depends on the subclasses, and either a global alignment (seeCrochemoreLandauZivUkelsonGlobalAlignment) or local alignment score (seeCrochemoreLandauZivUkelsonLocalAlignment) will be produced.Subclasses are required to implement the
locateScoreabstract method defined by this class according to their own method.Note that this method calculates the similarity value only (it doesn't trace back into the block table to retrieve the alignment itself).
- Specified by:
computeScorein classPairwiseAlignmentAlgorithm
- Returns:
- the score of the highest scoring alignment between the loaded sequences
- Throws:
IncompatibleScoringSchemeException- If the scoring scheme is not compatible with the loaded sequences.- See Also:
CrochemoreLandauZivUkelsonGlobalAlignment,CrochemoreLandauZivUkelsonLocalAlignment,locateScore()
computeBlockTable
protected void computeBlockTable() throws IncompatibleScoringSchemeException
- Computes the block table. This method is a general specification of how the block
table should be computed. It creates the block table according to the number of
factors of each sequence. It then goes over each position of the block table,
retrieves the corresponding factors from each sequence, and repasses the
information to the subclasses that will do the actual computation of each block
using the scoring scheme previously set.
There are four different cases that defines four abstract methods in this class, which subclasses must implement:
- createRootBlock - creates and computes block at row 0, column 0;
- createFirstColumnBlock - creates and computes blocks at column 0 which corresponds to alignment blocks between factors of sequence 1 and an empty string;
- createFirstRowBlock - creates and computes blocks at row 0 which corresponds to alignment blocks between factors of sequence 2 and an empty string;
- createBlock - creates and computes blocks at row > 0 and column > 0 which corresponds to alignment blocks between one factor of sequence 1 and one factor of sequence 2;
Note that each factor has a serial number which indicates its order in the list of factors of a sequence. This number will match with the row and column index of a block in the block table. For instance, if a block has factors F1 and F2 with serial numbers 12 and 53, respectively, this means that this block is found at row 12, column 53 of the block table.
- Throws:
IncompatibleScoringSchemeException- If the scoring scheme is not compatible with the loaded sequences.- See Also:
createRootBlock(neobio.alignment.Factor, neobio.alignment.Factor),createFirstColumnBlock(neobio.alignment.Factor, neobio.alignment.Factor, int),createFirstRowBlock(neobio.alignment.Factor, neobio.alignment.Factor, int),createBlock(neobio.alignment.Factor, neobio.alignment.Factor, int, int)
assembleDistMatrix
protected int[][] assembleDistMatrix(AlignmentBlock block, int dim, int r, int c, int lc)
- Assembles the DIST matrix of a block by retrieving the DIST columns of its prefix
blocks. In fact, it also stores pointers to the owner block for each column
retrieved. These pointers are later used during the trace back procedure that
builds an optimal alignment from the information computed in the block table. This
method is general enough to suit both global and local alignment versions of the
algorithm.
- Parameters:
block- the block for which the DIST matrix is neededdim- the dimension of the DIST matrixr- the row index of this block in the block tablec- the column index of this block in the block tablelc- the number of columns of the alignment block- Returns:
- the DIST matrix
assembleInputBorder
protected int[] assembleInputBorder(int dim, int r, int c, int lr)
- Assembles the input border of a block by retrieving the values at the output
borders of the left and top blocks. This method is general enough to suit both
global and local alignment versions of the algorithm. Note that it can be used to
assemble the input border of any block but the root one (it will cause an
ArrayIndexOutOfBoundsException.- Parameters:
dim- dimension of the input borderr- row index of the block in the block tablec- column index of the block in the block tablelr- number of row of the block- Returns:
- the block's input border
traverseBlock
protected void traverseBlock(AlignmentBlock block, int source, java.lang.StringBuffer gapped_seq1, java.lang.StringBuffer tag_line, java.lang.StringBuffer gapped_seq2) throws IncompatibleScoringSchemeException
- Traverses a block to retrieve a part of an optimal alignment from the specified
source in the output border to an entry in the input border.
- Parameters:
block- the block to be traversedsource- the source of the path in the output bordergapped_seq1- the StringBuffer to where the gapped sequence 1 is written totag_line- the StringBuffer to where the tag_line is written togapped_seq2- the StringBuffer to where the gapped sequence 2 is written to- Throws:
IncompatibleScoringSchemeException- If the scoring scheme is not compatible with the loaded sequences.
getLeftPrefix
protected AlignmentBlock getLeftPrefix(AlignmentBlock block)
- This method is a shorthand to retrieve the left prefix of a block from the block
table.
- Parameters:
block- the block- Returns:
- the block's left prefix
getDiagonalPrefix
protected AlignmentBlock getDiagonalPrefix(AlignmentBlock block)
- This method is a shorthand to retrieve the diagonal prefix of a block from the
block table.
- Parameters:
block- the block- Returns:
- the block's diagonal prefix
getTopPrefix
protected AlignmentBlock getTopPrefix(AlignmentBlock block)
- This method is a shorthand to retrieve the top prefix of a block from the block
table.
- Parameters:
block- the block- Returns:
- the block's top prefix
createRootBlock
protected abstract AlignmentBlock createRootBlock(Factor factor1, Factor factor2) throws IncompatibleScoringSchemeException
- Computes the root block of the block table. See subclasses for actual
implementation.
- Parameters:
factor1- the factor of the first sequence being alignedfactor2- the factor of the second sequence being aligned- Returns:
- the root block
- Throws:
IncompatibleScoringSchemeException- If the scoring scheme is not compatible with the loaded sequences.
createFirstRowBlock
protected abstract AlignmentBlock createFirstRowBlock(Factor factor1, Factor factor2, int col) throws IncompatibleScoringSchemeException
- Computes a block at the first row (row zero) of the block table, which corresponds
to an alignment block between one factor of sequence 2 and an empty string. See
subclasses for actual implementation.
- Parameters:
factor1- the factor of the first sequence being alignedfactor2- the factor of the second sequence being alignedcol- the column index of block in the block table- Returns:
- the computed block
- Throws:
IncompatibleScoringSchemeException- If the scoring scheme is not compatible with the loaded sequences.
createFirstColumnBlock
protected abstract AlignmentBlock createFirstColumnBlock(Factor factor1, Factor factor2, int row) throws IncompatibleScoringSchemeException
- Computes a block at the first column (column zero) of the block table, which
corresponds to an alignment block between one factor of sequence 1 and an empty
string. See subclasses for actual implementation.
- Parameters:
factor1- the factor of the first sequence being alignedfactor2- the factor of the second sequence being alignedrow- the row index of block in the block table- Returns:
- the computed block
- Throws:
IncompatibleScoringSchemeException- If the scoring scheme is not compatible with the loaded sequences.
createBlock
protected abstract AlignmentBlock createBlock(Factor factor1, Factor factor2, int row, int col) throws IncompatibleScoringSchemeException
- Computes a block of the block table, which corresponds to an alignment block
between one factor of sequence 1 and one factor of sequence 2. See subclasses for
actual implementation.
- Parameters:
factor1- the factor of the first sequence being alignedfactor2- the factor of the second sequence being alignedrow- the row index of block in the block tablecol- the column index of block in the block table- Returns:
- the computed block
- Throws:
IncompatibleScoringSchemeException- If the scoring scheme is not compatible with the loaded sequences.
buildOptimalAlignment
protected abstract PairwiseAlignment buildOptimalAlignment() throws IncompatibleScoringSchemeException
- Retrieves an optimal alignment between the loaded sequences. See subclasses for
actual implementation.
- Returns:
- the computed block
- Throws:
IncompatibleScoringSchemeException- If the scoring scheme is not compatible with the loaded sequences.
locateScore
protected abstract int locateScore()
- Locates the score of the highest scoring alignment between the two sequences in the
block table after is thas been computed. See subclasses for actual implementation.
- Returns:
- the score of the highest scoring alignment between the loaded sequences
- Throws:
IncompatibleScoringSchemeException- If the scoring scheme is not compatible with the loaded sequences.
|
|
||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
NeoBio is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with NeoBio; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
neobio-0.0.20030929/doc/neobio/alignment/package-summary.html 0000644 0002656 0002032 00000035312 07727746666 022670 0 ustar tillea admin
|
NeoBio API | ||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES | ||||||||
Package neobio.alignment
Provides implementation of sequence alignment algorithms.
See:
Description
| Interface Summary | |
| Matrix | This interface defines a minimal set of operations that a matrix must implement. |
| Class Summary | |
| AlignmentBlock | This class is used by the CrochemoreLandauZivUkelson algorithm to store the information of an alignment block. |
| BasicScoringScheme | This class implements a basic scoring scheme. |
| CharSequence | This class implements a sequence of characters stored as an array that provides random access to any position in constant time. |
| CrochemoreLandauZivUkelson | This abstract class is the superclass of both global and local sequence alignment algorithms (with linear gap penalty function) due to Maxime Crochemore, Gad Landau and Michal Ziv-Ukelson (2002). |
| CrochemoreLandauZivUkelsonGlobalAlignment | This class implements the global pairwise sequence alignment algorithm (with linear gap penalty function) due to Maxime Crochemore, Gad Landau and Michal Ziv-Ukelson (2002). |
| CrochemoreLandauZivUkelsonLocalAlignment | This class implements the local pairwise sequence alignment algorithm (with linear gap penalty function) due to Maxime Crochemore, Gad Landau and Michal Ziv-Ukelson (2002). |
| Factor | This class is used by FactorSequence to create a linked list of factors of a text as induced by its Lempel-Ziv (LZ78) factorisation. |
| FactorSequence | This class builds a list of factors of a character sequence as induced by its Lempel-Ziv (LZ78) factorisation. |
| LocalAlignmentBlock | This class is used by the CrochemoreLandauZivUkelsonLocalAlignment algorithm to store the information of an alignment block. |
| NeedlemanWunsch | This class implements the classic global alignment algorithm (with linear gap penalty function) due to S.B.Needleman and C.D.Wunsch (1970). |
| OutMatrix | Implements an interface to the OUT matrix of a block. |
| PairwiseAlignment | This class is the product of a pairwise alignment, generated by one subclasses of PairwiseAlignmentAlgorithm. |
| PairwiseAlignmentAlgorithm | This abstract class is the superclass of all classes implementing pairwise sequence alignment algorithms. |
| ScoringMatrix | This class implements a scoring scheme based on a substitution matrix. |
| ScoringScheme | This abstract class is the superclass of all scoring schemes. |
| Smawk | This class implement the SMAWK algorithm to compute column maxima on a totally monotone matrix as described. |
| SmithWaterman | This class implement the classic local alignment algorithm (with linear gap penalty function) due to T.F.Smith and M.S.Waterman (1981). |
| Trie | This class implements a trie, or a digital search tree. |
| Exception Summary | |
| IncompatibleScoringSchemeException | Signals that an scoring scheme is not compatible with the sequences being aligned. |
| InvalidScoringMatrixException | Signals that the substitution matrix does not comply with the specification (see ScoringMatrix for details). |
| InvalidSequenceException | Signals that the sequence does not comply with the specification (see CharSequence or FactorSequence for details). |
Package neobio.alignment Description
Provides implementation of sequence alignment algorithms.
Pairwise sequence alignment algorithms:
- Needleman & Wunsch (global alignment)
- Smith & Waterman (local alignment)
- Crochemore, Landau & Ziv-Ukelson for global alignment
- Crochemore, Landau & Ziv-Ukelson for local alignment
All algorithms use linear gap penalty functions (additive gap costs).
Main supporting classes:
- CharSequence and FactorSequence: store information about a sequence that can be aligned with another sequence using one alignment algorithm; they wrap the main input of alignment algorithms to provide ways of reading the data.
- ScoringScheme and its subclasses: implement scoring schemes used by alignment algorithms to calculate the similary between two sequences.
- PairwiseAlignment: this is the result of an execution of a pairwise alignment algorithm. It basically contains a string representation of both sequences with gaps (represented with dashes) that produces a highest scoring alignment between them.
- Smawk: both of Crochemore, Landau & Ziv-Ukelson's algorithms rely on this class to provide an implementation of an algorithm, nicknamed SMAWK in the literature, that computes in linear time all column (or row) maxima of a totally monotone matrix.
|
|
||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES | ||||||||
NeoBio is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with NeoBio; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
neobio-0.0.20030929/doc/neobio/alignment/ScoringScheme.html 0000644 0002656 0002032 00000047244 07727746672 022337 0 ustar tillea admin
|
NeoBio API | ||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
neobio.alignment
Class ScoringScheme
java.lang.Object | +--neobio.alignment.ScoringScheme
- Direct Known Subclasses:
- BasicScoringScheme, ScoringMatrix
- public abstract class ScoringScheme
- extends java.lang.Object
This abstract class is the superclass of all scoring schemes. It defines basic operations that must be provided by all subclasses. Scoring schemes are used by sequence alignment algorithms to compute the score of an alignment.
- Author:
- Sergio A. de Carvalho Jr.
- See Also:
PairwiseAlignmentAlgorithm
| Field Summary | |
protected boolean |
case_sensitive
Determines whether this scoring scheme ignores the case of characters when computing their score. |
| Constructor Summary | |
ScoringScheme()
Creates a new instance of an scoring scheme. |
|
ScoringScheme(boolean case_sensitive)
Creates a new instance of an scoring scheme. |
|
| Method Summary | |
boolean |
isCaseSensitive()
Tells whether this scoring scheme ignores the case of characters when computing their score. |
abstract boolean |
isPartialMatchSupported()
Returns true if this scoring scheme supports partial matches,
false otherwise. |
abstract int |
maxAbsoluteScore()
Returns the maximum absolute score that this scoring scheme can return for any substitution, deletion or insertion. |
abstract int |
scoreDeletion(char a)
Returns the score of a deletion of character a according to this
scoring scheme. |
abstract int |
scoreInsertion(char a)
Returns the score of an insertion of character a according to this
scoring scheme. |
abstract int |
scoreSubstitution(char a,
char b)
Returns the score of a substitution of character a for character
b according to this scoring scheme. |
| Methods inherited from class java.lang.Object |
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Field Detail |
case_sensitive
protected boolean case_sensitive
- Determines whether this scoring scheme ignores the case of characters when
computing their score. It is set by the constructor and cannot be changed
afterwards.
| Constructor Detail |
ScoringScheme
public ScoringScheme()
- Creates a new instance of an scoring scheme. The case of characters is significant
when subsequently computing their score.
ScoringScheme
public ScoringScheme(boolean case_sensitive)
- Creates a new instance of an scoring scheme. If
case_sensitiveistrue, the case of characters is significant when subsequently computing their score; otherwise the case is ignored. - Parameters:
case_sensitive-trueif the case of characters must be significant,falseotherwise
| Method Detail |
isCaseSensitive
public boolean isCaseSensitive()
- Tells whether this scoring scheme ignores the case of characters when computing
their score.
- Returns:
trueif the case of characters is significant,falseotherwise
scoreSubstitution
public abstract int scoreSubstitution(char a, char b) throws IncompatibleScoringSchemeException
- Returns the score of a substitution of character
afor characterbaccording to this scoring scheme. If this substitution is not defined, an exception is raised.- Parameters:
a- first characterb- second character- Returns:
- score of substitution of
aforb - Throws:
IncompatibleScoringSchemeException- if this substitution is not defined
scoreInsertion
public abstract int scoreInsertion(char a) throws IncompatibleScoringSchemeException
- Returns the score of an insertion of character
aaccording to this scoring scheme. If this character is not recognised, an exception is raised.- Parameters:
a- the character to be inserted- Returns:
- score of insertion of
a - Throws:
IncompatibleScoringSchemeException- if character is not recognised by this scoring scheme
scoreDeletion
public abstract int scoreDeletion(char a) throws IncompatibleScoringSchemeException
- Returns the score of a deletion of character
aaccording to this scoring scheme. If this character is not recognised, an exception is raised.- Parameters:
a- the character to be deleted- Returns:
- score of insertion of
a - Throws:
IncompatibleScoringSchemeException- if character is not recognised by this scoring scheme
maxAbsoluteScore
public abstract int maxAbsoluteScore()
- Returns the maximum absolute score that this scoring scheme can return for any
substitution, deletion or insertion.
- Returns:
- maximum absolute score that can be returned
isPartialMatchSupported
public abstract boolean isPartialMatchSupported()
- Returns
trueif this scoring scheme supports partial matches,falseotherwise. A partial match is a situation when two characters are not equal but, for any reason, are regarded as similar by this scoring scheme, which then returns a positive score. This is common when for scoring schemes that implement amino acid scoring matrices.- Returns:
trueif this scoring scheme supports partial matches,falseotherwise
|
|
||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
NeoBio is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with NeoBio; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
neobio-0.0.20030929/doc/neobio/alignment/Smawk.html 0000644 0002656 0002032 00000107202 07727746672 020657 0 ustar tillea admin
|
NeoBio API | ||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
neobio.alignment
Class Smawk
java.lang.Object | +--neobio.alignment.Smawk
- public class Smawk
- extends java.lang.Object
This class implement the SMAWK algorithm to compute column maxima on a totally monotone matrix as described.
This implementation derives from the paper of A.Aggarwal, M.Klawe, S.Moran, P.Shor, and R.Wilber, Geometric Applications of a Matrix Searching Algorithm, Algorithmica, 2, 195-208 (1987).
The matrix must be an object that implements the Matrix interface. It is also expected to be totally monotone, and the number of rows should be greater than or equals to the number of columns. If these conditions are not met, the the result is unpredictable and can lead to an ArrayIndexOutOfBoundsException.
computeColumnMaxima is the main public method of this
class. It computes the column maxima of a given matrix, i.e. the rows that contain the
maximum value of each column in O(n) (linear) time, where n is the number of rows. This
method does not return the maximum values itself, but just the indexes of their
rows.
Note that it is necessary to create an instance of this class to execute the
computeColumnMaxima because it stores temporary data is that instance. To
prevent problems with concurrent access, the computeColumnMaxima method is
declared synchronized.
// create an instance of Smawk
Smawk smawk = new Smawk();
// create an array to store the result
int col_maxima = new int [some_matrix.numColumns()];
// now compute column maxima
smawk.computeColumnMaxima (some_matrix, col_maxima)
Note that the array of column maxima indexes (the computation result) must be created beforehand and its size must be equal to the number of columns of the matrix.
This implementation creates arrays of row and column indexes from the original array and simulates all operations (reducing, deletion of odd columns, etc.) by manipulating these arrays. The benefit is two-fold. First the matrix is not required to implement any of these this operations but only a simple method to retrieve a value at a given position. Moreover, it tends to be faster since it uses a manipulation of these small vectors and no row or column is actually deleted. The downside is, of course, the use of extra memory (in practice, however, this is negligible).
Note that this class does not contain a computeRowMaxima method,
however, the computeColumnMaxima can easily be used to compute row maxima
by using a transposed matrix interface, i.e. one that inverts the indexes of the
valueAt method (returning [col,row] when [row,col] is requested) and swaps
the number of rows by the number of columns, and vice-versa.
Another simpler method, naiveComputeColumnMaxima,
does the same job without using the SMAWK algorithm. It takes advantage of the monotone
property of the matrix only (SMAWK explores the stronger constraint of total
monotonicity), and therefore has a worst case time complexity of O(n * m), where n is
the number of rows and m is the number of columns. However, this method tends to be
faster for small matrices because it avoids recursions and row and column
manipulations. There is also a
naiveComputeRowMaxima method to compute row maxima
with the naive approach.
- Author:
- Sergio A. de Carvalho Jr.
- See Also:
Matrix
| Field Summary | |
protected int[] |
col
An array of column indexes reflecting the current state of the matrix. |
protected Matrix |
matrix
A pointer to the matrix that is being manipulated. |
protected int |
numcols
The matrix's current number of columns. |
protected int |
numrows
The matrix's current number of rows. |
protected int[] |
row
An array of row indexes reflecting the current state of the matrix. |
protected int[] |
row_position
This array is used to store for each row of the original matrix, its index in the current state of the matrix, i.e. its index in the row array. |
| Constructor Summary | |
Smawk()
|
|
| Method Summary | |
protected void |
computeColumnMaxima(int[] col_maxima)
This method implements the SMAWK algorithm to compute the column maxima of a given matrix. |
void |
computeColumnMaxima(Matrix matrix,
int[] col_maxima)
Computes the column maxima of a given matrix. |
protected void |
deleteOddColumns()
This method simulates a deletion of odd rows by manipulating the col
array of indexes. |
protected void |
deleteRow(int reduced_rows,
int k)
This method simulates a deletion of a row in the matrix during the reduce operation. |
static void |
naiveComputeColumnMaxima(Matrix matrix,
int[] col_maxima)
This is a simpler method for calculating column maxima. |
static void |
naiveComputeRowMaxima(Matrix matrix,
int[] row_maxima)
This is a simpler method for calculating row maxima. |
protected void |
printMatrix()
Prints the current state of the matrix (reflecting deleted rows and columns) in the standard output. |
static void |
printMatrix(Matrix matrix)
Prints the contents of an object implementing the matrix interface in the standard output. |
protected void |
reduce()
This method is the key component of the SMAWK algorithm. |
protected void |
restoreOddColumns(int original_numcols)
Restores the col array of indexes to the state it was before the
deleteOddColumns method was called. |
protected void |
restoreRows(int original_numrows)
Restores the row array of indexes to the state it was before the
reduce method was called. |
protected int |
valueAt(int r,
int c)
This is a helper method to simplify the call to the valueAt method
of the matrix. |
| Methods inherited from class java.lang.Object |
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Field Detail |
matrix
protected Matrix matrix
- A pointer to the matrix that is being manipulated.
numrows
protected int numrows
- The matrix's current number of rows. This reflects any deletion of rows already
performed.
row
protected int[] row
- An array of row indexes reflecting the current state of the matrix. When rows are
deleted, the corresponding indexes are simply moved to the end of the vector.
row_position
protected int[] row_position
- This array is used to store for each row of the original matrix, its index in the
current state of the matrix, i.e. its index in the
rowarray.
numcols
protected int numcols
- The matrix's current number of columns. This reflects any deletion of columns
already performed.
col
protected int[] col
- An array of column indexes reflecting the current state of the matrix. When columns
are deleted, the corresponding indexes are simply moved to the end of the vector.
| Constructor Detail |
Smawk
public Smawk()
| Method Detail |
computeColumnMaxima
public void computeColumnMaxima(Matrix matrix, int[] col_maxima)
- Computes the column maxima of a given matrix. It first sets up arrays of row and
column indexes to simulate a copy of the matrix (where all operations will be
performed). It then calls the recursive protected
computeColumnMaximamethod.The matrix is required to be an object that implements the
Matrixinterface. It is also expected to be totally monotone, and the number of rows should be greater than or equals to the number of columns. If it is not, the the result is unpredictable and can lead to an ArrayIndexOutOfBoundsException.This method does not return the maximum values itself, but just the indexes of their rows. Note that the array of column maxima (the computation result) must be created beforehand and its size must be equal to the number of columns of the matrix.
To prevent problems with concurrent access, this method is declared
synchronized.- Parameters:
matrix- the matrix that will have its column maxima computedcol_maxima- the array of column maxima (indexes of the rows containing maximum values of each column); this is the computation result- See Also:
computeColumnMaxima(int[])
computeColumnMaxima
protected void computeColumnMaxima(int[] col_maxima)
- This method implements the SMAWK algorithm to compute the column maxima of a given
matrix. It uses the arrays of row and column indexes to performs all operations on
this 'fake' copy of the original matrix.
The first step is to reduce the matrix to a quadratic size (if necessary). It then delete all odd columns and recursively computes column maxima for this matrix. Finally, using the information computed for the odd columns, it searches for column maxima of the even columns. The column maxima are progressively stored in the
col_maximaarray (each recursive call will compute a set of column maxima).- Parameters:
col_maxima- the array of column maxima (the computation result)
valueAt
protected final int valueAt(int r, int c)
- This is a helper method to simplify the call to the
valueAtmethod of the matrix. It returns the value at rowr, columnc.- Parameters:
r- the row number of the value being retrievedc- the column number of the value being retrieved- Returns:
- the value at row
r, columnc - See Also:
Matrix.valueAt(int, int)
deleteOddColumns
protected void deleteOddColumns()
- This method simulates a deletion of odd rows by manipulating the
colarray of indexes. In fact, nothing is deleted, but the indexes are moved to the end of the array in a way that they can be easily restored by therestoreOddColumnsmethod using a reverse approach.- See Also:
restoreOddColumns(int)
restoreOddColumns
protected void restoreOddColumns(int original_numcols)
- Restores the
colarray of indexes to the state it was before thedeleteOddColumnsmethod was called. It only needs to know how many columns there was originally. The indexes that were moved to the end of the array are restored to their original position.- Parameters:
original_numcols- the number of columns before the odd ones were deleted- See Also:
deleteOddColumns()
reduce
protected void reduce()
- This method is the key component of the SMAWK algorithm. It reduces an n x m matrix
(n rows and m columns), where n >= m, to an n x n matrix by deleting m - n rows
that are guaranteed to have no maximum value for any column. The result is an
squared submatrix matrix that contains, for each column c, the row that has the
maximum value of c in the original matrix. The rows are deleted with the
deleteRowmethod.It uses the total monotonicity property of the matrix to identify which rows can safely be deleted.
- See Also:
deleteRow(int, int)
deleteRow
protected void deleteRow(int reduced_rows, int k)
- This method simulates a deletion of a row in the matrix during the
reduceoperation. It just moves the index to the end of the array in a way that it can be restored afterwards by therestoreRowsmethod (nothing is actually deleted). Deleted indexes are kept in ascending order.- Parameters:
reduced_rows- the current number of rows in the reducing matrixk- the index of the row to be deleted- See Also:
restoreRows(int)
restoreRows
protected void restoreRows(int original_numrows)
- Restores the
rowarray of indexes to the state it was before thereducemethod was called. It only needs to know how many rows there was originally. The indexes that were moved to the end of the array are restored to their original position.- Parameters:
original_numrows- the number of rows before the reduction was performed- See Also:
deleteRow(int, int),reduce()
naiveComputeColumnMaxima
public static void naiveComputeColumnMaxima(Matrix matrix, int[] col_maxima)
- This is a simpler method for calculating column maxima. It does the same job as
computeColumnMaxima, but without complexity of the SMAWK algorithm.The matrix is required to be an object that implements the
Matrixinterface. It is also expected to be monotone. If it is not, the result is unpredictable but, unlikecomputeColumnMaxima, it cannot lead to an ArrayIndexOutOfBoundsException.This method does not return the maximum values itself, but just the indexes of their rows. Note that the array of column maxima (the computation result) must be created beforehand and its size must be equal to the number of columns of the matrix.
It takes advantage of the monotone property of the matrix only (SMAWK explores the stronger constraint of total monotonicity), and therefore has a worst case time complexity of O(n * m), where n is the number of rows and m is the number of columns. However, this method tends to be faster for small matrices because it avoids recursions and row and column manipulations.
- Parameters:
matrix- the matrix that will have its column maxima computedcol_maxima- the array of column maxima (indexes of the rows containing maximum values of each column); this is the computation result- See Also:
naiveComputeRowMaxima(neobio.alignment.Matrix, int[])
naiveComputeRowMaxima
public static void naiveComputeRowMaxima(Matrix matrix, int[] row_maxima)
- This is a simpler method for calculating row maxima. It does not use the SMAWK
algorithm.
The matrix is required to be an object that implements the
Matrixinterface. It is also expected to be monotone. If it is not, the result is unpredictable but, unlikecomputeColumnMaxima, it cannot lead to an ArrayIndexOutOfBoundsException.This method does not return the maximum values itself, but just the indexes of their columns. Note that the array of row maxima (the computation result) must be created beforehand and its size must be equal to the number of columns of the matrix.
It takes advantage of the monotone property of the matrix only (SMAWK explores the stronger constraint of total monotonicity), and therefore has a worst case time complexity of O(n * m), where n is the number of rows and m is the number of columns. However, this method tends to be faster for small matrices because it avoids recursions and row and column manipulations.
- Parameters:
matrix- the matrix that will have its row maxima computedrow_maxima- the array of row maxima (indexes of the columns containing maximum values of each row); this is the computation result- See Also:
naiveComputeColumnMaxima(neobio.alignment.Matrix, int[])
printMatrix
protected void printMatrix()
- Prints the current state of the matrix (reflecting deleted rows and columns) in the
standard output. It can be used internally for debugging.
printMatrix
public static void printMatrix(Matrix matrix)
- Prints the contents of an object implementing the matrix interface in the standard
output. It can be used for debugging.
- Parameters:
matrix- a matrix
|
|
||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
NeoBio is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with NeoBio; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
neobio-0.0.20030929/doc/neobio/alignment/PairwiseAlignment.html 0000644 0002656 0002032 00000055523 07727746672 023227 0 ustar tillea admin
|
NeoBio API | ||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
neobio.alignment
Class PairwiseAlignment
java.lang.Object | +--neobio.alignment.PairwiseAlignment
- All Implemented Interfaces:
- java.io.Serializable
- public class PairwiseAlignment
- extends java.lang.Object
- implements java.io.Serializable
- extends java.lang.Object
This class is the product of a pairwise alignment, generated by one subclasses of
PairwiseAlignmentAlgorithm. It contains the two sequences strings with
gaps, a score tag line, and a score value. It is typically displayed in three rows as
in the following example of an alignment between parts of two protein sequences:
MDEIHQLEDMFTVDSETLRKVVKHFILPHD-----MRTTKHQEELWSFIAELDSLKDFMVEQE // sequence 1
M +I E +FTV +ETL+ V KHFILP D MRTT++ +ELW FIA DSLK F+ EQ // score tag line
MQQIENFEKIFTVPTETLQAVTKHFILP-DATETLMRTTQNPDELWEFIA--DSLKAFIDEQF // sequence 2
Each column has one character of each sequence and a score tag. The same character is displayed in all three rows when a column has an exact match (character of sequences 1 and 2 are equal). When a mismatch occurs (substitution of different characters), the score tag is left blank. A '+' in the score line signals a partial match (a substitution of similar characters). The difference between a partial match and a mismatch is that the score of a partial match is positive whereas the score of a mismatch is zero or negative (each case is determined by the scoring scheme).
Gaps are usually represented by dashes ('-') and have a blank score tag. Insertions have dashes in sequence 1 and the inserted character in sequence 2. Deletions, by contrast, have the deleted character in sequence 1 and dashes in sequence 2.
Each column carries a score value for the corresponding operation (as defined by the scoring scheme). The overall score of a pairwise alignment is the sum of all columns scores values.
When the scoring schemes does not support partial matches, a match is usually signaled by a '|' character.
Note that these special characters are defined by the
PairwiseAlignmentAlgorithm class. Consult that class specification for the
actual configuration. For instance, an alignment between two DNA fragmens may look like
this:
A--C--TAAAAAGCA--TT-AATAATAAA-A
| | |||| ||| || ||||| ||| |
AAGCCCTAAACCGCAAGTTTAATAA-AAATA
This class is serializable, so it can be saved to a file (or any other output). It
overrides the default equals method of the Object class to
allow a proper comparsion of alignments produced by different algorithms or even
different runs of the same algorithm. However, it does not override the
hashCode method as it is generally the case to maintain the contract for
the hashCode method (which states that equal objects must have equal hash
codes). Hence, as it is, its use in a hash table is not supported.
- Author:
- Sergio A. de Carvalho Jr.
- See Also:
PairwiseAlignmentAlgorithm,PairwiseAlignmentAlgorithm.MATCH_TAG,PairwiseAlignmentAlgorithm.APPROXIMATE_MATCH_TAG,PairwiseAlignmentAlgorithm.MISMATCH_TAG,PairwiseAlignmentAlgorithm.GAP_TAG,PairwiseAlignmentAlgorithm.GAP_CHARACTER,ScoringScheme,ScoringScheme.isPartialMatchSupported(), Serialized Form
| Field Summary | |
protected java.lang.String |
gapped_seq1
First gapped sequence. |
protected java.lang.String |
gapped_seq2
Second gapped sequence. |
protected int |
score
The overall score value for this alignment. |
protected java.lang.String |
score_tag_line
The score tag line. |
| Constructor Summary | |
PairwiseAlignment(java.lang.String gapped_seq1,
java.lang.String score_tag_line,
java.lang.String gapped_seq2,
int score)
Creates a PairwiseAlignment instance with the specified gapped
sequences, score tag line and score value. |
|
| Method Summary | |
boolean |
equals(java.lang.Object obj)
Compares this object to the specified object. |
java.lang.String |
getGappedSequence1()
Returns the first gapped sequence. |
java.lang.String |
getGappedSequence2()
Returns the second gapped sequence. |
int |
getScore()
Returns the score for this alignment. |
java.lang.String |
getScoreTagLine()
Returns the score tag line. |
java.lang.String |
toString()
Returns a four-line String representation of this alignment in the following order: first gapped sequence, score tag line, second gapped sequence and the score value. |
| Methods inherited from class java.lang.Object |
clone, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait |
| Field Detail |
gapped_seq1
protected java.lang.String gapped_seq1
- First gapped sequence.
score_tag_line
protected java.lang.String score_tag_line
- The score tag line.
gapped_seq2
protected java.lang.String gapped_seq2
- Second gapped sequence.
score
protected int score
- The overall score value for this alignment.
| Constructor Detail |
PairwiseAlignment
public PairwiseAlignment(java.lang.String gapped_seq1, java.lang.String score_tag_line, java.lang.String gapped_seq2, int score)
- Creates a
PairwiseAlignmentinstance with the specified gapped sequences, score tag line and score value. - Parameters:
gapped_seq1- the first gapped sequencescore_tag_line- the score tag linegapped_seq2- the second gapped sequencescore- the overall score value for this alignment
| Method Detail |
getGappedSequence1
public java.lang.String getGappedSequence1()
- Returns the first gapped sequence.
- Returns:
- first gapped sequence
getScoreTagLine
public java.lang.String getScoreTagLine()
- Returns the score tag line.
- Returns:
- score tag line
getGappedSequence2
public java.lang.String getGappedSequence2()
- Returns the second gapped sequence.
- Returns:
- second gapped sequence
getScore
public int getScore()
- Returns the score for this alignment.
- Returns:
- overall score for this alignment
toString
public java.lang.String toString()
- Returns a four-line String representation of this alignment in the following
order: first gapped sequence, score tag line, second gapped sequence and the
score value.
- Overrides:
toStringin classjava.lang.Object
- Returns:
- a String representation of this scoring matrix
equals
public boolean equals(java.lang.Object obj)
- Compares this object to the specified object. The result is
trueif and only if the argument is notnulland is anPairwiseAlignmentobject that contains the same values as this object, i.e. the same gapped sequences, the same score tag line and the same score.- Overrides:
equalsin classjava.lang.Object
- Parameters:
obj- the object to compare with- Returns:
trueif objects are the same,falseotherwise
|
|
||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
NeoBio is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with NeoBio; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
neobio-0.0.20030929/doc/neobio/alignment/package-frame.html 0000644 0002656 0002032 00000005740 07727746666 022267 0 ustar tillea admin
|
Interfaces
Matrix |
|
Exceptions
IncompatibleScoringSchemeException InvalidScoringMatrixException InvalidSequenceException |
|
NeoBio API | ||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
neobio.alignment
Class InvalidSequenceException
java.lang.Object
|
+--java.lang.Throwable
|
+--java.lang.Exception
|
+--neobio.alignment.InvalidSequenceException
- All Implemented Interfaces:
- java.io.Serializable
- public class InvalidSequenceException
- extends java.lang.Exception
Signals that the sequence does not comply with the specification (see CharSequence or FactorSequence for details).
- Author:
- Sergio A. de Carvalho Jr.
- See Also:
CharSequence,FactorSequence, Serialized Form
| Field Summary |
| Fields inherited from class java.lang.Exception |
|
| Fields inherited from class java.lang.Throwable |
|
| Constructor Summary | |
InvalidSequenceException()
Constructs an InvalidSequenceException with null as its
error detail message. |
|
InvalidSequenceException(java.lang.String message)
Constructs an InvalidSequenceException with the specified
detail message. |
|
InvalidSequenceException(java.lang.String message,
java.lang.Throwable cause)
Constructs an InvalidSequenceException with the specified
detail message and cause. |
|
InvalidSequenceException(java.lang.Throwable cause)
Constructs an InvalidSequenceException with the specified
cause (and a detail message that typically contains the class and detail message
of cause). |
|
| Methods inherited from class java.lang.Throwable |
fillInStackTrace, getCause, getLocalizedMessage, getMessage, getStackTrace, initCause, printStackTrace, printStackTrace, printStackTrace, setStackTrace, toString |
| Methods inherited from class java.lang.Object |
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait |
| Constructor Detail |
InvalidSequenceException
public InvalidSequenceException()
- Constructs an
InvalidSequenceExceptionwith null as its error detail message.
InvalidSequenceException
public InvalidSequenceException(java.lang.String message)
- Constructs an
InvalidSequenceExceptionwith the specified detail message. - Parameters:
message- an error message
InvalidSequenceException
public InvalidSequenceException(java.lang.Throwable cause)
- Constructs an
InvalidSequenceExceptionwith the specified cause (and a detail message that typically contains the class and detail message of cause). - Parameters:
cause- a cause
InvalidSequenceException
public InvalidSequenceException(java.lang.String message, java.lang.Throwable cause)
- Constructs an
InvalidSequenceExceptionwith the specified detail message and cause. - Parameters:
message- an error messagecause- a cause
|
|
||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
NeoBio is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with NeoBio; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
neobio-0.0.20030929/doc/neobio/alignment/CrochemoreLandauZivUkelsonLocalAlignment.html 0000644 0002656 0002032 00000143650 07727746672 027663 0 ustar tillea admin
|
NeoBio API | ||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
neobio.alignment
Class CrochemoreLandauZivUkelsonLocalAlignment
java.lang.Object | +--neobio.alignment.PairwiseAlignmentAlgorithm | +--neobio.alignment.CrochemoreLandauZivUkelson | +--neobio.alignment.CrochemoreLandauZivUkelsonLocalAlignment
- public class CrochemoreLandauZivUkelsonLocalAlignment
- extends CrochemoreLandauZivUkelson
This class implements the local pairwise sequence alignment algorithm (with linear gap penalty function) due to Maxime Crochemore, Gad Landau and Michal Ziv-Ukelson (2002).
This implementation derives from the paper of M.Crochemore, G.Landau and M.Ziv-Ukelson, A Sub-quadratic Sequence Alignment Algorithm for Unrestricted Scoring Matrices (available here as PDF or Postscript).
For a general description of the algorithm, please refer to the specification of the abstract CrochemoreLandauZivUkelson superclass.
This class consist mainly of methods that:
createBlock
and its variants);
computeOutputBorder;
locateScore;
buildOptimalAlignment.
This algorithm works essentially in the same way as the global alignment version. The main differences is that an aptimal path can either be contained entirely in a block (called C-path) or be a block-crossing path. A block-crossing path consists of a (possibly empty) S-path (a path that starts inside a block and ends in its output border), followed by any number of paths that cross a block from its input border to its output border, and ending in an E-path (a path that starts in the input border of a block and ends inside the block).
Therefore, it is necessary to compute extra information to keep track of these possibilities. This is accomplished by using an instance of a LocalAlignmentBlock (which extends the AlignmentBlock class) for every block in the block table.
- Author:
- Sergio A. de Carvalho Jr.
- See Also:
CrochemoreLandauZivUkelson,CrochemoreLandauZivUkelsonLocalAlignment
| Field Summary | |
protected int |
max_col
The column index of a block (in the block table) where the high scoring local alignment ends. |
protected byte |
max_path_type
The type of the high scoring local alignment found. |
protected int |
max_row
The row index of a block (in the block table) where the high scoring local alignment ends. |
protected int |
max_score
The score of the high scoring local alignment found. |
protected int |
max_source_index
If the high scoring local alignment ends in an E-path at a block B, this field contains the index of the entry in the input border of B that where the E-path starts. |
protected static byte |
TYPE_C_PATH
A constant that indicates that the high scoring path ending in a given block is a C-path, i.e. one that starts inside the block. |
protected static byte |
TYPE_CROSSING_PATH
A constant that indicates that the best path ending at a given entry of the output border is a block-crossing path (one that starts outside the block). |
protected static byte |
TYPE_E_PATH
A constant that indicates that the high scoring path ending in a given block is an E-path, i.e. one that starts at its input border. |
protected static byte |
TYPE_S_PATH
A constant that indicates that the best path ending at a given entry of the output border is a S-path (one that starts inside the block). |
| Fields inherited from class neobio.alignment.CrochemoreLandauZivUkelson |
block_table, DIAGONAL_DIRECTION, LEFT_DIRECTION, num_cols, num_rows, out_matrix, seq1, seq2, smawk, STOP_DIRECTION, TOP_DIRECTION |
| Fields inherited from class neobio.alignment.PairwiseAlignmentAlgorithm |
alignment, APPROXIMATE_MATCH_TAG, GAP_CHARACTER, GAP_TAG, MATCH_TAG, MISMATCH_TAG, score, score_computed, scoring, sequences_loaded, use_match_tag |
| Constructor Summary | |
CrochemoreLandauZivUkelsonLocalAlignment()
|
|
| Method Summary | |
protected PairwiseAlignment |
buildOptimalAlignment()
Builds an optimal local alignment between the loaded sequences after the block table has been computed by tracing a path back in the block table. |
protected void |
computeOutputBorder(LocalAlignmentBlock block,
int row,
int col,
int dim,
int lc,
int lr)
Computes the output border of a block. |
protected AlignmentBlock |
createBlock(Factor factor1,
Factor factor2,
int row,
int col)
Creates and computes all information of an alignment block. |
protected AlignmentBlock |
createFirstColumnBlock(Factor factor1,
Factor factor2,
int row)
Creates and computes all information of an alignment block of the first column of the block table. |
protected AlignmentBlock |
createFirstRowBlock(Factor factor1,
Factor factor2,
int col)
Creates and computes all information of an alignment block of the first column of the block table. |
protected AlignmentBlock |
createRootBlock(Factor factor1,
Factor factor2)
Creates the root block. |
protected int |
locateScore()
Returns the score of the high scoring local alignment in the block table. |
protected void |
traverseBlockCrossingPath(LocalAlignmentBlock block,
java.lang.StringBuffer gapped_seq1,
java.lang.StringBuffer tag_line,
java.lang.StringBuffer gapped_seq2)
Traverses a series of block crossing paths to retrieve an optimal alignment. |
protected void |
traverseS_Path(LocalAlignmentBlock block,
java.lang.StringBuffer gapped_seq1,
java.lang.StringBuffer tag_line,
java.lang.StringBuffer gapped_seq2)
Traverses an S-path of a block to retrieve a part of an optimal alignment from the new vertex of a block to entry in its input border. |
| Methods inherited from class neobio.alignment.CrochemoreLandauZivUkelson |
assembleDistMatrix, assembleInputBorder, computeBlockTable, computePairwiseAlignment, computeScore, getDiagonalPrefix, getLeftPrefix, getTopPrefix, loadSequencesInternal, traverseBlock, unloadSequencesInternal |
| Methods inherited from class neobio.alignment.PairwiseAlignmentAlgorithm |
getPairwiseAlignment, getScore, loadSequences, max, max, max, scoreDeletion, scoreInsertion, scoreSubstitution, setScoringScheme, unloadSequences, useMatchTag |
| Methods inherited from class java.lang.Object |
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Field Detail |
TYPE_CROSSING_PATH
protected static final byte TYPE_CROSSING_PATH
- A constant that indicates that the best path ending at a given entry of the output
border is a block-crossing path (one that starts outside the block).
- See Also:
- Constant Field Values
TYPE_S_PATH
protected static final byte TYPE_S_PATH
- A constant that indicates that the best path ending at a given entry of the output
border is a S-path (one that starts inside the block).
- See Also:
- Constant Field Values
TYPE_C_PATH
protected static final byte TYPE_C_PATH
- A constant that indicates that the high scoring path ending in a given block is a
C-path, i.e. one that starts inside the block.
- See Also:
- Constant Field Values
TYPE_E_PATH
protected static final byte TYPE_E_PATH
- A constant that indicates that the high scoring path ending in a given block is an
E-path, i.e. one that starts at its input border.
- See Also:
- Constant Field Values
max_score
protected int max_score
- The score of the high scoring local alignment found.
max_row
protected int max_row
- The row index of a block (in the block table) where the high scoring local
alignment ends.
max_col
protected int max_col
- The column index of a block (in the block table) where the high scoring local
alignment ends.
max_path_type
protected byte max_path_type
- The type of the high scoring local alignment found.
max_source_index
protected int max_source_index
- If the high scoring local alignment ends in an E-path at a block B, this field
contains the index of the entry in the input border of B that where the E-path
starts.
| Constructor Detail |
CrochemoreLandauZivUkelsonLocalAlignment
public CrochemoreLandauZivUkelsonLocalAlignment()
| Method Detail |
createBlock
protected AlignmentBlock createBlock(Factor factor1, Factor factor2, int row, int col) throws IncompatibleScoringSchemeException
- Creates and computes all information of an alignment block. This method works
essentially in the same way as its global alignment counterpart. Its main job is to
compute the DIST column for the block. It then request the
computeOutputBordermethod to compute the block's output border. It also computes all S, C and E-paths of this block. Finally, it checks if the C-path of this block is higher than the highest score found so far.- Specified by:
createBlockin classCrochemoreLandauZivUkelson
- Parameters:
factor1- factor of the first sequencefactor2- factor of the second sequencerow- row index of the block in the block tablecol- column index of the block in the block table- Returns:
- the computed block
- Throws:
IncompatibleScoringSchemeException- if the scoring scheme is not compatible with the sequences being aligned
createRootBlock
protected AlignmentBlock createRootBlock(Factor factor1, Factor factor2)
- Creates the root block. This is a special case of the
createBlockmethod. No information is actually computed.- Specified by:
createRootBlockin classCrochemoreLandauZivUkelson
- Parameters:
factor1- factor of the first sequencefactor2- factor of the second sequence- Returns:
- the root block
createFirstRowBlock
protected AlignmentBlock createFirstRowBlock(Factor factor1, Factor factor2, int col) throws IncompatibleScoringSchemeException
- Creates and computes all information of an alignment block of the first column of
the block table. This is a special case of the
createBlockmethod.- Specified by:
createFirstRowBlockin classCrochemoreLandauZivUkelson
- Parameters:
factor1- factor of the first sequencefactor2- factor of the second sequencecol- column index of the block in the block table- Returns:
- the computed block
- Throws:
IncompatibleScoringSchemeException- if the scoring scheme is not compatible with the sequences being aligned- See Also:
createBlock
createFirstColumnBlock
protected AlignmentBlock createFirstColumnBlock(Factor factor1, Factor factor2, int row) throws IncompatibleScoringSchemeException
- Creates and computes all information of an alignment block of the first column of
the block table. This is a special case of the
createBlockmethod.- Specified by:
createFirstColumnBlockin classCrochemoreLandauZivUkelson
- Parameters:
factor1- factor of the first sequencefactor2- factor of the second sequencerow- row index of the block in the block table- Returns:
- the computed block
- Throws:
IncompatibleScoringSchemeException- if the scoring scheme is not compatible with the sequences being aligned- See Also:
createBlock
computeOutputBorder
protected void computeOutputBorder(LocalAlignmentBlock block, int row, int col, int dim, int lc, int lr)
- Computes the output border of a block. This method works essentially in the same
way as its global alignment counterpart:
- Retrieve the block's input border;
- Retrieve the block's complete DIST matrix;
- Create an interface to the OUT matrix from the input border and DIST matrix;
- Use SMAWK to compute all column maxima of the OUT matrix (SMAWK finds the index of the row that contains the maximum value of a column);
- Assemble the output border by extracting the maximum values of each column of the OUT matrix using the information obtained in the previous step.
However, it also check if there is a better path starting inside the block (an S path) and oupdate the output border accordingly. It also checks if this block has any path of score higher than the maximum score found so far.
- Parameters:
block- the block for which the output border is to be computedrow- row index of the block in the block tablecol- column index of the block in the block tabledim- dimension of the output borderlc- number of columns of the blocklr- number of row of the block
buildOptimalAlignment
protected PairwiseAlignment buildOptimalAlignment() throws IncompatibleScoringSchemeException
- Builds an optimal local alignment between the loaded sequences after the block
table has been computed by tracing a path back in the block table.
- Specified by:
buildOptimalAlignmentin classCrochemoreLandauZivUkelson
- Returns:
- an optimal global alignment
- Throws:
IncompatibleScoringSchemeException- If the scoring scheme is not compatible with the loaded sequences.- See Also:
CrochemoreLandauZivUkelson.traverseBlock(neobio.alignment.AlignmentBlock, int, java.lang.StringBuffer, java.lang.StringBuffer, java.lang.StringBuffer)
traverseBlockCrossingPath
protected void traverseBlockCrossingPath(LocalAlignmentBlock block, java.lang.StringBuffer gapped_seq1, java.lang.StringBuffer tag_line, java.lang.StringBuffer gapped_seq2) throws IncompatibleScoringSchemeException
- Traverses a series of block crossing paths to retrieve an optimal alignment. A
block-crossing path consists of a (possibly empty) S-path (a path that
starts inside a block and ends in its output border), followed by any number of
paths that cross a block from its input border to its output border, and ending in
an E-path (a path that starts in the input border of a block and ends inside
the block).
- Parameters:
block- the block to be traversedgapped_seq1- the StringBuffer to where the gapped sequence 1 is written totag_line- the StringBuffer to where the tag_line is written togapped_seq2- the StringBuffer to where the gapped sequence 2 is written to- Throws:
IncompatibleScoringSchemeException- If the scoring scheme is not compatible with the loaded sequences.
traverseS_Path
protected void traverseS_Path(LocalAlignmentBlock block, java.lang.StringBuffer gapped_seq1, java.lang.StringBuffer tag_line, java.lang.StringBuffer gapped_seq2) throws IncompatibleScoringSchemeException
- Traverses an S-path of a block to retrieve a part of an optimal alignment from the
new vertex of a block to entry in its input border. This method is essentially
similar to the
traverseBlock. The only difference is that it uses the information of theS_direction fieldof theLocalAlignmentBlockclass.- Parameters:
block- the block to be traversedgapped_seq1- the StringBuffer to where the gapped sequence 1 is written totag_line- the StringBuffer to where the tag_line is written togapped_seq2- the StringBuffer to where the gapped sequence 2 is written to- Throws:
IncompatibleScoringSchemeException- If the scoring scheme is not compatible with the loaded sequences.
locateScore
protected int locateScore()
- Returns the score of the high scoring local alignment in the block table.
- Specified by:
locateScorein classCrochemoreLandauZivUkelson
- Returns:
- the score of the highest scoring local alignment
|
|
||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
NeoBio is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with NeoBio; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
neobio-0.0.20030929/doc/neobio/alignment/OutMatrix.html 0000644 0002656 0002032 00000051340 07727746672 021532 0 ustar tillea admin
|
NeoBio API | ||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
neobio.alignment
Class OutMatrix
java.lang.Object | +--neobio.alignment.OutMatrix
- All Implemented Interfaces:
- Matrix
Implements an interface to the OUT matrix of a block. This class is used by the CrochemoreLandauZivUkelson and subclasses to enconde the OUT matrix from the input border and DIST matrix of an AlignmentBlock.
The OUT matrix defined as OUT[i,j] = I[i] + DIST[i,j] where I is the
input border array and DIST is the DIST matrix.
The output border of a block is computed from the OUT matrix by taking the maximum value of each column. Note that this class does not compute the OUT matrix, it just stores the necessary information to retrieve a value at any position of the matrix.
It implements the Matrix interface so that the SMAWK algorithm can be used to compute its column maxima.
For more information on how this class is used, please refer to the specification
of the CrochemoreLandauZivUkelson and its subclasses.
- Author:
- Sergio A. de Carvalho Jr.
- See Also:
CrochemoreLandauZivUkelson,CrochemoreLandauZivUkelsonGlobalAlignment,CrochemoreLandauZivUkelsonLocalAlignment,AlignmentBlock,Smawk
| Field Summary | |
protected int |
dim
The dimension of the OUT matrix. |
protected int[][] |
dist
The DIST matrix of a block. |
protected int[] |
input_border
The input border of a block. |
protected int |
lc
The number of columns of the block. |
protected int |
max_length
The length of the longest sequence (number of characters) being aligned. |
protected int |
max_score
The maximum absolute score that the current scoring scheme can return. |
| Constructor Summary | |
OutMatrix()
|
|
| Method Summary | |
void |
init(int max_length,
int max_score)
Initialised this OUT matrix interface. |
int |
numColumns()
Returns the number of columns of this OUT matrix. |
int |
numRows()
Returns the number of rows of this OUT matrix. |
void |
setData(int[][] dist,
int[] input_border,
int dim,
int lc)
Sets this interface's data to represent an OUT matrix for a block. |
int |
valueAt(int row,
int col)
Returns the value at a given position of the matrix. |
| Methods inherited from class java.lang.Object |
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Field Detail |
max_length
protected int max_length
- The length of the longest sequence (number of characters) being aligned. It needs
to be set only once per alignment.
max_score
protected int max_score
- The maximum absolute score that the current scoring scheme can return. It needs
to be set only once per alignment.
dist
protected int[][] dist
- The DIST matrix of a block.
input_border
protected int[] input_border
- The input border of a block.
dim
protected int dim
- The dimension of the OUT matrix.
lc
protected int lc
- The number of columns of the block.
| Constructor Detail |
OutMatrix
public OutMatrix()
| Method Detail |
init
public void init(int max_length, int max_score)
- Initialised this OUT matrix interface. This method needs to be executed only once
per alignment.
- Parameters:
max_length- the length of the longest sequence (number of characters) being alignedmax_score- the maximum absolute score that the current scoring scheme can return
setData
public void setData(int[][] dist, int[] input_border, int dim, int lc)
- Sets this interface's data to represent an OUT matrix for a block. This method
is typically executed once for each block being aligned.
- Parameters:
dist- the DIST matrixinput_border- the input borderdim- the dimension of the OUT matrixlc- the number of columns of the block
valueAt
public int valueAt(int row, int col)
- Returns the value at a given position of the matrix. In general it returns the
value of
DIST[col][row] + input_border[row]. However, special cases occur for its upper right and lower left triangular parts.- Parameters:
row- row indexcol- column index- Returns:
- the value at row
row, columncolof this OUT matrix
numRows
public int numRows()
- Returns the number of rows of this OUT matrix.
- Returns:
- the number of rows of this OUT matrix
numColumns
public int numColumns()
- Returns the number of columns of this OUT matrix.
- Specified by:
numColumnsin interfaceMatrix
- Returns:
- the number of columns of this OUT matrix
|
|
||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
NeoBio is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with NeoBio; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
neobio-0.0.20030929/doc/neobio/alignment/FactorSequence.html 0000644 0002656 0002032 00000051570 07727746672 022512 0 ustar tillea admin
|
NeoBio API | ||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
neobio.alignment
Class FactorSequence
java.lang.Object | +--neobio.alignment.FactorSequence
- public class FactorSequence
- extends java.lang.Object
This class builds a list of factors of a character sequence as induced by its Lempel-Ziv (LZ78) factorisation. Each factor is enconded as the longest factor previously seen plus one character.
The input can come from any source, provided it is encapsulated in a proper
Reader instance. The stream is expected to be ready (i.e. the next
read operation must return the first character of the sequence) and it is
not closed when its end is reached, so the client is allowed to reset it and maybe use
it for another purpose.
Sequences can contain letters only although lines started with the
COMMENT_CHAR character ('>') are regarded as comments and are completely
skipped. White spaces (including tabs, line feeds and carriage returns) are also
ignored throughout.
This class uses a Trie to keep track of a list of factors. Each node of the trie contains a Factor of the text. As the sequence is read from the input, the trie is traversed as far as possible. When a leaf node is reached (which means that the longest prefix of the input has been found), two tasks are accomplished:
- a new
Factoris created with the character at the current position of the input and the leaf node's factor; - a new node is added to the trie with the character at the current position of the input;
Each factor also receives a serial number according to the order they are found and a pointer to the next factor (in that order) for fast access. This pointer, together with the factor's ancestor pointer forms a doubly-linked list of factors. The original text can then be reconstructed simply by following the linked list and writing out its factors.
As an example, the sequence ACTAAACCGCATTAATAATAAAA is parsed into the
following 12 factors:
0 ( , ) = empty
1 (0,A) = A
2 (0,C) = C
3 (0,T) = T
4 (1,A) = AA
5 (1,C) = AC
6 (2,G) = CG
7 (2,A) = CA
8 (3,T) = TT
9 (4,T) = AAT
10 (9,A) = AATA
11 (4,A) = AAA
serial # (prefix, new char) = factor text
This class is used by CrochemoreLandauZivUkelson algorithm to speed up the classic dynamic programming approach to sequence alignment.
- Author:
- Sergio A. de Carvalho Jr.
- See Also:
Factor,Trie,CrochemoreLandauZivUkelson
| Field Summary | |
protected static char |
COMMENT_CHAR
The character used to start a comment line in a sequence file. |
protected int |
num_chars
The numbers of character represented by this sequence. |
protected int |
num_factors
The numbers of factors generated by the LZ78 parsing of the sequence. |
protected Factor |
root_factor
A pointer to the root factor, the one that starts the list of factors. |
| Constructor Summary | |
FactorSequence(java.io.Reader reader)
Creates a new instance of a FactorSequence, loading the sequence data
from the Reader input stream. |
|
| Method Summary | |
Factor |
getRootFactor()
Returns the root factor, the one that starts the list of factors. |
int |
numChars()
Returns the number of characters of the original sequence. |
int |
numFactors()
Returns the number of factors produced by the LZ78 parsing of the text. |
java.lang.String |
printFactors()
Returns a string representation of the actual list of factors produced by the LZ78 parsing of the text. |
java.lang.String |
toString()
Reconstructs the sequence from the list of factors induced by the LZ78 parsing of the text. |
| Methods inherited from class java.lang.Object |
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait |
| Field Detail |
COMMENT_CHAR
protected static final char COMMENT_CHAR
- The character used to start a comment line in a sequence file. When this character
is found, the rest of the line is ignored.
- See Also:
- Constant Field Values
root_factor
protected Factor root_factor
- A pointer to the root factor, the one that starts the list of factors.
num_chars
protected int num_chars
- The numbers of character represented by this sequence.
num_factors
protected int num_factors
- The numbers of factors generated by the LZ78 parsing of the sequence.
| Constructor Detail |
FactorSequence
public FactorSequence(java.io.Reader reader) throws java.io.IOException, InvalidSequenceException
- Creates a new instance of a
FactorSequence, loading the sequence data from theReaderinput stream. A doubly-linked list of factors is built according to its LZ78 factorisation. - Parameters:
reader- source of characters for this sequence- Throws:
java.io.IOException- if an I/O exception occurs when reading the inputInvalidSequenceException- if the input does not contain a valid sequence
| Method Detail |
getRootFactor
public Factor getRootFactor()
- Returns the root factor, the one that starts the list of factors.
- Returns:
- root factor
numFactors
public int numFactors()
- Returns the number of factors produced by the LZ78 parsing of the text.
- Returns:
- number of factors
numChars
public int numChars()
- Returns the number of characters of the original sequence.
- Returns:
- number of characters of the original sequence
toString
public java.lang.String toString()
- Reconstructs the sequence from the list of factors induced by the LZ78 parsing of
the text.
- Overrides:
toStringin classjava.lang.Object
- Returns:
- the original sequence
printFactors
public java.lang.String printFactors()
- Returns a string representation of the actual list of factors produced by the LZ78
parsing of the text. Each factor is printed out in a separate line, in the order
they appear in the text, with its serial number, its ancestor's serial number, its
new character, length and a string representation of the factor itself.
- Returns:
- a string representation of the list of factors
|
|
||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
NeoBio is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with NeoBio; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
neobio-0.0.20030929/doc/constant-values.html 0000644 0002656 0002032 00000034423 07727746666 017501 0 ustar tillea admin
|
NeoBio API | ||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||
Constant Field Values
Contents
| neobio.alignment.* |
| neobio.alignment.CharSequence | ||
protected static final char |
COMMENT_CHAR |
62 |
| neobio.alignment.CrochemoreLandauZivUkelson | ||
protected static final byte |
DIAGONAL_DIRECTION |
2 |
protected static final byte |
LEFT_DIRECTION |
1 |
protected static final byte |
STOP_DIRECTION |
0 |
protected static final byte |
TOP_DIRECTION |
3 |
| neobio.alignment.CrochemoreLandauZivUkelsonLocalAlignment | ||
protected static final byte |
TYPE_C_PATH |
2 |
protected static final byte |
TYPE_CROSSING_PATH |
0 |
protected static final byte |
TYPE_E_PATH |
3 |
protected static final byte |
TYPE_S_PATH |
1 |
| neobio.alignment.FactorSequence | ||
protected static final char |
COMMENT_CHAR |
62 |
| neobio.alignment.PairwiseAlignmentAlgorithm | ||
protected static final char |
APPROXIMATE_MATCH_TAG |
43 |
protected static final char |
GAP_CHARACTER |
45 |
protected static final char |
GAP_TAG |
32 |
protected static final char |
MATCH_TAG |
124 |
protected static final char |
MISMATCH_TAG |
32 |
| neobio.alignment.ScoringMatrix | ||
protected static final char |
COMMENT_CHAR |
35 |
protected static final char |
INDEL_CHAR |
42 |
|
|
||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||
NeoBio is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with NeoBio; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
neobio-0.0.20030929/doc/allclasses-frame.html 0000644 0002656 0002032 00000006556 07727746666 017577 0 ustar tillea admin
|
NeoBio API | ||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||
Serialized Form
| Package neobio.alignment |
| Class neobio.alignment.IncompatibleScoringSchemeException implements Serializable |
| Class neobio.alignment.InvalidScoringMatrixException implements Serializable |
| Class neobio.alignment.InvalidSequenceException implements Serializable |
| Class neobio.alignment.PairwiseAlignment implements Serializable |
| Serialized Fields |
gapped_seq1
java.lang.String gapped_seq1
- First gapped sequence.
-
score_tag_line
java.lang.String score_tag_line
- The score tag line.
-
gapped_seq2
java.lang.String gapped_seq2
- Second gapped sequence.
-
score
int score
- The overall score value for this alignment.
-
| Package neobio.gui |
| Class neobio.gui.AboutDialog implements Serializable |
| Serialized Fields |
image_label
javax.swing.JLabel image_label
| Class neobio.gui.NeoBio implements Serializable |
| Serialized Fields |
file_menu
javax.swing.JMenu file_menu
help_menu
javax.swing.JMenu help_menu
menu_bar
javax.swing.JMenuBar menu_bar
new_alignment_item
javax.swing.JMenuItem new_alignment_item
exit_menuitem
javax.swing.JMenuItem exit_menuitem
about_menuitem
javax.swing.JMenuItem about_menuitem
mid_separator
javax.swing.JSeparator mid_separator
file_toolbar
javax.swing.JToolBar file_toolbar
toolbar_panel
javax.swing.JPanel toolbar_panel
alignment_button
javax.swing.JButton alignment_button
desktop_pane
javax.swing.JDesktopPane desktop_pane
| Class neobio.gui.PairwiseAlignmentFrame implements Serializable |
| Serialized Fields |
parent_frame
java.awt.Frame parent_frame
input_panel
javax.swing.JPanel input_panel
scoring_panel
javax.swing.JPanel scoring_panel
algorithm_panel
javax.swing.JPanel algorithm_panel
output_panel
javax.swing.JPanel output_panel
progress_tab_panel
javax.swing.JPanel progress_tab_panel
output_tab_panel
javax.swing.JPanel output_tab_panel
seq1_field
javax.swing.JTextField seq1_field
seq2_field
javax.swing.JTextField seq2_field
matrix_field
javax.swing.JTextField matrix_field
output_field
javax.swing.JTextField output_field
match_field
javax.swing.JTextField match_field
mismatch_field
javax.swing.JTextField mismatch_field
gap_field
javax.swing.JTextField gap_field
progress_area
javax.swing.JTextArea progress_area
output_area
javax.swing.JTextArea output_area
find_seq1_button
javax.swing.JButton find_seq1_button
find_seq2_button
javax.swing.JButton find_seq2_button
find_output_button
javax.swing.JButton find_output_button
find_matrix_button
javax.swing.JButton find_matrix_button
run_button
javax.swing.JButton run_button
algorithm_combo
javax.swing.JComboBox algorithm_combo
output_tab
javax.swing.JTabbedPane output_tab
screen_button
javax.swing.JRadioButton screen_button
file_button
javax.swing.JRadioButton file_button
basic_button
javax.swing.JRadioButton basic_button
matrix_button
javax.swing.JRadioButton matrix_button
scoring_group
javax.swing.ButtonGroup scoring_group
output_group
javax.swing.ButtonGroup output_group
seq1_label
javax.swing.JLabel seq1_label
seq2_label
javax.swing.JLabel seq2_label
match_label
javax.swing.JLabel match_label
mismatch_label
javax.swing.JLabel mismatch_label
gap_label
javax.swing.JLabel gap_label
find_dialog
javax.swing.JFileChooser find_dialog
output_to_file
boolean output_to_file
basic_scheme
boolean basic_scheme
algorithm_name
java.lang.String[] algorithm_name
algorithm
PairwiseAlignmentAlgorithm[] algorithm
|
|
||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||
NeoBio is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with NeoBio; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
neobio-0.0.20030929/doc/allclasses-noframe.html 0000644 0002656 0002032 00000006126 07727746666 020125 0 ustar tillea admin
|
NeoBio API | ||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||
How This API Document Is Organized
Overview
The Overview page is the front page of this API document and provides a list of all packages with a summary for each. This page can also contain an overall description of the set of packages.
Package
Each package has a page that contains a list of its classes and interfaces, with a summary for each. This page can contain four categories:
- Interfaces (italic)
- Classes
- Exceptions
- Errors
Class/Interface
Each class, interface, nested class and nested interface has its own separate page. Each of these pages has three sections consisting of a class/interface description, summary tables, and detailed member descriptions:
Each summary entry contains the first sentence from the detailed description for that item. The summary entries are alphabetical, while the detailed descriptions are in the order they appear in the source code. This preserves the logical groupings established by the programmer.
- Class inheritance diagram
- Direct Subclasses
- All Known Subinterfaces
- All Known Implementing Classes
- Class/interface declaration
- Class/interface description
- Nested Class Summary
- Field Summary
- Constructor Summary
- Method Summary
- Field Detail
- Constructor Detail
- Method Detail
Tree (Class Hierarchy)
There is a Class Hierarchy page for all packages, plus a hierarchy for each package. Each hierarchy page contains a list of classes and a list of interfaces. The classes are organized by inheritance structure starting withjava.lang.Object. The interfaces do not inherit fromjava.lang.Object.
- When viewing the Overview page, clicking on "Tree" displays the hierarchy for all packages.
- When viewing a particular package, class or interface page, clicking "Tree" displays the hierarchy for only that package.
Index
The Index contains an alphabetic list of all classes, interfaces, constructors, methods, and fields.
Prev/Next
These links take you to the next or previous class, interface, package, or related page.Frames/No Frames
These links show and hide the HTML frames. All pages are available with or without frames.
Serialized Form
Each serializable or externalizable class has a description of its serialization fields and methods. This information is of interest to re-implementors, not to developers using the API. While there is no link in the navigation bar, you can get to this information by going to any serialized class and clicking "Serialized Form" in the "See also" section of the class description.
This help file applies to API documentation generated using the standard doclet.
|
|
||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||
NeoBio is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with NeoBio; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
neobio-0.0.20030929/doc/overview-frame.html 0000644 0002656 0002032 00000002376 07727746666 017313 0 ustar tillea admin
| NeoBio API |
| All Classes
Packages
|
neobio-0.0.20030929/doc/index-all.html 0000644 0002656 0002032 00000346110 07727746666 016227 0 ustar tillea admin
|
NeoBio API | ||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||
A
- about_menuitem - Variable in class neobio.gui.NeoBio
- AboutDialog - class neobio.gui.AboutDialog.
- About screen.
- AboutDialog(Frame) - Constructor for class neobio.gui.AboutDialog
- Creates a new instance of the About screen.
- aboutMenuItemActionPerformed(ActionEvent) - Method in class neobio.gui.NeoBio
- add(JComponent, JComponent, GridBagConstraints, int, int) - Method in class neobio.gui.PairwiseAlignmentFrame
- add(Object, char) - Method in class neobio.alignment.Trie
- Adds a new child to this node.
- addSibling(Object, char) - Method in class neobio.alignment.Trie
- Adds a sibling to this node.
- algorithm - Variable in class neobio.gui.PairwiseAlignmentFrame
- algorithm_combo - Variable in class neobio.gui.PairwiseAlignmentFrame
- algorithm_name - Variable in class neobio.gui.PairwiseAlignmentFrame
- algorithm_panel - Variable in class neobio.gui.PairwiseAlignmentFrame
- alignment - Variable in class neobio.alignment.PairwiseAlignmentAlgorithm
- Stores the product of the last pairwise alignment performed.
- alignment_button - Variable in class neobio.gui.NeoBio
- AlignmentBlock - class neobio.alignment.AlignmentBlock.
- This class is used by the CrochemoreLandauZivUkelson algorithm to store the information of an alignment block.
- AlignmentBlock(Factor, Factor) - Constructor for class neobio.alignment.AlignmentBlock
- Creates a new root block.
- AlignmentBlock(Factor, Factor, int) - Constructor for class neobio.alignment.AlignmentBlock
- Creates a new alignment block, with all arrays created with the specified size.
- ancestor - Variable in class neobio.alignment.AlignmentBlock
- An array of pointers to prefix blocks of this block.
- ancestor - Variable in class neobio.alignment.Factor
- A pointer to this factor's ancestor, which represents a prefix of this factor's text.
- APPROXIMATE_MATCH_TAG - Static variable in class neobio.alignment.PairwiseAlignmentAlgorithm
- Tag character that signals an approximate match in the score tag line of an alignment.
- assembleDistMatrix(AlignmentBlock, int, int, int, int) - Method in class neobio.alignment.CrochemoreLandauZivUkelson
- Assembles the DIST matrix of a block by retrieving the DIST columns of its prefix blocks.
- assembleInputBorder(int, int, int, int) - Method in class neobio.alignment.CrochemoreLandauZivUkelson
- Assembles the input border of a block by retrieving the values at the output borders of the left and top blocks.
B
- basic_button - Variable in class neobio.gui.PairwiseAlignmentFrame
- basic_scheme - Variable in class neobio.gui.PairwiseAlignmentFrame
- BasicScoringScheme - class neobio.alignment.BasicScoringScheme.
- This class implements a basic scoring scheme.
- BasicScoringScheme(int, int, int) - Constructor for class neobio.alignment.BasicScoringScheme
- Creates a new instance of a basic scoring scheme with the specified values of match reward, mismatch penalty and gap cost.
- BasicScoringScheme(int, int, int, boolean) - Constructor for class neobio.alignment.BasicScoringScheme
- Creates a new instance of basic scoring scheme with the specified values of match reward, mismatch penalty and gap cost.
- block_table - Variable in class neobio.alignment.CrochemoreLandauZivUkelson
- The block table, which is a matrix of alignment blocks where each block represents the alignment between one factor of each sequence.
- buildOptimalAlignment() - Method in class neobio.alignment.CrochemoreLandauZivUkelson
- Retrieves an optimal alignment between the loaded sequences.
- buildOptimalAlignment() - Method in class neobio.alignment.CrochemoreLandauZivUkelsonLocalAlignment
- Builds an optimal local alignment between the loaded sequences after the block table has been computed by tracing a path back in the block table.
- buildOptimalAlignment() - Method in class neobio.alignment.CrochemoreLandauZivUkelsonGlobalAlignment
- Builds an optimal global alignment between the loaded sequences after the block table has been computed.
- buildOptimalAlignment() - Method in class neobio.alignment.NeedlemanWunsch
- Builds an optimal global alignment between the loaded sequences.
- buildOptimalAlignment() - Method in class neobio.alignment.SmithWaterman
- Builds an optimal local alignment between the loaded sequences.
C
- C - Variable in class neobio.alignment.LocalAlignmentBlock
- The value of the highest scoring path contained in this block, called C-path.
- case_sensitive - Variable in class neobio.alignment.ScoringScheme
- Determines whether this scoring scheme ignores the case of characters when computing their score.
- charAt(int) - Method in class neobio.alignment.CharSequence
- Returns the character at a given position.
- CharSequence - class neobio.alignment.CharSequence.
- This class implements a sequence of characters stored as an array that provides random access to any position in constant time.
- CharSequence(Reader) - Constructor for class neobio.alignment.CharSequence
- Creates a new instance of a
CharSequence, loading the sequence data from theReaderinput stream. - checkRunButtonStatus() - Method in class neobio.gui.PairwiseAlignmentFrame
- closeDialog(WindowEvent) - Method in class neobio.gui.AboutDialog
- col - Variable in class neobio.alignment.Smawk
- An array of column indexes reflecting the current state of the matrix.
- col_codes - Variable in class neobio.alignment.ScoringMatrix
- Stores matrix column headers in the order they were found.
- COMMENT_CHAR - Static variable in class neobio.alignment.ScoringMatrix
- The character used to start a comment line in the scoring matrix file.
- COMMENT_CHAR - Static variable in class neobio.alignment.FactorSequence
- The character used to start a comment line in a sequence file.
- COMMENT_CHAR - Static variable in class neobio.alignment.CharSequence
- The character used to start a comment line in a sequence file.
- computeBlockTable() - Method in class neobio.alignment.CrochemoreLandauZivUkelson
- Computes the block table.
- computeColumnMaxima(int[]) - Method in class neobio.alignment.Smawk
- This method implements the SMAWK algorithm to compute the column maxima of a given matrix.
- computeColumnMaxima(Matrix, int[]) - Method in class neobio.alignment.Smawk
- Computes the column maxima of a given matrix.
- computeMatrix() - Method in class neobio.alignment.NeedlemanWunsch
- Computes the dynamic programming matrix.
- computeMatrix() - Method in class neobio.alignment.SmithWaterman
- Computes the dynamic programming matrix.
- computeOutputBorder(AlignmentBlock, int, int, int, int, int) - Method in class neobio.alignment.CrochemoreLandauZivUkelsonGlobalAlignment
- Computes the output border of a block.
- computeOutputBorder(LocalAlignmentBlock, int, int, int, int, int) - Method in class neobio.alignment.CrochemoreLandauZivUkelsonLocalAlignment
- Computes the output border of a block.
- computePairwiseAlignment() - Method in class neobio.alignment.CrochemoreLandauZivUkelson
- Computes the block table (the result depends on subclasses, see
computeBlockTablefor details) and requests subclasses to retrieve an optimal alignment between the loaded sequences. - computePairwiseAlignment() - Method in class neobio.alignment.NeedlemanWunsch
- Builds an optimal global alignment between the loaded sequences after computing the dynamic programming matrix.
- computePairwiseAlignment() - Method in class neobio.alignment.SmithWaterman
- Builds an optimal local alignment between the loaded sequences after computing the dynamic programming matrix.
- computePairwiseAlignment() - Method in class neobio.alignment.PairwiseAlignmentAlgorithm
- Subclasses must implement this method to compute an alignment between the loaded sequences using the scoring scheme previously set.
- computeScore() - Method in class neobio.alignment.CrochemoreLandauZivUkelson
- Computes the block table (the result depends on subclasses, see
computeBlockTablefor details) and requests subclasses to locate the score of the highest scoring alignment between the two sequences in the block table. - computeScore() - Method in class neobio.alignment.NeedlemanWunsch
- Computes the score of the best global alignment between the two sequences using the scoring scheme previously set.
- computeScore() - Method in class neobio.alignment.SmithWaterman
- Computes the score of the best local alignment between the two sequences using the scoring scheme previously set.
- computeScore() - Method in class neobio.alignment.PairwiseAlignmentAlgorithm
- Subclasses must implement this method to compute the score of the alignment between the loaded sequences using the scoring scheme previously set.
- createBlock(Factor, Factor, int, int) - Method in class neobio.alignment.CrochemoreLandauZivUkelson
- Computes a block of the block table, which corresponds to an alignment block between one factor of sequence 1 and one factor of sequence 2.
- createBlock(Factor, Factor, int, int) - Method in class neobio.alignment.CrochemoreLandauZivUkelsonLocalAlignment
- Creates and computes all information of an alignment block.
- createBlock(Factor, Factor, int, int) - Method in class neobio.alignment.CrochemoreLandauZivUkelsonGlobalAlignment
- Creates and computes all information of an alignment block.
- createFirstColumnBlock(Factor, Factor, int) - Method in class neobio.alignment.CrochemoreLandauZivUkelson
- Computes a block at the first column (column zero) of the block table, which corresponds to an alignment block between one factor of sequence 1 and an empty string.
- createFirstColumnBlock(Factor, Factor, int) - Method in class neobio.alignment.CrochemoreLandauZivUkelsonLocalAlignment
- Creates and computes all information of an alignment block of the first column of the block table.
- createFirstColumnBlock(Factor, Factor, int) - Method in class neobio.alignment.CrochemoreLandauZivUkelsonGlobalAlignment
- Creates and computes all information of an alignment block of the first column of the block table.
- createFirstRowBlock(Factor, Factor, int) - Method in class neobio.alignment.CrochemoreLandauZivUkelson
- Computes a block at the first row (row zero) of the block table, which corresponds to an alignment block between one factor of sequence 2 and an empty string.
- createFirstRowBlock(Factor, Factor, int) - Method in class neobio.alignment.CrochemoreLandauZivUkelsonLocalAlignment
- Creates and computes all information of an alignment block of the first column of the block table.
- createFirstRowBlock(Factor, Factor, int) - Method in class neobio.alignment.CrochemoreLandauZivUkelsonGlobalAlignment
- Creates and computes all information of an alignment block of the first row of the block table.
- createRootBlock(Factor, Factor) - Method in class neobio.alignment.CrochemoreLandauZivUkelson
- Computes the root block of the block table.
- createRootBlock(Factor, Factor) - Method in class neobio.alignment.CrochemoreLandauZivUkelsonLocalAlignment
- Creates the root block.
- createRootBlock(Factor, Factor) - Method in class neobio.alignment.CrochemoreLandauZivUkelsonGlobalAlignment
- Creates the root block.
- CrochemoreLandauZivUkelson - class neobio.alignment.CrochemoreLandauZivUkelson.
- This abstract class is the superclass of both global and local sequence alignment algorithms (with linear gap penalty function) due to Maxime Crochemore, Gad Landau and Michal Ziv-Ukelson (2002).
- CrochemoreLandauZivUkelson() - Constructor for class neobio.alignment.CrochemoreLandauZivUkelson
- CrochemoreLandauZivUkelsonGlobalAlignment - class neobio.alignment.CrochemoreLandauZivUkelsonGlobalAlignment.
- This class implements the global pairwise sequence alignment algorithm (with linear gap penalty function) due to Maxime Crochemore, Gad Landau and Michal Ziv-Ukelson (2002).
- CrochemoreLandauZivUkelsonGlobalAlignment() - Constructor for class neobio.alignment.CrochemoreLandauZivUkelsonGlobalAlignment
- CrochemoreLandauZivUkelsonLocalAlignment - class neobio.alignment.CrochemoreLandauZivUkelsonLocalAlignment.
- This class implements the local pairwise sequence alignment algorithm (with linear gap penalty function) due to Maxime Crochemore, Gad Landau and Michal Ziv-Ukelson (2002).
- CrochemoreLandauZivUkelsonLocalAlignment() - Constructor for class neobio.alignment.CrochemoreLandauZivUkelsonLocalAlignment
D
- data - Variable in class neobio.alignment.Trie
- This node's stored data.
- deleteOddColumns() - Method in class neobio.alignment.Smawk
- This method simulates a deletion of odd rows by manipulating the
colarray of indexes. - deleteRow(int, int) - Method in class neobio.alignment.Smawk
- This method simulates a deletion of a row in the matrix during the
reduceoperation. - desktop_pane - Variable in class neobio.gui.NeoBio
- DIAGONAL_DIRECTION - Static variable in class neobio.alignment.CrochemoreLandauZivUkelson
- A constant that indicates that the diagonal direction must be followed to reach the source of an optimal path in a block during the trace back procedure to retrieve a high scoring alignment.
- dim - Variable in class neobio.alignment.OutMatrix
- The dimension of the OUT matrix.
- dimension - Variable in class neobio.alignment.ScoringMatrix
- Dimension of the (squared) matrix.
- direction - Variable in class neobio.alignment.AlignmentBlock
- An array of directions that must be followed to reach the source of the highest scoring path for each entry in the output border.
- dist - Variable in class neobio.alignment.OutMatrix
- The DIST matrix of a block.
- dist_column - Variable in class neobio.alignment.AlignmentBlock
- The DIST column of this block.
- DNA_CHARS - Static variable in class neobio.textui.RandomFactorSequenceGenerator
- Character set for DNA sequences.
- DNA_CHARS - Static variable in class neobio.textui.RandomSequenceGenerator
- Character set for DNA sequences.
E
- E_path_ancestor - Variable in class neobio.alignment.LocalAlignmentBlock
- An array of pointers to blocks that are source of E-paths.
- E_path_ancestor_index - Variable in class neobio.alignment.LocalAlignmentBlock
- Indexes of of the entry in the ancestor block that is the source of the E-path.
- E_path_score - Variable in class neobio.alignment.LocalAlignmentBlock
- The value of the highest scoring path which starts at the input border of this block and ends inside it, called E-path.
- equals(Object) - Method in class neobio.alignment.PairwiseAlignment
- Compares this object to the specified object.
- exit_menuitem - Variable in class neobio.gui.NeoBio
- exitForm() - Method in class neobio.gui.NeoBio
- exitMenuItemActionPerformed(ActionEvent) - Method in class neobio.gui.NeoBio
F
- Factor - class neobio.alignment.Factor.
- This class is used by FactorSequence to create a linked list of factors of a text as induced by its Lempel-Ziv (LZ78) factorisation.
- Factor() - Constructor for class neobio.alignment.Factor
- Creates a new empty
Factor. - Factor(Factor, int, char) - Constructor for class neobio.alignment.Factor
- Creates a new
Factorinstance with the specified serial number and new character, and pointing to the given ancestor. - factor1 - Variable in class neobio.alignment.AlignmentBlock
- A pointer to the factor of the first sequence being aligned.
- factor2 - Variable in class neobio.alignment.AlignmentBlock
- A pointer to the factor of the second sequence being aligned.
- FactorSequence - class neobio.alignment.FactorSequence.
- This class builds a list of factors of a character sequence as induced by its Lempel-Ziv (LZ78) factorisation.
- FactorSequence(Reader) - Constructor for class neobio.alignment.FactorSequence
- Creates a new instance of a
FactorSequence, loading the sequence data from theReaderinput stream. - file_button - Variable in class neobio.gui.PairwiseAlignmentFrame
- file_menu - Variable in class neobio.gui.NeoBio
- file_toolbar - Variable in class neobio.gui.NeoBio
- find_dialog - Variable in class neobio.gui.PairwiseAlignmentFrame
- find_matrix_button - Variable in class neobio.gui.PairwiseAlignmentFrame
- find_output_button - Variable in class neobio.gui.PairwiseAlignmentFrame
- find_seq1_button - Variable in class neobio.gui.PairwiseAlignmentFrame
- find_seq2_button - Variable in class neobio.gui.PairwiseAlignmentFrame
- findMatrixButtonActionPerformed() - Method in class neobio.gui.PairwiseAlignmentFrame
- findOutputButtonActionPerformed() - Method in class neobio.gui.PairwiseAlignmentFrame
- findSeq1ButtonActionPerformed() - Method in class neobio.gui.PairwiseAlignmentFrame
- findSeq2ButtonActionPerformed() - Method in class neobio.gui.PairwiseAlignmentFrame
G
- GAP_CHARACTER - Static variable in class neobio.alignment.PairwiseAlignmentAlgorithm
- Character that signals a gap in sequence.
- gap_cost - Variable in class neobio.alignment.BasicScoringScheme
- The cost of a gap (an insertion or deletion of a character).
- gap_field - Variable in class neobio.gui.PairwiseAlignmentFrame
- gap_label - Variable in class neobio.gui.PairwiseAlignmentFrame
- GAP_TAG - Static variable in class neobio.alignment.PairwiseAlignmentAlgorithm
- Character that signals a gap in the score tag line of an alignment.
- gapped_seq1 - Variable in class neobio.alignment.PairwiseAlignment
- First gapped sequence.
- gapped_seq2 - Variable in class neobio.alignment.PairwiseAlignment
- Second gapped sequence.
- getAncestor() - Method in class neobio.alignment.Factor
- Returns this factor's ancestor factor.
- getAncestorSerialNumber() - Method in class neobio.alignment.Factor
- This method is a shorthand to return the serial number of this factor's ancestor.
- getData() - Method in class neobio.alignment.Trie
- Returns the data associated with this node.
- getDiagonalPrefix(AlignmentBlock) - Method in class neobio.alignment.CrochemoreLandauZivUkelson
- This method is a shorthand to retrieve the diagonal prefix of a block from the block table.
- getGappedSequence1() - Method in class neobio.alignment.PairwiseAlignment
- Returns the first gapped sequence.
- getGappedSequence2() - Method in class neobio.alignment.PairwiseAlignment
- Returns the second gapped sequence.
- getLeftPrefix(AlignmentBlock) - Method in class neobio.alignment.CrochemoreLandauZivUkelson
- This method is a shorthand to retrieve the left prefix of a block from the block table.
- getNewChar() - Method in class neobio.alignment.Factor
- Returns this factor's new character.
- getNext() - Method in class neobio.alignment.Factor
- Returns this factor's next factor.
- getPairwiseAlignment() - Method in class neobio.alignment.PairwiseAlignmentAlgorithm
- Return the last pairwise alignment computed (if any) or request subclasses to
compute one and return the result by calling the
computePairwiseAlignmentmethod. - getRootFactor() - Method in class neobio.alignment.FactorSequence
- Returns the root factor, the one that starts the list of factors.
- getScore() - Method in class neobio.alignment.PairwiseAlignment
- Returns the score for this alignment.
- getScore() - Method in class neobio.alignment.PairwiseAlignmentAlgorithm
- Returns the score of the last alignment computed (if any) or request subclasses to
compute one and return the result by calling the
computeScoremethod. - getScoreTagLine() - Method in class neobio.alignment.PairwiseAlignment
- Returns the score tag line.
- getSerialNumber() - Method in class neobio.alignment.Factor
- Returns this factor's serial number.
- getTopPrefix(AlignmentBlock) - Method in class neobio.alignment.CrochemoreLandauZivUkelson
- This method is a shorthand to retrieve the top prefix of a block from the block table.
H
I
- image_label - Variable in class neobio.gui.AboutDialog
- IncompatibleScoringSchemeException - exception neobio.alignment.IncompatibleScoringSchemeException.
- Signals that an scoring scheme is not compatible with the sequences being aligned.
- IncompatibleScoringSchemeException() - Constructor for class neobio.alignment.IncompatibleScoringSchemeException
- Constructs an
IncompatibleScoringSchemeExceptionwith null as its error detail message. - IncompatibleScoringSchemeException(String) - Constructor for class neobio.alignment.IncompatibleScoringSchemeException
- Constructs an
IncompatibleScoringSchemeExceptionwith the specified detail message. - IncompatibleScoringSchemeException(String, Throwable) - Constructor for class neobio.alignment.IncompatibleScoringSchemeException
- Constructs an
IncompatibleScoringSchemeExceptionwith the specified detail message and cause. - IncompatibleScoringSchemeException(Throwable) - Constructor for class neobio.alignment.IncompatibleScoringSchemeException
- Constructs an
IncompatibleScoringSchemeExceptionwith the specified cause (and a detail message that typically contains the class and detail message of cause). - INDEL_CHAR - Static variable in class neobio.alignment.ScoringMatrix
- The character that indicates the row and column for insertion and deletion penalties in the matrix.
- init(int, int) - Method in class neobio.alignment.OutMatrix
- Initialised this OUT matrix interface.
- initComponents() - Method in class neobio.gui.PairwiseAlignmentFrame
- initComponents() - Method in class neobio.gui.NeoBio
- initComponents() - Method in class neobio.gui.AboutDialog
- input_border - Variable in class neobio.alignment.OutMatrix
- The input border of a block.
- input_panel - Variable in class neobio.gui.PairwiseAlignmentFrame
- InvalidScoringMatrixException - exception neobio.alignment.InvalidScoringMatrixException.
- Signals that the substitution matrix does not comply with the specification (see ScoringMatrix for details).
- InvalidScoringMatrixException() - Constructor for class neobio.alignment.InvalidScoringMatrixException
- Constructs an
InvalidScoringMatrixExceptionwith null as its error detail message. - InvalidScoringMatrixException(String) - Constructor for class neobio.alignment.InvalidScoringMatrixException
- Constructs an
InvalidScoringMatrixExceptionwith the specified detail message. - InvalidScoringMatrixException(String, Throwable) - Constructor for class neobio.alignment.InvalidScoringMatrixException
- Constructs an
InvalidScoringMatrixExceptionwith the specified detail message and cause. - InvalidScoringMatrixException(Throwable) - Constructor for class neobio.alignment.InvalidScoringMatrixException
- Constructs an
InvalidScoringMatrixExceptionwith the specified cause (and a detail message that typically contains the class and detail message of cause). - InvalidSequenceException - exception neobio.alignment.InvalidSequenceException.
- Signals that the sequence does not comply with the specification (see CharSequence or FactorSequence for details).
- InvalidSequenceException() - Constructor for class neobio.alignment.InvalidSequenceException
- Constructs an
InvalidSequenceExceptionwith null as its error detail message. - InvalidSequenceException(String) - Constructor for class neobio.alignment.InvalidSequenceException
- Constructs an
InvalidSequenceExceptionwith the specified detail message. - InvalidSequenceException(String, Throwable) - Constructor for class neobio.alignment.InvalidSequenceException
- Constructs an
InvalidSequenceExceptionwith the specified detail message and cause. - InvalidSequenceException(Throwable) - Constructor for class neobio.alignment.InvalidSequenceException
- Constructs an
InvalidSequenceExceptionwith the specified cause (and a detail message that typically contains the class and detail message of cause). - isCaseSensitive() - Method in class neobio.alignment.ScoringScheme
- Tells whether this scoring scheme ignores the case of characters when computing their score.
- isPartialMatchSupported() - Method in class neobio.alignment.ScoringMatrix
- Tells whether this scoring scheme supports partial matches, which it does, although a particular scoring matrix loaded by this instace might not.
- isPartialMatchSupported() - Method in class neobio.alignment.ScoringScheme
- Returns
trueif this scoring scheme supports partial matches,falseotherwise. - isPartialMatchSupported() - Method in class neobio.alignment.BasicScoringScheme
- Tells whether this scoring scheme supports partial matches, which it does not.
L
- lc - Variable in class neobio.alignment.OutMatrix
- The number of columns of the block.
- LEFT_DIRECTION - Static variable in class neobio.alignment.CrochemoreLandauZivUkelson
- A constant that indicates that the left direction must be followed to reach the source of an optimal path in a block during the trace back procedure to retrieve a high scoring alignment.
- length - Variable in class neobio.alignment.Factor
- The number of characters of the text represented by this factor.
- length() - Method in class neobio.alignment.Factor
- Returns this factor's length.
- length() - Method in class neobio.alignment.CharSequence
- Returns the number of characters of this sequence.
- loadSequences(Reader, Reader) - Method in class neobio.alignment.PairwiseAlignmentAlgorithm
- Request subclasses to load the sequences according to their own needs.
- loadSequencesInternal(Reader, Reader) - Method in class neobio.alignment.CrochemoreLandauZivUkelson
- Loads sequences into
FactorSequenceinstances. - loadSequencesInternal(Reader, Reader) - Method in class neobio.alignment.NeedlemanWunsch
- Loads sequences into CharSequence instances.
- loadSequencesInternal(Reader, Reader) - Method in class neobio.alignment.SmithWaterman
- Loads sequences into CharSequence instances.
- loadSequencesInternal(Reader, Reader) - Method in class neobio.alignment.PairwiseAlignmentAlgorithm
- Subclasses must implement this method to load sequences according to their own needs and throw an exception in case of any failure.
- LocalAlignmentBlock - class neobio.alignment.LocalAlignmentBlock.
- This class is used by the CrochemoreLandauZivUkelsonLocalAlignment algorithm to store the information of an alignment block.
- LocalAlignmentBlock(Factor, Factor) - Constructor for class neobio.alignment.LocalAlignmentBlock
- Creates a new root block.
- LocalAlignmentBlock(Factor, Factor, int) - Constructor for class neobio.alignment.LocalAlignmentBlock
- Creates a new alignment block, with all arrays created with the specified size.
- locateScore() - Method in class neobio.alignment.CrochemoreLandauZivUkelson
- Locates the score of the highest scoring alignment between the two sequences in the block table after is thas been computed.
- locateScore() - Method in class neobio.alignment.CrochemoreLandauZivUkelsonLocalAlignment
- Returns the score of the high scoring local alignment in the block table.
- locateScore() - Method in class neobio.alignment.CrochemoreLandauZivUkelsonGlobalAlignment
- Locate the score of the highest scoring global alignment in the block table.
M
- main(String[]) - Static method in class neobio.textui.RandomFactorSequenceGenerator
- The main method takes three parameters from the command line to generate a sequence.
- main(String[]) - Static method in class neobio.textui.RandomSequenceGenerator
- The main method takes three parameters from the command line to generate a sequence.
- main(String[]) - Static method in class neobio.textui.NeoBio
- The main method takes parameters from the command line to compute a pairwise sequence alignment.
- main(String[]) - Static method in class neobio.gui.NeoBio
- Create and run a new interface.
- match_field - Variable in class neobio.gui.PairwiseAlignmentFrame
- match_label - Variable in class neobio.gui.PairwiseAlignmentFrame
- match_reward - Variable in class neobio.alignment.BasicScoringScheme
- The reward for a match (a substitution of equal characters).
- MATCH_TAG - Static variable in class neobio.alignment.PairwiseAlignmentAlgorithm
- Tag character that signals a match in the score tag line of an alignment.
- matrix - Variable in class neobio.alignment.ScoringMatrix
- Stores values for each operation (substitution, insertion or deletion) defined by this matrix.
- matrix - Variable in class neobio.alignment.Smawk
- A pointer to the matrix that is being manipulated.
- matrix - Variable in class neobio.alignment.NeedlemanWunsch
- The dynamic programming matrix.
- matrix - Variable in class neobio.alignment.SmithWaterman
- The dynamic programming matrix.
- Matrix - interface neobio.alignment.Matrix.
- This interface defines a minimal set of operations that a matrix must implement.
- matrix_button - Variable in class neobio.gui.PairwiseAlignmentFrame
- matrix_field - Variable in class neobio.gui.PairwiseAlignmentFrame
- max_absolute_score - Variable in class neobio.alignment.ScoringMatrix
- The maximum absolute score that this matrix can return for any substitution, deletion or insertion.
- max_absolute_score - Variable in class neobio.alignment.BasicScoringScheme
- The maximum absolute score that this scoring scheme can return, which is the
maximum absolute value among
match_reward,mismatch_penaltyandgap_cost. - max_col - Variable in class neobio.alignment.CrochemoreLandauZivUkelsonLocalAlignment
- The column index of a block (in the block table) where the high scoring local alignment ends.
- max_col - Variable in class neobio.alignment.SmithWaterman
- Indicate the column of where an optimal local alignment can be found in the matrix.
- max_length - Variable in class neobio.alignment.OutMatrix
- The length of the longest sequence (number of characters) being aligned.
- max_path_type - Variable in class neobio.alignment.CrochemoreLandauZivUkelsonLocalAlignment
- The type of the high scoring local alignment found.
- max_row - Variable in class neobio.alignment.CrochemoreLandauZivUkelsonLocalAlignment
- The row index of a block (in the block table) where the high scoring local alignment ends.
- max_row - Variable in class neobio.alignment.SmithWaterman
- Indicate the row of where an optimal local alignment can be found in the matrix..
- max_score - Variable in class neobio.alignment.OutMatrix
- The maximum absolute score that the current scoring scheme can return.
- max_score - Variable in class neobio.alignment.CrochemoreLandauZivUkelsonLocalAlignment
- The score of the high scoring local alignment found.
- max_source_index - Variable in class neobio.alignment.CrochemoreLandauZivUkelsonLocalAlignment
- If the high scoring local alignment ends in an E-path at a block B, this field contains the index of the entry in the input border of B that where the E-path starts.
- max(int, int) - Method in class neobio.alignment.PairwiseAlignmentAlgorithm
- Helper method to compute the the greater of two values.
- max(int, int, int) - Method in class neobio.alignment.PairwiseAlignmentAlgorithm
- Helper method to compute the the greater of three values.
- max(int, int, int, int) - Method in class neobio.alignment.PairwiseAlignmentAlgorithm
- Helper method to compute the the greater of four values.
- maxAbsoluteScore() - Method in class neobio.alignment.ScoringMatrix
- Returns the maximum absolute score that this scoring scheme can return for any substitution, deletion or insertion.
- maxAbsoluteScore() - Method in class neobio.alignment.ScoringScheme
- Returns the maximum absolute score that this scoring scheme can return for any substitution, deletion or insertion.
- maxAbsoluteScore() - Method in class neobio.alignment.BasicScoringScheme
- Returns the maximum absolute score that this scoring scheme can return for any
substitution, deletion or insertion, which is the maximum absolute value among
match_reward,mismatch_penaltyandgap_cost. - menu_bar - Variable in class neobio.gui.NeoBio
- mid_separator - Variable in class neobio.gui.NeoBio
- mismatch_field - Variable in class neobio.gui.PairwiseAlignmentFrame
- mismatch_label - Variable in class neobio.gui.PairwiseAlignmentFrame
- mismatch_penalty - Variable in class neobio.alignment.BasicScoringScheme
- The penalty for a mismatch (a substitution of different characters).
- MISMATCH_TAG - Static variable in class neobio.alignment.PairwiseAlignmentAlgorithm
- Character that signals a mismatch in the score tag line of an alignment.
N
- naiveComputeColumnMaxima(Matrix, int[]) - Static method in class neobio.alignment.Smawk
- This is a simpler method for calculating column maxima.
- naiveComputeRowMaxima(Matrix, int[]) - Static method in class neobio.alignment.Smawk
- This is a simpler method for calculating row maxima.
- NeedlemanWunsch - class neobio.alignment.NeedlemanWunsch.
- This class implements the classic global alignment algorithm (with linear gap penalty function) due to S.B.Needleman and C.D.Wunsch (1970).
- NeedlemanWunsch() - Constructor for class neobio.alignment.NeedlemanWunsch
- NeoBio - class neobio.textui.NeoBio.
- This class is a simple command line based utility for computing pairwise sequence alignments using one of the the algorithms provided in the neobio.alignment package.
- NeoBio - class neobio.gui.NeoBio.
- This class is a simple GUI utility for computing pairwise sequence alignments using one of the the algorithms provided in the neobio.alignment package.
- neobio.alignment - package neobio.alignment
- Provides implementation of sequence alignment algorithms.
- neobio.gui - package neobio.gui
- Graphical user interface tools to run the algorithms provided by other packages.
- neobio.textui - package neobio.textui
- Command line based tools to run the algorithms provided by other packages.
- NeoBio() - Constructor for class neobio.textui.NeoBio
- NeoBio() - Constructor for class neobio.gui.NeoBio
- Creates a new instance of a graphical interface.
- new_alignment_item - Variable in class neobio.gui.NeoBio
- new_char - Variable in class neobio.alignment.Factor
- The new character of this factor.
- newAlignmentActionPerformed(ActionEvent) - Method in class neobio.gui.NeoBio
- next - Variable in class neobio.alignment.Factor
- A pointer to the next factor.
- num_chars - Variable in class neobio.alignment.FactorSequence
- The numbers of character represented by this sequence.
- num_cols - Variable in class neobio.alignment.CrochemoreLandauZivUkelson
- Number of columns of the block table.
- num_factors - Variable in class neobio.alignment.FactorSequence
- The numbers of factors generated by the LZ78 parsing of the sequence.
- num_rows - Variable in class neobio.alignment.CrochemoreLandauZivUkelson
- Number of rows of the block table.
- numChars() - Method in class neobio.alignment.FactorSequence
- Returns the number of characters of the original sequence.
- numcols - Variable in class neobio.alignment.Smawk
- The matrix's current number of columns.
- numColumns() - Method in class neobio.alignment.OutMatrix
- Returns the number of columns of this OUT matrix.
- numColumns() - Method in interface neobio.alignment.Matrix
- Returns the number of columns that this matrix has.
- numFactors() - Method in class neobio.alignment.FactorSequence
- Returns the number of factors produced by the LZ78 parsing of the text.
- numrows - Variable in class neobio.alignment.Smawk
- The matrix's current number of rows.
- numRows() - Method in class neobio.alignment.OutMatrix
- Returns the number of rows of this OUT matrix.
- numRows() - Method in interface neobio.alignment.Matrix
- Returns the number of rows that this matrix has.
O
- out_matrix - Variable in class neobio.alignment.CrochemoreLandauZivUkelson
- An instance of the
OutMatrixclass that encodes the OUT matrix of a block when supplied with the DIST matrix and the input border array of a block. - OutMatrix - class neobio.alignment.OutMatrix.
- Implements an interface to the OUT matrix of a block.
- OutMatrix() - Constructor for class neobio.alignment.OutMatrix
- output_area - Variable in class neobio.gui.PairwiseAlignmentFrame
- output_border - Variable in class neobio.alignment.AlignmentBlock
- This block's output border.
- output_field - Variable in class neobio.gui.PairwiseAlignmentFrame
- output_group - Variable in class neobio.gui.PairwiseAlignmentFrame
- output_panel - Variable in class neobio.gui.PairwiseAlignmentFrame
- output_tab - Variable in class neobio.gui.PairwiseAlignmentFrame
- output_tab_panel - Variable in class neobio.gui.PairwiseAlignmentFrame
- output_to_file - Variable in class neobio.gui.PairwiseAlignmentFrame
- outputOptionStateChanged() - Method in class neobio.gui.PairwiseAlignmentFrame
P
- PairwiseAlignment - class neobio.alignment.PairwiseAlignment.
- This class is the product of a pairwise alignment, generated by one subclasses of PairwiseAlignmentAlgorithm.
- pairwiseAlignment() - Method in class neobio.gui.NeoBio
- PairwiseAlignment(String, String, String, int) - Constructor for class neobio.alignment.PairwiseAlignment
- Creates a
PairwiseAlignmentinstance with the specified gapped sequences, score tag line and score value. - PairwiseAlignmentAlgorithm - class neobio.alignment.PairwiseAlignmentAlgorithm.
- This abstract class is the superclass of all classes implementing pairwise sequence alignment algorithms.
- PairwiseAlignmentAlgorithm() - Constructor for class neobio.alignment.PairwiseAlignmentAlgorithm
- PairwiseAlignmentFrame - class neobio.gui.PairwiseAlignmentFrame.
- This class is the internal frame of NeoBio's graphical interface for computing pairwise sequence alignments using one of the the algorithms provided in the neobio.alignment package.
- PairwiseAlignmentFrame(Frame) - Constructor for class neobio.gui.PairwiseAlignmentFrame
- Creates a new instance of the internal frame.
- parent_frame - Variable in class neobio.gui.PairwiseAlignmentFrame
- path_type - Variable in class neobio.alignment.LocalAlignmentBlock
- The type of the highest scoring path ending at a given position of the output border of a block.
- printFactors() - Method in class neobio.alignment.FactorSequence
- Returns a string representation of the actual list of factors produced by the LZ78 parsing of the text.
- printMatrix() - Method in class neobio.alignment.Smawk
- Prints the current state of the matrix (reflecting deleted rows and columns) in the standard output.
- printMatrix(Matrix) - Static method in class neobio.alignment.Smawk
- Prints the contents of an object implementing the matrix interface in the standard output.
- progress_area - Variable in class neobio.gui.PairwiseAlignmentFrame
- progress_tab_panel - Variable in class neobio.gui.PairwiseAlignmentFrame
- PROT_CHARS - Static variable in class neobio.textui.RandomFactorSequenceGenerator
- Character set for protein sequences.
- PROT_CHARS - Static variable in class neobio.textui.RandomSequenceGenerator
- Character set for protein sequences.
R
- RandomFactorSequenceGenerator - class neobio.textui.RandomFactorSequenceGenerator.
- This class is a simple command line based utility for generating random sequences with optimal LZ78 factorisation.
- RandomFactorSequenceGenerator() - Constructor for class neobio.textui.RandomFactorSequenceGenerator
- RandomSequenceGenerator - class neobio.textui.RandomSequenceGenerator.
- This class is a simple command line based utility for generating random sequences.
- RandomSequenceGenerator() - Constructor for class neobio.textui.RandomSequenceGenerator
- reduce() - Method in class neobio.alignment.Smawk
- This method is the key component of the SMAWK algorithm.
- restoreOddColumns(int) - Method in class neobio.alignment.Smawk
- Restores the
colarray of indexes to the state it was before thedeleteOddColumnsmethod was called. - restoreRows(int) - Method in class neobio.alignment.Smawk
- Restores the
rowarray of indexes to the state it was before thereducemethod was called. - root_factor - Variable in class neobio.alignment.FactorSequence
- A pointer to the root factor, the one that starts the list of factors.
- row - Variable in class neobio.alignment.Smawk
- An array of row indexes reflecting the current state of the matrix.
- row_codes - Variable in class neobio.alignment.ScoringMatrix
- Stores matrix row headers in the order they were found.
- row_position - Variable in class neobio.alignment.Smawk
- This array is used to store for each row of the original matrix, its index in the
current state of the matrix, i.e. its index in the
rowarray. - run_button - Variable in class neobio.gui.PairwiseAlignmentFrame
- runButtonActionPerformed() - Method in class neobio.gui.PairwiseAlignmentFrame
S
- S_direction - Variable in class neobio.alignment.LocalAlignmentBlock
- The direction to the source of the S-path of the new vertex of this block.
- S_path_score - Variable in class neobio.alignment.LocalAlignmentBlock
- The value of the highest scoring path which starts inside the block and ends at its output border.
- schemeOptionStateChanged() - Method in class neobio.gui.PairwiseAlignmentFrame
- score - Variable in class neobio.alignment.PairwiseAlignment
- The overall score value for this alignment.
- score - Variable in class neobio.alignment.PairwiseAlignmentAlgorithm
- This field stores just the score of the last pairwise alignment performed (if the
score_computed flagis set to true). - score_computed - Variable in class neobio.alignment.PairwiseAlignmentAlgorithm
- Flags whether the score of the alignment between the last two loaded sequences has already been computed.
- score_tag_line - Variable in class neobio.alignment.PairwiseAlignment
- The score tag line.
- scoreDeletion(char) - Method in class neobio.alignment.ScoringMatrix
- Returns the score of a deletion of character
aaccording to this scoring matrix. - scoreDeletion(char) - Method in class neobio.alignment.PairwiseAlignmentAlgorithm
- Helper method to invoke the
scoreDeletionmethod of the scoring scheme set to this algorithm. - scoreDeletion(char) - Method in class neobio.alignment.ScoringScheme
- Returns the score of a deletion of character
aaccording to this scoring scheme. - scoreDeletion(char) - Method in class neobio.alignment.BasicScoringScheme
- Always returns
gap_costfor the deletion of any character. - scoreInsertion(char) - Method in class neobio.alignment.ScoringMatrix
- Returns the score of an insertion of character
aaccording to this scoring matrix. - scoreInsertion(char) - Method in class neobio.alignment.PairwiseAlignmentAlgorithm
- Helper method to invoke the
scoreInsertionmethod of the scoring scheme set to this algorithm. - scoreInsertion(char) - Method in class neobio.alignment.ScoringScheme
- Returns the score of an insertion of character
aaccording to this scoring scheme. - scoreInsertion(char) - Method in class neobio.alignment.BasicScoringScheme
- Always returns
gap_costfor the insertion of any character. - scoreSubstitution(char, char) - Method in class neobio.alignment.ScoringMatrix
- Returns the score of a substitution of character
afor characterbaccording to this scoring matrix. - scoreSubstitution(char, char) - Method in class neobio.alignment.PairwiseAlignmentAlgorithm
- Helper method to invoke the
scoreSubstitutionmethod of the scoring scheme set to this algorithm. - scoreSubstitution(char, char) - Method in class neobio.alignment.ScoringScheme
- Returns the score of a substitution of character
afor characterbaccording to this scoring scheme. - scoreSubstitution(char, char) - Method in class neobio.alignment.BasicScoringScheme
- Returns the score of a substitution of character
afor characterbaccording to this scoring scheme. - scoring - Variable in class neobio.alignment.PairwiseAlignmentAlgorithm
- The scoring scheme used to compute a pairwise sequence alignment.
- scoring_group - Variable in class neobio.gui.PairwiseAlignmentFrame
- scoring_panel - Variable in class neobio.gui.PairwiseAlignmentFrame
- ScoringMatrix - class neobio.alignment.ScoringMatrix.
- This class implements a scoring scheme based on a substitution matrix.
- ScoringMatrix(Reader) - Constructor for class neobio.alignment.ScoringMatrix
- Creates a new instance of a substitution matrix loaded from the character stream.
- ScoringMatrix(Reader, boolean) - Constructor for class neobio.alignment.ScoringMatrix
- Creates a new instance of a substitution matrix loaded from the character stream.
- ScoringScheme - class neobio.alignment.ScoringScheme.
- This abstract class is the superclass of all scoring schemes.
- ScoringScheme() - Constructor for class neobio.alignment.ScoringScheme
- Creates a new instance of an scoring scheme.
- ScoringScheme(boolean) - Constructor for class neobio.alignment.ScoringScheme
- Creates a new instance of an scoring scheme.
- screen_button - Variable in class neobio.gui.PairwiseAlignmentFrame
- seq1 - Variable in class neobio.alignment.CrochemoreLandauZivUkelson
- The first factorised sequence being aligned.
- seq1 - Variable in class neobio.alignment.NeedlemanWunsch
- The first sequence of an alignment.
- seq1 - Variable in class neobio.alignment.SmithWaterman
- The first sequence of an alignment.
- seq1_field - Variable in class neobio.gui.PairwiseAlignmentFrame
- seq1_label - Variable in class neobio.gui.PairwiseAlignmentFrame
- seq2 - Variable in class neobio.alignment.CrochemoreLandauZivUkelson
- The second factorised sequence being aligned.
- seq2 - Variable in class neobio.alignment.NeedlemanWunsch
- The second sequence of an alignment.
- seq2 - Variable in class neobio.alignment.SmithWaterman
- The second sequence of an alignment.
- seq2_field - Variable in class neobio.gui.PairwiseAlignmentFrame
- seq2_label - Variable in class neobio.gui.PairwiseAlignmentFrame
- sequence - Variable in class neobio.alignment.CharSequence
- Stores the sequence as an array of characters.
- sequences_loaded - Variable in class neobio.alignment.PairwiseAlignmentAlgorithm
- Flags whether sequences have been loaded.
- serial_number - Variable in class neobio.alignment.Factor
- This factor's serial number, which indicates the order of this factor inside the linked list of factors of a text.
- setData(int[][], int[], int, int) - Method in class neobio.alignment.OutMatrix
- Sets this interface's data to represent an OUT matrix for a block.
- setNext(Factor) - Method in class neobio.alignment.Factor
- Sets this factor's
nextpointer to point to the specified factor. - setScoringScheme(ScoringScheme) - Method in class neobio.alignment.PairwiseAlignmentAlgorithm
- Sets the scoring scheme to be used for the next alignments.
- showError(String) - Method in class neobio.gui.PairwiseAlignmentFrame
- sibling - Variable in class neobio.alignment.Trie
- A pointer to this node's next sibling.
- smawk - Variable in class neobio.alignment.CrochemoreLandauZivUkelson
- An instance of the
Smawkclass that implements the SMAWK algorithm to compute the column maxima of a totally monotone matrix. - Smawk - class neobio.alignment.Smawk.
- This class implement the SMAWK algorithm to compute column maxima on a totally monotone matrix as described.
- Smawk() - Constructor for class neobio.alignment.Smawk
- SmithWaterman - class neobio.alignment.SmithWaterman.
- This class implement the classic local alignment algorithm (with linear gap penalty function) due to T.F.Smith and M.S.Waterman (1981).
- SmithWaterman() - Constructor for class neobio.alignment.SmithWaterman
- son - Variable in class neobio.alignment.Trie
- A pointer to the first of this node's children.
- source_path - Variable in class neobio.alignment.AlignmentBlock
- An array of indexes to the source of the highest scoring path for each entry in the output border.
- spellDown(char) - Method in class neobio.alignment.Trie
- Follows a path from this node to one of its children by spelling the character supplied as an argument.
- spellRight(char) - Method in class neobio.alignment.Trie
- Follows a path from this node to one of its sibling by spelling the character supplied as an argument.
- STOP_DIRECTION - Static variable in class neobio.alignment.CrochemoreLandauZivUkelson
- A constant that indicates that the source of an optimal path has been reached in a block and that the trace back procedure to retrieve a high scoring alignment can stop.
T
- to_sibling - Variable in class neobio.alignment.Trie
- The character that labels the edge from this node to the sibling pointer by
sibling. - to_son - Variable in class neobio.alignment.Trie
- The character that labels the edge from this node to the child node pointer by
son. - toolbar_panel - Variable in class neobio.gui.NeoBio
- TOP_DIRECTION - Static variable in class neobio.alignment.CrochemoreLandauZivUkelson
- A constant that indicates that the top direction must be followed to reach the source of an optimal path in a block during the trace back procedure to retrieve a high scoring alignment.
- toString() - Method in class neobio.alignment.ScoringMatrix
- Returns a String representation of this scoring matrix.
- toString() - Method in class neobio.alignment.Factor
- Returns a string representation of the text represented by this factor.
- toString() - Method in class neobio.alignment.PairwiseAlignment
- Returns a four-line String representation of this alignment in the following order: first gapped sequence, score tag line, second gapped sequence and the score value.
- toString() - Method in class neobio.alignment.FactorSequence
- Reconstructs the sequence from the list of factors induced by the LZ78 parsing of the text.
- toString() - Method in class neobio.alignment.CharSequence
- Returns a string representation of the sequence.
- toString() - Method in class neobio.alignment.BasicScoringScheme
- Returns a String representation of this scoring scheme.
- traverseBlock(AlignmentBlock, int, StringBuffer, StringBuffer, StringBuffer) - Method in class neobio.alignment.CrochemoreLandauZivUkelson
- Traverses a block to retrieve a part of an optimal alignment from the specified source in the output border to an entry in the input border.
- traverseBlockCrossingPath(LocalAlignmentBlock, StringBuffer, StringBuffer, StringBuffer) - Method in class neobio.alignment.CrochemoreLandauZivUkelsonLocalAlignment
- Traverses a series of block crossing paths to retrieve an optimal alignment.
- traverseS_Path(LocalAlignmentBlock, StringBuffer, StringBuffer, StringBuffer) - Method in class neobio.alignment.CrochemoreLandauZivUkelsonLocalAlignment
- Traverses an S-path of a block to retrieve a part of an optimal alignment from the new vertex of a block to entry in its input border.
- Trie - class neobio.alignment.Trie.
- This class implements a trie, or a digital search tree.
- Trie(Object) - Constructor for class neobio.alignment.Trie
- Creates a new trie node with the specified data.
- TYPE_C_PATH - Static variable in class neobio.alignment.CrochemoreLandauZivUkelsonLocalAlignment
- A constant that indicates that the high scoring path ending in a given block is a C-path, i.e. one that starts inside the block.
- TYPE_CROSSING_PATH - Static variable in class neobio.alignment.CrochemoreLandauZivUkelsonLocalAlignment
- A constant that indicates that the best path ending at a given entry of the output border is a block-crossing path (one that starts outside the block).
- TYPE_E_PATH - Static variable in class neobio.alignment.CrochemoreLandauZivUkelsonLocalAlignment
- A constant that indicates that the high scoring path ending in a given block is an E-path, i.e. one that starts at its input border.
- TYPE_S_PATH - Static variable in class neobio.alignment.CrochemoreLandauZivUkelsonLocalAlignment
- A constant that indicates that the best path ending at a given entry of the output border is a S-path (one that starts inside the block).
U
- unloadSequences() - Method in class neobio.alignment.PairwiseAlignmentAlgorithm
- Frees pointer to loaded sequences and computed alignments (if any) so that their data can be garbage collected.
- unloadSequencesInternal() - Method in class neobio.alignment.CrochemoreLandauZivUkelson
- Frees pointers to loaded sequences and the the block table so that their data can be garbage collected.
- unloadSequencesInternal() - Method in class neobio.alignment.NeedlemanWunsch
- Frees pointers to loaded sequences and the dynamic programming matrix so that their data can be garbage collected.
- unloadSequencesInternal() - Method in class neobio.alignment.SmithWaterman
- Frees pointers to loaded sequences and the dynamic programming matrix so that their data can be garbage collected.
- unloadSequencesInternal() - Method in class neobio.alignment.PairwiseAlignmentAlgorithm
- Subclasses must implement this method to unload sequences according to their own storage, freeing pointers to sequences and any intermediate data so that they can be garbage collected.
- usage() - Static method in class neobio.textui.RandomFactorSequenceGenerator
- Prints command line usage.
- usage() - Static method in class neobio.textui.RandomSequenceGenerator
- Prints command line usage.
- usage() - Static method in class neobio.textui.NeoBio
- Prints command line usage.
- use_match_tag - Variable in class neobio.alignment.PairwiseAlignmentAlgorithm
- Indicates if the
MATCH_TAGtag should be used or not. - useMatchTag() - Method in class neobio.alignment.PairwiseAlignmentAlgorithm
- Tells wether the
MATCH_TAGtag should be used or not.
V
- valueAt(int, int) - Method in class neobio.alignment.OutMatrix
- Returns the value at a given position of the matrix.
- valueAt(int, int) - Method in class neobio.alignment.Smawk
- This is a helper method to simplify the call to the
valueAtmethod of the matrix. - valueAt(int, int) - Method in interface neobio.alignment.Matrix
- Returns the value at an specified row and column.
W
- window_number - Static variable in class neobio.gui.PairwiseAlignmentFrame
A B C D E F G H I L M N O P R S T U V W
|
|
||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||
NeoBio is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with NeoBio; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
neobio-0.0.20030929/doc/overview-summary.html 0000644 0002656 0002032 00000017051 07727746666 017712 0 ustar tillea admin
|
NeoBio API | ||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||
NeoBio class library API
See:
Description
| Packages | |
| neobio.alignment | Provides implementation of sequence alignment algorithms. |
| neobio.gui | Graphical user interface tools to run the algorithms provided by other packages. |
| neobio.textui | Command line based tools to run the algorithms provided by other packages. |
This document is the API specification for the NeoBio class library of computational biology algorithms.
| Sergio Anibal de Carvalho Junior | sergioanibaljr@users.sourceforge.net |
| Department of Computer Science | http://www.dcs.kcl.ac.uk |
| King's College London, UK | http://www.kcl.ac.uk |
This project was supervised by Professor Maxime Crochemore.
|
|
||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||
NeoBio is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with NeoBio; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
neobio-0.0.20030929/doc/index.html 0000644 0002656 0002032 00000001371 07727746666 015456 0 ustar tillea admin
001 /* 002 * PairwiseAlignmentFrame.java 003 * 004 * Copyright 2003 Sergio Anibal de Carvalho Junior 005 * 006 * This file is part of NeoBio. 007 * 008 * NeoBio is free software; you can redistribute it and/or modify it under the terms of 009 * the GNU General Public License as published by the Free Software Foundation; either 010 * version 2 of the License, or (at your option) any later version. 011 * 012 * NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 013 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 014 * PURPOSE. See the GNU General Public License for more details. 015 * 016 * You should have received a copy of the GNU General Public License along with NeoBio; 017 * if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, 018 * Boston, MA 02111-1307, USA. 019 * 020 * Proper attribution of the author as the source of the software would be appreciated. 021 * 022 * Sergio Anibal de Carvalho Junior mailto:sergioanibaljr@users.sourceforge.net 023 * Department of Computer Science http://www.dcs.kcl.ac.uk 024 * King's College London, UK http://www.kcl.ac.uk 025 * 026 * Please visit http://neobio.sourceforge.net 027 * 028 * This project was supervised by Professor Maxime Crochemore. 029 * 030 */ 031 032 package neobio.gui; 033 034 import neobio.alignment.*; 035 036 import java.io.*; 037 import java.awt.*; 038 import java.awt.event.*; 039 import javax.swing.*; 040 import javax.swing.border.*; 041 import javax.swing.event.*; 042 043 /** 044 * This class is the internal frame of NeoBio's graphical interface for computing pairwise 045 * sequence alignments using one of the the algorithms provided in the {@link 046 * neobio.alignment} package. 047 * 048 * @author Sergio A. de Carvalho Jr. 049 */ 050 public class PairwiseAlignmentFrame extends JInternalFrame 051 { 052 private static int window_number = 1; 053 054 private Frame parent_frame; 055 056 private JPanel input_panel, scoring_panel, algorithm_panel, output_panel; 057 private JPanel progress_tab_panel, output_tab_panel; 058 private JTextField seq1_field, seq2_field, matrix_field, output_field; 059 private JTextField match_field, mismatch_field, gap_field; 060 private JTextArea progress_area, output_area; 061 private JButton find_seq1_button, find_seq2_button, find_output_button; 062 private JButton find_matrix_button, run_button; 063 private JComboBox algorithm_combo; 064 private JTabbedPane output_tab; 065 private JRadioButton screen_button, file_button, basic_button, matrix_button; 066 private ButtonGroup scoring_group, output_group; 067 private JLabel seq1_label, seq2_label; 068 private JLabel match_label, mismatch_label, gap_label; 069 070 private JFileChooser find_dialog; 071 072 private boolean output_to_file, basic_scheme; 073 074 private String[] algorithm_name = {"Needleman & Wunsch (global alignment)", 075 "Smith & Waterman (local alignment)", 076 "Crochemore, Landau & Ziv-Ukelson for global alignment", 077 "Crochemore, Landau & Ziv-Ukelson for local alignment"}; 078 079 private PairwiseAlignmentAlgorithm[] algorithm = {new NeedlemanWunsch(), 080 new SmithWaterman(), 081 new CrochemoreLandauZivUkelsonGlobalAlignment(), 082 new CrochemoreLandauZivUkelsonLocalAlignment()}; 083 084 /** 085 * Creates a new instance of the internal frame. 086 * 087 * @param parent_frame the parent frame 088 */ 089 public PairwiseAlignmentFrame (Frame parent_frame) 090 { 091 this.parent_frame = parent_frame; 092 initComponents(); 093 } 094 095 private void initComponents() 096 { 097 JComponent pane; 098 GridBagConstraints c; 099 100 setIconifiable(true); 101 setMaximizable(true); 102 setResizable(true); 103 setClosable(true); 104 setTitle("Pairwise Sequence Alignment " + window_number++); 105 setMinimumSize(new Dimension(500, 500)); 106 107 pane = (JComponent) getContentPane(); 108 pane.setLayout(new GridBagLayout()); 109 110 c = new GridBagConstraints(); 111 c.insets = new Insets (4, 4, 4, 4); 112 c.fill = GridBagConstraints.BOTH; 113 c.weightx = 1.0; c.weighty = 0; 114 115 // input panel 116 input_panel = new JPanel (); 117 add (pane, input_panel, c, 0, 0); 118 119 // scoring panel 120 scoring_panel = new JPanel (); 121 add (pane, scoring_panel, c, 0, 1); 122 123 // output panel 124 output_panel = new JPanel (); 125 add (pane, output_panel, c, 0, 2); 126 127 // algorithm panel 128 algorithm_panel = new JPanel (); 129 add (pane, algorithm_panel, c, 0, 3); 130 131 c.weightx = 1.0; c.weighty = 1.0; 132 133 // output tab 134 output_tab = new JTabbedPane(); 135 add (pane, output_tab, c, 0, 4); 136 137 find_dialog = new JFileChooser(); 138 find_dialog.setDialogTitle("Find..."); 139 find_dialog.setDialogType(JFileChooser.OPEN_DIALOG ); 140 141 // ***************** INPUT PANEL ***************** 142 input_panel.setLayout(new GridBagLayout()); 143 input_panel.setBorder(BorderFactory.createTitledBorder(new EtchedBorder( 144 EtchedBorder.LOWERED), "Input")); 145 146 seq1_label = new JLabel("Sequence 1:"); 147 seq2_label = new JLabel("Sequence 2:"); 148 149 seq1_field = new JTextField(); 150 seq1_field.addCaretListener (new CaretListener() 151 { 152 public void caretUpdate (CaretEvent e) 153 { 154 checkRunButtonStatus (); 155 } 156 }); 157 158 seq2_field = new JTextField(); 159 seq2_field.addCaretListener (new CaretListener() 160 { 161 public void caretUpdate (CaretEvent e) 162 { 163 checkRunButtonStatus (); 164 } 165 }); 166 167 find_seq1_button = new JButton("Find..."); 168 find_seq1_button.addActionListener (new ActionListener() 169 { 170 public void actionPerformed (ActionEvent e) 171 { 172 findSeq1ButtonActionPerformed(); 173 } 174 }); 175 176 find_seq2_button = new JButton("Find..."); 177 find_seq2_button.addActionListener (new ActionListener() 178 { 179 public void actionPerformed (ActionEvent e) 180 { 181 findSeq2ButtonActionPerformed(); 182 } 183 }); 184 185 c.weightx = 0; c.weighty = 0; c.anchor = GridBagConstraints.EAST; 186 add (input_panel, seq1_label, c, 0, 0); 187 add (input_panel, seq2_label, c, 0, 1); 188 189 c.anchor = GridBagConstraints.CENTER; 190 add (input_panel, find_seq1_button, c, 2, 0); 191 add (input_panel, find_seq2_button, c, 2, 1); 192 193 c.weightx = 1.0; c.fill = GridBagConstraints.HORIZONTAL; 194 add (input_panel, seq1_field, c, 1, 0); 195 add (input_panel, seq2_field, c, 1, 1); 196 197 // ***************** SCORING SCHEME PANEL ***************** 198 scoring_panel.setLayout(new GridBagLayout()); 199 scoring_panel.setBorder(BorderFactory.createTitledBorder(new EtchedBorder( 200 EtchedBorder.LOWERED), "Scoring Scheme")); 201 202 basic_scheme = true; 203 basic_button = new JRadioButton("Basic:"); 204 basic_button.setSelected(true); 205 basic_button.addItemListener (new ItemListener() 206 { 207 public void itemStateChanged (ItemEvent e) 208 { 209 schemeOptionStateChanged(); 210 } 211 }); 212 213 matrix_button = new JRadioButton("Substitution Matrix:"); 214 matrix_button.addItemListener (new ItemListener() 215 { 216 public void itemStateChanged (ItemEvent e) 217 { 218 schemeOptionStateChanged(); 219 } 220 }); 221 222 match_label = new JLabel("Match:"); 223 mismatch_label = new JLabel ("Mismatch:"); 224 gap_label = new JLabel ("Gap:"); 225 226 match_field = new JTextField("1", 2); 227 match_field.setHorizontalAlignment(JTextField.RIGHT); 228 match_field.addCaretListener (new CaretListener() 229 { 230 public void caretUpdate (CaretEvent e) 231 { 232 checkRunButtonStatus (); 233 } 234 }); 235 236 mismatch_field = new JTextField("-1", 2); 237 mismatch_field.setHorizontalAlignment(JTextField.RIGHT); 238 mismatch_field.addCaretListener (new CaretListener() 239 { 240 public void caretUpdate (CaretEvent e) 241 { 242 checkRunButtonStatus (); 243 } 244 }); 245 246 gap_field = new JTextField("-1", 2); 247 gap_field.setHorizontalAlignment(JTextField.RIGHT); 248 gap_field.addCaretListener (new CaretListener() 249 { 250 public void caretUpdate (CaretEvent e) 251 { 252 checkRunButtonStatus (); 253 } 254 }); 255 256 matrix_field = new JTextField(); 257 matrix_field.setEnabled(false); 258 matrix_field.addCaretListener (new CaretListener() 259 { 260 public void caretUpdate (CaretEvent e) 261 { 262 checkRunButtonStatus (); 263 } 264 }); 265 266 find_matrix_button = new JButton("Find..."); 267 find_matrix_button.setEnabled(false); 268 find_matrix_button.addActionListener (new ActionListener() 269 { 270 public void actionPerformed (ActionEvent e) 271 { 272 findMatrixButtonActionPerformed(); 273 } 274 }); 275 276 scoring_group = new ButtonGroup (); 277 scoring_group.add(basic_button); 278 scoring_group.add(matrix_button); 279 280 c.weightx = 0; c.fill = GridBagConstraints.NONE; 281 c.anchor = GridBagConstraints.WEST; 282 add (scoring_panel, basic_button, c, 0, 0); 283 284 c.anchor = GridBagConstraints.EAST; 285 add (scoring_panel, match_label, c, 1, 0); 286 add (scoring_panel, mismatch_label, c, 3, 0); 287 add (scoring_panel, gap_label, c, 5, 0); 288 289 c.anchor = GridBagConstraints.WEST; 290 add (scoring_panel, matrix_button, c, 0, 1); 291 292 c.anchor = GridBagConstraints.CENTER; 293 add (scoring_panel, find_matrix_button, c, 7, 1); 294 295 c.weightx = 1.0 / 3; c.fill = GridBagConstraints.HORIZONTAL; 296 add (scoring_panel, match_field, c, 2, 0); 297 add (scoring_panel, mismatch_field, c, 4, 0); 298 add (scoring_panel, gap_field, c, 6, 0); 299 300 c.weightx = 1.0; c.gridwidth = 6; 301 add (scoring_panel, matrix_field, c, 1, 1); 302 c.gridwidth = 1; 303 304 // ***************** OUTPUT PANEL ***************** 305 output_panel.setLayout(new GridBagLayout()); 306 output_panel.setBorder(BorderFactory.createTitledBorder(new EtchedBorder( 307 EtchedBorder.LOWERED), "Output")); 308 309 screen_button = new JRadioButton("Screen"); 310 screen_button.setSelected(true); 311 312 output_to_file = false; 313 file_button = new JRadioButton("File:"); 314 file_button.addItemListener (new ItemListener() 315 { 316 public void itemStateChanged (ItemEvent e) 317 { 318 outputOptionStateChanged(); 319 } 320 }); 321 322 output_field = new JTextField(); 323 output_field.setEnabled(false); 324 output_field.addCaretListener (new CaretListener() 325 { 326 public void caretUpdate (CaretEvent e) 327 { 328 checkRunButtonStatus (); 329 } 330 }); 331 332 find_output_button = new JButton("Find..."); 333 find_output_button.setEnabled(false); 334 find_output_button.addActionListener (new ActionListener() 335 { 336 public void actionPerformed (ActionEvent e) 337 { 338 findOutputButtonActionPerformed(); 339 } 340 }); 341 342 output_group = new ButtonGroup (); 343 output_group.add(screen_button); 344 output_group.add(file_button); 345 346 c.weightx = 0; c.weighty = 0; c.fill = GridBagConstraints.NONE; 347 add (output_panel, screen_button, c, 0, 0); 348 add (output_panel, file_button, c, 1, 0); 349 add (output_panel, find_output_button, c, 3, 0); 350 351 c.weightx = 1.0; c.weighty = 0; c.fill = GridBagConstraints.HORIZONTAL; 352 add (output_panel, output_field, c, 2, 0); 353 354 // ***************** ALGORITHM PANEL ***************** 355 algorithm_panel.setLayout(new GridBagLayout()); 356 algorithm_panel.setBorder(BorderFactory.createTitledBorder(new EtchedBorder( 357 EtchedBorder.LOWERED), "Alignment Algorithm")); 358 359 algorithm_combo = new JComboBox(algorithm_name); 360 361 run_button = new JButton("Run"); 362 run_button.setEnabled(false); 363 run_button.addActionListener (new ActionListener() 364 { 365 public void actionPerformed (ActionEvent e) 366 { 367 runButtonActionPerformed(); 368 } 369 }); 370 371 372 c.weightx = 1.0; c.weighty = 0; c.fill = GridBagConstraints.HORIZONTAL; 373 add (algorithm_panel, algorithm_combo, c, 0, 0); 374 375 c.weightx = 0; c.weighty = 0; c.fill = GridBagConstraints.NONE; 376 add (algorithm_panel, run_button, c, 1, 0); 377 378 // ***************** OUTPUT TAB ***************** 379 progress_area = new JTextArea (); 380 progress_area.setEditable (false); 381 progress_area.setBorder (BorderFactory.createBevelBorder(BevelBorder.LOWERED)); 382 progress_tab_panel = new JPanel (); 383 progress_tab_panel.setLayout (new GridLayout()); 384 progress_tab_panel.add (new JScrollPane (progress_area)); 385 output_tab.addTab ("Progress", progress_tab_panel); 386 387 output_area = new JTextArea (); 388 output_area.setEditable (false); 389 output_area.setBorder (BorderFactory.createBevelBorder(BevelBorder.LOWERED)); 390 output_area.setFont (new Font("Monospaced", Font.PLAIN, 12)); 391 output_tab_panel = new JPanel(); 392 output_tab_panel.setLayout (new GridLayout()); 393 output_tab_panel.add (new JScrollPane (output_area)); 394 output_tab.addTab ("Output", output_tab_panel); 395 } 396 397 private void add (JComponent a, JComponent b, GridBagConstraints c, int x, int y) 398 { 399 c.gridx = x; 400 c.gridy = y; 401 a.add (b, c); 402 } 403 404 private void findSeq1ButtonActionPerformed () 405 { 406 int c = find_dialog.showOpenDialog (this); 407 408 if (c != JFileChooser.APPROVE_OPTION) return; 409 410 seq1_field.setText (find_dialog.getSelectedFile().getPath()); 411 } 412 413 private void findSeq2ButtonActionPerformed () 414 { 415 int c = find_dialog.showOpenDialog (this); 416 417 if (c != JFileChooser.APPROVE_OPTION) return; 418 419 seq2_field.setText (find_dialog.getSelectedFile().getPath()); 420 } 421 422 private void findMatrixButtonActionPerformed () 423 { 424 int c = find_dialog.showOpenDialog (this); 425 426 if (c != JFileChooser.APPROVE_OPTION) return; 427 428 matrix_field.setText (find_dialog.getSelectedFile().getPath()); 429 } 430 431 private void findOutputButtonActionPerformed () 432 { 433 int c = find_dialog.showOpenDialog (this); 434 435 if (c != JFileChooser.APPROVE_OPTION) return; 436 437 output_field.setText (find_dialog.getSelectedFile().getPath()); 438 } 439 440 private void schemeOptionStateChanged () 441 { 442 basic_scheme = basic_button.isSelected(); 443 444 match_label.setEnabled(basic_scheme); 445 match_field.setEnabled(basic_scheme); 446 mismatch_label.setEnabled(basic_scheme); 447 mismatch_field.setEnabled(basic_scheme); 448 gap_label.setEnabled(basic_scheme); 449 gap_field.setEnabled(basic_scheme); 450 451 matrix_field.setEnabled (!basic_scheme); 452 find_matrix_button.setEnabled (!basic_scheme); 453 454 checkRunButtonStatus(); 455 } 456 457 private void outputOptionStateChanged () 458 { 459 output_to_file = file_button.isSelected(); 460 461 output_field.setEnabled (output_to_file); 462 find_output_button.setEnabled (output_to_file); 463 464 checkRunButtonStatus(); 465 } 466 467 private void checkRunButtonStatus () 468 { 469 boolean run = true; 470 471 if (seq1_field.getText().length() == 0 || seq2_field.getText().length() == 0) 472 { 473 run = false; 474 } 475 else 476 { 477 if (file_button.isSelected() && output_field.getText().length() == 0) 478 { 479 run = false; 480 } 481 else 482 { 483 if (matrix_button.isSelected()) 484 { 485 if (matrix_field.getText().length() == 0) 486 { 487 run = false; 488 } 489 } 490 else 491 { 492 if (match_field.getText().length() == 0 493 || mismatch_field.getText().length() == 0 494 || gap_field.getText().length() == 0) 495 { 496 run = false; 497 } 498 } 499 } 500 } 501 502 if ((run_button.isEnabled() && !run) || (!run_button.isEnabled() && run)) 503 run_button.setEnabled(run); 504 } 505 506 private void runButtonActionPerformed () 507 { 508 ScoringScheme scoring; 509 PairwiseAlignment alignment; 510 FileReader seq1_file, seq2_file, matrix_file; 511 BufferedWriter output_file; 512 String seq1_filename, seq2_filename; 513 String matrix_filename, output_filename, message; 514 int alg, match, mismatch, gap; 515 long start, elapsed; 516 517 alg = algorithm_combo.getSelectedIndex(); 518 519 output_tab.setSelectedIndex(0); 520 521 output_area.setText (""); 522 523 // ***************** SET SCORING SCHEME ***************** 524 if (basic_scheme) 525 { 526 progress_area.setText ("Creating scoring scheme... "); 527 try 528 { 529 match = Integer.parseInt (match_field.getText()); 530 mismatch = Integer.parseInt (mismatch_field.getText()); 531 gap = Integer.parseInt (gap_field.getText()); 532 533 scoring = new BasicScoringScheme (match, mismatch, gap); 534 algorithm[alg].setScoringScheme(scoring); 535 progress_area.append ("OK"); 536 } 537 catch (NumberFormatException e) 538 { 539 message = "Invalid scoring arguments."; 540 progress_area.append ("\n" + message); 541 showError (message); 542 return; 543 } 544 } 545 else 546 { 547 matrix_filename = matrix_field.getText (); 548 progress_area.setText ("Loading matrix file... "); 549 try 550 { 551 matrix_file = new FileReader (matrix_filename); 552 } 553 catch (FileNotFoundException e) 554 { 555 message = "File \"" + matrix_filename + "\" not found."; 556 progress_area.append("\n" + message); 557 showError (message); 558 return; 559 } 560 561 try 562 { 563 try 564 { 565 scoring = new ScoringMatrix (matrix_file); 566 algorithm[alg].setScoringScheme(scoring); 567 progress_area.append ("OK"); 568 } 569 catch (InvalidScoringMatrixException e) 570 { 571 matrix_file.close(); 572 message = "Invalid matrix file \"" + matrix_filename + "\"."; 573 progress_area.append ("\n" + message); 574 showError (message); 575 return; 576 } 577 matrix_file.close(); 578 } 579 catch (IOException e) 580 { 581 message = "Error reading file."; 582 progress_area.append("\n" + message); 583 showError (message); 584 return; 585 } 586 } 587 588 // ***************** LOAD SEQUENCES ***************** 589 progress_area.append ("\n\nLoading sequences... "); 590 591 seq1_filename = seq1_field.getText (); 592 try 593 { 594 seq1_file = new FileReader (seq1_filename); 595 } 596 catch (FileNotFoundException e) 597 { 598 message = "File \"" + seq1_filename +"\" not found."; 599 progress_area.append("\n" + message); 600 showError (message); 601 return; 602 } 603 604 seq2_filename = seq2_field.getText (); 605 try 606 { 607 seq2_file = new FileReader (seq2_filename); 608 } 609 catch (FileNotFoundException e) 610 { 611 message = "File \"" + seq2_filename +"\" not found."; 612 progress_area.append("\n" + message); 613 showError (message); 614 return; 615 } 616 617 try 618 { 619 try 620 { 621 start = System.currentTimeMillis(); 622 algorithm[alg].loadSequences (seq1_file, seq2_file); 623 elapsed = System.currentTimeMillis() - start; 624 progress_area.append ("OK"); 625 progress_area.append ("\n[ Elapsed time: " + elapsed + " milliseconds ]"); 626 627 } 628 catch (InvalidSequenceException e) 629 { 630 seq1_file.close(); 631 seq2_file.close(); 632 message = "Invalid sequence files."; 633 progress_area.append ("\n" + message); 634 showError (message); 635 return; 636 } 637 seq1_file.close(); 638 seq2_file.close(); 639 } 640 catch (IOException e) 641 { 642 message = "Error reading sequence files."; 643 progress_area.append("\n" + message); 644 showError (message); 645 return; 646 } 647 648 // ***************** EXECUTE ALGORITHM ***************** 649 progress_area.append("\n\nRunning " + algorithm_combo.getSelectedItem() + "... "); 650 try 651 { 652 start = System.currentTimeMillis(); 653 alignment = algorithm[alg].getPairwiseAlignment(); 654 elapsed = System.currentTimeMillis() - start; 655 progress_area.append ("OK"); 656 progress_area.append ("\n[ Elapsed time: " + elapsed + " milliseconds ]"); 657 } 658 catch (IncompatibleScoringSchemeException e) 659 { 660 message = "Scoring matrix is not compatible with loaded sequences."; 661 progress_area.append ("\n" + message); 662 showError (message); 663 return; 664 } 665 catch (OutOfMemoryError e) 666 { 667 message = "Insufficient memory to compute an alignment"; 668 progress_area.append ("\n" + message); 669 showError (message); 670 return; 671 } 672 673 // ***************** DISPLAY / SAVE OUTPUT ***************** 674 if (output_to_file) 675 { 676 output_filename = output_field.getText (); 677 progress_area.append ("\n\nSaving alignment... "); 678 try 679 { 680 int length = alignment.getGappedSequence1().length(); 681 682 output_file = new BufferedWriter(new FileWriter (output_filename)); 683 output_file.write(alignment.getGappedSequence1(), 0, length); 684 output_file.newLine(); 685 output_file.write(alignment.getScoreTagLine(), 0, length); 686 output_file.newLine(); 687 output_file.write(alignment.getGappedSequence2(), 0, length); 688 output_file.newLine(); 689 String tmp = "Score: " + alignment.getScore(); 690 output_file.write(tmp, 0, tmp.length()); 691 output_file.close(); 692 } 693 catch (IOException e) 694 { 695 message = "Error writing file \"" + output_filename +"\"."; 696 progress_area.append("\n" + message); 697 showError (message); 698 return; 699 } 700 progress_area.append ("OK"); 701 } 702 else 703 { 704 output_area.setText (alignment.toString()); 705 output_tab.setSelectedIndex(1); 706 } 707 } 708 709 private void showError (String message) 710 { 711 JOptionPane.showMessageDialog(this, message, "Error", JOptionPane.ERROR_MESSAGE); 712 } 713 }neobio-0.0.20030929/doc/src-html/neobio/gui/AboutDialog.html 0000644 0002656 0002032 00000017127 07727746664 022335 0 ustar tillea admin
001 /* 002 * About.java 003 * 004 * Copyright 2003 Sergio Anibal de Carvalho Junior 005 * 006 * This file is part of NeoBio. 007 * 008 * NeoBio is free software; you can redistribute it and/or modify it under the terms of 009 * the GNU General Public License as published by the Free Software Foundation; either 010 * version 2 of the License, or (at your option) any later version. 011 * 012 * NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 013 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 014 * PURPOSE. See the GNU General Public License for more details. 015 * 016 * You should have received a copy of the GNU General Public License along with NeoBio; 017 * if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, 018 * Boston, MA 02111-1307, USA. 019 * 020 * Proper attribution of the author as the source of the software would be appreciated. 021 * 022 * Sergio Anibal de Carvalho Junior mailto:sergioanibaljr@users.sourceforge.net 023 * Department of Computer Science http://www.dcs.kcl.ac.uk 024 * King's College London, UK http://www.kcl.ac.uk 025 * 026 * Please visit http://neobio.sourceforge.net 027 * 028 * This project was supervised by Professor Maxime Crochemore. 029 * 030 */ 031 032 package neobio.gui; 033 034 import java.awt.*; 035 import java.awt.event.*; 036 import javax.swing.*; 037 import java.net.URL; 038 039 /** 040 * About screen. 041 * 042 * @author Sergio A. de Carvalho Jr. 043 */ 044 public class AboutDialog extends JDialog 045 { 046 private JLabel image_label; 047 048 /** 049 * Creates a new instance of the About screen. 050 * 051 * @param parent the parent frame 052 */ 053 public AboutDialog (Frame parent) 054 { 055 super (parent, true); 056 initComponents (); 057 pack (); 058 } 059 060 private void initComponents () 061 { 062 URL image_filename; 063 064 setTitle ("About"); 065 setResizable (false); 066 setDefaultCloseOperation (WindowConstants.DISPOSE_ON_CLOSE); 067 068 addWindowListener (new WindowAdapter () 069 { 070 public void windowClosing (WindowEvent e) 071 { 072 closeDialog (e); 073 } 074 }); 075 076 image_filename = getClass().getResource("icons/about.jpg"); 077 if (image_filename != null) 078 { 079 image_label = new JLabel (); 080 image_label.setIcon(new ImageIcon(image_filename)); 081 getContentPane().add(image_label, BorderLayout.CENTER); 082 } 083 } 084 085 private void closeDialog(WindowEvent e) 086 { 087 setVisible (false); 088 dispose (); 089 } 090 }neobio-0.0.20030929/doc/src-html/neobio/gui/NeoBio.html 0000644 0002656 0002032 00000046617 07727746664 021324 0 ustar tillea admin
001 /* 002 * NeoBio.java 003 * 004 * Copyright 2003 Sergio Anibal de Carvalho Junior 005 * 006 * This file is part of NeoBio. 007 * 008 * NeoBio is free software; you can redistribute it and/or modify it under the terms of 009 * the GNU General Public License as published by the Free Software Foundation; either 010 * version 2 of the License, or (at your option) any later version. 011 * 012 * NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 013 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 014 * PURPOSE. See the GNU General Public License for more details. 015 * 016 * You should have received a copy of the GNU General Public License along with NeoBio; 017 * if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, 018 * Boston, MA 02111-1307, USA. 019 * 020 * Proper attribution of the author as the source of the software would be appreciated. 021 * 022 * Sergio Anibal de Carvalho Junior mailto:sergioanibaljr@users.sourceforge.net 023 * Department of Computer Science http://www.dcs.kcl.ac.uk 024 * King's College London, UK http://www.kcl.ac.uk 025 * 026 * Please visit http://neobio.sourceforge.net 027 * 028 * This project was supervised by Professor Maxime Crochemore. 029 * 030 */ 031 032 package neobio.gui; 033 034 import java.io.*; 035 import java.awt.*; 036 import java.awt.event.*; 037 import javax.swing.*; 038 import javax.swing.border.*; 039 import java.applet.*; 040 import java.util.*; 041 import java.net.URL; 042 import java.beans.PropertyVetoException; 043 044 /** 045 * This class is a simple GUI utility for computing pairwise sequence alignments using one 046 * of the the algorithms provided in the {@link neobio.alignment} package. 047 * 048 * @author Sergio A. de Carvalho Jr. 049 */ 050 public class NeoBio extends JFrame 051 { 052 private JMenu file_menu, help_menu; 053 private JMenuBar menu_bar; 054 private JMenuItem new_alignment_item, exit_menuitem, about_menuitem; 055 private JSeparator mid_separator; 056 private JToolBar file_toolbar; 057 private JPanel toolbar_panel; 058 private JButton alignment_button; 059 060 private JDesktopPane desktop_pane; 061 062 /** 063 * Creates a new instance of a graphical interface. 064 */ 065 public NeoBio() 066 { 067 super(); 068 069 setTitle("NeoBio"); 070 setDefaultCloseOperation (WindowConstants.DISPOSE_ON_CLOSE); 071 initComponents(); 072 073 show(); 074 075 // always open pairwise alignment internal frame 076 pairwiseAlignment(); 077 } 078 079 private void initComponents() 080 { 081 URL icon; 082 083 // window closing event 084 addWindowListener(new WindowAdapter() 085 { 086 public void windowClosing(WindowEvent e) 087 { 088 exitForm(); 089 } 090 }); 091 092 Container content_pane = getContentPane(); 093 094 desktop_pane = new JDesktopPane(); 095 096 content_pane.add (desktop_pane, BorderLayout.CENTER); 097 098 new_alignment_item = new JMenuItem("Pairwise Alignment"); 099 new_alignment_item.setMnemonic('p'); 100 new_alignment_item.addActionListener(new ActionListener() 101 { 102 public void actionPerformed(ActionEvent e) 103 { 104 newAlignmentActionPerformed(e); 105 } 106 }); 107 icon = getClass().getResource("icons/alignment.gif"); 108 if (icon != null) new_alignment_item.setIcon(new ImageIcon(icon)); 109 110 mid_separator = new JSeparator(); 111 112 exit_menuitem = new JMenuItem("Exit"); 113 exit_menuitem.setMnemonic('x'); 114 exit_menuitem.addActionListener(new ActionListener() 115 { 116 public void actionPerformed(ActionEvent e) 117 { 118 exitMenuItemActionPerformed(e); 119 } 120 }); 121 122 file_menu = new JMenu("File"); 123 file_menu.setMnemonic('f'); 124 file_menu.add(new_alignment_item); 125 file_menu.add(mid_separator); 126 file_menu.add(exit_menuitem); 127 128 about_menuitem = new JMenuItem("About"); 129 about_menuitem.addActionListener(new ActionListener() 130 { 131 public void actionPerformed(ActionEvent e) 132 { 133 aboutMenuItemActionPerformed(e); 134 } 135 }); 136 icon = getClass().getResource("icons/help.gif"); 137 if (icon != null) about_menuitem.setIcon(new ImageIcon(icon)); 138 139 help_menu = new JMenu("Help"); 140 help_menu.add(about_menuitem); 141 142 menu_bar = new JMenuBar(); 143 //menu_bar.setFont(getFont()); 144 menu_bar.add(file_menu); 145 menu_bar.add(help_menu); 146 147 setJMenuBar(menu_bar); 148 149 alignment_button = new JButton(); 150 alignment_button.setMnemonic('p'); 151 alignment_button.setToolTipText("Pairwise Alignment..."); 152 alignment_button.addActionListener(new ActionListener() 153 { 154 public void actionPerformed(ActionEvent e) 155 { 156 newAlignmentActionPerformed(e); 157 } 158 }); 159 icon = getClass().getResource("icons/alignment.gif"); 160 if (icon != null) alignment_button.setIcon(new ImageIcon(icon)); 161 162 file_toolbar = new JToolBar(); 163 file_toolbar.setRollover(true); 164 file_toolbar.add(alignment_button); 165 166 toolbar_panel = new JPanel(); 167 toolbar_panel.setLayout(new FlowLayout(FlowLayout.LEFT, 0, 0)); 168 toolbar_panel.setBorder(new EtchedBorder()); 169 toolbar_panel.add(file_toolbar); 170 171 content_pane.add(toolbar_panel, BorderLayout.NORTH); 172 173 // set frame size 174 Dimension screen = Toolkit.getDefaultToolkit().getScreenSize(); 175 setSize((screen.width * 2) / 3, (screen.height * 7) / 8); 176 setLocation(screen.width / 6, screen.height / 16); 177 } 178 179 private void aboutMenuItemActionPerformed (ActionEvent e) 180 { 181 (new AboutDialog(this)).show(); 182 } 183 184 private void exitMenuItemActionPerformed (ActionEvent e) 185 { 186 exitForm(); 187 } 188 189 private void exitForm () 190 { 191 System.exit(0); 192 } 193 194 private void newAlignmentActionPerformed (ActionEvent e) 195 { 196 pairwiseAlignment(); 197 } 198 199 private void pairwiseAlignment () 200 { 201 PairwiseAlignmentFrame alignment_frame = new PairwiseAlignmentFrame (this); 202 203 desktop_pane.add (alignment_frame); 204 205 alignment_frame.setBounds(0, 0, 500, 500); 206 alignment_frame.show(); 207 alignment_frame.toFront(); 208 209 try 210 { 211 alignment_frame.setMaximum (true); 212 } 213 catch (PropertyVetoException e) {} 214 } 215 216 /** 217 * Create and run a new interface. The main method takes no parameter from the 218 * command line. 219 * 220 * @param args command line arguments 221 */ 222 public static void main(String args[]) 223 { 224 new NeoBio(); 225 } 226 }neobio-0.0.20030929/doc/src-html/neobio/textui/ 0002755 0002656 0002032 00000000000 07727746552 020001 5 ustar tillea admin neobio-0.0.20030929/doc/src-html/neobio/textui/RandomFactorSequenceGenerator.html 0000644 0002656 0002032 00000053157 07727746664 026623 0 ustar tillea admin
001 /* 002 * RandomFactorSequenceGenerator.java 003 * 004 * Copyright 2003 Sergio Anibal de Carvalho Junior 005 * 006 * This file is part of NeoBio. 007 * 008 * NeoBio is free software; you can redistribute it and/or modify it under the terms of 009 * the GNU General Public License as published by the Free Software Foundation; either 010 * version 2 of the License, or (at your option) any later version. 011 * 012 * NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 013 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 014 * PURPOSE. See the GNU General Public License for more details. 015 * 016 * You should have received a copy of the GNU General Public License along with NeoBio; 017 * if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, 018 * Boston, MA 02111-1307, USA. 019 * 020 * Proper attribution of the author as the source of the software would be appreciated. 021 * 022 * Sergio Anibal de Carvalho Junior mailto:sergioanibaljr@users.sourceforge.net 023 * Department of Computer Science http://www.dcs.kcl.ac.uk 024 * King's College London, UK http://www.kcl.ac.uk 025 * 026 * Please visit http://neobio.sourceforge.net 027 * 028 * This project was supervised by Professor Maxime Crochemore. 029 * 030 */ 031 032 package neobio.textui; 033 034 import java.io.BufferedWriter; 035 import java.io.Writer; 036 import java.io.FileWriter; 037 import java.io.OutputStreamWriter; 038 import java.io.IOException; 039 040 /** 041 * This class is a simple command line based utility for generating random sequences with 042 * optimal LZ78 factorisation. 043 * 044 * <P>The main method takes three parameters from the command line to generate a 045 * sequence: <CODE>type</CODE>, <CODE>size</CODE> and <CODE>file</CODE>, where: 046 * <UL> 047 * <LI><B><CODE>type</CODE></B> is either <CODE>DNA</CODE> for DNA sequences or 048 * <CODE>PROT</CODE> for protein sequences. 049 * <LI><B><CODE>size</CODE></B> is the number os characters. 050 * <LI><B><CODE>file</CODE></B> (optional) is the name of a file (if ommited, sequence 051 * is written to standard output). 052 * </UL> 053 * </P> 054 * 055 * @author Sergio A. de Carvalho Jr. 056 */ 057 public class RandomFactorSequenceGenerator 058 { 059 /** 060 * Character set for DNA sequences. 061 */ 062 private static final char[] DNA_CHARS = {'A', 'C', 'G', 'T'}; 063 064 /** 065 * Character set for protein sequences. 066 */ 067 private static final char[] PROT_CHARS = {'A','R','N','D','C','Q','E','G','H','I', 068 'L','K','M','F','P','S','T','W','Y','V','B','Z','X'}; 069 070 /** 071 * The main method takes three parameters from the command line to generate a 072 * sequence. See the class description for details. 073 * 074 * @param args command line arguments 075 */ 076 public static void main (String[] args) 077 { 078 Writer output; 079 String seq_type, filename; 080 int size, random; 081 char[] charset; 082 int[] qty; 083 int[] factor; 084 085 try 086 { 087 // get 1st argument (required): file type 088 seq_type = args[0]; 089 090 // get 2nd argument (required): number of characters 091 size = Integer.parseInt(args[1]); 092 } 093 catch (ArrayIndexOutOfBoundsException e) 094 { 095 usage(); 096 System.exit(1); 097 return; 098 } 099 catch (NumberFormatException e) 100 { 101 usage(); 102 System.exit(1); 103 return; 104 } 105 106 // validate character set 107 if (seq_type.equalsIgnoreCase("DNA")) 108 charset = DNA_CHARS; 109 else if (seq_type.equalsIgnoreCase("PROT")) 110 charset = PROT_CHARS; 111 else 112 { 113 // no such option 114 usage(); 115 System.exit(1); 116 return; 117 } 118 119 // validate size 120 if (size <= 3) 121 { 122 System.err.println ("Error: size must be greater than 3."); 123 System.exit(1); 124 return; 125 } 126 127 try 128 { 129 // get 3rd argument (optional): file name 130 filename = args[2]; 131 132 try 133 { 134 // open file for writing 135 output = new BufferedWriter (new FileWriter (filename)); 136 } 137 catch (IOException e) 138 { 139 System.err.println ("Error: couldn't open " + filename + " for writing."); 140 e.printStackTrace(); 141 System.exit(2); 142 return; 143 } 144 } 145 catch (ArrayIndexOutOfBoundsException e) 146 { 147 // file name was ommited, use standard output 148 filename = null; 149 output = new OutputStreamWriter (System.out); 150 } 151 152 // alocate an of characters statistics 153 qty = new int[charset.length]; 154 155 // alocate an array to store the growing factor 156 // its size will be no greather than half sequence size 157 // (in fact, it's much less than that!) 158 factor = new int [size / 2]; 159 160 try 161 { 162 int s = 0, i, f_size = 0; 163 164 // write sequence 165 while (s < size) 166 { 167 // copy previous factor 168 for (i = 0; i < f_size && s < size; i++) 169 { 170 output.write(charset[factor[i]]); 171 172 s++; 173 174 // keep track of how many characters 175 // have been writen of each type 176 qty[factor[i]]++; 177 } 178 179 if (s < size) 180 { 181 182 // choose a character index randomly 183 random = (int) (Math.random() * charset.length); 184 185 // extend factor with the random char index 186 factor[f_size++] = random; 187 188 // keep track of how many characters 189 // have been writen of each type 190 qty[random]++; 191 192 output.write(charset[random]); 193 194 s++; 195 } 196 } 197 198 output.flush(); 199 200 if (filename != null) output.close(); 201 } 202 catch (IOException e) 203 { 204 System.err.println ("Error: failed to write sequence."); 205 e.printStackTrace(); 206 System.exit(2); 207 return; 208 } 209 210 // print character distribution 211 System.out.println("\nCharacter distribution:"); 212 for (int i = 0; i < charset.length; i++) 213 System.err.println(charset[i] + ": " + qty[i]); 214 215 System.exit(0); 216 } 217 218 /** 219 * Prints command line usage. 220 */ 221 private static void usage () 222 { 223 System.err.println( 224 "\nUsage: RandomFactorSequenceGenerator <type> <size> [<file>]\n\n" + 225 "where:\n\n" + 226 " <type> = DNA for nucleotide sequences\n" + 227 " or PROT for protein sequences\n\n" + 228 " <size> = number os characters\n\n" + 229 " <file> = name of a file to where the sequence is to be written\n" + 230 " (if ommited, sequence is written to standard output)" 231 ); 232 } 233 }neobio-0.0.20030929/doc/src-html/neobio/textui/RandomSequenceGenerator.html 0000644 0002656 0002032 00000045115 07727746664 025457 0 ustar tillea admin
001 /* 002 * RandomSequenceGenerator.java 003 * 004 * Copyright 2003 Sergio Anibal de Carvalho Junior 005 * 006 * This file is part of NeoBio. 007 * 008 * NeoBio is free software; you can redistribute it and/or modify it under the terms of 009 * the GNU General Public License as published by the Free Software Foundation; either 010 * version 2 of the License, or (at your option) any later version. 011 * 012 * NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 013 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 014 * PURPOSE. See the GNU General Public License for more details. 015 * 016 * You should have received a copy of the GNU General Public License along with NeoBio; 017 * if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, 018 * Boston, MA 02111-1307, USA. 019 * 020 * Proper attribution of the author as the source of the software would be appreciated. 021 * 022 * Sergio Anibal de Carvalho Junior mailto:sergioanibaljr@users.sourceforge.net 023 * Department of Computer Science http://www.dcs.kcl.ac.uk 024 * King's College London, UK http://www.kcl.ac.uk 025 * 026 * Please visit http://neobio.sourceforge.net 027 * 028 * This project was supervised by Professor Maxime Crochemore. 029 * 030 */ 031 032 package neobio.textui; 033 034 import java.io.BufferedWriter; 035 import java.io.Writer; 036 import java.io.FileWriter; 037 import java.io.OutputStreamWriter; 038 import java.io.IOException; 039 040 /** 041 * This class is a simple command line based utility for generating random sequences. 042 * 043 * <P>The main method takes three parameters from the command line to generate a 044 * sequence: <CODE>type</CODE>, <CODE>size</CODE> and <CODE>file</CODE>, where: 045 * <UL> 046 * <LI><B><CODE>type</CODE></B> is either <CODE>DNA</CODE> for DNA sequences or 047 * <CODE>PROT</CODE> for protein sequences. 048 * <LI><B><CODE>size</CODE></B> is the number os characters. 049 * <LI><B><CODE>file</CODE></B> (optional) is the name of a file (if ommited, sequence 050 * is written to standard output). 051 * </UL> 052 * </P> 053 * 054 * @author Sergio A. de Carvalho Jr. 055 */ 056 public class RandomSequenceGenerator 057 { 058 /** 059 * Character set for DNA sequences. 060 */ 061 private static final char DNA_CHARS[] = {'A', 'C', 'G', 'T'}; 062 063 /** 064 * Character set for protein sequences. 065 */ 066 private static final char PROT_CHARS[] = {'A','R','N','D','C','Q','E','G','H','I', 067 'L','K','M','F','P','S','T','W','Y','V','B','Z','X'}; 068 069 /** 070 * The main method takes three parameters from the command line to generate a 071 * sequence. See the class description for details. 072 * 073 * @param args command line arguments 074 */ 075 public static void main (String args[]) 076 { 077 Writer output; 078 String seq_type, filename; 079 int size, random; 080 char charset[]; 081 int qty[]; 082 083 try 084 { 085 // get 1st argument (required): file type 086 seq_type = args[0]; 087 088 // get 2nd argument (required): number of characters 089 size = Integer.parseInt(args[1]); 090 } 091 catch (ArrayIndexOutOfBoundsException e) 092 { 093 usage(); 094 System.exit(1); 095 return; 096 } 097 catch (NumberFormatException e) 098 { 099 usage(); 100 System.exit(1); 101 return; 102 } 103 104 // validate character set 105 if (seq_type.equalsIgnoreCase("DNA")) 106 charset = DNA_CHARS; 107 else if (seq_type.equalsIgnoreCase("PROT")) 108 charset = PROT_CHARS; 109 else 110 { 111 // no such option 112 usage(); 113 System.exit(1); 114 return; 115 } 116 117 // validate size 118 if (size < 1) 119 { 120 System.err.println ("Error: size must be greater than 1."); 121 System.exit(1); 122 return; 123 } 124 125 try 126 { 127 // get 3rd argument (optional): file name 128 filename = args[2]; 129 130 try 131 { 132 // open file for writing 133 output = new BufferedWriter (new FileWriter (filename)); 134 } 135 catch (IOException e) 136 { 137 System.err.println ("Error: couldn't open " + filename + " for writing."); 138 e.printStackTrace(); 139 System.exit(2); 140 return; 141 } 142 } 143 catch (ArrayIndexOutOfBoundsException e) 144 { 145 // file name was ommited, use standard output 146 filename = null; 147 output = new OutputStreamWriter (System.out); 148 } 149 150 // alocate a vector of characters 151 qty = new int[charset.length]; 152 153 try 154 { 155 // write sequence 156 for (int i = 0; i < size; i++) 157 { 158 // choose a character randomly 159 random = (int) (Math.random() * charset.length); 160 161 // keep track of how many characters 162 // have been writen 163 qty[random]++; 164 165 output.write(charset[random]); 166 } 167 168 output.flush(); 169 170 if (filename != null) output.close(); 171 } 172 catch (IOException e) 173 { 174 System.err.println ("Error: failed to write sequence."); 175 e.printStackTrace(); 176 System.exit(2); 177 return; 178 } 179 180 // print character distribution 181 //for (int i = 0; i < charset.length; i++) 182 //System.err.println(charset[i] + ": " + qty[i]); 183 184 System.exit(0); 185 } 186 187 /** 188 * Prints command line usage. 189 */ 190 private static void usage () 191 { 192 System.err.println( 193 "\nUsage: RandomSequenceGenerator <type> <size> [<file>]\n\n" + 194 "where:\n\n" + 195 " <type> = DNA for nucleotide sequences\n" + 196 " or PROT for protein sequences\n\n" + 197 " <size> = number os characters\n\n" + 198 " <file> = name of a file to where the sequence is to be written\n" + 199 " (if ommited, sequence is written to standard output)" 200 ); 201 } 202 }neobio-0.0.20030929/doc/src-html/neobio/textui/NeoBio.html 0000644 0002656 0002032 00000065274 07727746664 022062 0 ustar tillea admin
001 /* 002 * NeoBio.java 003 * 004 * Copyright 2003 Sergio Anibal de Carvalho Junior 005 * 006 * This file is part of NeoBio. 007 * 008 * NeoBio is free software; you can redistribute it and/or modify it under the terms of 009 * the GNU General Public License as published by the Free Software Foundation; either 010 * version 2 of the License, or (at your option) any later version. 011 * 012 * NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 013 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 014 * PURPOSE. See the GNU General Public License for more details. 015 * 016 * You should have received a copy of the GNU General Public License along with NeoBio; 017 * if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, 018 * Boston, MA 02111-1307, USA. 019 * 020 * Proper attribution of the author as the source of the software would be appreciated. 021 * 022 * Sergio Anibal de Carvalho Junior mailto:sergioanibaljr@users.sourceforge.net 023 * Department of Computer Science http://www.dcs.kcl.ac.uk 024 * King's College London, UK http://www.kcl.ac.uk 025 * 026 * Please visit http://neobio.sourceforge.net 027 * 028 * This project was supervised by Professor Maxime Crochemore. 029 * 030 */ 031 032 package neobio.textui; 033 034 import neobio.alignment.*; 035 import java.io.FileReader; 036 import java.io.IOException; 037 038 /** 039 * This class is a simple command line based utility for computing pairwise sequence 040 * alignments using one of the the algorithms provided in the {@link neobio.alignment} 041 * package. 042 * 043 * <P>The main method takes the follwing parameters from the command line: 044 * 045 * <CODE><BLOCKQUOTE> 046 * NeoBio <alg> <S1> <S2> [M <matrix> | S <match> 047 * <mismatch> <gap>] 048 * </BLOCKQUOTE></CODE> 049 * 050 * <UL> 051 * <LI><B><CODE><alg></CODE></B> is either <B><CODE>NW</CODE></B> for {@linkplain 052 * neobio.alignment.NeedlemanWunsch Needleman & Wunsch} (global alignment), 053 * <B><CODE>SW</CODE></B> for {@linkplain neobio.alignment.SmithWaterman Smith & Waterman} 054 * (local alignment), <B><CODE>CLZG</CODE></B> for {@linkplain 055 * neobio.alignment.CrochemoreLandauZivUkelsonGlobalAlignment Crochemore, Landau & 056 * Ziv-Ukelson global alignment} or <B><CODE>CLZL</CODE></B> for {@linkplain 057 * neobio.alignment.CrochemoreLandauZivUkelsonLocalAlignment Crochemore, Landau & 058 * Ziv-Ukelson local alignment}; 059 * 060 * <LI><B><CODE><S1></CODE></B> is the first sequence file; 061 * 062 * <LI><B><CODE><S2></CODE></B> is the second sequence file; 063 * 064 * <LI><B><CODE>M <matrix></CODE></B> is for using a scoring matrix file; 065 * 066 * <LI><B><CODE>S <match> <mismatch> <gap></CODE></B> is for using a 067 * simple scoring scheme, where <B><CODE><match></CODE></B> is the match reward 068 * value, <B><CODE><mismatch></CODE></B> is the mismatch penalty value and 069 * <B><CODE><gap></CODE></B> is the cost of a gap (linear gap cost function). 070 * </UL> 071 * 072 * @author Sergio A. de Carvalho Jr. 073 */ 074 public class NeoBio 075 { 076 /** 077 * The main method takes parameters from the command line to compute a pairwise 078 * sequence alignment. See the class description for details. 079 * 080 * @param args command line arguments 081 */ 082 public static void main (String args[]) 083 { 084 PairwiseAlignmentAlgorithm algorithm; 085 FileReader seq1, seq2; 086 ScoringScheme scoring; 087 PairwiseAlignment alignment; 088 String algo, file1, file2, scoring_type; 089 long start, elapsed; 090 int match, mismatch, gap; 091 092 try 093 { 094 // create an instance of the 095 // requested algorithm 096 algo = args[0]; 097 098 if (algo.equalsIgnoreCase("nw")) 099 algorithm = new NeedlemanWunsch(); 100 else if (algo.equalsIgnoreCase("sw")) 101 algorithm = new SmithWaterman(); 102 else if (algo.equalsIgnoreCase("clzg")) 103 algorithm = new CrochemoreLandauZivUkelsonGlobalAlignment(); 104 else if (algo.equalsIgnoreCase("clzl")) 105 algorithm = new CrochemoreLandauZivUkelsonLocalAlignment(); 106 else 107 { 108 usage(); 109 System.exit(1); 110 return; 111 } 112 113 // sequences file names 114 file1 = args[1]; 115 file2 = args[2]; 116 } 117 catch (ArrayIndexOutOfBoundsException e) 118 { 119 usage(); 120 System.exit(1); 121 return; 122 } 123 124 try 125 { 126 // scoring scheme type 127 scoring_type = args[3]; 128 129 try 130 { 131 if (scoring_type.equalsIgnoreCase("M")) 132 { 133 // use scoring matrix 134 scoring = new ScoringMatrix (new FileReader(args[4])); 135 } 136 else if (scoring_type.equalsIgnoreCase("S")) 137 { 138 // use basic scoring scheme 139 match = Integer.parseInt(args[4]); 140 mismatch = Integer.parseInt(args[5]); 141 gap = Integer.parseInt(args[6]); 142 143 scoring = new BasicScoringScheme (match, mismatch, gap); 144 } 145 else 146 { 147 usage(); 148 System.exit(1); 149 return; 150 } 151 } 152 catch (NumberFormatException e) 153 { 154 usage(); 155 System.exit(1); 156 return; 157 } 158 catch (ArrayIndexOutOfBoundsException e) 159 { 160 usage(); 161 System.exit(1); 162 return; 163 } 164 catch (InvalidScoringMatrixException e) 165 { 166 System.err.println(e.getMessage()); 167 System.exit(2); 168 return; 169 } 170 catch (IOException e) 171 { 172 System.err.println(e.getMessage()); 173 System.exit(2); 174 return; 175 } 176 } 177 catch (ArrayIndexOutOfBoundsException e) 178 { 179 // not specified: use default scoring scheme 180 scoring = new BasicScoringScheme (1, -1, -1); 181 } 182 183 // set scoring scheme 184 algorithm.setScoringScheme(scoring); 185 186 try 187 { 188 // load sequences 189 System.err.println("\nLoading sequences..."); 190 191 seq1 = new FileReader(file1); 192 seq2 = new FileReader(file2); 193 194 start = System.currentTimeMillis(); 195 algorithm.loadSequences(seq1, seq2); 196 elapsed = System.currentTimeMillis() - start; 197 198 // close files 199 seq1.close(); 200 seq2.close(); 201 202 System.err.println("[ Elapsed time: " + elapsed + " milliseconds ]\n"); 203 204 /* 205 // compute score only 206 System.err.println("\nComputing score..."); 207 208 start = System.currentTimeMillis(); 209 score = algorithm.getScore(); 210 elapsed = System.currentTimeMillis() - start; 211 212 System.out.println("Score: " + score); 213 System.err.println("[ Elapsed time: " + elapsed + " milliseconds ]"); 214 //*/ 215 216 // compute alignment 217 System.err.println("Computing alignment..."); 218 219 start = System.currentTimeMillis(); 220 alignment = algorithm.getPairwiseAlignment(); 221 elapsed = System.currentTimeMillis() - start; 222 223 System.err.println("[ Elapsed time: " + elapsed + " milliseconds ]\n"); 224 225 System.out.println("Alignment:\n" + alignment); 226 } 227 catch (InvalidSequenceException e) 228 { 229 System.err.println("Invalid sequence file."); 230 System.exit(2); 231 return; 232 } 233 catch (IncompatibleScoringSchemeException e) 234 { 235 System.err.println("Incompatible scoring scheme."); 236 System.exit(2); 237 return; 238 } 239 catch (IOException e) 240 { 241 System.err.println(e.getMessage()); 242 System.exit(2); 243 return; 244 } 245 246 // print scoring scheme 247 //System.out.println(scoring); 248 249 System.exit(0); 250 } 251 252 /** 253 * Prints command line usage. 254 */ 255 public static void usage () 256 { 257 System.err.println( 258 "\nUsage: NeoBio <alg> <S1> <S2> [M <matrix> | S <match> <mismatch> <gap>]\n\n" + 259 "where:\n\n" + 260 " <alg> = NW for Needleman & Wunsch (global alignment)\n" + 261 " or SW for Smith & Waterman (local alignment)\n" + 262 " or CLZG for Crochemore, Landau & Ziv-Ukelson global alignment\n" + 263 " or CLZL for Crochemore, Landau & Ziv-Ukelson local alignment\n\n" + 264 " <S1> = first sequence file\n\n" + 265 " <S2> = second sequence file\n\n" + 266 " M <matrix> for using a scoring matrix file\n\n" + 267 "or\n\n" + 268 " S <match> <mismatch> <gap> for using a simple scoring scheme\n" + 269 " where <match> = match reward value\n" + 270 " <mismatch> = mismatch penalty value\n" + 271 " <gap> = cost of a gap (linear gap cost function)" 272 ); 273 } 274 }neobio-0.0.20030929/doc/src-html/neobio/alignment/ 0002755 0002656 0002032 00000000000 07727746550 020433 5 ustar tillea admin neobio-0.0.20030929/doc/src-html/neobio/alignment/LocalAlignmentBlock.html 0000644 0002656 0002032 00000025253 07727746662 025176 0 ustar tillea admin
001 /* 002 * LocalAlignmentBlock.java 003 * 004 * Copyright 2003 Sergio Anibal de Carvalho Junior 005 * 006 * This file is part of NeoBio. 007 * 008 * NeoBio is free software; you can redistribute it and/or modify it under the terms of 009 * the GNU General Public License as published by the Free Software Foundation; either 010 * version 2 of the License, or (at your option) any later version. 011 * 012 * NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 013 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 014 * PURPOSE. See the GNU General Public License for more details. 015 * 016 * You should have received a copy of the GNU General Public License along with NeoBio; 017 * if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, 018 * Boston, MA 02111-1307, USA. 019 * 020 * Proper attribution of the author as the source of the software would be appreciated. 021 * 022 * Sergio Anibal de Carvalho Junior mailto:sergioanibaljr@users.sourceforge.net 023 * Department of Computer Science http://www.dcs.kcl.ac.uk 024 * King's College London, UK http://www.kcl.ac.uk 025 * 026 * Please visit http://neobio.sourceforge.net 027 * 028 * This project was supervised by Professor Maxime Crochemore. 029 * 030 */ 031 032 package neobio.alignment; 033 034 /** 035 * This class is used by the {@linkplain CrochemoreLandauZivUkelsonLocalAlignment} 036 * algorithm to store the information of an alignment block. All fields are public (but 037 * final) in order to simplify the access to the data. 038 * 039 * <P>For more information on how this class is used, please refer to the specification 040 * of the <CODE>CrochemoreLandauZivUkelsonLocalAlignment</CODE> class.</P> 041 * 042 * @author Sergio A. de Carvalho Jr. 043 * @see CrochemoreLandauZivUkelsonLocalAlignment 044 */ 045 public class LocalAlignmentBlock extends AlignmentBlock 046 { 047 /** 048 * The value of the highest scoring path which starts at the input border of this 049 * block and ends inside it, called E-path. 050 */ 051 public int[] E_path_score; 052 053 /** 054 * An array of pointers to blocks that are source of E-paths. 055 */ 056 public LocalAlignmentBlock[] E_path_ancestor; 057 058 /** 059 * Indexes of of the entry in the ancestor block that is the source of the E-path. 060 */ 061 public int[] E_path_ancestor_index; 062 063 /** 064 * The value of the highest scoring path which starts inside the block and ends at its 065 * output border. 066 */ 067 public int[] S_path_score; 068 069 /** 070 * The type of the highest scoring path ending at a given position of the output 071 * border of a block. 072 */ 073 public byte[] path_type; 074 075 /** 076 * The direction to the source of the S-path of the new vertex of this block. 077 */ 078 public byte S_direction; 079 080 /** 081 * The value of the highest scoring path contained in this block, called C-path. 082 */ 083 public int C; 084 085 /** 086 * Creates a new root block. 087 * 088 * @param factor1 factor of the first sequence being aligned 089 * @param factor2 factor of the second sequence being aligned 090 */ 091 LocalAlignmentBlock (Factor factor1, Factor factor2) 092 { 093 super (factor1, factor2); 094 095 E_path_score = S_path_score = new int[] {0}; 096 E_path_ancestor = new LocalAlignmentBlock [] {this}; 097 E_path_ancestor_index = new int [] {0}; 098 } 099 100 /** 101 * Creates a new alignment block, with all arrays created with the specified size. 102 * 103 * @param factor1 factor of the first sequence being aligned 104 * @param factor2 factor of the second sequence being aligned 105 * @param size size of the arrays to be created 106 */ 107 LocalAlignmentBlock (Factor factor1, Factor factor2, int size) 108 { 109 super (factor1, factor2, size); 110 111 E_path_score = new int [size]; 112 E_path_ancestor = new LocalAlignmentBlock [size]; 113 E_path_ancestor_index = new int [size]; 114 S_path_score = new int [size]; 115 path_type = new byte [size]; 116 } 117 }neobio-0.0.20030929/doc/src-html/neobio/alignment/ScoringMatrix.html 0000644 0002656 0002032 00000120657 07727746662 024127 0 ustar tillea admin
001 /* 002 * ScoringMatrix.java 003 * 004 * Copyright 2003 Sergio Anibal de Carvalho Junior 005 * 006 * This file is part of NeoBio. 007 * 008 * NeoBio is free software; you can redistribute it and/or modify it under the terms of 009 * the GNU General Public License as published by the Free Software Foundation; either 010 * version 2 of the License, or (at your option) any later version. 011 * 012 * NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 013 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 014 * PURPOSE. See the GNU General Public License for more details. 015 * 016 * You should have received a copy of the GNU General Public License along with NeoBio; 017 * if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, 018 * Boston, MA 02111-1307, USA. 019 * 020 * Proper attribution of the author as the source of the software would be appreciated. 021 * 022 * Sergio Anibal de Carvalho Junior mailto:sergioanibaljr@users.sourceforge.net 023 * Department of Computer Science http://www.dcs.kcl.ac.uk 024 * King's College London, UK http://www.kcl.ac.uk 025 * 026 * Please visit http://neobio.sourceforge.net 027 * 028 * This project was supervised by Professor Maxime Crochemore. 029 * 030 */ 031 032 package neobio.alignment; 033 034 import java.io.Reader; 035 import java.io.StreamTokenizer; 036 import java.io.IOException; 037 038 /** 039 * This class implements a scoring scheme based on a substitution matrix. It is useful 040 * to represent PAM and BLOSUM family of amino acids scoring matrices. Its constructor 041 * loads such matrices from a file (or any other character stream). The following is an 042 * extract of a BLOSUM62 scoring matrix file: 043 * <CODE><BLOCKQUOTE><PRE> 044 * A R N D C Q E G H I L K M F P S T W Y V B Z X * 045 * A 4 -1 -2 -2 0 -1 -1 0 -2 -1 -1 -1 -1 -2 -1 1 0 -3 -2 0 -2 -1 0 -4 046 * R -1 5 0 -2 -3 1 0 -2 0 -3 -2 2 -1 -3 -2 -1 -1 -3 -2 -3 -1 0 -1 -4 047 * ... 048 * B -2 -1 3 4 -3 0 1 -1 0 -3 -4 0 -3 -3 -2 0 -1 -4 -3 -3 4 1 -1 -4 049 * Z -1 0 0 1 -3 3 4 -2 0 -3 -3 1 -1 -3 -1 0 -1 -3 -2 -2 1 4 -1 -4 050 * X 0 -1 -1 -1 -2 -1 -1 -1 -1 -1 -1 -1 -1 -1 -2 0 0 -2 -1 -1 -1 -1 -1 -4 051 * * -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 1 052 * </PRE></BLOCKQUOTE></CODE> 053 * 054 * <P>Matrices are expected to follow this format. They must have one row an one column 055 * for each defined character (not necessarily in the same order). Each row and column 056 * must start with a distinct character (no repetition) and all row characters must have a 057 * correspondent column, and vice versa.</P> 058 * 059 * <P>Value at position (i,j) represent the score of substituting character of row i for 060 * character of column j. Insertion penalties are specified by the last row while deletion 061 * penalties must be located at the last column (both represented by the special character 062 * defined by the <CODE>INDEL_CHAR</CODE> constant). Note that it only supports an 063 * additive gap cost function. In case any of this rules are not followed, an 064 * {@linkplain InvalidScoringMatrixException} exception is raised by the constructor.</P> 065 * 066 * <P>If a scoring operation (substitution, insertion or deletion) involves a character 067 * not found in the matrix, an exception is raised.</P> 068 * 069 * @author Sergio A. de Carvalho Jr. 070 * @see InvalidScoringMatrixException 071 */ 072 public class ScoringMatrix extends ScoringScheme 073 { 074 /** 075 * The character that indicates the row and column for insertion and deletion 076 * penalties in the matrix. 077 */ 078 protected static final char INDEL_CHAR = '*'; 079 080 /** 081 * The character used to start a comment line in the scoring matrix file. 082 */ 083 protected static final char COMMENT_CHAR = '#'; 084 085 /** 086 * Stores matrix column headers in the order they were found. 087 */ 088 protected String col_codes; 089 090 /** 091 * Stores matrix row headers in the order they were found. 092 */ 093 protected String row_codes; 094 095 /** 096 * Stores values for each operation (substitution, insertion or deletion) defined by 097 * this matrix. 098 */ 099 protected int matrix[][]; 100 101 /** 102 * Dimension of the (squared) matrix. 103 */ 104 protected int dimension; 105 106 /** 107 * The maximum absolute score that this matrix can return for any substitution, 108 * deletion or insertion. 109 */ 110 protected int max_absolute_score; 111 112 /** 113 * Creates a new instance of a substitution matrix loaded from the character stream. 114 * The case of characters is significant when subsequently computing their score. 115 * 116 * @param input character stream from where the matrix is read 117 * @throws IOException if an I/O operation fails when reading from input 118 * @throws InvalidScoringMatrixException if the matrix does not comply with the 119 * specification 120 */ 121 public ScoringMatrix (Reader input) 122 throws IOException, InvalidScoringMatrixException 123 { 124 this (input, true); 125 } 126 127 /** 128 * Creates a new instance of a substitution matrix loaded from the character stream. 129 * If <CODE>case_sensitive</CODE> is <CODE>true</CODE>, the case of characters is 130 * significant when subsequently computing their score; otherwise the case is 131 * ignored. 132 * 133 * @param input character stream from where the matrix is read 134 * @param case_sensitive <CODE>true</CODE> if the case of characters must be 135 * @throws IOException if an I/O operation fails when reading from input 136 * @throws InvalidScoringMatrixException if the matrix does not comply with the 137 * specification 138 */ 139 public ScoringMatrix (Reader input, boolean case_sensitive) 140 throws IOException, InvalidScoringMatrixException 141 { 142 super (case_sensitive); 143 144 StreamTokenizer in; 145 StringBuffer buf = new StringBuffer(); 146 int row, col, max_abs = 0; 147 char c; 148 149 // create a stream tokenizer on top of the input 150 // stream and set the COMMENT_CHAR as the comment character 151 in = new StreamTokenizer(input); 152 in.commentChar(COMMENT_CHAR); 153 154 // consider ends of line when reading the first row 155 in.eolIsSignificant(true); 156 157 // skip blank lines (if any) 158 for (in.nextToken(); in.ttype == StreamTokenizer.TT_EOL; in.nextToken()); 159 160 // read first row: column character codes 161 while ((in.ttype != StreamTokenizer.TT_EOF) && 162 (in.ttype != StreamTokenizer.TT_EOL)) 163 { 164 if (in.ttype == StreamTokenizer.TT_WORD) 165 { 166 if (in.sval.length() > 1) 167 throw new InvalidScoringMatrixException 168 ("Column headers must have one-character only."); 169 170 buf.append(in.sval.charAt(0)); 171 } 172 else if (in.ttype == INDEL_CHAR) 173 { 174 buf.append(INDEL_CHAR); 175 } 176 else 177 { 178 throw new InvalidScoringMatrixException("Column headers must be " + 179 "one-character codes or the special character '" + INDEL_CHAR + "'."); 180 } 181 182 in.nextToken(); 183 } 184 185 // convert everything to upper case if it's not case sensitive 186 if (case_sensitive) 187 col_codes = buf.toString(); 188 else 189 col_codes = buf.toString().toUpperCase(); 190 191 dimension = col_codes.length(); 192 193 // check if there's a column for deletion penalties 194 if (col_codes.indexOf (INDEL_CHAR) == -1) 195 throw new InvalidScoringMatrixException 196 ("Matrix have no column for deletion penalties."); 197 198 // check if there is at least one character code (besides the INDEL char) 199 if (dimension < 2) 200 throw new InvalidScoringMatrixException 201 ("Matrix must have at least one column with a character code."); 202 203 // check for repeated column codes 204 for (int i = 0; i < dimension; i++) 205 if (col_codes.indexOf(col_codes.charAt(i),i+1) > i) 206 throw new InvalidScoringMatrixException 207 ("Columns must have distinct one-character codes."); 208 209 // allocate matrix 210 matrix = new int[dimension][dimension]; 211 212 // reset buffer 213 buf.delete (0, dimension); 214 215 // from now on, ignore ends of line 216 in.eolIsSignificant(false); 217 if (in.ttype == StreamTokenizer.TT_EOL) in.nextToken(); 218 219 // read rest of matrix (one line for each character, but 220 // not necessarily in the same order as the columns) 221 for (row = 0; row < dimension && in.ttype != StreamTokenizer.TT_EOF; row++) 222 { 223 // start reading the line: the character code must come first 224 if (in.ttype == StreamTokenizer.TT_WORD) 225 { 226 if (in.sval.length() > 1) 227 throw new InvalidScoringMatrixException 228 ("Codes must have one character only."); 229 230 buf.append(in.sval.charAt(0)); 231 } 232 else if (in.ttype == INDEL_CHAR) 233 { 234 buf.append(INDEL_CHAR); 235 } 236 else 237 { 238 throw new InvalidScoringMatrixException ("Rows must start with an" + 239 " one-character code or the special character '" + INDEL_CHAR + "'."); 240 } 241 242 // now, the set of values 243 for (col = 0; col < dimension; col++) 244 { 245 // start reading the values 246 if (in.nextToken() != StreamTokenizer.TT_NUMBER) 247 throw new InvalidScoringMatrixException 248 ("Invalid value at row " + (row+1) + ", column " + (col+1) + "."); 249 250 matrix[row][col] = (int) in.nval; 251 252 if (Math.abs(matrix[row][col]) > max_abs) 253 max_abs = Math.abs(matrix[row][col]); 254 } 255 256 in.nextToken(); 257 } 258 259 // convert everything to upper case if it's not case sensitive 260 if (case_sensitive) 261 row_codes = buf.toString(); 262 else 263 row_codes = buf.toString().toUpperCase(); 264 265 // check if read as many rows as columns 266 if (row_codes.length() != dimension) 267 throw new InvalidScoringMatrixException 268 ("Matrix must have as many rows as columns."); 269 270 // check if there's a row for insertion penalties 271 if (row_codes.indexOf(INDEL_CHAR) == -1) 272 throw new InvalidScoringMatrixException 273 ("Matrix have no row for insertion penalties."); 274 275 // check for repeated row codes 276 for (int i = 0; i < dimension; i++) 277 if (row_codes.indexOf(row_codes.charAt(i),i+1) > i) 278 throw new InvalidScoringMatrixException 279 ("Rows must have distinct one-character codes."); 280 281 // check if all rows have a corresponding column 282 for (int i = 0; i < dimension; i++) 283 if (col_codes.indexOf(c = row_codes.charAt(i)) == -1) 284 throw new InvalidScoringMatrixException 285 ("There is no corresponding column for row character '" + c + "'."); 286 287 // store the maximum absolute value found 288 this.max_absolute_score = max_abs; 289 } 290 291 /** 292 * Returns the score of a substitution of character <CODE>a</CODE> for character 293 * <CODE>b</CODE> according to this scoring matrix. 294 * 295 * @param a first character 296 * @param b second character 297 * @return score of a substitution of character <CODE>a</CODE> for <CODE>b</CODE> 298 * @throws IncompatibleScoringSchemeException if this substitution is not defined 299 */ 300 public int scoreSubstitution (char a, char b) 301 throws IncompatibleScoringSchemeException 302 { 303 int r,c; 304 305 if (case_sensitive) 306 { 307 r = row_codes.indexOf(a); 308 c = col_codes.indexOf(b); 309 } 310 else 311 { 312 r = row_codes.indexOf(Character.toUpperCase(a)); 313 c = col_codes.indexOf(Character.toUpperCase(b)); 314 } 315 316 if (r < 0 || c < 0) 317 throw new IncompatibleScoringSchemeException ("Substitution of character " + 318 a + " for " + b + " is not defined."); 319 320 return matrix[r][c]; 321 } 322 323 /** 324 * Returns the score of an insertion of character <CODE>a</CODE> according to this 325 * scoring matrix. 326 * 327 * @param a character to be inserted 328 * @return score of insertion of <CODE>a</CODE> 329 * @throws IncompatibleScoringSchemeException if this character is not recognised 330 */ 331 public int scoreInsertion (char a) throws IncompatibleScoringSchemeException 332 { 333 return scoreSubstitution (INDEL_CHAR, a); 334 } 335 336 /** 337 * Returns the score of a deletion of character <CODE>a</CODE> according to this 338 * scoring matrix. 339 * 340 * @param a character to be deleted 341 * @return score of deletion of <CODE>a</CODE> 342 * @throws IncompatibleScoringSchemeException if this character is not recognised 343 */ 344 public int scoreDeletion (char a) throws IncompatibleScoringSchemeException 345 { 346 return scoreSubstitution (a, INDEL_CHAR); 347 } 348 349 /** 350 * Tells whether this scoring scheme supports partial matches, which it does, although 351 * a particular scoring matrix loaded by this instace might not. A partial match is 352 * a situation when two characters are not equal but, for any reason, are regarded 353 * as similar by this scoring scheme, which then returns a positive score value. This 354 * is common for amino acid scoring matrices. 355 * 356 * @return always return <CODE>true</CODE> 357 */ 358 public boolean isPartialMatchSupported () 359 { 360 return true; 361 } 362 363 /** 364 * Returns the maximum absolute score that this scoring scheme can return for any 365 * substitution, deletion or insertion. 366 * 367 * @return maximum absolute score that can be returned 368 */ 369 public int maxAbsoluteScore () 370 { 371 return max_absolute_score; 372 } 373 374 /** 375 * Returns a String representation of this scoring matrix. 376 * 377 * @return a String representation of this scoring matrix 378 */ 379 public String toString () 380 { 381 int row, col; 382 383 StringBuffer buf = new StringBuffer(); 384 385 // column numbers 386 buf.append("Scoring matrix:\n\t"); 387 for (col = 0; col < dimension; col++) 388 { 389 buf.append("\t" + col); 390 } 391 buf.append("\n\t"); 392 393 // column headers 394 for (col = 0; col < dimension; col++) 395 { 396 buf.append('\t'); 397 buf.append(col_codes.charAt(col)); 398 } 399 400 // rest of matrix 401 for (row = 0; row < dimension; row++) 402 { 403 // row number and code 404 buf.append("\n" + row + "\t" + row_codes.charAt(row)); 405 406 for (col = 0; col < dimension; col++) 407 { 408 buf.append('\t'); 409 buf.append(matrix[row][col]); 410 } 411 } 412 413 return buf.toString(); 414 } 415 }neobio-0.0.20030929/doc/src-html/neobio/alignment/SmithWaterman.html 0000644 0002656 0002032 00000115114 07727746664 024113 0 ustar tillea admin
001 /* 002 * SmithWaterman.java 003 * 004 * Copyright 2003 Sergio Anibal de Carvalho Junior 005 * 006 * This file is part of NeoBio. 007 * 008 * NeoBio is free software; you can redistribute it and/or modify it under the terms of 009 * the GNU General Public License as published by the Free Software Foundation; either 010 * version 2 of the License, or (at your option) any later version. 011 * 012 * NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 013 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 014 * PURPOSE. See the GNU General Public License for more details. 015 * 016 * You should have received a copy of the GNU General Public License along with NeoBio; 017 * if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, 018 * Boston, MA 02111-1307, USA. 019 * 020 * Proper attribution of the author as the source of the software would be appreciated. 021 * 022 * Sergio Anibal de Carvalho Junior mailto:sergioanibaljr@users.sourceforge.net 023 * Department of Computer Science http://www.dcs.kcl.ac.uk 024 * King's College London, UK http://www.kcl.ac.uk 025 * 026 * Please visit http://neobio.sourceforge.net 027 * 028 * This project was supervised by Professor Maxime Crochemore. 029 * 030 */ 031 032 package neobio.alignment; 033 034 import java.io.Reader; 035 import java.io.IOException; 036 037 /** 038 * This class implement the classic local alignment algorithm (with linear gap penalty 039 * function) due to T.F.Smith and M.S.Waterman (1981). 040 * 041 * <P>This algorithm is very similar to the {@linkplain NeedlemanWunsch} algorithm for 042 * global alignment. The idea here also consists of building an (n+1 x m+1) matrix M given 043 * two sequences A and B of sizes n and m, respectively. However, unlike in the global 044 * alignment case, every position M[i,j] in the matrix contains the similarity score of 045 * <B>suffixes</B> of A[1..i] and B[1..j].</P> 046 * 047 * <P>Starting from row 0, column 0, the {@link #computeMatrix computeMatrix} method 048 * computes each position M[i,j] with the following recurrence:</P> 049 * 050 * <CODE><BLOCKQUOTE><PRE> 051 * M[0,0] = <B>M[0,j]</B> = <B>M[i,0]</B> = 0 052 * M[i,j] = max { M[i,j-1] + scoreInsertion (B[j]), 053 * M[i-1,j-1] + scoreSubstitution (A[i], B[j]), 054 * M[i-1,j] + scoreDeletion(A[i]) } 055 * </PRE></BLOCKQUOTE></CODE> 056 * 057 * <P>Note that, here, all cells in the first row and column are set to zero. The best 058 * local alignment score is the highest value found anywhere in the matrix.</P> 059 * 060 * <P>Just like in global alignment case, this algorithm has quadratic space complexity 061 * because it needs to keep an (n+1 x m+1) matrix in memory. And since the work of 062 * computing each cell is constant, it also has quadratic time complexity.</P> 063 * 064 * <P>After the matrix has been computed, the alignment can be retrieved by tracing a path 065 * back in the matrix from the position of the highest score until a cell of value zero is 066 * reached. This step is performed by the {@link #buildOptimalAlignment 067 * buildOptimalAlignment} method, and its time complexity is linear on the size of the 068 * alignment. 069 * 070 * <P>If the similarity value only is needed (and not the alignment itself), it is easy to 071 * reduce the space requirement to O(n) by keeping just the last row or column in memory. 072 * This is precisely what is done by the {@link #computeScore computeScore} method. Note 073 * that it still requires O(n<SUP>2</SUP>) time.</P> 074 * 075 * <P>For a more efficient approach to the local alignment problem, see the 076 * {@linkplain CrochemoreLandauZivUkelson} algorithm. For global alignment, see the 077 * {@linkplain NeedlemanWunsch} algorithm.</P> 078 * 079 * @author Sergio A. de Carvalho Jr. 080 * @see NeedlemanWunsch 081 * @see CrochemoreLandauZivUkelson 082 * @see CrochemoreLandauZivUkelsonLocalAlignment 083 * @see CrochemoreLandauZivUkelsonGlobalAlignment 084 */ 085 public class SmithWaterman extends PairwiseAlignmentAlgorithm 086 { 087 /** 088 * The first sequence of an alignment. 089 */ 090 protected CharSequence seq1; 091 092 /** 093 * The second sequence of an alignment. 094 */ 095 protected CharSequence seq2; 096 097 /** 098 * The dynamic programming matrix. Each position (i, j) represents the best score 099 * between a suffic of the firsts i characters of <CODE>seq1</CODE> and a suffix of 100 * the first j characters of <CODE>seq2</CODE>. 101 */ 102 protected int[][] matrix; 103 104 /** 105 * Indicate the row of where an optimal local alignment can be found in the matrix.. 106 */ 107 protected int max_row; 108 109 /** 110 * Indicate the column of where an optimal local alignment can be found in the matrix. 111 */ 112 protected int max_col; 113 114 /** 115 * Loads sequences into {@linkplain CharSequence} instances. In case of any error, an 116 * exception is raised by the constructor of <CODE>CharSequence</CODE> (please check 117 * the specification of that class for specific requirements). 118 * 119 * @param input1 Input for first sequence 120 * @param input2 Input for second sequence 121 * @throws IOException If an I/O error occurs when reading the sequences 122 * @throws InvalidSequenceException If the sequences are not valid 123 * @see CharSequence 124 */ 125 protected void loadSequencesInternal (Reader input1, Reader input2) 126 throws IOException, InvalidSequenceException 127 { 128 // load sequences into instances of CharSequence 129 this.seq1 = new CharSequence(input1); 130 this.seq2 = new CharSequence(input2); 131 } 132 133 /** 134 * Frees pointers to loaded sequences and the dynamic programming matrix so that their 135 * data can be garbage collected. 136 */ 137 protected void unloadSequencesInternal () 138 { 139 this.seq1 = null; 140 this.seq2 = null; 141 this.matrix = null; 142 } 143 144 /** 145 * Builds an optimal local alignment between the loaded sequences after computing the 146 * dynamic programming matrix. It calls the <CODE>buildOptimalAlignment</CODE> method 147 * after the <CODE>computeMatrix</CODE> method computes the dynamic programming 148 * matrix. 149 * 150 * @return an optimal pairwise alignment between the loaded sequences 151 * @throws IncompatibleScoringSchemeException If the scoring scheme is not compatible 152 * with the loaded sequences. 153 * @see #computeMatrix 154 * @see #buildOptimalAlignment 155 */ 156 protected PairwiseAlignment computePairwiseAlignment () 157 throws IncompatibleScoringSchemeException 158 { 159 // compute the matrix 160 computeMatrix (); 161 162 // build and return an optimal local alignment 163 PairwiseAlignment alignment = buildOptimalAlignment (); 164 165 // allow the matrix to be garbage collected 166 matrix = null; 167 168 return alignment; 169 } 170 171 /** 172 * Computes the dynamic programming matrix. 173 * 174 * @throws IncompatibleScoringSchemeException If the scoring scheme is not compatible 175 * with the loaded sequences. 176 */ 177 protected void computeMatrix () throws IncompatibleScoringSchemeException 178 { 179 int r, c, rows, cols, ins, sub, del, max_score; 180 181 rows = seq1.length()+1; 182 cols = seq2.length()+1; 183 184 matrix = new int [rows][cols]; 185 186 // initiate first row 187 for (c = 0; c < cols; c++) 188 matrix[0][c] = 0; 189 190 // keep track of the maximum score 191 this.max_row = this.max_col = max_score = 0; 192 193 // calculates the similarity matrix (row-wise) 194 for (r = 1; r < rows; r++) 195 { 196 // initiate first column 197 matrix[r][0] = 0; 198 199 for (c = 1; c < cols; c++) 200 { 201 ins = matrix[r][c-1] + scoreInsertion(seq2.charAt(c)); 202 sub = matrix[r-1][c-1] + scoreSubstitution(seq1.charAt(r),seq2.charAt(c)); 203 del = matrix[r-1][c] + scoreDeletion(seq1.charAt(r)); 204 205 // choose the greatest 206 matrix[r][c] = max (ins, sub, del, 0); 207 208 if (matrix[r][c] > max_score) 209 { 210 // keep track of the maximum score 211 max_score = matrix[r][c]; 212 this.max_row = r; this.max_col = c; 213 } 214 } 215 } 216 } 217 218 /** 219 * Builds an optimal local alignment between the loaded sequences. Before it is 220 * executed, the dynamic programming matrix must already have been computed by 221 * the <CODE>computeMatrix</CODE> method. 222 * 223 * @return an optimal local alignment between the loaded sequences 224 * @throws IncompatibleScoringSchemeException If the scoring scheme is not compatible 225 * with the loaded sequences. 226 * @see #computeMatrix 227 */ 228 protected PairwiseAlignment buildOptimalAlignment () throws 229 IncompatibleScoringSchemeException 230 { 231 StringBuffer gapped_seq1, score_tag_line, gapped_seq2; 232 int r, c, max_score, sub; 233 234 // start at the cell with maximum score 235 r = this.max_row; 236 c = this.max_col; 237 238 max_score = matrix[r][c]; 239 240 gapped_seq1 = new StringBuffer(); 241 score_tag_line = new StringBuffer(); 242 gapped_seq2 = new StringBuffer(); 243 244 while ((r > 0 || c > 0) && (matrix[r][c] > 0)) 245 { 246 if (c > 0) 247 if (matrix[r][c] == matrix[r][c-1] + scoreInsertion(seq2.charAt(c))) 248 { 249 // insertion 250 gapped_seq1.insert (0, GAP_CHARACTER); 251 score_tag_line.insert (0, GAP_TAG); 252 gapped_seq2.insert (0, seq2.charAt(c)); 253 254 c = c - 1; 255 256 // skip to the next iteration 257 continue; 258 } 259 260 if ((r > 0) && (c > 0)) 261 { 262 sub = scoreSubstitution(seq1.charAt(r), seq2.charAt(c)); 263 264 if (matrix[r][c] == matrix[r-1][c-1] + sub) 265 { 266 // substitution 267 gapped_seq1.insert (0, seq1.charAt(r)); 268 if (seq1.charAt(r) == seq2.charAt(c)) 269 if (useMatchTag()) 270 score_tag_line.insert (0, MATCH_TAG); 271 else 272 score_tag_line.insert (0, seq1.charAt(r)); 273 else if (sub > 0) 274 score_tag_line.insert (0, APPROXIMATE_MATCH_TAG); 275 else 276 score_tag_line.insert (0, MISMATCH_TAG); 277 gapped_seq2.insert (0, seq2.charAt(c)); 278 279 r = r - 1; c = c - 1; 280 281 // skip to the next iteration 282 continue; 283 } 284 } 285 286 // must be a deletion 287 gapped_seq1.insert (0, seq1.charAt(r)); 288 score_tag_line.insert (0, GAP_TAG); 289 gapped_seq2.insert (0,GAP_CHARACTER); 290 291 r = r - 1; 292 } 293 294 return new PairwiseAlignment (gapped_seq1.toString(), score_tag_line.toString(), 295 gapped_seq2.toString(), max_score); 296 } 297 298 /** 299 * Computes the score of the best local alignment between the two sequences using the 300 * scoring scheme previously set. This method calculates the similarity value only 301 * (doesn't build the whole matrix so the alignment cannot be recovered, however it 302 * has the advantage of requiring O(n) space only). 303 * 304 * @return the score of the best local alignment between the loaded sequences 305 * @throws IncompatibleScoringSchemeException If the scoring scheme is not compatible 306 * with the loaded sequences. 307 */ 308 protected int computeScore () throws IncompatibleScoringSchemeException 309 { 310 int[] array; 311 int rows = seq1.length()+1, cols = seq2.length()+1; 312 int r, c, tmp, ins, del, sub, max_score; 313 314 // keep track of the maximum score 315 max_score = 0; 316 317 if (rows <= cols) 318 { 319 // goes columnwise 320 array = new int [rows]; 321 322 // initiate first column 323 for (r = 0; r < rows; r++) 324 array[r] = 0; 325 326 // calculate the similarity matrix (keep current column only) 327 for (c = 1; c < cols; c++) 328 { 329 // set first position to zero (tmp hold values 330 // that will be later moved to the array) 331 tmp = 0; 332 333 for (r = 1; r < rows; r++) 334 { 335 ins = array[r] + scoreInsertion(seq2.charAt(c)); 336 sub = array[r-1] + scoreSubstitution(seq1.charAt(r), seq2.charAt(c)); 337 del = tmp + scoreDeletion(seq1.charAt(r)); 338 339 // move the temp value to the array 340 array[r-1] = tmp; 341 342 // choose the greatest (or zero if all negative) 343 tmp = max (ins, sub, del, 0); 344 345 // keep track of the maximum score 346 if (tmp > max_score) max_score = tmp; 347 } 348 349 // move the temp value to the array 350 array[rows - 1] = tmp; 351 } 352 } 353 else 354 { 355 // goes rowwise 356 array = new int [cols]; 357 358 // initiate first row 359 for (c = 0; c < cols; c++) 360 array[c] = 0; 361 362 // calculate the similarity matrix (keep current row only) 363 for (r = 1; r < rows; r++) 364 { 365 // set first position to zero (tmp hold values 366 // that will be later moved to the array) 367 tmp = 0; 368 369 for (c = 1; c < cols; c++) 370 { 371 ins = tmp + scoreInsertion(seq2.charAt(c)); 372 sub = array[c-1] + scoreSubstitution(seq1.charAt(r), seq2.charAt(c)); 373 del = array[c] + scoreDeletion(seq1.charAt(r)); 374 375 // move the temp value to the array 376 array[c-1] = tmp; 377 378 // choose the greatest (or zero if all negative) 379 tmp = max (ins, sub, del, 0); 380 381 // keep track of the maximum score 382 if (tmp > max_score) max_score = tmp; 383 } 384 385 // move the temp value to the array 386 array[cols - 1] = tmp; 387 } 388 } 389 390 return max_score; 391 } 392 }neobio-0.0.20030929/doc/src-html/neobio/alignment/InvalidScoringMatrixException.html 0000644 0002656 0002032 00000017201 07727746664 027305 0 ustar tillea admin
001 /* 002 * InvalidScoringMatrixException.java 003 * 004 * Copyright 2003 Sergio Anibal de Carvalho Junior 005 * 006 * This file is part of NeoBio. 007 * 008 * NeoBio is free software; you can redistribute it and/or modify it under the terms of 009 * the GNU General Public License as published by the Free Software Foundation; either 010 * version 2 of the License, or (at your option) any later version. 011 * 012 * NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 013 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 014 * PURPOSE. See the GNU General Public License for more details. 015 * 016 * You should have received a copy of the GNU General Public License along with NeoBio; 017 * if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, 018 * Boston, MA 02111-1307, USA. 019 * 020 * Proper attribution of the author as the source of the software would be appreciated. 021 * 022 * Sergio Anibal de Carvalho Junior mailto:sergioanibaljr@users.sourceforge.net 023 * Department of Computer Science http://www.dcs.kcl.ac.uk 024 * King's College London, UK http://www.kcl.ac.uk 025 * 026 * Please visit http://neobio.sourceforge.net 027 * 028 * This project was supervised by Professor Maxime Crochemore. 029 * 030 */ 031 032 package neobio.alignment; 033 034 /** 035 * Signals that the substitution matrix does not comply with the specification (see 036 * {@linkplain ScoringMatrix} for details). 037 * 038 * @author Sergio A. de Carvalho Jr. 039 * @see ScoringMatrix 040 */ 041 public class InvalidScoringMatrixException extends Exception 042 { 043 /** 044 * Constructs an <CODE>InvalidScoringMatrixException</CODE> with null as its error 045 * detail message. 046 */ 047 public InvalidScoringMatrixException () 048 { 049 super(); 050 } 051 052 /** 053 * Constructs an <CODE>InvalidScoringMatrixException</CODE> with the specified detail 054 * message. 055 * 056 * @param message an error message 057 */ 058 public InvalidScoringMatrixException (String message) 059 { 060 super(message); 061 } 062 063 /** 064 * Constructs an <CODE>InvalidScoringMatrixException</CODE> with the specified cause 065 * (and a detail message that typically contains the class and detail message of 066 * cause). 067 * 068 * @param cause a cause 069 */ 070 public InvalidScoringMatrixException (Throwable cause) 071 { 072 super(cause); 073 } 074 075 /** 076 * Constructs an <CODE>InvalidScoringMatrixException</CODE> with the specified detail 077 * message and cause. 078 * 079 * @param message an error message 080 * @param cause a cause 081 */ 082 public InvalidScoringMatrixException (String message, Throwable cause) 083 { 084 super(message, cause); 085 } 086 }neobio-0.0.20030929/doc/src-html/neobio/alignment/IncompatibleScoringSchemeException.html 0000644 0002656 0002032 00000017254 07727746662 030273 0 ustar tillea admin
001 /* 002 * IncompatibleScoringSchemeException.java 003 * 004 * Copyright 2003 Sergio Anibal de Carvalho Junior 005 * 006 * This file is part of NeoBio. 007 * 008 * NeoBio is free software; you can redistribute it and/or modify it under the terms of 009 * the GNU General Public License as published by the Free Software Foundation; either 010 * version 2 of the License, or (at your option) any later version. 011 * 012 * NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 013 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 014 * PURPOSE. See the GNU General Public License for more details. 015 * 016 * You should have received a copy of the GNU General Public License along with NeoBio; 017 * if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, 018 * Boston, MA 02111-1307, USA. 019 * 020 * Proper attribution of the author as the source of the software would be appreciated. 021 * 022 * Sergio Anibal de Carvalho Junior mailto:sergioanibaljr@users.sourceforge.net 023 * Department of Computer Science http://www.dcs.kcl.ac.uk 024 * King's College London, UK http://www.kcl.ac.uk 025 * 026 * Please visit http://neobio.sourceforge.net 027 * 028 * This project was supervised by Professor Maxime Crochemore. 029 * 030 */ 031 032 package neobio.alignment; 033 034 /** 035 * Signals that an scoring scheme is not compatible with the sequences being aligned. 036 * 037 * @author Sergio A. de Carvalho Jr. 038 * @see ScoringScheme 039 * @see PairwiseAlignmentAlgorithm 040 */ 041 public class IncompatibleScoringSchemeException extends Exception 042 { 043 /** 044 * Constructs an <CODE>IncompatibleScoringSchemeException</CODE> with null as its 045 * error detail message. 046 */ 047 public IncompatibleScoringSchemeException () 048 { 049 super(); 050 } 051 052 /** 053 * Constructs an <CODE>IncompatibleScoringSchemeException</CODE> with the specified 054 * detail message. 055 * 056 * @param message an error message 057 */ 058 public IncompatibleScoringSchemeException (String message) 059 { 060 super(message); 061 } 062 063 /** 064 * Constructs an <CODE>IncompatibleScoringSchemeException</CODE> with the specified 065 * cause (and a detail message that typically contains the class and detail message 066 * of cause). 067 * 068 * @param cause a cause 069 */ 070 public IncompatibleScoringSchemeException (Throwable cause) 071 { 072 super(cause); 073 } 074 075 /** 076 * Constructs an <CODE>IncompatibleScoringSchemeException</CODE> with the specified 077 * detail message and cause. 078 * 079 * @param message an error message 080 * @param cause a cause 081 */ 082 public IncompatibleScoringSchemeException (String message, Throwable cause) 083 { 084 super(message, cause); 085 } 086 }neobio-0.0.20030929/doc/src-html/neobio/alignment/CharSequence.html 0000644 0002656 0002032 00000035114 07727746664 023677 0 ustar tillea admin
001 /* 002 * CharSequence.java 003 * 004 * Copyright 2003 Sergio Anibal de Carvalho Junior 005 * 006 * This file is part of NeoBio. 007 * 008 * NeoBio is free software; you can redistribute it and/or modify it under the terms of 009 * the GNU General Public License as published by the Free Software Foundation; either 010 * version 2 of the License, or (at your option) any later version. 011 * 012 * NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 013 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 014 * PURPOSE. See the GNU General Public License for more details. 015 * 016 * You should have received a copy of the GNU General Public License along with NeoBio; 017 * if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, 018 * Boston, MA 02111-1307, USA. 019 * 020 * Proper attribution of the author as the source of the software would be appreciated. 021 * 022 * Sergio Anibal de Carvalho Junior mailto:sergioanibaljr@users.sourceforge.net 023 * Department of Computer Science http://www.dcs.kcl.ac.uk 024 * King's College London, UK http://www.kcl.ac.uk 025 * 026 * Please visit http://neobio.sourceforge.net 027 * 028 * This project was supervised by Professor Maxime Crochemore. 029 * 030 */ 031 032 package neobio.alignment; 033 034 import java.io.Reader; 035 import java.io.BufferedReader; 036 import java.io.IOException; 037 038 /** 039 * This class implements a sequence of characters stored as an array that provides random 040 * access to any position in constant time. 041 * 042 * <P>The input can come from any source, provided it is encapsulated in a proper 043 * <CODE>Reader</CODE> instance. The stream is expected to be ready (i.e. the next 044 * <CODE>read</CODE> operation must return the first character of the sequence) and it is 045 * not closed when its end is reached, so the client is allowed to reset it and maybe use 046 * it for another purpose.</P> 047 * 048 * <P>Sequences can contain letters only although lines started with the 049 * <CODE>COMMENT_CHAR</CODE> character ('>') are regarded as comments and are completely 050 * skipped. White spaces (including tabs, line feeds and carriage returns) are also 051 * ignored throughout.</P> 052 * 053 * <P>This class is used by two sequence alignment algorithms: {@linkplain SmithWaterman} 054 * and {@linkplain NeedlemanWunsch}.</P> 055 * 056 * @author Sergio A. de Carvalho Jr. 057 * @see SmithWaterman 058 * @see NeedlemanWunsch 059 */ 060 public class CharSequence 061 { 062 /** 063 * The character used to start a comment line in a sequence file. When this character 064 * is found, the rest of the line is ignored. 065 */ 066 protected static final char COMMENT_CHAR = '>'; 067 068 /** 069 * Stores the sequence as an array of characters. 070 */ 071 protected char sequence[]; 072 073 /** 074 * Creates a new instance of a <CODE>CharSequence</CODE>, loading the sequence data 075 * from the <CODE>Reader</CODE> input stream. 076 * 077 * @param reader source of characters for this sequence 078 * @throws IOException if an I/O exception occurs when reading the input 079 * @throws InvalidSequenceException if the input does not contain a valid sequence 080 */ 081 public CharSequence (Reader reader) throws IOException, InvalidSequenceException 082 { 083 int ch; 084 char c; 085 086 BufferedReader input = new BufferedReader(reader); 087 088 StringBuffer buf = new StringBuffer(); 089 090 // read characters 091 while ((ch = input.read()) != -1) 092 { 093 // conver to char 094 c = (char) ch; 095 096 // skip line if comment character is found 097 if (c == COMMENT_CHAR) 098 input.readLine(); 099 100 // accept letters only 101 else if (Character.isLetter(c)) 102 buf.append(c); 103 104 // anything else, except whitespaces, will throw an exception 105 else if (!Character.isWhitespace(c)) 106 throw new InvalidSequenceException 107 ("Sequences can contain letters only."); 108 } 109 110 // check if read anything! 111 if (buf.length() > 0) 112 sequence = new char[buf.length()]; 113 else 114 throw new InvalidSequenceException ("Empty sequence."); 115 116 // copy data to 117 buf.getChars(0, buf.length(), sequence, 0); 118 } 119 120 /** 121 * Returns the number of characters of this sequence. 122 * 123 * @return int number of characters of this sequence 124 */ 125 public int length () 126 { 127 return sequence.length; 128 } 129 130 /** 131 * Returns the character at a given position. For the client, the first character is 132 * at position 1, while the last character is at position <CODE>length()</CODE>. This 133 * is convinient for sequence alignment algorithms based on a classic dynamic 134 * programming matrix since the sequences usually start at row/column 1. This method 135 * does not check boundaries, therefore an <CODE>ArrayIndexOutOfBoundsException</CODE> 136 * may be raised if <CODE>pos</CODE> is out of bounds. 137 * 138 * @param pos position of character (from 1 to <CODE>length()</CODE> inclusive) 139 * @return the character 140 */ 141 public char charAt (int pos) 142 { 143 // convert from one-based to zero-based index 144 return sequence[pos-1]; 145 } 146 147 /** 148 * Returns a string representation of the sequence. 149 * 150 * @return a string representation of the sequence 151 */ 152 public String toString () 153 { 154 return new String(sequence); 155 } 156 }neobio-0.0.20030929/doc/src-html/neobio/alignment/AlignmentBlock.html 0000644 0002656 0002032 00000027254 07727746662 024226 0 ustar tillea admin
001 /* 002 * AlignmentBlock.java 003 * 004 * Copyright 2003 Sergio Anibal de Carvalho Junior 005 * 006 * This file is part of NeoBio. 007 * 008 * NeoBio is free software; you can redistribute it and/or modify it under the terms of 009 * the GNU General Public License as published by the Free Software Foundation; either 010 * version 2 of the License, or (at your option) any later version. 011 * 012 * NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 013 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 014 * PURPOSE. See the GNU General Public License for more details. 015 * 016 * You should have received a copy of the GNU General Public License along with NeoBio; 017 * if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, 018 * Boston, MA 02111-1307, USA. 019 * 020 * Proper attribution of the author as the source of the software would be appreciated. 021 * 022 * Sergio Anibal de Carvalho Junior mailto:sergioanibaljr@users.sourceforge.net 023 * Department of Computer Science http://www.dcs.kcl.ac.uk 024 * King's College London, UK http://www.kcl.ac.uk 025 * 026 * Please visit http://neobio.sourceforge.net 027 * 028 * This project was supervised by Professor Maxime Crochemore. 029 * 030 */ 031 032 package neobio.alignment; 033 034 /** 035 * This class is used by the {@linkplain CrochemoreLandauZivUkelson} algorithm to store 036 * the information of an alignment block. All fields are public (but final) in order to 037 * simplify the access to the data. 038 * 039 * <P>For more information on how this class is used, please refer to the specification 040 * of the <CODE>CrochemoreLandauZivUkelson</CODE> class and it subclasses.</P> 041 * 042 * @author Sergio A. de Carvalho Jr. 043 * @see CrochemoreLandauZivUkelson 044 */ 045 public class AlignmentBlock 046 { 047 /** 048 * A pointer to the factor of the first sequence being aligned. 049 */ 050 public final Factor factor1; 051 052 /** 053 * A pointer to the factor of the second sequence being aligned. 054 */ 055 public final Factor factor2; 056 057 /** 058 * The DIST column of this block. 059 */ 060 public final int[] dist_column; 061 062 /** 063 * An array of pointers to prefix blocks of this block. 064 */ 065 public final AlignmentBlock[] ancestor; 066 067 /** 068 * This block's output border. 069 */ 070 public final int[] output_border; 071 072 /** 073 * An array of indexes to the source of the highest scoring path for each entry in 074 * the output border. 075 */ 076 public final int[] source_path; 077 078 /** 079 * An array of directions that must be followed to reach the source of the highest 080 * scoring path for each entry in the output border. 081 * 082 * @see CrochemoreLandauZivUkelson#STOP_DIRECTION 083 * @see CrochemoreLandauZivUkelson#LEFT_DIRECTION 084 * @see CrochemoreLandauZivUkelson#DIAGONAL_DIRECTION 085 * @see CrochemoreLandauZivUkelson#TOP_DIRECTION 086 */ 087 public final byte[] direction; 088 089 /** 090 * Creates a new root block. A root block does not have <CODE>source_path</CODE> and 091 * <CODE>ancestor</CODE> arrays. Moreover, its <CODE>dist_column</CODE> and 092 * <CODE>output_border</CODE> arrays are set to zero, and the <CODE>direction</CODE> 093 * array is set to contain an <CODE>STOP_DIRECTION</CODE>. 094 * 095 * @param factor1 factor of the first sequence being aligned 096 * @param factor2 factor of the second sequence being aligned 097 */ 098 public AlignmentBlock (Factor factor1, Factor factor2) 099 { 100 this.factor1 = factor1; 101 this.factor2 = factor2; 102 103 dist_column = output_border = new int[] {0}; 104 direction = new byte [] {0}; // STOP_DIRECTION 105 source_path = null; 106 ancestor = null; 107 } 108 109 /** 110 * Creates a new alignment block, with all arrays created with the specified size. 111 * 112 * @param factor1 factor of the first sequence being aligned 113 * @param factor2 factor of the second sequence being aligned 114 * @param size size of the arrays to be created 115 */ 116 public AlignmentBlock (Factor factor1, Factor factor2, int size) 117 { 118 this.factor1 = factor1; 119 this.factor2 = factor2; 120 121 dist_column = new int[size]; 122 output_border = new int[size]; 123 direction = new byte[size]; 124 source_path = new int[size]; 125 ancestor = new AlignmentBlock[size]; 126 } 127 }neobio-0.0.20030929/doc/src-html/neobio/alignment/PairwiseAlignmentAlgorithm.html 0000644 0002656 0002032 00000133270 07727746664 026624 0 ustar tillea admin
001 /* 002 * PairwiseAlignmentAlgorithm.java 003 * 004 * Copyright 2003 Sergio Anibal de Carvalho Junior 005 * 006 * This file is part of NeoBio. 007 * 008 * NeoBio is free software; you can redistribute it and/or modify it under the terms of 009 * the GNU General Public License as published by the Free Software Foundation; either 010 * version 2 of the License, or (at your option) any later version. 011 * 012 * NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 013 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 014 * PURPOSE. See the GNU General Public License for more details. 015 * 016 * You should have received a copy of the GNU General Public License along with NeoBio; 017 * if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, 018 * Boston, MA 02111-1307, USA. 019 * 020 * Proper attribution of the author as the source of the software would be appreciated. 021 * 022 * Sergio Anibal de Carvalho Junior mailto:sergioanibaljr@users.sourceforge.net 023 * Department of Computer Science http://www.dcs.kcl.ac.uk 024 * King's College London, UK http://www.kcl.ac.uk 025 * 026 * Please visit http://neobio.sourceforge.net 027 * 028 * This project was supervised by Professor Maxime Crochemore. 029 * 030 */ 031 032 package neobio.alignment; 033 034 import java.io.Reader; 035 import java.io.IOException; 036 037 /** 038 * This abstract class is the superclass of all classes implementing pairwise sequence 039 * alignment algorithms. Subclasses are required to provide methods to build a high 040 * scoring alignment between two sequences and compute its score with a given scoring 041 * scheme. 042 * 043 * <P>Clients are required to set a scoring scheme and load two sequences before 044 * requesting an alignment or the computation of its score. They typically make the 045 * following sequence of method calls:</P> 046 * 047 * <CODE><BLOCKQUOTE><PRE> 048 * // prepare 049 * PairwiseAlignmentAlgorithm algorithm = new SomePairwiseAlignmentAlgorith (); 050 * algorithm.setScoringScheme (some_scoring_scheme); 051 * algorithm.loadSequences (sequence1, sequence2); 052 * 053 * // now compute the alignment 054 * PairwiseAlignment alignment = algorithm.getPairwiseAlignment(); 055 * int score = algorithm.getScore(); 056 * </PRE></BLOCKQUOTE></CODE> 057 * 058 * @author Sergio A. de Carvalho Jr. 059 * @see PairwiseAlignment 060 */ 061 public abstract class PairwiseAlignmentAlgorithm 062 { 063 /** 064 * Tag character that signals a match in the score tag line of an alignment. Its use 065 * is conditioned by the <CODE>use_match_tag</CODE> flag. 066 * 067 * @see #use_match_tag 068 * @see #useMatchTag 069 */ 070 protected static final char MATCH_TAG = '|'; 071 072 /** 073 * Tag character that signals an approximate match in the score tag line of an 074 * alignment. 075 */ 076 protected static final char APPROXIMATE_MATCH_TAG = '+'; 077 078 /** 079 * Character that signals a mismatch in the score tag line of an alignment. 080 */ 081 protected static final char MISMATCH_TAG = ' '; 082 083 /** 084 * Character that signals a gap in the score tag line of an alignment. 085 */ 086 protected static final char GAP_TAG = ' '; 087 088 /** 089 * Character that signals a gap in sequence. 090 */ 091 protected static final char GAP_CHARACTER = '-'; 092 093 /** 094 * Indicates if the <CODE>MATCH_TAG</CODE> tag should be used or not. If it is 095 * <CODE>true</CODE>, the alignment algorithm should write the <CODE>MATCH_TAG</CODE> 096 * tag in the score tag line of the alignment whenever a match occurs between 097 * characters of the two sequences. If it is <CODE>false</CODE> the matching character 098 * should be written instead. This flag is updated whenever a scoring scheme is set to 099 * this <CODE>PairwiseAlignmentAlgorithm</CODE> by the <CODE>setScoringScheme</CODE> 100 * method. 101 * 102 * @see #MATCH_TAG 103 * @see #useMatchTag 104 * @see #setScoringScheme 105 */ 106 protected boolean use_match_tag; 107 108 /** 109 * The scoring scheme used to compute a pairwise sequence alignment. It must be set 110 * before performing the alignment, and if a new scoring scheme is set, any alignment 111 * or score already computed is lost. 112 */ 113 protected ScoringScheme scoring; 114 115 /** 116 * Stores the product of the last pairwise alignment performed. It contains a string 117 * representation of a highest scoring alignment between the two sequences and its 118 * score. It is set after a successful execution of the 119 * <CODE>computePairwiseAlignment</CODE> method that subclasses must implement. It is 120 * set to null if new sequences are loaded or a new scoring scheme is set. 121 */ 122 protected PairwiseAlignment alignment; 123 124 /** 125 * This field stores just the score of the last pairwise alignment performed (if the 126 * <CODE>score_computed flag</CODE> is set to true). It is useful when just the score 127 * is needed (and not the alignment itselft). Its value is set after a successful 128 * execution of both <CODE>computePairwiseAlignment</CODE> or 129 * <CODE>computeScore</CODE> methods that subclasses must implement. If new sequences 130 * are loaded or a new scoring scheme is set, the <CODE>score_computed</CODE> flag is 131 * set to false, and this field's value becomes undefined. 132 */ 133 protected int score; 134 135 /** 136 * Flags whether the score of the alignment between the last two loaded sequences has 137 * already been computed. It is set to true after a successful execution of both 138 * <CODE>computePairwiseAlignment</CODE> or <CODE>computeScore</CODE> methods that 139 * subclasses must implement. It is set to falsef if new sequences are loaded or a new 140 * scoring scheme is set. 141 */ 142 protected boolean score_computed = false; 143 144 /** 145 * Flags whether sequences have been loaded. It is set to true after subclasses 146 * successfully load two sequences. 147 */ 148 protected boolean sequences_loaded = false; 149 150 /** 151 * Sets the scoring scheme to be used for the next alignments. Any alignment or score 152 * already computed is lost. If the scoring scheme supports partial matches, this 153 * <CODE>PairwiseAlignmentAlgorithm</CODE> is set not to use the 154 * <CODE>MATCH_TAG</CODE> tag because in this case the score tag line be confusing. 155 * If the scoring scheme does not support partial matches, then the use of the 156 * <CODE>MATCH_TAG</CODE> tag is enabled. 157 * 158 * @param scoring Scoring scheme to be used 159 * @see #MATCH_TAG 160 * @see ScoringScheme#isPartialMatchSupported 161 */ 162 public void setScoringScheme (ScoringScheme scoring) 163 { 164 if (scoring == null) 165 throw new IllegalArgumentException ("Null scoring scheme object."); 166 167 this.scoring = scoring; 168 169 // if the scoring scheme supports partial matches, 170 // disable the use of the MATCH_TAG character 171 if (scoring.isPartialMatchSupported()) 172 this.use_match_tag = false; 173 else 174 this.use_match_tag = true; 175 176 // when a new scoring scheme is set, 177 // the alignment needs to be recomputed 178 this.alignment = null; 179 this.score_computed = false; 180 } 181 182 /** 183 * Tells wether the <CODE>MATCH_TAG</CODE> tag should be used or not. If it returns 184 * <CODE>true</CODE>, the alignment algorithm should write the <CODE>MATCH_TAG</CODE> 185 * tag in the score tag line of the alignment produced whenever a match occurs between 186 * characters of the two sequences. If it returns <CODE>false</CODE> the matching 187 * character should be written instead. The value returned is conditioned by the 188 * <CODE>use_match_tag</CODE> flag, which is updated whenever a scoring scheme is set 189 * to this <CODE>PairwiseAlignmentAlgorithm</CODE> by the 190 * <CODE>setScoringScheme</CODE> method. 191 * 192 * @return <CODE>true</CODE if the <CODE>MATCH_TAG</CODE> tag should be used, 193 * <CODE>false</CODE> otherwise 194 * @see #MATCH_TAG 195 * @see #use_match_tag 196 * @see #setScoringScheme 197 */ 198 protected boolean useMatchTag () 199 { 200 return use_match_tag; 201 } 202 203 /** 204 * Request subclasses to load the sequences according to their own needs. Any 205 * alignment and score already computed is lost. If no exception is raised, the loaded 206 * flag is set to true. Subclasses typically store the sequences in instances of an 207 * appropiate class and each can have its own contract, so check each algorithm to see 208 * what kind of sequences it produces. Input can come from any source provided they 209 * are encapsulated with a proper Reader. They must be ready to be read, i.e. the next 210 * read operation must return the sequence's first character. 211 * 212 * @param input1 First sequence 213 * @param input2 Second sequence 214 * @throws IOException If an I/O error occurs when reading the sequences 215 * @throws InvalidSequenceException If the sequences are not valid 216 */ 217 public void loadSequences (Reader input1, Reader input2) 218 throws IOException, InvalidSequenceException 219 { 220 // when new sequences are loaded, the 221 // alignment and score needs to be recomputed 222 this.alignment = null; 223 this.score_computed = false; 224 225 // make sure that if an exception is raised 226 // the sequences_loaded flag is false 227 this.sequences_loaded = false; 228 229 // request subclasses to load sequences 230 loadSequencesInternal (input1, input2); 231 232 // if no exception is raised, 233 // set the loaded flag to true 234 this.sequences_loaded = true; 235 } 236 237 /** 238 * Frees pointer to loaded sequences and computed alignments (if any) so that their 239 * data can be garbage collected. 240 */ 241 public void unloadSequences () 242 { 243 // allow any alignment already computed 244 // to be garbage collected 245 this.alignment = null; 246 this.score_computed = false; 247 248 // request subclasses to unload sequences 249 unloadSequencesInternal (); 250 251 this.sequences_loaded = false; 252 } 253 254 /** 255 * Return the last pairwise alignment computed (if any) or request subclasses to 256 * compute one and return the result by calling the 257 * <CODE>computePairwiseAlignment</CODE> method. The sequences must already be loaded 258 * and a scoring scheme must already be set. 259 * 260 * @return a pairwise alignment between the loaded sequences 261 * @throws IncompatibleScoringSchemeException If the scoring scheme 262 * is not compatible with the loaded sequences 263 * @see #computePairwiseAlignment 264 */ 265 public PairwiseAlignment getPairwiseAlignment () 266 throws IncompatibleScoringSchemeException 267 { 268 if (!sequences_loaded) 269 throw new IllegalStateException ("Sequences have not been loaded."); 270 271 if (scoring == null) 272 throw new IllegalStateException ("Scoring scheme has not been set."); 273 274 if (this.alignment == null) 275 { 276 // make sure the scoring scheme won't be changed 277 // in the middle of the alignment computation 278 synchronized (scoring) 279 { 280 // compute the alignment if it hasn't been computed yet 281 this.alignment = computePairwiseAlignment(); 282 } 283 284 // store the score as well 285 this.score = this.alignment.getScore(); 286 this.score_computed = true; 287 } 288 289 return this.alignment; 290 } 291 292 /** 293 * Returns the score of the last alignment computed (if any) or request subclasses to 294 * compute one and return the result by calling the <CODE>computeScore</CODE> method. 295 * The sequences must already be loaded and a scoring scheme must already be set. 296 * 297 * @return the score of the alignment between the loaded sequences 298 * @throws IncompatibleScoringSchemeException If the scoring scheme 299 * is not compatible with the loaded sequences 300 * @see #computeScore 301 */ 302 public int getScore () throws IncompatibleScoringSchemeException 303 { 304 if (!sequences_loaded) 305 throw new IllegalStateException ("Sequences have not been loaded."); 306 307 if (scoring == null) 308 throw new IllegalStateException ("Scoring scheme has not been set."); 309 310 if (!score_computed) 311 { 312 // make sure the scoring scheme won't be changed 313 // in the middle of the alignment computation 314 synchronized (scoring) 315 { 316 // compute the alignment's score if it hasn't been computed yet 317 this.score = computeScore(); 318 } 319 320 this.score_computed = true; 321 } 322 323 return this.score; 324 } 325 326 /** 327 * Subclasses must implement this method to load sequences according to their own 328 * needs and throw an exception in case of any failure. If no exception is raised, the 329 * loaded flag is set to true by the public method and the sequences are believed to 330 * be loaded (so an alignment or score can be requested). 331 * 332 * @param input1 First sequence 333 * @param input2 Second sequence 334 * @throws IOException If an I/O error occurs when reading the sequences 335 * @throws InvalidSequenceException If the sequences are not valid 336 * @see #loadSequences 337 * @see CharSequence 338 * @see FactorSequence 339 */ 340 protected abstract void loadSequencesInternal (Reader input1, Reader input2) 341 throws IOException, InvalidSequenceException; 342 343 /** 344 * Subclasses must implement this method to unload sequences according to their own 345 * storage, freeing pointers to sequences and any intermediate data so that they can 346 * be garbage collected. This methid is called by the public 347 * <CODE>unloadSequences</CODE> method. 348 * 349 * @see #unloadSequences 350 */ 351 protected abstract void unloadSequencesInternal (); 352 353 /** 354 * Subclasses must implement this method to compute an alignment between the loaded 355 * sequences using the scoring scheme previously set. This methid is called by the 356 * <CODE>getPairwiseAlignment</CODE> method when needed. 357 * 358 * @return a pairwise alignment between the loaded sequences 359 * @throws IncompatibleScoringSchemeException If the scoring scheme 360 * is not compatible with the loaded sequences 361 * @see #getPairwiseAlignment 362 */ 363 protected abstract PairwiseAlignment computePairwiseAlignment () 364 throws IncompatibleScoringSchemeException; 365 366 /** 367 * Subclasses must implement this method to compute the score of the alignment between 368 * the loaded sequences using the scoring scheme previously set. This methid is called 369 * by the <CODE>getScore</CODE> method when needed. 370 * 371 * @return the score of the alignment between the loaded sequences 372 * @throws IncompatibleScoringSchemeException If the scoring scheme 373 * is not compatible with the loaded sequences 374 * @see #getScore 375 */ 376 protected abstract int computeScore () throws IncompatibleScoringSchemeException; 377 378 /** 379 * Helper method to invoke the <CODE>scoreSubstitution</CODE> method of the scoring 380 * scheme set to this algorithm. 381 * 382 * @param a first character 383 * @param b second character 384 * @return score of substitution of <CODE>a</CODE> for <CODE>b</CODE> 385 * @throws IncompatibleScoringSchemeException if the scoring scheme is not compatible 386 * with the sequences being aligned 387 * @see ScoringScheme#scoreSubstitution 388 */ 389 protected final int scoreSubstitution (char a, char b) 390 throws IncompatibleScoringSchemeException 391 { 392 return scoring.scoreSubstitution (a, b); 393 } 394 395 /** 396 * Helper method to invoke the <CODE>scoreInsertion</CODE> method of the scoring 397 * scheme set to this algorithm. 398 * 399 * @param a the character to be inserted 400 * @return score of insertion of <CODE>a</CODE> 401 * @throws IncompatibleScoringSchemeException if the scoring scheme is not compatible 402 * with the sequences being aligned 403 * @see ScoringScheme#scoreInsertion 404 */ 405 protected final int scoreInsertion (char a) throws IncompatibleScoringSchemeException 406 { 407 return scoring.scoreInsertion (a); 408 } 409 410 /** 411 * Helper method to invoke the <CODE>scoreDeletion</CODE> method of the scoring scheme 412 * set to this algorithm. 413 * 414 * @param a the character to be deleted 415 * @return score of deletion of <CODE>a</CODE> 416 * @throws IncompatibleScoringSchemeException if the scoring scheme is not compatible 417 * with the sequences being aligned 418 * @see ScoringScheme#scoreDeletion 419 */ 420 protected final int scoreDeletion (char a) throws IncompatibleScoringSchemeException 421 { 422 return scoring.scoreDeletion (a); 423 } 424 425 /** 426 * Helper method to compute the the greater of two values. 427 * 428 * @param v1 first value 429 * @param v2 second value 430 * @return the larger of <CODE>v1</CODE> and <CODE>v2</CODE> 431 */ 432 protected final int max (int v1, int v2) 433 { 434 return (v1 >= v2) ? v1 : v2; 435 } 436 437 /** 438 * Helper method to compute the the greater of three values. 439 * 440 * @param v1 first value 441 * @param v2 second value 442 * @param v3 third value 443 * @return the larger of <CODE>v1</CODE>, <CODE>v2</CODE> and <CODE>v3</CODE> 444 */ 445 protected final int max (int v1, int v2, int v3) 446 { 447 return (v1 >= v2) ? ((v1 >= v3)? v1 : v3) : ((v2 >= v3)? v2 : v3); 448 } 449 450 /** 451 * Helper method to compute the the greater of four values. 452 * 453 * @param v1 first value 454 * @param v2 second value 455 * @param v3 third value 456 * @param v4 fourth value 457 * @return the larger of <CODE>v1</CODE>, <CODE>v2</CODE> <CODE>v3</CODE> and 458 * <CODE>v4</CODE> 459 */ 460 protected final int max (int v1, int v2, int v3, int v4) 461 { 462 int m1 = ((v1 >= v2) ? v1 : v2); 463 int m2 = ((v3 >= v4) ? v3 : v4); 464 465 return (m1 >= m2) ? m1 : m2; 466 } 467 }neobio-0.0.20030929/doc/src-html/neobio/alignment/NeedlemanWunsch.html 0000644 0002656 0002032 00000110155 07727746662 024406 0 ustar tillea admin
001 /* 002 * NeedlemanWunsch.java 003 * 004 * Copyright 2003 Sergio Anibal de Carvalho Junior 005 * 006 * This file is part of NeoBio. 007 * 008 * NeoBio is free software; you can redistribute it and/or modify it under the terms of 009 * the GNU General Public License as published by the Free Software Foundation; either 010 * version 2 of the License, or (at your option) any later version. 011 * 012 * NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 013 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 014 * PURPOSE. See the GNU General Public License for more details. 015 * 016 * You should have received a copy of the GNU General Public License along with NeoBio; 017 * if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, 018 * Boston, MA 02111-1307, USA. 019 * 020 * Proper attribution of the author as the source of the software would be appreciated. 021 * 022 * Sergio Anibal de Carvalho Junior mailto:sergioanibaljr@users.sourceforge.net 023 * Department of Computer Science http://www.dcs.kcl.ac.uk 024 * King's College London, UK http://www.kcl.ac.uk 025 * 026 * Please visit http://neobio.sourceforge.net 027 * 028 * This project was supervised by Professor Maxime Crochemore. 029 * 030 */ 031 032 package neobio.alignment; 033 034 import java.io.Reader; 035 import java.io.IOException; 036 037 /** 038 * This class implements the classic global alignment algorithm (with linear gap penalty 039 * function) due to S.B.Needleman and C.D.Wunsch (1970). 040 * 041 * <P>It is based on a dynamic programming approach. The idea consists of, given two 042 * sequences A and B of sizes n and m, respectively, building an (n+1 x m+1) matrix M that 043 * contains the similarity of prefixes of A and B. Every position M[i,j] in the matrix 044 * holds the score between the subsequences A[1..i] and B[1..j]. The first row and column 045 * represent alignments with spaces.</P> 046 * 047 * <P>Starting from row 0, column 0, the algorithm computes each position M[i,j] with the 048 * following recurrence:</P> 049 * 050 * <CODE><BLOCKQUOTE><PRE> 051 * M[0,0] = 0 052 * M[i,j] = max { M[i,j-1] + scoreInsertion (B[j]), 053 * M[i-1,j-1] + scoreSubstitution (A[i], B[j]), 054 * M[i-1,j] + scoreDeletion(A[i]) } 055 * </PRE></BLOCKQUOTE></CODE> 056 * 057 * <P>In the end, the value at the last position (last row, last column) will contain 058 * the similarity between the two sequences. This part of the algorithm is accomplished 059 * by the {@link #computeMatrix computeMatrix} method. It has quadratic space complexity 060 * since it needs to keep an (n+1 x m+1) matrix in memory. And since the work of computing 061 * each cell is constant, it also has quadratic time complexity.</P> 062 * 063 * <P>After the matrix has been computed, the alignment can be retrieved by tracing a path 064 * back in the matrix from the last position to the first. This step is performed by 065 * the {@link #buildOptimalAlignment buildOptimalAlignment} method, and since the path can 066 * be roughly as long as (m + n), this method has O(n) time complexity.</P> 067 * 068 * <P>If the similarity value only is needed (and not the alignment itself), it is easy to 069 * reduce the space requirement to O(n) by keeping just the last row or column in memory. 070 * This is precisely what is done by the {@link #computeScore computeScore} method. Note 071 * that it still requires O(n<SUP>2</SUP>) time.</P> 072 * 073 * <P>For a more efficient approach to the global alignment problem, see the 074 * {@linkplain CrochemoreLandauZivUkelson} algorithm. For local alignment, see the 075 * {@linkplain SmithWaterman} algorithm.</P> 076 * 077 * @author Sergio A. de Carvalho Jr. 078 * @see SmithWaterman 079 * @see CrochemoreLandauZivUkelson 080 * @see CrochemoreLandauZivUkelsonLocalAlignment 081 * @see CrochemoreLandauZivUkelsonGlobalAlignment 082 */ 083 public class NeedlemanWunsch extends PairwiseAlignmentAlgorithm 084 { 085 /** 086 * The first sequence of an alignment. 087 */ 088 protected CharSequence seq1; 089 090 /** 091 * The second sequence of an alignment. 092 */ 093 protected CharSequence seq2; 094 095 /** 096 * The dynamic programming matrix. Each position (i, j) represents the best score 097 * between the firsts i characters of <CODE>seq1</CODE> and j characters of 098 * <CODE>seq2</CODE>. 099 */ 100 protected int[][] matrix; 101 102 /** 103 * Loads sequences into {@linkplain CharSequence} instances. In case of any error, 104 * an exception is raised by the constructor of <CODE>CharSequence</CODE> (please 105 * check the specification of that class for specific requirements). 106 * 107 * @param input1 Input for first sequence 108 * @param input2 Input for second sequence 109 * @throws IOException If an I/O error occurs when reading the sequences 110 * @throws InvalidSequenceException If the sequences are not valid 111 * @see CharSequence 112 */ 113 protected void loadSequencesInternal (Reader input1, Reader input2) 114 throws IOException, InvalidSequenceException 115 { 116 // load sequences into instances of CharSequence 117 this.seq1 = new CharSequence(input1); 118 this.seq2 = new CharSequence(input2); 119 } 120 121 /** 122 * Frees pointers to loaded sequences and the dynamic programming matrix so that their 123 * data can be garbage collected. 124 */ 125 protected void unloadSequencesInternal () 126 { 127 this.seq1 = null; 128 this.seq2 = null; 129 this.matrix = null; 130 } 131 132 /** 133 * Builds an optimal global alignment between the loaded sequences after computing the 134 * dynamic programming matrix. It calls the <CODE>buildOptimalAlignment</CODE> method 135 * after the <CODE>computeMatrix</CODE> method computes the dynamic programming 136 * matrix. 137 * 138 * @return an optimal global alignment between the loaded sequences 139 * @throws IncompatibleScoringSchemeException If the scoring scheme is not compatible 140 * with the loaded sequences. 141 * @see #computeMatrix 142 * @see #buildOptimalAlignment 143 */ 144 protected PairwiseAlignment computePairwiseAlignment () 145 throws IncompatibleScoringSchemeException 146 { 147 // compute the matrix 148 computeMatrix (); 149 150 // build and return an optimal global alignment 151 PairwiseAlignment alignment = buildOptimalAlignment (); 152 153 // allow the matrix to be garbage collected 154 matrix = null; 155 156 return alignment; 157 } 158 159 /** 160 * Computes the dynamic programming matrix. 161 * 162 * @throws IncompatibleScoringSchemeException If the scoring scheme is not compatible 163 * with the loaded sequences. 164 */ 165 protected void computeMatrix () throws IncompatibleScoringSchemeException 166 { 167 int r, c, rows, cols, ins, del, sub; 168 169 rows = seq1.length()+1; 170 cols = seq2.length()+1; 171 172 matrix = new int [rows][cols]; 173 174 // initiate first row 175 matrix[0][0] = 0; 176 for (c = 1; c < cols; c++) 177 matrix[0][c] = matrix[0][c-1] + scoreInsertion(seq2.charAt(c)); 178 179 // calculates the similarity matrix (row-wise) 180 for (r = 1; r < rows; r++) 181 { 182 // initiate first column 183 matrix[r][0] = matrix[r-1][0] + scoreDeletion(seq1.charAt(r)); 184 185 for (c = 1; c < cols; c++) 186 { 187 ins = matrix[r][c-1] + scoreInsertion(seq2.charAt(c)); 188 sub = matrix[r-1][c-1] + scoreSubstitution(seq1.charAt(r),seq2.charAt(c)); 189 del = matrix[r-1][c] + scoreDeletion(seq1.charAt(r)); 190 191 // choose the greatest 192 matrix[r][c] = max (ins, sub, del); 193 } 194 } 195 } 196 197 /** 198 * Builds an optimal global alignment between the loaded sequences. Before it is 199 * executed, the dynamic programming matrix must already have been computed by 200 * the <CODE>computeMatrix</CODE> method. 201 * 202 * @return an optimal global alignment between the loaded sequences 203 * @throws IncompatibleScoringSchemeException If the scoring scheme 204 * is not compatible with the loaded sequences. 205 * @see #computeMatrix 206 */ 207 protected PairwiseAlignment buildOptimalAlignment () 208 throws IncompatibleScoringSchemeException 209 { 210 StringBuffer gapped_seq1, score_tag_line, gapped_seq2; 211 int r, c, sub, max_score; 212 213 gapped_seq1 = new StringBuffer(); 214 score_tag_line = new StringBuffer(); 215 gapped_seq2 = new StringBuffer(); 216 217 // start at the last row, last column 218 r = matrix.length - 1; 219 c = matrix[r].length - 1; 220 max_score = matrix[r][c]; 221 222 while ((r > 0) || (c > 0)) 223 { 224 if (c > 0) 225 if (matrix[r][c] == matrix[r][c-1] + scoreInsertion(seq2.charAt(c))) 226 { 227 // insertion was used 228 gapped_seq1.insert (0, GAP_CHARACTER); 229 score_tag_line.insert (0, GAP_TAG); 230 gapped_seq2.insert (0, seq2.charAt(c)); 231 c = c - 1; 232 233 // skip to the next iteration 234 continue; 235 } 236 237 if ((r > 0) && (c > 0)) 238 { 239 sub = scoreSubstitution(seq1.charAt(r), seq2.charAt(c)); 240 241 if (matrix[r][c] == matrix[r-1][c-1] + sub) 242 { 243 // substitution was used 244 gapped_seq1.insert (0, seq1.charAt(r)); 245 if (seq1.charAt(r) == seq2.charAt(c)) 246 if (useMatchTag()) 247 score_tag_line.insert (0, MATCH_TAG); 248 else 249 score_tag_line.insert (0, seq1.charAt(r)); 250 else if (sub > 0) 251 score_tag_line.insert (0, APPROXIMATE_MATCH_TAG); 252 else 253 score_tag_line.insert (0, MISMATCH_TAG); 254 gapped_seq2.insert (0, seq2.charAt(c)); 255 r = r - 1; c = c - 1; 256 257 // skip to the next iteration 258 continue; 259 } 260 } 261 262 // must be a deletion 263 gapped_seq1.insert (0, seq1.charAt(r)); 264 score_tag_line.insert (0, GAP_TAG); 265 gapped_seq2.insert (0, GAP_CHARACTER); 266 r = r - 1; 267 } 268 269 return new PairwiseAlignment (gapped_seq1.toString(), score_tag_line.toString(), 270 gapped_seq2.toString(), max_score); 271 } 272 273 /** 274 * Computes the score of the best global alignment between the two sequences using the 275 * scoring scheme previously set. This method calculates the similarity value only 276 * (doesn't build the whole matrix so the alignment cannot be recovered, however it 277 * has the advantage of requiring O(n) space only). 278 * 279 * @return score of the best global alignment between the loaded sequences 280 * @throws IncompatibleScoringSchemeException If the scoring scheme is not compatible 281 * with the loaded sequences. 282 */ 283 protected int computeScore () throws IncompatibleScoringSchemeException 284 { 285 int[] array; 286 int r, c, rows, cols, tmp, ins, del, sub; 287 288 rows = seq1.length()+1; 289 cols = seq2.length()+1; 290 291 if (rows <= cols) 292 { 293 // goes columnwise 294 array = new int [rows]; 295 296 // initiate first column 297 array[0] = 0; 298 for (r = 1; r < rows; r++) 299 array[r] = array[r-1] + scoreDeletion(seq1.charAt(r)); 300 301 // calculate the similarity matrix (keep current column only) 302 for (c = 1; c < cols; c++) 303 { 304 // initiate first row (tmp hold values 305 // that will be later moved to the array) 306 tmp = array[0] + scoreInsertion(seq2.charAt(c)); 307 308 for (r = 1; r < rows; r++) 309 { 310 ins = array[r] + scoreInsertion(seq2.charAt(c)); 311 sub = array[r-1] + scoreSubstitution(seq1.charAt(r), seq2.charAt(c)); 312 del = tmp + scoreDeletion(seq1.charAt(r)); 313 314 // move the temp value to the array 315 array[r-1] = tmp; 316 317 // choose the greatest 318 tmp = max (ins, sub, del); 319 } 320 321 // move the temp value to the array 322 array[rows - 1] = tmp; 323 } 324 325 return array[rows - 1]; 326 } 327 else 328 { 329 // goes rowwise 330 array = new int [cols]; 331 332 // initiate first row 333 array[0] = 0; 334 for (c = 1; c < cols; c++) 335 array[c] = array[c-1] + scoreInsertion(seq2.charAt(c)); 336 337 // calculate the similarity matrix (keep current row only) 338 for (r = 1; r < rows; r++) 339 { 340 // initiate first column (tmp hold values 341 // that will be later moved to the array) 342 tmp = array[0] + scoreDeletion(seq1.charAt(r)); 343 344 for (c = 1; c < cols; c++) 345 { 346 ins = tmp + scoreInsertion(seq2.charAt(c)); 347 sub = array[c-1] + scoreSubstitution(seq1.charAt(r), seq2.charAt(c)); 348 del = array[c] + scoreDeletion(seq1.charAt(r)); 349 350 // move the temp value to the array 351 array[c-1] = tmp; 352 353 // choose the greatest 354 tmp = max (ins, sub, del); 355 } 356 357 // move the temp value to the array 358 array[cols - 1] = tmp; 359 } 360 361 return array[cols - 1]; 362 } 363 } 364 }neobio-0.0.20030929/doc/src-html/neobio/alignment/Matrix.html 0000644 0002656 0002032 00000013676 07727746662 022604 0 ustar tillea admin
001 /* 002 * Matrix.java 003 * 004 * Copyright 2003 Sergio Anibal de Carvalho Junior 005 * 006 * This file is part of NeoBio. 007 * 008 * NeoBio is free software; you can redistribute it and/or modify it under the terms of 009 * the GNU General Public License as published by the Free Software Foundation; either 010 * version 2 of the License, or (at your option) any later version. 011 * 012 * NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 013 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 014 * PURPOSE. See the GNU General Public License for more details. 015 * 016 * You should have received a copy of the GNU General Public License along with NeoBio; 017 * if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, 018 * Boston, MA 02111-1307, USA. 019 * 020 * Proper attribution of the author as the source of the software would be appreciated. 021 * 022 * Sergio Anibal de Carvalho Junior mailto:sergioanibaljr@users.sourceforge.net 023 * Department of Computer Science http://www.dcs.kcl.ac.uk 024 * King's College London, UK http://www.kcl.ac.uk 025 * 026 * Please visit http://neobio.sourceforge.net 027 * 028 * This project was supervised by Professor Maxime Crochemore. 029 * 030 */ 031 032 package neobio.alignment; 033 034 /** 035 * This interface defines a minimal set of operations that a matrix must implement. This 036 * interface is used by the {@linkplain Smawk} class to provide a general services 037 * regardless of how the matrix is actually stored. 038 * 039 * @author Sergio A. de Carvalho Jr. 040 * @see Smawk 041 */ 042 public interface Matrix 043 { 044 /** 045 * Returns the value at an specified row and column. 046 * 047 * @param row row number of element to be retrieved 048 * @param col column number of element to be retrieved 049 * @return value at row <CODE>row</CODE> column <CODE>col</CODE> 050 */ 051 public int valueAt (int row, int col); 052 053 /** 054 * Returns the number of rows that this matrix has. 055 * 056 * @return number of rows 057 */ 058 public int numRows (); 059 060 /** 061 * Returns the number of columns that this matrix has. 062 * 063 * @return number of columns 064 */ 065 public int numColumns (); 066 }neobio-0.0.20030929/doc/src-html/neobio/alignment/Factor.html 0000644 0002656 0002032 00000047562 07727746662 022557 0 ustar tillea admin
001 /* 002 * Factor.java 003 * 004 * Copyright 2003 Sergio Anibal de Carvalho Junior 005 * 006 * This file is part of NeoBio. 007 * 008 * NeoBio is free software; you can redistribute it and/or modify it under the terms of 009 * the GNU General Public License as published by the Free Software Foundation; either 010 * version 2 of the License, or (at your option) any later version. 011 * 012 * NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 013 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 014 * PURPOSE. See the GNU General Public License for more details. 015 * 016 * You should have received a copy of the GNU General Public License along with NeoBio; 017 * if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, 018 * Boston, MA 02111-1307, USA. 019 * 020 * Proper attribution of the author as the source of the software would be appreciated. 021 * 022 * Sergio Anibal de Carvalho Junior mailto:sergioanibaljr@users.sourceforge.net 023 * Department of Computer Science http://www.dcs.kcl.ac.uk 024 * King's College London, UK http://www.kcl.ac.uk 025 * 026 * Please visit http://neobio.sourceforge.net 027 * 028 * This project was supervised by Professor Maxime Crochemore. 029 * 030 */ 031 032 package neobio.alignment; 033 034 /** 035 * This class is used by {@linkplain FactorSequence} to create a linked list of factors of 036 * a text as induced by its Lempel-Ziv (LZ78) factorisation. 037 * 038 * <P>Each instance of this class represent a string composed of its an ancestor factor's 039 * string plus one character, and contains: 040 * 041 * <UL> 042 * <LI>a pointer to its ancestor factor (the longest factor previously seen in the text 043 * during its LZ78 factorisation); 044 * <LI>the new character; 045 * <LI>a serial number (which represents its order in the text) 046 * <LI>a pointer to the next factor of the text 047 * <LI>its length (number of characters, which is equal to its ancestor's length plus one) 048 * </UL> 049 * 050 * @author Sergio A. de Carvalho Jr. 051 * @see FactorSequence 052 */ 053 public class Factor 054 { 055 /** 056 * A pointer to this factor's ancestor, which represents a prefix of this factor's 057 * text. 058 */ 059 protected Factor ancestor; 060 061 /** 062 * A pointer to the next factor. 063 */ 064 protected Factor next; 065 066 /** 067 * This factor's serial number, which indicates the order of this factor inside the 068 * linked list of factors of a text. 069 */ 070 protected int serial_number; 071 072 /** 073 * The number of characters of the text represented by this factor. 074 */ 075 protected int length; 076 077 /** 078 * The new character of this factor. 079 */ 080 protected char new_char; 081 082 /** 083 * Creates a new empty <CODE>Factor</CODE>. It has no ancestor and no character (both 084 * are set to <CODE>null</CODE>). Its serial number is set to zero as well as its 085 * length. 086 * 087 * <P>This constructor is used to initiate the a linked list of factors of a text. Its 088 * <CODE>next</CODE> pointer is initially <CODE>null</CODE>, but it is typically set 089 * to point to the first factor afterwards (with the <CODE>setNext</CODE> method). 090 * 091 * @see #setNext 092 */ 093 public Factor () 094 { 095 this.ancestor = null; 096 this.next = null; 097 this.serial_number = 0; 098 this.length = 0; 099 this.new_char = 0; 100 } 101 102 /** 103 * Creates a new <CODE>Factor</CODE> instance with the specified serial number and 104 * new character, and pointing to the given ancestor. Its length is set to its 105 * ancestor's length plus 1. 106 * 107 * <P>Its <CODE>next</CODE> pointer is initially <CODE>null</CODE>, but it is 108 * typically set to point to the next factor afterwards (with the <CODE>setNext</CODE> 109 * method). 110 * 111 * @param ancestor this factor's ancestor 112 * @param serial_number this factor's serial number 113 * @param new_char this factor's new character 114 * @see #setNext 115 */ 116 public Factor (Factor ancestor, int serial_number, char new_char) 117 { 118 this.ancestor = ancestor; 119 this.serial_number = serial_number; 120 this.new_char = new_char; 121 if (ancestor != null) 122 this.length = ancestor.length() + 1; 123 else 124 throw new IllegalArgumentException ("Ancestor factor cannot be null."); 125 } 126 127 /** 128 * Sets this factor's <CODE>next</CODE> pointer to point to the specified factor. 129 * Although the next factor has typically a serial number equal to this factor's 130 * serial number plus 1, no attempt is made to guarantee this rule. This allows 131 * special constructs or a different order in the factorisation. 132 * 133 * @param next the factor that will be pointed to 134 * @see #getNext 135 */ 136 public void setNext (Factor next) 137 { 138 this.next = next; 139 } 140 141 /** 142 * Returns this factor's ancestor factor. 143 * 144 * @return this factor's ancestor factor 145 */ 146 public Factor getAncestor () 147 { 148 return ancestor; 149 } 150 151 /** 152 * This method is a shorthand to return the serial number of this factor's ancestor. 153 * Note that it does not check if this factor has an ancestor or not, therefore, if 154 * it is called on the root factor, a NullPointerException is raised. 155 * 156 * @return the serial number of this factor's ancestor 157 */ 158 public int getAncestorSerialNumber () 159 { 160 return ancestor.getSerialNumber(); 161 } 162 163 /** 164 * Returns this factor's next factor. 165 * 166 * @return this factor's next factor 167 * @see #setNext 168 */ 169 public Factor getNext () 170 { 171 return next; 172 } 173 174 /** 175 * Returns this factor's serial number. 176 * 177 * @return this factor's serial number 178 */ 179 public int getSerialNumber () 180 { 181 return serial_number; 182 } 183 184 /** 185 * Returns this factor's length. 186 * 187 * @return this factor's length 188 */ 189 public int length () 190 { 191 return length; 192 } 193 194 /** 195 * Returns this factor's new character. 196 * 197 * @return this factor's new character 198 */ 199 public char getNewChar () 200 { 201 return new_char; 202 } 203 204 /** 205 * Returns a string representation of the text represented by this factor. It inspects 206 * its chain of ancestors up until as far as the root factor, spelling their new 207 * characters out. 208 * 209 * @return a string representation of the text denoted by this factor 210 */ 211 public String toString () 212 { 213 StringBuffer buf = new StringBuffer(); 214 Factor ancestor = this; 215 216 while (ancestor.getAncestor() != null) 217 { 218 buf.insert(0, ancestor.getNewChar()); 219 ancestor = ancestor.getAncestor(); 220 } 221 222 return buf.toString(); 223 } 224 }neobio-0.0.20030929/doc/src-html/neobio/alignment/Trie.html 0000644 0002656 0002032 00000072635 07727746664 022245 0 ustar tillea admin
001 /* 002 * Trie.java 003 * 004 * Copyright 2003 Sergio Anibal de Carvalho Junior 005 * 006 * This file is part of NeoBio. 007 * 008 * NeoBio is free software; you can redistribute it and/or modify it under the terms of 009 * the GNU General Public License as published by the Free Software Foundation; either 010 * version 2 of the License, or (at your option) any later version. 011 * 012 * NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 013 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 014 * PURPOSE. See the GNU General Public License for more details. 015 * 016 * You should have received a copy of the GNU General Public License along with NeoBio; 017 * if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, 018 * Boston, MA 02111-1307, USA. 019 * 020 * Proper attribution of the author as the source of the software would be appreciated. 021 * 022 * Sergio Anibal de Carvalho Junior mailto:sergioanibaljr@users.sourceforge.net 023 * Department of Computer Science http://www.dcs.kcl.ac.uk 024 * King's College London, UK http://www.kcl.ac.uk 025 * 026 * Please visit http://neobio.sourceforge.net 027 * 028 * This project was supervised by Professor Maxime Crochemore. 029 * 030 */ 031 032 package neobio.alignment; 033 034 /** 035 * This class implements a trie, or a digital search tree. A trie is a multiway tree 036 * (each node can have multiple children) that represents a set of strings. 037 * 038 * <P>Each node contains data encapsulated in an object instance. Each edge spells out a 039 * character and each path from the root represents a string described by the characters 040 * labelling the traversed edges. Moreover, for each string represented, there is a unique 041 * path from the root.</P> 042 * 043 * <P>The trie of the following example represents the strings 'a', 'd', 'b', 'ac', 'ba', 044 * 'be', 'bd', 'bad' and 'bae'.</P> 045 * 046 * <CODE><BLOCKQUOTE><PRE> 047 * [0] 048 * --+-- 049 * / | \ 050 * a/ d| \b 051 * [1] [2] [4] 052 * | --+-- 053 * | / | \ 054 * c| a/ e| d\ 055 * [3] [5] [6] [9] 056 * --+-- 057 * / \ 058 * d/ e\ 059 * [7] [8] 060 * </PRE></BLOCKQUOTE></CODE> 061 * 062 * <P>It is easy to see that strings with common prefixes will branch off from each other 063 * at the first distinguishing character. This feature makes the trie a good data 064 * structure to identify and represent phrases of a text such as the ones induced by the 065 * Lempel-Ziv familiy of compression algorithms. For instance, the LZ78 version parses 066 * the text into phrases, where each phrase is the longest matching phrase seen previously 067 * plus one character.</P> 068 * 069 * <P>In this implementation, each node is actually an instance of this class. To build a 070 * trie, one must first create the root using the public constructor:</P> 071 * 072 * <CODE><BLOCKQUOTE><PRE> 073 * Trie root = new Trie (some_object); 074 * </PRE></BLOCKQUOTE></CODE> 075 * 076 * <P>Here <CODE>some_object</CODE> contains any relevant information encapsulated in an 077 * object instance. Typically, that's the only moment the public constructor is used. From 078 * now on, all new nodes will be added as a new child of one existing node using the 079 * <CODE>add</CODE> method:</P> 080 * 081 * <CODE><BLOCKQUOTE><PRE> 082 * new_node = any_node.add (some_object, character); 083 * </PRE></BLOCKQUOTE></CODE> 084 * 085 * <P>Here <CODE>character</CODE> is the character that will label the edge from 086 * <CODE>any_node</CODE> to <CODE>new_node</CODE>. Note that this transition must not 087 * already exist, otherwise an exception is raised. 088 * 089 * <P>To find the longest prefix of a given string, we follow a path from the root down 090 * the tree, character by character, with the <CODE>spellDown</CODE> method:</P> 091 * 092 * <CODE><BLOCKQUOTE><PRE> 093 * next_node = root; 094 * while (next_node != null) 095 * { 096 * current_node = next_node; 097 * char c = get next character from somewhere 098 * <B>next_node = current_node.spellDown (c);</B> 099 * } 100 * </PRE></BLOCKQUOTE></CODE> 101 * 102 * <P><CODE>spellDown</CODE> follows the edge out of <CODE>current_node</CODE> labelled by 103 * the character <CODE>c</CODE> and returns the next node. If there is no such a path, it 104 * returns null.</P> 105 * 106 * <P>To retrieve the information stored at any node, simply use the <CODE>getData</CODE> 107 * method.</P> 108 * 109 * <P>In fact, there are many ways to implement a trie. To avoid wasting space with 110 * multiple pointers at each node, this implementation uses an approach with a linked list 111 * of siblings. Each node actually contains a pointer to one of its children and a pointer 112 * to one of its siblings only. Together with the pointers, each node also stores the 113 * character that labels the edge to the pointed node.<P> 114 * 115 * <CODE><BLOCKQUOTE><PRE> 116 * [0] 117 * | 118 * a| d b 119 * [1]---[2]---[4] 120 * | | 121 * c| a| e d 122 * [3] [5]---[6]---[9] 123 * | 124 * d| e 125 * [7]---[8] 126 * </PRE></BLOCKQUOTE></CODE> 127 * 128 * <P>In this way, a trie is similar to a binary tree. Although this implementation is 129 * more efficient in terms of space, the search for a label with a given character leaving 130 * a node <CODE>n</CODE> is no more constant but proportional to the number of children of 131 * <CODE>n</CODE>. In the previous example, it is necessary to traverse three edges to 132 * reach node 9 from node 4 with character d.</P> 133 * 134 * <P>This class is used by the {@linkplain FactorSequence} to build a linked list of 135 * factors of a sequence in a LZ78 fashion, i.e. where each factor is the longest factor 136 * previously seen plus one character.</P> 137 * 138 * @author Sergio A. de Carvalho Jr. 139 * @see FactorSequence 140 */ 141 public class Trie 142 { 143 /** 144 * A pointer to the first of this node's children. 145 */ 146 protected Trie son; 147 148 /** 149 * The character that labels the edge from this node to the child node pointer by 150 * <CODE>son</CODE>. 151 */ 152 protected char to_son; 153 154 /** 155 * A pointer to this node's next sibling. 156 */ 157 protected Trie sibling; 158 159 /** 160 * The character that labels the edge from this node to the sibling pointer by 161 * <CODE>sibling</CODE>. 162 */ 163 protected char to_sibling; 164 165 /** 166 * This node's stored data. 167 */ 168 protected Object data; 169 170 /** 171 * Creates a new trie node with the specified data. This constructor is typically used 172 * by the client only once to instantiate the root node. After that, all new nodes are 173 * implicitly instantiated by the <CODE>add</CODE> method. 174 * 175 * @param data the data that will be associated with the new node 176 */ 177 public Trie (Object data) 178 { 179 this.son = null; 180 this.sibling = null; 181 this.data = data; 182 } 183 184 /** 185 * Returns the data associated with this node. 186 * 187 * @return data associated with this node 188 */ 189 public Object getData () 190 { 191 return data; 192 } 193 194 /** 195 * Adds a new child to this node. The new node will be implicitly instantiated with 196 * the <CODE>data</CODE> argument, and the edge from this node to the new node will be 197 * labelled by the character argument. If this node already have an edge labelled with 198 * this character, an exception is raised. Otherwise, the new node created and 199 * returned. 200 * 201 * <P>If this node have no child, a new node is created straight away. Otherwise, the 202 * task is assigned to its first child that will add the new node as a sibling.</P> 203 * 204 * @param data the data that will be associated with the new node 205 * @param c the character that will label the edge from this node to the new node 206 * @return the added node 207 * @throws IllegalStateException if this node already have an edge labelled by 208 * <CODE>c</CODE> 209 */ 210 public Trie add (Object data, char c) 211 { 212 if (son == null) 213 { 214 son = new Trie (data); 215 to_son = c; 216 return son; 217 } 218 else 219 { 220 if (to_son != c) 221 return son.addSibling (data, c); 222 else 223 // duplicate char 224 throw new IllegalStateException ("Failed to add character " + c + 225 " already exists."); 226 } 227 } 228 229 /** 230 * Adds a sibling to this node. The new node will be implicitly instantiated with 231 * the <CODE>data</CODE> argument, and the edge from this node to the new node will be 232 * labelled by the character argument. If this node already have a sibling with this 233 * character, an exception is raised. Otherwise, the new node is created and returned. 234 * 235 * <P>If this node have no direct sibling, a new node is created straight away. 236 * Otherwise, the task is assigned to its next sibling.</P> 237 * 238 * @param data the data that will be associated with the new node 239 * @param c the character that will label the edge from this node to the new node 240 * @return the added node 241 * @throws IllegalStateException if this node already have an edge labelled by 242 * <CODE>c</CODE> 243 */ 244 protected Trie addSibling (Object data, char c) 245 { 246 if (sibling == null) 247 { 248 sibling = new Trie (data); 249 to_sibling = c; 250 return sibling; 251 } 252 else 253 { 254 if (to_sibling != c) 255 return sibling.addSibling (data, c); 256 else 257 // duplicate char 258 throw new IllegalStateException ("Failed to add character: " + c + 259 " already exists."); 260 } 261 } 262 263 /** 264 * Follows a path from this node to one of its children by spelling the character 265 * supplied as an argument. If there is no such a path, <CODE>null</CODE> is returned. 266 * Otherwise, the reached child node is returned. 267 * 268 * <P>If this node's direct child is reached with an edge labelled by the character, 269 * it is returned straight away. Otherwise, it is assigned the task of finding another 270 * sibling labelled with that character.</P> 271 * 272 * @param c the character that labels the path to be followed to this node's child 273 * @return the child node reached by traversing the edge labelled by <CODE>c</CODE> 274 */ 275 public Trie spellDown (char c) 276 { 277 if (son == null) return null; 278 279 if (to_son == c) 280 return son; 281 else 282 return son.spellRight(c); 283 } 284 285 /** 286 * Follows a path from this node to one of its sibling by spelling the character 287 * supplied as an argument. If there is no such a path, <CODE>null</CODE> is returned. 288 * Otherwise, the reached sibling node is returned. 289 * 290 * <P>If this node's direct sibling is reached with an edge labelled by the character, 291 * it is returned straight away. Otherwise, it is assigned the task of finding another 292 * sibling labelled with that character.</P> 293 * 294 * @param c the character that labels the path to be followed to the sibling 295 * @return the sibling node reached by traversing the edge labelled by <CODE>c</CODE> 296 */ 297 protected Trie spellRight (char c) 298 { 299 if (sibling == null) return null; 300 301 if (to_sibling == c) 302 return sibling; 303 else 304 return sibling.spellRight(c); 305 } 306 }neobio-0.0.20030929/doc/src-html/neobio/alignment/BasicScoringScheme.html 0000644 0002656 0002032 00000046637 07727746664 025040 0 ustar tillea admin
001 /* 002 * BasicScoringScheme.java 003 * 004 * Copyright 2003 Sergio Anibal de Carvalho Junior 005 * 006 * This file is part of NeoBio. 007 * 008 * NeoBio is free software; you can redistribute it and/or modify it under the terms of 009 * the GNU General Public License as published by the Free Software Foundation; either 010 * version 2 of the License, or (at your option) any later version. 011 * 012 * NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 013 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 014 * PURPOSE. See the GNU General Public License for more details. 015 * 016 * You should have received a copy of the GNU General Public License along with NeoBio; 017 * if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, 018 * Boston, MA 02111-1307, USA. 019 * 020 * Proper attribution of the author as the source of the software would be appreciated. 021 * 022 * Sergio Anibal de Carvalho Junior mailto:sergioanibaljr@users.sourceforge.net 023 * Department of Computer Science http://www.dcs.kcl.ac.uk 024 * King's College London, UK http://www.kcl.ac.uk 025 * 026 * Please visit http://neobio.sourceforge.net 027 * 028 * This project was supervised by Professor Maxime Crochemore. 029 * 030 */ 031 032 package neobio.alignment; 033 034 /** 035 * This class implements a basic scoring scheme. At least three parameters must be 036 * provided to the constructor: the reward for a match (a substitution of equal 037 * characters), the penalty for a mismatch (a substitution of different characters) and 038 * the cost of a gap (an insertion or deletion of a character). Note that it only supports 039 * an additive gap cost function. 040 * 041 * <P>Although the match reward is expected to be a positive value, and the mismatch 042 * penalty and the gap cost are expected to be negative, no attempt is made to enforce 043 * these behaviour.</P> 044 * 045 * @author Sergio A. de Carvalho Jr. 046 */ 047 public class BasicScoringScheme extends ScoringScheme 048 { 049 /** 050 * The reward for a match (a substitution of equal characters). 051 */ 052 protected int match_reward; 053 054 /** 055 * The penalty for a mismatch (a substitution of different characters). 056 */ 057 protected int mismatch_penalty; 058 059 /** 060 * The cost of a gap (an insertion or deletion of a character). 061 */ 062 protected int gap_cost; 063 064 /** 065 * The maximum absolute score that this scoring scheme can return, which is the 066 * maximum absolute value among <CODE>match_reward</CODE>, 067 * <CODE>mismatch_penalty</CODE> and <CODE>gap_cost</CODE>. 068 */ 069 protected int max_absolute_score; 070 071 /** 072 * Creates a new instance of a basic scoring scheme with the specified values of 073 * match reward, mismatch penalty and gap cost. The case of characters is significant 074 * when subsequently computing their score. 075 * 076 * @param match_reward reward for a substitution of equal characters 077 * @param mismatch_penalty penalty for a substitution of different characters 078 * @param gap_cost cost of an insertion or deletion of any character 079 */ 080 public BasicScoringScheme (int match_reward, int mismatch_penalty, int gap_cost) 081 { 082 this (match_reward, mismatch_penalty, gap_cost, true); 083 } 084 085 /** 086 * Creates a new instance of basic scoring scheme with the specified values of 087 * match reward, mismatch penalty and gap cost. If <CODE>case_sensitive</CODE> is 088 * <CODE>true</CODE>, the case of characters is significant when subsequently 089 * computing their score; otherwise the case is ignored. 090 * 091 * @param match_reward reward for a substitution of equal characters 092 * @param mismatch_penalty penalty for a substitution of different characters 093 * @param gap_cost cost of an insertion or deletion of any character 094 * @param case_sensitive <CODE>true</CODE> if the case of characters must be 095 * significant, <CODE>false</CODE> otherwise 096 */ 097 public BasicScoringScheme (int match_reward, int mismatch_penalty, int gap_cost, 098 boolean case_sensitive) 099 { 100 super(case_sensitive); 101 102 this.match_reward = match_reward; 103 this.mismatch_penalty = mismatch_penalty; 104 this.gap_cost = gap_cost; 105 106 // store the maximum absolute score that this scoring scheme can return, 107 // which is the maximum absolute value among match_reward, mismatch_penalty 108 // and gap_cost 109 if (Math.abs(match_reward) >= Math.abs(mismatch_penalty)) 110 if (Math.abs(match_reward) >= Math.abs(gap_cost)) 111 this.max_absolute_score = Math.abs(match_reward); 112 else 113 this.max_absolute_score = Math.abs(gap_cost); 114 else 115 if (Math.abs(mismatch_penalty) >= Math.abs(gap_cost)) 116 this.max_absolute_score = Math.abs(mismatch_penalty); 117 else 118 this.max_absolute_score = Math.abs(gap_cost); 119 } 120 121 /** 122 * Returns the score of a substitution of character <CODE>a</CODE> for character 123 * <CODE>b</CODE> according to this scoring scheme. It is <CODE>match_reward</CODE> 124 * if <CODE>a</CODE> equals <CODE>b</CODE>, <CODE>mismatch_penalty</CODE> otherwise. 125 * 126 * @param a first character 127 * @param b second character 128 * @return <CODE>match_reward</CODE> if <CODE>a</CODE> equals <CODE>b</CODE>, 129 * <CODE>mismatch_penalty</CODE> otherwise. 130 */ 131 public int scoreSubstitution (char a, char b) 132 { 133 if (isCaseSensitive()) 134 if (a == b) 135 return match_reward; 136 else 137 return mismatch_penalty; 138 else 139 if (Character.toLowerCase(a) == Character.toLowerCase(b)) 140 return match_reward; 141 else 142 return mismatch_penalty; 143 } 144 145 /** 146 * Always returns <CODE>gap_cost</CODE> for the insertion of any character. 147 * 148 * @param a the character to be inserted 149 * @return <CODE>gap_cost</CODE> 150 */ 151 public int scoreInsertion (char a) 152 { 153 return gap_cost; 154 } 155 156 /** 157 * Always returns <CODE>gap_cost</CODE> for the deletion of any character. 158 * 159 * @param a the character to be deleted 160 * @return <CODE>gap_cost</CODE> 161 */ 162 public int scoreDeletion (char a) 163 { 164 return gap_cost; 165 } 166 167 /** 168 * Returns the maximum absolute score that this scoring scheme can return for any 169 * substitution, deletion or insertion, which is the maximum absolute value among 170 * <CODE>match_reward</CODE>, <CODE>mismatch_penalty</CODE> and 171 * <CODE>gap_cost</CODE>. 172 * 173 * @return the maximum absolute value among <CODE>match_reward</CODE>, 174 * <CODE>mismatch_penalty</CODE> and <CODE>gap_cost</CODE>. 175 */ 176 public int maxAbsoluteScore () 177 { 178 return max_absolute_score; 179 } 180 181 /** 182 * Tells whether this scoring scheme supports partial matches, which it does not. 183 * 184 * @return always return <CODE>false</CODE> 185 */ 186 public boolean isPartialMatchSupported () 187 { 188 return false; 189 } 190 191 /** 192 * Returns a String representation of this scoring scheme. 193 * 194 * @return a String representation of this scoring scheme 195 */ 196 public String toString () 197 { 198 return "Basic scoring scheme: match reward = " + match_reward + 199 ", mismatch penalty = " + mismatch_penalty + ", gap cost = " + gap_cost; 200 } 201 }neobio-0.0.20030929/doc/src-html/neobio/alignment/CrochemoreLandauZivUkelsonGlobalAlignment.html 0000644 0002656 0002032 00000107406 07727746662 031560 0 ustar tillea admin
001 /* 002 * CrochemoreLandauZivUkelsonGlobalAlignment.java 003 * 004 * Copyright 2003 Sergio Anibal de Carvalho Junior 005 * 006 * This file is part of NeoBio. 007 * 008 * NeoBio is free software; you can redistribute it and/or modify it under the terms of 009 * the GNU General Public License as published by the Free Software Foundation; either 010 * version 2 of the License, or (at your option) any later version. 011 * 012 * NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 013 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 014 * PURPOSE. See the GNU General Public License for more details. 015 * 016 * You should have received a copy of the GNU General Public License along with NeoBio; 017 * if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, 018 * Boston, MA 02111-1307, USA. 019 * 020 * Proper attribution of the author as the source of the software would be appreciated. 021 * 022 * Sergio Anibal de Carvalho Junior mailto:sergioanibaljr@users.sourceforge.net 023 * Department of Computer Science http://www.dcs.kcl.ac.uk 024 * King's College London, UK http://www.kcl.ac.uk 025 * 026 * Please visit http://neobio.sourceforge.net 027 * 028 * This project was supervised by Professor Maxime Crochemore. 029 * 030 */ 031 032 package neobio.alignment; 033 034 /** 035 * This class implements the <B>global</B> pairwise sequence alignment algorithm (with 036 * linear gap penalty function) due to Maxime Crochemore, Gad Landau and Michal 037 * Ziv-Ukelson (2002). 038 * 039 * <P>This implementation derives from the paper of M.Crochemore, G.Landau and 040 * M.Ziv-Ukelson, <I>A Sub-quadratic Sequence Alignment Algorithm for Unrestricted Scoring 041 * Matrices</I> (available here as 042 * <A HREF="doc-files/Crochemore_Landau_Ziv-Ukelson_algorithm.pdf">PDF</A> or 043 * <A HREF="doc-files/Crochemore_Landau_Ziv-Ukelson_algorithm.pdf">Postscript</A>).</P> 044 * 045 * <P>For a general description of the algorithm, please refer to the specification of the 046 * abstract {@linkplain CrochemoreLandauZivUkelson} superclass.</P> 047 * 048 * <P>This class consist mainly of methods that:</P> 049 * 050 * <LU> 051 * <LI>create and compute all information of a block (see {@link #createBlock createBlock} 052 * and its variants); 053 * <LI>compute the output border of a block (see {@link #computeOutputBorder 054 * computeOutputBorder}; 055 * <LI>locate the score of a high scoring global alignment in the block table (see {@link 056 * #locateScore locateScore}; 057 * <LI>build an optimal global alignment from the information stored in the block table 058 * (see {@link #buildOptimalAlignment buildOptimalAlignment}. 059 * </LU> 060 * 061 * @see CrochemoreLandauZivUkelson 062 * @see CrochemoreLandauZivUkelsonLocalAlignment 063 * @author Sergio A. de Carvalho Jr. 064 */ 065 public class CrochemoreLandauZivUkelsonGlobalAlignment extends CrochemoreLandauZivUkelson 066 { 067 /** 068 * Creates and computes all information of an alignment block. Its main job is to 069 * compute the DIST column for the block. It then request the 070 * <CODE>computeOutputBorder</CODE> method to compute the block's output border. 071 * 072 * @param factor1 factor of the first sequence 073 * @param factor2 factor of the second sequence 074 * @param row row index of the block in the block table 075 * @param col column index of the block in the block table 076 * @return the computed block 077 * @throws IncompatibleScoringSchemeException if the scoring scheme is not compatible 078 * with the sequences being aligned 079 */ 080 protected AlignmentBlock createBlock (Factor factor1, Factor factor2, int row, 081 int col) throws IncompatibleScoringSchemeException 082 { 083 AlignmentBlock block, left_prefix, diag_prefix, top_prefix; 084 int size, lr, lc, score_ins, score_sub, score_del, ins, del, sub, max; 085 086 lr = factor1.length(); 087 lc = factor2.length(); 088 size = lr + lc + 1; 089 090 block = new AlignmentBlock (factor1, factor2, size); 091 092 // set up pointers to prefixes 093 left_prefix = getLeftPrefix (block); 094 diag_prefix = getDiagonalPrefix (block); 095 top_prefix = getTopPrefix (block); 096 097 // compute scores 098 score_ins = scoreInsertion (factor2.getNewChar()); 099 score_sub = scoreSubstitution (factor1.getNewChar(), factor2.getNewChar()); 100 score_del = scoreDeletion (factor1.getNewChar()); 101 102 // compute dist column and direction 103 for (int i = 0; i < size; i++) 104 { 105 // compute optimal path to 106 // input border's ith position 107 108 ins = sub = del = Integer.MIN_VALUE; 109 110 if (i < size - 1) 111 ins = left_prefix.dist_column[i] + score_ins; 112 113 if ((i > 0) && (i < size - 1)) 114 sub = diag_prefix.dist_column[i - 1] + score_sub; 115 116 if (i > 0) 117 del = top_prefix.dist_column[i - 1] + score_del; 118 119 block.dist_column[i] = max = max (ins, sub, del); 120 121 // record the direction to of the optimal 122 // path to input border's ith position 123 if (max == ins) 124 block.direction[i] = LEFT_DIRECTION; 125 else if (max == sub) 126 block.direction[i] = DIAGONAL_DIRECTION; 127 else 128 block.direction[i] = TOP_DIRECTION; 129 } 130 131 computeOutputBorder (block, row, col, size, lc, lr); 132 133 return block; 134 } 135 136 /** 137 * Creates the root block. This is a special case of the <CODE>createBlock</CODE> 138 * method. No information is actually computed. 139 * 140 * @param factor1 factor of the first sequence 141 * @param factor2 factor of the second sequence 142 * @return the root block 143 */ 144 protected AlignmentBlock createRootBlock (Factor factor1, Factor factor2) 145 { 146 return new AlignmentBlock (factor1, factor2); 147 } 148 149 /** 150 * Creates and computes all information of an alignment block of the first row of the 151 * block table. This is a special case of the <CODE>createBlock</CODE> method. 152 * 153 * @param factor1 factor of the first sequence 154 * @param factor2 factor of the second sequence 155 * @param col column index of the block in the block table 156 * @return the computed block 157 * @throws IncompatibleScoringSchemeException if the scoring scheme is not compatible 158 * with the sequences being aligned 159 * @see #createBlock createBlock 160 */ 161 protected AlignmentBlock createFirstRowBlock (Factor factor1, Factor factor2, int col) 162 throws IncompatibleScoringSchemeException 163 { 164 AlignmentBlock block, left_prefix; 165 int size, lr, lc, score_ins; 166 167 lr = 0; // factor1.length(); 168 lc = factor2.length(); 169 size = lr + lc + 1; 170 171 block = new AlignmentBlock (factor1, factor2, size); 172 173 // set up pointer to left prefix 174 left_prefix = getLeftPrefix (block); 175 176 // compute insertion's score 177 score_ins = scoreInsertion (factor2.getNewChar()); 178 179 // compute dist column and direction 180 for (int i = 0; i < lc; i++) 181 { 182 block.dist_column[i] = left_prefix.dist_column[i] + score_ins; 183 block.direction[i] = LEFT_DIRECTION; 184 } 185 186 // last position 187 block.dist_column[lc] = 0; 188 block.direction[lc] = STOP_DIRECTION; 189 190 computeOutputBorder (block, 0, col, size, lc, lr); 191 192 return block; 193 } 194 195 /** 196 * Creates and computes all information of an alignment block of the first column of 197 * the block table. This is a special case of the <CODE>createBlock</CODE> method. 198 * 199 * @param factor1 factor of the first sequence 200 * @param factor2 factor of the second sequence 201 * @param row row index of the block in the block table 202 * @return the computed block 203 * @throws IncompatibleScoringSchemeException if the scoring scheme is not compatible 204 * with the sequences being aligned 205 * @see #createBlock createBlock 206 */ 207 protected AlignmentBlock createFirstColumnBlock (Factor factor1, Factor factor2, 208 int row) throws IncompatibleScoringSchemeException 209 { 210 AlignmentBlock block, top_prefix; 211 int size, lr, lc, score_del; 212 213 lr = factor1.length(); 214 lc = 0; // factor2.length(); 215 size = lr + lc + 1; 216 217 block = new AlignmentBlock (factor1, factor2, size); 218 219 // set up pointer to top prefix 220 top_prefix = getTopPrefix (block); 221 222 // compute deletion's score 223 score_del = scoreDeletion (factor1.getNewChar()); 224 225 // first position 226 block.dist_column[0] = 0; 227 block.direction[0] = STOP_DIRECTION; 228 229 // compute dist column and direction 230 for (int i = 1; i < size; i++) 231 { 232 block.dist_column[i] = top_prefix.dist_column[i - 1] + score_del; 233 block.direction[i] = TOP_DIRECTION; 234 } 235 236 computeOutputBorder (block, row, 0, size, lc, lr); 237 238 return block; 239 } 240 241 /** 242 * Computes the output border of a block. This is performed in five steps: 243 * 244 * <LU> 245 * <LI>Retrieve the block's input border; 246 * <LI>Retrieve the block's complete DIST matrix; 247 * <LI>Create an interface to the {@linkplain OutMatrix OUT} matrix from the input 248 * border and DIST matrix; 249 * <LI>Use {@linkplain Smawk SMAWK} to compute all column maxima of the OUT matrix 250 * (SMAWK finds the index of the row that contains the maximum value of a column); 251 * <LI>Assemble the output border by extracting the maximum values of each column of 252 * the OUT matrix using the information obtained in the previous step. 253 * </LU> 254 * 255 * @param block the block for which the output border is to be computed 256 * @param row row index of the block in the block table 257 * @param col column index of the block in the block table 258 * @param dim dimension of the output border 259 * @param lc number of columns of the block 260 * @param lr number of row of the block 261 */ 262 protected void computeOutputBorder (AlignmentBlock block, int row, int col, int dim, 263 int lc, int lr) 264 { 265 int[] input = assembleInputBorder (dim, row, col, lr); 266 267 int[][] dist = assembleDistMatrix (block, dim, row, col, lc); 268 269 // update the interface to the OUT matrix 270 out_matrix.setData (dist, input, dim, lc); 271 272 // compute source_path using Smawk 273 smawk.computeColumnMaxima (out_matrix, block.source_path); 274 275 // update output border 276 for (int i = 0; i < dim; i++) 277 block.output_border[i] = out_matrix.valueAt(block.source_path[i], i); 278 } 279 280 /** 281 * Builds an optimal global alignment between the loaded sequences after the block 282 * table has been computed. This method traces a path back in the block table, from 283 * the last block to the first. 284 * 285 * @return an optimal global alignment 286 * @throws IncompatibleScoringSchemeException If the scoring scheme is not compatible 287 * with the loaded sequences. 288 * @see CrochemoreLandauZivUkelson#traverseBlock 289 */ 290 protected PairwiseAlignment buildOptimalAlignment () 291 throws IncompatibleScoringSchemeException 292 { 293 AlignmentBlock block, ancestor; 294 StringBuffer gapped_seq1, tag_line, gapped_seq2; 295 int source, dest, ancestor_source; 296 int row, col; 297 298 gapped_seq1 = new StringBuffer(); 299 tag_line = new StringBuffer(); 300 gapped_seq2 = new StringBuffer(); 301 302 // start at the last row, last column of block table 303 row = num_rows - 1; col = num_cols - 1; 304 block = block_table[row][col]; 305 dest = block.factor2.length(); 306 307 while (row > 0 || col > 0) 308 { 309 block = block_table[row][col]; 310 source = block.source_path[dest]; 311 ancestor = block.ancestor[dest]; 312 313 ancestor_source = source; 314 if (dest > block.factor2.length()) 315 ancestor_source -= (block.factor1.length() - ancestor.factor1.length()); 316 317 traverseBlock (ancestor, ancestor_source, gapped_seq1, tag_line, gapped_seq2); 318 319 if (row == 0) 320 { 321 col = col - 1; 322 dest = block_table[row][col].factor2.length(); 323 } 324 else if (col == 0) 325 { 326 row = row - 1; 327 dest = 0; 328 } 329 else 330 { 331 if (source < block.factor1.length()) 332 { 333 col = col - 1; 334 dest = block_table[row][col].factor2.length() + source; 335 } 336 else if (source == block.factor1.length()) 337 { 338 row = row - 1; col = col - 1; 339 dest = block_table[row][col].factor2.length(); 340 } 341 else 342 { 343 row = row - 1; 344 dest = source - block.factor1.length(); 345 } 346 } 347 } 348 349 return new PairwiseAlignment (gapped_seq1.toString(), tag_line.toString(), 350 gapped_seq2.toString(), locateScore()); 351 } 352 353 /** 354 * Locate the score of the highest scoring global alignment in the block table. This 355 * value is found in the output border of the last block (last row, last column). 356 * 357 * @return the score of the highest scoring global alignment 358 */ 359 protected int locateScore () 360 { 361 AlignmentBlock last_block = block_table[num_rows - 1][num_cols - 1]; 362 363 return last_block.output_border[last_block.factor2.length()]; 364 } 365 }neobio-0.0.20030929/doc/src-html/neobio/alignment/CrochemoreLandauZivUkelson.html 0000644 0002656 0002032 00000235706 07727746662 026605 0 ustar tillea admin
001 /* 002 * CrochemoreLandauZivUkelson.java 003 * 004 * Copyright 2003 Sergio Anibal de Carvalho Junior 005 * 006 * This file is part of NeoBio. 007 * 008 * NeoBio is free software; you can redistribute it and/or modify it under the terms of 009 * the GNU General Public License as published by the Free Software Foundation; either 010 * version 2 of the License, or (at your option) any later version. 011 * 012 * NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 013 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 014 * PURPOSE. See the GNU General Public License for more details. 015 * 016 * You should have received a copy of the GNU General Public License along with NeoBio; 017 * if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, 018 * Boston, MA 02111-1307, USA. 019 * 020 * Proper attribution of the author as the source of the software would be appreciated. 021 * 022 * Sergio Anibal de Carvalho Junior mailto:sergioanibaljr@users.sourceforge.net 023 * Department of Computer Science http://www.dcs.kcl.ac.uk 024 * King's College London, UK http://www.kcl.ac.uk 025 * 026 * Please visit http://neobio.sourceforge.net 027 * 028 * This project was supervised by Professor Maxime Crochemore. 029 * 030 */ 031 032 package neobio.alignment; 033 034 import java.io.Reader; 035 import java.io.IOException; 036 037 /** 038 * This abstract class is the superclass of both global and local sequence alignment 039 * algorithms (with linear gap penalty function) due to Maxime Crochemore, Gad Landau and 040 * Michal Ziv-Ukelson (2002). 041 * 042 * <P>This implementation derives from the paper of M.Crochemore, G.Landau and 043 * M.Ziv-Ukelson, <I>A Sub-quadratic Sequence Alignment Algorithm for Unrestricted Scoring 044 * Matrices</I> (available here as 045 * <A HREF="doc-files/Crochemore_Landau_Ziv-Ukelson_algorithm.pdf">PDF</A> or 046 * <A HREF="doc-files/Crochemore_Landau_Ziv-Ukelson_algorithm.pdf">Postscript</A>).</P> 047 * 048 * <P>It employs Lempel-Ziv compression techniques to speed up the classic dynamic 049 * programmin approach to sequence alignment (see {@linkplain NeedlemanWunsch} and 050 * {@linkplain SmithWaterman} classes). It reduces the time and space complexity from 051 * O(n<SUP>2</SUP>) to O(n<SUP>2</SUP>/log n). In fact, the complexity is actually O(h 052 * n<SUP>2</SUP>/log n), where 0 <= h <= 1 is a real number denoting the entropy of the 053 * text (a measure of how compressible it is). This means that, the more compressible a 054 * sequence is, the less memory the algorithm will require, and the faster it will 055 * run.</P> 056 * 057 * <P>The idea behind this improvement is to identify repetitions in the sequences and 058 * reuse the computation of their alignments. The first step is, therefore, to parse the 059 * sequences into LZ78-like factors. LZ78 is a popular compression algorithm of the 060 * Lempel-Ziv familiy due to J.Ziv and A.Lempel (1978). This factorisation is accomplished 061 * by the {@linkplain FactorSequence} class (for more information about this 062 * factorisation, please refer to the specification of that class) that builds a 063 * doubly-linked list of factors. Each factor is an instance of the {@linkplain Factor} 064 * class (refer to the specification of this class for more information).</P> 065 * 066 * <P>Once the sequences have been parsed, the algorithm builds a matrix of blocks, called 067 * block table, that is vaguely similar to the dynamic programming matrix used by both 068 * <CODE>NeedlemanWunsch</CODE> and <CODE>SmithWaterman</CODE>. Each block contains an 069 * instance of an {@linkplain AlignmentBlock} (please refer to its specification for more 070 * information on what information is stored) and represents the alignment beteween one 071 * factor of each sequence. This block table is, in fact, a partition of the alignment 072 * graph.</P> 073 * 074 * <P>Consider a block B which corresponds to the alignment of factor F1 = xa from 075 * sequence S1 and factor F2 = yb from sequence S2. Here, F1 extends a previous factor of 076 * S1 with character a, while F2 extends a previous factor of S2 with character b. We can 077 * define the input border of B as the set of values at the left and top borders of block 078 * B, and the output border as the set of values at the right and bottom borders of B. 079 * Moreover, we can define the following prefix blocks of B:</P> 080 * 081 * <UL> 082 * <LI><B>Left prefix</B> - is the block that contains the alignment of factor F1 with 083 * a factor F2' = y (a prefix of factor F2). 084 * <LI><B>Diagonal prefix</B> - is the block that contains the alignment of factor F1' = x 085 * (a prefix of factor F1) with a factor F2' = y (a prefix of factor F2). 086 * <LI><B>Top prefix</B> - is the block that contains the alignment of factor F1' = x (a 087 * prefix of factor F1) with factor F2. 088 * </UL> 089 * 090 * <P>Note that each factor has a pointer to its prefix factor, called ancestor (see the 091 * specification of the <CODE>Factor</CODE> class). This pointer makes it easy to retrieve 092 * any of the three prefix blocks of B in constant time.</P> 093 * 094 * <P>Rather than computing each value of the alignment block B, the algorithm will only 095 * compute the values on its input and output borders. This is precisely what makes it 096 * more efficient.</P> 097 * 098 * <P>In this class there is a general specification of how the block table is computed 099 * (see the {@link #computeBlockTable computeBlockTable} method for details). The actual 100 * method depends on the subclasses. In general, there are two phases:</P> 101 * 102 * <UL> 103 * <LI><B>Encoding</B> - the structure of a block B is studied and represented in an 104 * efficient way by computing weights of optimal paths connecting each entry of its input 105 * border to each entry of its output border. This information is encoded in a DIST matrix 106 * where DIST[i,j] stores the weight of an optimal paths connecting entry i of the input 107 * border to entry j the output border of B. 108 * <LI><B>Propagation</B> - the input border of a block B is retrieved (from the left and 109 * top blocks of B) and its output border is computed with the help of the DIST matrix. 110 * </UL> 111 * 112 * <P>In fact, for each block, only one column of the DIST matrix needs to be computed, 113 * all other columns are actually retrieved from its prefix blocks. This is precisely what 114 * is accomplished by the {@link #assembleDistMatrix assembleDistMatrix} method found in 115 * this class (it is general enough for both global and local alignment versions of the 116 * algorithm.</P> 117 * 118 * <P>From the DIST matrix, we obtain the OUT matrix defined as 119 * <CODE>OUT[i,j] = I[i] + DIST[i,j]</CODE> where I is the input border array. This means 120 * that the OUT matrix is the DIST matrix updated by the input border of a block. The 121 * output border is then computed from the OUT matrix by taking the maximum value of each 122 * column. This class also have a general method for assembling the input border (see 123 * {@link #assembleInputBorder assembleInputBorder}</P> 124 * 125 * <P>The OUT matrix is encoded by the {@linkplain OutMatrix} class that takes as 126 * both a DIST matrix and an input border array. Note that <B>it does not compute the OUT 127 * matrix</B>, it just stores the necessary information to retrieve a value at any 128 * position of the matrix.</P> 129 * 130 * <P>A naive approach to compute the output border of a block from the OUT matrix of size 131 * n x n would take a time proportional to n<SUP>2</SUP>. However, it happens that, due to 132 * the nature of the DIST matrix, both DIST and OUT matrices are Monge arrays, which 133 * implies that they are also <I>totally monotone</I>. This property allows the 134 * computation of the output border of B in linear time with the SMAWK algorithm (see the 135 * specification of the {@linkplain Smawk} class for more information on SMAWK).</P> 136 * 137 * <P>This class contains a general specification that is pertinent to both global and 138 * local versions of the algorithm. For more information on each version of, please refer 139 * to the appropriate subclass.</P> 140 * 141 * <P><B>A note about the performance of these algorithms.</B> Although theoretical 142 * results suggest that these algorithms are faster and consume less memory than the 143 * classical methods, in practice it is hard to realise their performance gains. 144 * 145 * <P>These algorithms are extremely complex and require the storage of many extra 146 * pointers and other auxiliary data for each block (see the <CODE>AlignmentBlock</CODE> 147 * class for more details). Hence, even though the space requirement is 148 * O(n<SUP>2</SUP>/log n), which is less than O(n<SUP>2</SUP>), in practice, for most of 149 * the cases these algorithms will take more time and memory space than their clasical 150 * counterparts (we have to keep in mind that the Big Oh notation ignores all constants 151 * involved).</P> 152 * 153 * <P>Therefore, in order to realise the full power of these algorithms, they have to be 154 * used with extremly large and redundant sequences. This will allow a proper 155 * reutilisation of the computations and, maybe, provide an improvement in terms of space 156 * and run time. For instance, it is easy to devise such a sequence if we use a 157 * one-character alphabet because, in this case, a sequence is factorised into a series 158 * of factors that are a prefix of the next.</P> 159 * 160 * @author Sergio A. de Carvalho Jr. 161 * @see CrochemoreLandauZivUkelsonGlobalAlignment 162 * @see CrochemoreLandauZivUkelsonLocalAlignment 163 * @see NeedlemanWunsch 164 * @see SmithWaterman 165 * @see FactorSequence 166 * @see AlignmentBlock 167 * @see OutMatrix 168 * @see Smawk 169 * @see #computeBlockTable 170 * @see #assembleDistMatrix 171 */ 172 public abstract class CrochemoreLandauZivUkelson extends PairwiseAlignmentAlgorithm 173 { 174 /** 175 * A constant that indicates that the source of an optimal path has been reached in a 176 * block and that the trace back procedure to retrieve a high scoring alignment can 177 * stop. 178 */ 179 protected static final byte STOP_DIRECTION = 0; 180 181 /** 182 * A constant that indicates that the left direction must be followed to reach the 183 * source of an optimal path in a block during the trace back procedure to retrieve a 184 * high scoring alignment. 185 */ 186 protected static final byte LEFT_DIRECTION = 1; 187 188 /** 189 * A constant that indicates that the diagonal direction must be followed to reach the 190 * source of an optimal path in a block during the trace back procedure to retrieve a 191 * high scoring alignment. 192 */ 193 protected static final byte DIAGONAL_DIRECTION = 2; 194 195 /** 196 * A constant that indicates that the top direction must be followed to reach the 197 * source of an optimal path in a block during the trace back procedure to retrieve a 198 * high scoring alignment. 199 */ 200 protected static final byte TOP_DIRECTION = 3; 201 202 /** 203 * The first factorised sequence being aligned. 204 */ 205 protected FactorSequence seq1; 206 207 /** 208 * The second factorised sequence being aligned. 209 */ 210 protected FactorSequence seq2; 211 212 /** 213 * The block table, which is a matrix of alignment blocks where each block represents 214 * the alignment between one factor of each sequence. 215 */ 216 protected AlignmentBlock[][] block_table; 217 218 /** 219 * Number of rows of the block table. It is determined by the number of factors of the 220 * first sequence. 221 */ 222 protected int num_rows; 223 224 /** 225 * Number of columns of the block table. It is determined by the number of factors of 226 * the second sequence. 227 */ 228 protected int num_cols; 229 230 /** 231 * An instance of the <CODE>Smawk</CODE> class that implements the SMAWK algorithm to 232 * compute the column maxima of a totally monotone matrix. It is used to speed up the 233 * computation of the output border of a block. 234 */ 235 protected Smawk smawk = new Smawk(); 236 237 /** 238 * An instance of the <CODE>OutMatrix</CODE> class that encodes the OUT matrix of a 239 * block when supplied with the DIST matrix and the input border array of a block. 240 * Note that it does not compute the OUT matrix itselft, it just stores the necessary 241 * information to retrieve a value at any position of the matrix. 242 * 243 * <P>This object is then used to compute the output border of a block with the 244 * <CODE>Smawk</CODE> class. Note that the <CODE>OutMatrix</CODE> class implements the 245 * <CODE>Matrix</CODE> interface as required by the <CODE>Smawk</CODE> class. 246 * 247 * @see Matrix 248 * @see Smawk 249 */ 250 protected OutMatrix out_matrix = new OutMatrix (); 251 252 /** 253 * Loads sequences into <CODE>FactorSequence</CODE> instances. In case of any error, 254 * an exception is raised by the constructor of <CODE>FactorSequence</CODE> (please 255 * check the specification of that class for specific requirements). 256 * 257 * <P>A <CODE>FactorSequence</CODE> is an LZ78-like factorisation of the sequences 258 * being aligned. 259 * 260 * @param input1 Input for first sequence 261 * @param input2 Input for second sequence 262 * @throws IOException If an I/O error occurs when reading the sequences 263 * @throws InvalidSequenceException If the sequences are not valid 264 * @see FactorSequence 265 */ 266 protected void loadSequencesInternal (Reader input1, Reader input2) 267 throws IOException, InvalidSequenceException 268 { 269 // load sequences into instances of CharSequence 270 this.seq1 = new FactorSequence(input1); 271 this.seq2 = new FactorSequence(input2); 272 273 // determine the block table's dimensions 274 this.num_rows = seq1.numFactors(); 275 this.num_cols = seq2.numFactors(); 276 } 277 278 /** 279 * Frees pointers to loaded sequences and the the block table so that their data can 280 * be garbage collected. 281 */ 282 protected void unloadSequencesInternal () 283 { 284 this.seq1 = null; 285 this.seq2 = null; 286 this.block_table = null; 287 } 288 289 /** 290 * Computes the block table (the result depends on subclasses, see 291 * <CODE>computeBlockTable</CODE> for details) and requests subclasses to retrieve an 292 * optimal alignment between the loaded sequences. The actual product depends on the 293 * subclasses which can produce a global (see 294 * <CODE>CrochemoreLandauZivUkelsonGlobalAlignment</CODE>) or local alignment (see 295 * <CODE>CrochemoreLandauZivUkelsonLocalAlignment</CODE>). 296 * 297 * <P>Subclasses are required to implement the <CODE>buildOptimalAlignment</CODE> 298 * abstract method defined by this class according to their own method.</P> 299 * 300 * @return an optimal alignment between the loaded sequences 301 * @throws IncompatibleScoringSchemeException If the scoring scheme is not compatible 302 * with the loaded sequences. 303 * @see CrochemoreLandauZivUkelsonGlobalAlignment 304 * @see CrochemoreLandauZivUkelsonLocalAlignment 305 * @see #computeBlockTable 306 * @see #buildOptimalAlignment 307 */ 308 protected PairwiseAlignment computePairwiseAlignment () 309 throws IncompatibleScoringSchemeException 310 { 311 // compute block table 312 computeBlockTable (); 313 314 // build and return an optimal global alignment 315 PairwiseAlignment alignment = buildOptimalAlignment (); 316 317 // allow the block table to be garbage collected 318 block_table = null; 319 320 return alignment; 321 } 322 323 /** 324 * Computes the block table (the result depends on subclasses, see 325 * <CODE>computeBlockTable</CODE> for details) and requests subclasses to locate the 326 * score of the highest scoring alignment between the two sequences in the block 327 * table. The result depends on the subclasses, and either a global alignment 328 * (see <CODE>CrochemoreLandauZivUkelsonGlobalAlignment</CODE>) or local alignment 329 * score (see <CODE>CrochemoreLandauZivUkelsonLocalAlignment</CODE>) will be produced. 330 * 331 * <P>Subclasses are required to implement the <CODE>locateScore</CODE> abstract 332 * method defined by this class according to their own method.</P> 333 * 334 * <P>Note that this method calculates the similarity value only (it doesn't trace 335 * back into the block table to retrieve the alignment itself).</P> 336 * 337 * @return the score of the highest scoring alignment between the loaded sequences 338 * @throws IncompatibleScoringSchemeException If the scoring scheme is not compatible 339 * with the loaded sequences. 340 * @see CrochemoreLandauZivUkelsonGlobalAlignment 341 * @see CrochemoreLandauZivUkelsonLocalAlignment 342 * @see #locateScore 343 */ 344 protected int computeScore () throws IncompatibleScoringSchemeException 345 { 346 // compute block table 347 computeBlockTable (); 348 349 // get score 350 int score = locateScore (); 351 352 // allow the block table to be garbage collected 353 block_table = null; 354 355 return score; 356 } 357 358 /** 359 * Computes the block table. This method is a general specification of how the block 360 * table should be computed. It creates the block table according to the number of 361 * factors of each sequence. It then goes over each position of the block table, 362 * retrieves the corresponding factors from each sequence, and repasses the 363 * information to the subclasses that will do the actual computation of each block 364 * using the scoring scheme previously set. 365 * 366 * <P>There are four different cases that defines four abstract methods in this class, 367 * which subclasses must implement:</P> 368 * 369 * <UL> 370 * <LI><B>createRootBlock</B> - creates and computes block at row 0, column 0; 371 * <LI><B>createFirstColumnBlock</B> - creates and computes blocks at column 0 which 372 * corresponds to alignment blocks between factors of sequence 1 and an empty string; 373 * <LI><B>createFirstRowBlock</B> - creates and computes blocks at row 0 which 374 * corresponds to alignment blocks between factors of sequence 2 and an empty string; 375 * <LI><B>createBlock</B> - creates and computes blocks at row > 0 and column > 0 376 * which corresponds to alignment blocks between one factor of sequence 1 and one 377 * factor of sequence 2; 378 * </UL> 379 * 380 * <P>Note that each factor has a serial number which indicates its order in the list 381 * of factors of a sequence. This number will match with the row and column index of 382 * a block in the block table. For instance, if a block has factors F1 and F2 with 383 * serial numbers 12 and 53, respectively, this means that this block is found at row 384 * 12, column 53 of the block table.</P> 385 * 386 * @throws IncompatibleScoringSchemeException If the scoring scheme is not compatible 387 * with the loaded sequences. 388 * @see #createRootBlock 389 * @see #createFirstColumnBlock 390 * @see #createFirstRowBlock 391 * @see #createBlock 392 */ 393 protected void computeBlockTable () throws IncompatibleScoringSchemeException 394 { 395 Factor factor1, factor2; 396 int r, c, max_length; 397 398 // create block table 399 block_table = new AlignmentBlock[num_rows][num_cols]; 400 401 // find the length of the longest sequence (number of characters) 402 max_length = Math.max(seq1.numChars(), seq2.numChars()); 403 404 // prepares the OUT matrix object 405 out_matrix.init (max_length, scoring.maxAbsoluteScore()); 406 407 // start at the root of each trie 408 factor1 = seq1.getRootFactor(); 409 factor2 = seq2.getRootFactor(); 410 411 // check if roots' indexes are both zero 412 if (factor1.getSerialNumber() != 0 || factor2.getSerialNumber() != 0) 413 throw new IndexOutOfBoundsException ("Unexpected factor index."); 414 415 // initiate first cell of block table 416 block_table[0][0] = createRootBlock (factor1, factor2); 417 418 // compute first row 419 for (c = 1; c < num_cols; c++) 420 { 421 factor2 = factor2.getNext(); 422 423 // check if factor2's index equals its column number (except for 424 // the last factor that can be a repetition of a previous one) 425 if (c < num_cols - 1 && factor2.getSerialNumber() != c) 426 throw new IndexOutOfBoundsException ("Unexpected factor index."); 427 428 block_table[0][c] = createFirstRowBlock (factor1, factor2, c); 429 } 430 431 for (r = 1; r < num_rows; r++) 432 { 433 factor1 = factor1.getNext(); 434 435 // check if factor1's index equals its row number (except for 436 // the last factor that can be a repetition of a previous one) 437 if (r < num_rows - 1 && factor1.getSerialNumber() != r) 438 throw new IndexOutOfBoundsException ("Unexpected factor index."); 439 440 // go back to the root of sequence 2 441 factor2 = seq2.getRootFactor(); 442 443 if (factor2.getSerialNumber() != 0) 444 throw new IndexOutOfBoundsException ("Unexpected factor index."); 445 446 // compute first column of current row 447 block_table[r][0] = createFirstColumnBlock (factor1, factor2, r); 448 449 for (c = 1; c < num_cols; c++) 450 { 451 factor2 = factor2.getNext(); 452 453 // check if factor2's index equals its column number (except for 454 // the last factor that can be a repetition of a previous one) 455 if (c < num_cols - 1 && factor2.getSerialNumber() != c) 456 throw new IndexOutOfBoundsException ("Unexpected factor index."); 457 458 // compute row r, col c 459 block_table[r][c] = createBlock (factor1, factor2, r, c); 460 } 461 } 462 } 463 464 /** 465 * Assembles the DIST matrix of a block by retrieving the DIST columns of its prefix 466 * blocks. In fact, it also stores pointers to the owner block for each column 467 * retrieved. These pointers are later used during the trace back procedure that 468 * builds an optimal alignment from the information computed in the block table. This 469 * method is general enough to suit both global and local alignment versions of the 470 * algorithm. 471 * 472 * @param block the block for which the DIST matrix is needed 473 * @param dim the dimension of the DIST matrix 474 * @param r the row index of this block in the block table 475 * @param c the column index of this block in the block table 476 * @param lc the number of columns of the alignment block 477 * @return the DIST matrix 478 */ 479 protected int[][] assembleDistMatrix (AlignmentBlock block, int dim, int r, int c, 480 int lc) 481 { 482 AlignmentBlock ancestor; 483 Factor parent; 484 int[][] dist; 485 int i; 486 487 dist = new int[dim][]; 488 489 // columns to the left of lc 490 parent = block.factor2.getAncestor(); 491 for (i = lc - 1; i >= 0; i--) 492 { 493 ancestor = block_table[r][parent.getSerialNumber()]; 494 block.ancestor[i] = ancestor; 495 dist[i] = ancestor.dist_column; 496 parent = parent.getAncestor(); 497 } 498 499 // column lc 500 dist[lc] = block.dist_column; 501 block.ancestor[lc] = block; 502 503 // columns to the right of lc 504 parent = block.factor1.getAncestor(); 505 for (i = lc + 1; i < dim; i++) 506 { 507 ancestor = block_table[parent.getSerialNumber()][c]; 508 block.ancestor[i] = ancestor; 509 dist[i] = ancestor.dist_column; 510 parent = parent.getAncestor(); 511 } 512 513 return dist; 514 } 515 516 /** 517 * Assembles the input border of a block by retrieving the values at the output 518 * borders of the left and top blocks. This method is general enough to suit both 519 * global and local alignment versions of the algorithm. Note that it can be used to 520 * assemble the input border of any block but the root one (it will cause an 521 * <CODE>ArrayIndexOutOfBoundsException</CODE>. 522 * 523 * @param dim dimension of the input border 524 * @param r row index of the block in the block table 525 * @param c column index of the block in the block table 526 * @param lr number of row of the block 527 * @return the block's input border 528 */ 529 protected int[] assembleInputBorder (int dim, int r, int c, int lr) 530 { 531 AlignmentBlock left = null, top = null; 532 int[] input; 533 int i; 534 535 input = new int [dim]; 536 537 // set up pointers to the left and top blocks (if applicable) 538 if (c > 0) left = block_table[r][c-1]; 539 if (r > 0) top = block_table[r-1][c]; 540 541 for (i = 0; i < dim; i++) 542 { 543 if (i < lr) 544 { 545 if (left != null) 546 input[i] = left.output_border[left.factor2.length() + i]; 547 else 548 // there is no block to the left, so set a big negative value 549 // to make sure it will not be used (unfortunately, MIN_VALUE 550 // can overflow to a positive value when substracted by any 551 // number, so we use half of it as a workaround) 552 input[i] = Integer.MIN_VALUE / 2; 553 } 554 else if (i == lr) 555 { 556 if (left != null) 557 input[i] = left.output_border[left.factor2.length() + i]; 558 else 559 // no need to check if top is not null 560 // (because we assume this is not the root block) 561 input[i] = top.output_border[i - lr]; 562 } 563 else 564 { 565 if (top != null) 566 input[i] = top.output_border[i - lr]; 567 else 568 // there is no top block (see note for the left case) 569 input[i] = Integer.MIN_VALUE / 2; 570 } 571 } 572 573 return input; 574 } 575 576 /** 577 * Traverses a block to retrieve a part of an optimal alignment from the specified 578 * source in the output border to an entry in the input border. 579 * 580 * @param block the block to be traversed 581 * @param source the source of the path in the output border 582 * @param gapped_seq1 the StringBuffer to where the gapped sequence 1 is written to 583 * @param tag_line the StringBuffer to where the tag_line is written to 584 * @param gapped_seq2 the StringBuffer to where the gapped sequence 2 is written to 585 * @throws IncompatibleScoringSchemeException If the scoring scheme is not compatible 586 * with the loaded sequences. 587 */ 588 protected void traverseBlock (AlignmentBlock block, int source, 589 StringBuffer gapped_seq1, StringBuffer tag_line, StringBuffer gapped_seq2) 590 throws IncompatibleScoringSchemeException 591 { 592 char char1, char2; 593 594 while (block.direction[source] != STOP_DIRECTION) 595 { 596 char1 = block.factor1.getNewChar(); 597 char2 = block.factor2.getNewChar(); 598 599 switch (block.direction[source]) 600 { 601 case LEFT_DIRECTION: 602 gapped_seq1.insert (0, GAP_CHARACTER); 603 tag_line.insert (0, GAP_TAG); 604 gapped_seq2.insert (0, char2); 605 606 block = getLeftPrefix (block); 607 break; 608 609 case DIAGONAL_DIRECTION: 610 gapped_seq1.insert (0, char1); 611 if (char1 == char2) 612 if (useMatchTag()) 613 tag_line.insert (0, MATCH_TAG); 614 else 615 tag_line.insert (0, char1); 616 else if (scoreSubstitution(char1, char2) > 0) 617 tag_line.insert (0, APPROXIMATE_MATCH_TAG); 618 else 619 tag_line.insert (0, MISMATCH_TAG); 620 gapped_seq2.insert (0, char2); 621 622 block = getDiagonalPrefix (block); 623 source --; 624 break; 625 626 case TOP_DIRECTION: 627 gapped_seq1.insert (0, char1); 628 tag_line.insert (0, GAP_TAG); 629 gapped_seq2.insert (0, GAP_CHARACTER); 630 631 block = getTopPrefix (block); 632 source --; 633 break; 634 } 635 } 636 } 637 638 /** 639 * This method is a shorthand to retrieve the left prefix of a block from the block 640 * table. 641 * 642 * @param block the block 643 * @return the block's left prefix 644 */ 645 protected AlignmentBlock getLeftPrefix (AlignmentBlock block) 646 { 647 int prefix_row = block.factor1.getSerialNumber(); 648 int prefix_col = block.factor2.getAncestorSerialNumber(); 649 650 return block_table[prefix_row][prefix_col]; 651 } 652 653 /** 654 * This method is a shorthand to retrieve the diagonal prefix of a block from the 655 * block table. 656 * 657 * @param block the block 658 * @return the block's diagonal prefix 659 */ 660 protected AlignmentBlock getDiagonalPrefix (AlignmentBlock block) 661 { 662 int prefix_row = block.factor1.getAncestorSerialNumber(); 663 int prefix_col = block.factor2.getAncestorSerialNumber(); 664 665 return block_table[prefix_row][prefix_col]; 666 } 667 668 /** 669 * This method is a shorthand to retrieve the top prefix of a block from the block 670 * table. 671 * 672 * @param block the block 673 * @return the block's top prefix 674 */ 675 protected AlignmentBlock getTopPrefix (AlignmentBlock block) 676 { 677 int prefix_row = block.factor1.getAncestorSerialNumber(); 678 int prefix_col = block.factor2.getSerialNumber(); 679 680 return block_table[prefix_row][prefix_col]; 681 } 682 683 /** 684 * Computes the root block of the block table. See subclasses for actual 685 * implementation. 686 * 687 * @param factor1 the factor of the first sequence being aligned 688 * @param factor2 the factor of the second sequence being aligned 689 * @return the root block 690 * @throws IncompatibleScoringSchemeException If the scoring scheme is not compatible 691 * with the loaded sequences. 692 */ 693 protected abstract AlignmentBlock createRootBlock (Factor factor1, Factor factor2) 694 throws IncompatibleScoringSchemeException; 695 696 /** 697 * Computes a block at the first row (row zero) of the block table, which corresponds 698 * to an alignment block between one factor of sequence 2 and an empty string. See 699 * subclasses for actual implementation. 700 * 701 * @param factor1 the factor of the first sequence being aligned 702 * @param factor2 the factor of the second sequence being aligned 703 * @param col the column index of block in the block table 704 * @return the computed block 705 * @throws IncompatibleScoringSchemeException If the scoring scheme is not compatible 706 * with the loaded sequences. 707 */ 708 protected abstract AlignmentBlock createFirstRowBlock (Factor factor1, Factor factor2, 709 int col) throws IncompatibleScoringSchemeException; 710 711 /** 712 * Computes a block at the first column (column zero) of the block table, which 713 * corresponds to an alignment block between one factor of sequence 1 and an empty 714 * string. See subclasses for actual implementation. 715 * 716 * @param factor1 the factor of the first sequence being aligned 717 * @param factor2 the factor of the second sequence being aligned 718 * @param row the row index of block in the block table 719 * @return the computed block 720 * @throws IncompatibleScoringSchemeException If the scoring scheme is not compatible 721 * with the loaded sequences. 722 */ 723 protected abstract AlignmentBlock createFirstColumnBlock (Factor factor1, 724 Factor factor2, int row) throws IncompatibleScoringSchemeException; 725 726 /** 727 * Computes a block of the block table, which corresponds to an alignment block 728 * between one factor of sequence 1 and one factor of sequence 2. See subclasses for 729 * actual implementation. 730 * 731 * @param factor1 the factor of the first sequence being aligned 732 * @param factor2 the factor of the second sequence being aligned 733 * @param row the row index of block in the block table 734 * @param col the column index of block in the block table 735 * @return the computed block 736 * @throws IncompatibleScoringSchemeException If the scoring scheme is not compatible 737 * with the loaded sequences. 738 */ 739 protected abstract AlignmentBlock createBlock (Factor factor1, Factor factor2, 740 int row, int col) throws IncompatibleScoringSchemeException; 741 742 /** 743 * Retrieves an optimal alignment between the loaded sequences. See subclasses for 744 * actual implementation. 745 * 746 * @return the computed block 747 * @throws IncompatibleScoringSchemeException If the scoring scheme is not compatible 748 * with the loaded sequences. 749 */ 750 protected abstract PairwiseAlignment buildOptimalAlignment () 751 throws IncompatibleScoringSchemeException; 752 753 /** 754 * Locates the score of the highest scoring alignment between the two sequences in the 755 * block table after is thas been computed. See subclasses for actual implementation. 756 * 757 * @return the score of the highest scoring alignment between the loaded sequences 758 * @throws IncompatibleScoringSchemeException If the scoring scheme is not compatible 759 * with the loaded sequences. 760 */ 761 protected abstract int locateScore (); 762 }neobio-0.0.20030929/doc/src-html/neobio/alignment/ScoringScheme.html 0000644 0002656 0002032 00000033054 07727746664 024063 0 ustar tillea admin
001 /* 002 * ScoringScheme.java 003 * 004 * Copyright 2003 Sergio Anibal de Carvalho Junior 005 * 006 * This file is part of NeoBio. 007 * 008 * NeoBio is free software; you can redistribute it and/or modify it under the terms of 009 * the GNU General Public License as published by the Free Software Foundation; either 010 * version 2 of the License, or (at your option) any later version. 011 * 012 * NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 013 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 014 * PURPOSE. See the GNU General Public License for more details. 015 * 016 * You should have received a copy of the GNU General Public License along with NeoBio; 017 * if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, 018 * Boston, MA 02111-1307, USA. 019 * 020 * Proper attribution of the author as the source of the software would be appreciated. 021 * 022 * Sergio Anibal de Carvalho Junior mailto:sergioanibaljr@users.sourceforge.net 023 * Department of Computer Science http://www.dcs.kcl.ac.uk 024 * King's College London, UK http://www.kcl.ac.uk 025 * 026 * Please visit http://neobio.sourceforge.net 027 * 028 * This project was supervised by Professor Maxime Crochemore. 029 * 030 */ 031 032 package neobio.alignment; 033 034 /** 035 * This abstract class is the superclass of all scoring schemes. It defines basic 036 * operations that must be provided by all subclasses. Scoring schemes are used by 037 * sequence alignment algorithms to compute the score of an alignment. 038 * 039 * @author Sergio A. de Carvalho Jr. 040 * @see PairwiseAlignmentAlgorithm 041 */ 042 public abstract class ScoringScheme 043 { 044 /** 045 * Determines whether this scoring scheme ignores the case of characters when 046 * computing their score. It is set by the constructor and cannot be changed 047 * afterwards. 048 */ 049 protected boolean case_sensitive; 050 051 /** 052 * Creates a new instance of an scoring scheme. The case of characters is significant 053 * when subsequently computing their score. 054 */ 055 public ScoringScheme () 056 { 057 this (true); 058 } 059 060 /** 061 * Creates a new instance of an scoring scheme. If <CODE>case_sensitive</CODE> is 062 * <CODE>true</CODE>, the case of characters is significant when subsequently 063 * computing their score; otherwise the case is ignored. 064 * 065 * @param case_sensitive <CODE>true</CODE> if the case of characters must be 066 * significant, <CODE>false</CODE> otherwise 067 */ 068 public ScoringScheme (boolean case_sensitive) 069 { 070 this.case_sensitive = case_sensitive; 071 } 072 073 /** 074 * Tells whether this scoring scheme ignores the case of characters when computing 075 * their score. 076 * 077 * @return <CODE>true</CODE> if the case of characters is significant, 078 * <CODE>false</CODE> otherwise 079 */ 080 public boolean isCaseSensitive () 081 { 082 return this.case_sensitive; 083 } 084 085 /** 086 * Returns the score of a substitution of character <CODE>a</CODE> for character 087 * <CODE>b</CODE> according to this scoring scheme. If this substitution is not 088 * defined, an exception is raised. 089 * 090 * @param a first character 091 * @param b second character 092 * @return score of substitution of <CODE>a</CODE> for <CODE>b</CODE> 093 * @throws IncompatibleScoringSchemeException if this substitution is not defined 094 */ 095 public abstract int scoreSubstitution (char a, char b) 096 throws IncompatibleScoringSchemeException; 097 098 /** 099 * Returns the score of an insertion of character <CODE>a</CODE> according to this 100 * scoring scheme. If this character is not recognised, an exception is raised. 101 * 102 * @param a the character to be inserted 103 * @return score of insertion of <CODE>a</CODE> 104 * @throws IncompatibleScoringSchemeException if character is not recognised by this 105 * scoring scheme 106 */ 107 public abstract int scoreInsertion (char a) 108 throws IncompatibleScoringSchemeException; 109 110 /** 111 * Returns the score of a deletion of character <CODE>a</CODE> according to this 112 * scoring scheme. If this character is not recognised, an exception is raised. 113 * 114 * @param a the character to be deleted 115 * @return score of insertion of <CODE>a</CODE> 116 * @throws IncompatibleScoringSchemeException if character is not recognised by this 117 * scoring scheme 118 */ 119 public abstract int scoreDeletion (char a) 120 throws IncompatibleScoringSchemeException; 121 122 /** 123 * Returns the maximum absolute score that this scoring scheme can return for any 124 * substitution, deletion or insertion. 125 * 126 * @return maximum absolute score that can be returned 127 */ 128 public abstract int maxAbsoluteScore (); 129 130 /** 131 * Returns <CODE>true</CODE> if this scoring scheme supports partial matches, 132 * <CODE>false</CODE> otherwise. A partial match is a situation when two characters 133 * are not equal but, for any reason, are regarded as similar by this scoring scheme, 134 * which then returns a positive score. This is common when for scoring schemes 135 * that implement amino acid scoring matrices. 136 * 137 * @return <CODE>true</CODE> if this scoring scheme supports partial matches, 138 * <CODE>false</CODE> otherwise 139 */ 140 public abstract boolean isPartialMatchSupported (); 141 }neobio-0.0.20030929/doc/src-html/neobio/alignment/Smawk.html 0000644 0002656 0002032 00000160000 07727746662 022402 0 ustar tillea admin
001 /* 002 * Smawk.java 003 * 004 * Copyright 2003 Sergio Anibal de Carvalho Junior 005 * 006 * This file is part of NeoBio. 007 * 008 * NeoBio is free software; you can redistribute it and/or modify it under the terms of 009 * the GNU General Public License as published by the Free Software Foundation; either 010 * version 2 of the License, or (at your option) any later version. 011 * 012 * NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 013 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 014 * PURPOSE. See the GNU General Public License for more details. 015 * 016 * You should have received a copy of the GNU General Public License along with NeoBio; 017 * if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, 018 * Boston, MA 02111-1307, USA. 019 * 020 * Proper attribution of the author as the source of the software would be appreciated. 021 * 022 * Sergio Anibal de Carvalho Junior mailto:sergioanibaljr@users.sourceforge.net 023 * Department of Computer Science http://www.dcs.kcl.ac.uk 024 * King's College London, UK http://www.kcl.ac.uk 025 * 026 * Please visit http://neobio.sourceforge.net 027 * 028 * This project was supervised by Professor Maxime Crochemore. 029 * 030 */ 031 032 package neobio.alignment; 033 034 035 /** 036 * This class implement the SMAWK algorithm to compute column maxima on a totally monotone 037 * matrix as described. 038 * 039 * <P>This implementation derives from the paper of A.Aggarwal, M.Klawe, S.Moran, P.Shor, 040 * and R.Wilber, <I>Geometric Applications of a Matrix Searching Algorithm</I>, 041 * Algorithmica, 2, 195-208 (1987).</P> 042 * 043 * <P>The matrix must be an object that implements the {@linkplain Matrix} interface. It 044 * is also expected to be totally monotone, and the number of rows should be greater than 045 * or equals to the number of columns. If these conditions are not met, the the result is 046 * unpredictable and can lead to an ArrayIndexOutOfBoundsException.</P> 047 * 048 * <P>{@link #computeColumnMaxima computeColumnMaxima} is the main public method of this 049 * class. It computes the column maxima of a given matrix, i.e. the rows that contain the 050 * maximum value of each column in O(n) (linear) time, where n is the number of rows. This 051 * method does not return the maximum values itself, but just the indexes of their 052 * rows.</P> 053 * 054 * <P>Note that it is necessary to create an instance of this class to execute the 055 * <CODE>computeColumnMaxima</CODE> because it stores temporary data is that instance. To 056 * prevent problems with concurrent access, the <CODE>computeColumnMaxima</CODE> method is 057 * declared <CODE>synchronized</CODE>. 058 * 059 * <CODE><BLOCKQUOTE><PRE> 060 * // create an instance of Smawk 061 * Smawk smawk = new Smawk(); 062 * 063 * // create an array to store the result 064 * int col_maxima = new int [some_matrix.numColumns()]; 065 * 066 * // now compute column maxima 067 * smawk.computeColumnMaxima (some_matrix, col_maxima) 068 * </PRE></BLOCKQUOTE></CODE> 069 * 070 * <P>Note that the array of column maxima indexes (the computation result) must be 071 * created beforehand and its size must be equal to the number of columns of the 072 * matrix.</P> 073 * 074 * <P>This implementation creates arrays of row and column indexes from the original array 075 * and simulates all operations (reducing, deletion of odd columns, etc.) by manipulating 076 * these arrays. The benefit is two-fold. First the matrix is not required to implement 077 * any of these this operations but only a simple method to retrieve a value at a given 078 * position. Moreover, it tends to be faster since it uses a manipulation of these small 079 * vectors and no row or column is actually deleted. The downside is, of course, the use 080 * of extra memory (in practice, however, this is negligible).</P> 081 * 082 * <P>Note that this class does not contain a <CODE>computeRowMaxima</CODE> method, 083 * however, the <CODE>computeColumnMaxima</CODE> can easily be used to compute row maxima 084 * by using a transposed matrix interface, i.e. one that inverts the indexes of the 085 * <CODE>valueAt</CODE> method (returning [col,row] when [row,col] is requested) and swaps 086 * the number of rows by the number of columns, and vice-versa.</P> 087 * 088 * <P>Another simpler method, {@link #naiveComputeColumnMaxima naiveComputeColumnMaxima}, 089 * does the same job without using the SMAWK algorithm. It takes advantage of the monotone 090 * property of the matrix only (SMAWK explores the stronger constraint of total 091 * monotonicity), and therefore has a worst case time complexity of O(n * m), where n is 092 * the number of rows and m is the number of columns. However, this method tends to be 093 * faster for small matrices because it avoids recursions and row and column 094 * manipulations. There is also a 095 * {@linkplain #naiveComputeRowMaxima naiveComputeRowMaxima} method to compute row maxima 096 * with the naive approach.</P> 097 * 098 * @author Sergio A. de Carvalho Jr. 099 * @see Matrix 100 */ 101 public class Smawk 102 { 103 /** 104 * A pointer to the matrix that is being manipulated. 105 */ 106 protected Matrix matrix; 107 108 /** 109 * The matrix's current number of rows. This reflects any deletion of rows already 110 * performed. 111 */ 112 protected int numrows; 113 114 /** 115 * An array of row indexes reflecting the current state of the matrix. When rows are 116 * deleted, the corresponding indexes are simply moved to the end of the vector. 117 */ 118 protected int row[]; 119 120 /** 121 * This array is used to store for each row of the original matrix, its index in the 122 * current state of the matrix, i.e. its index in the <CODE>row</CODE> array. 123 */ 124 protected int row_position[]; 125 126 /** 127 * The matrix's current number of columns. This reflects any deletion of columns 128 * already performed. 129 */ 130 protected int numcols; 131 132 /** 133 * An array of column indexes reflecting the current state of the matrix. When columns 134 * are deleted, the corresponding indexes are simply moved to the end of the vector. 135 */ 136 protected int col[]; 137 138 /** 139 * Computes the column maxima of a given matrix. It first sets up arrays of row and 140 * column indexes to simulate a copy of the matrix (where all operations will be 141 * performed). It then calls the recursive protected <CODE>computeColumnMaxima</CODE> 142 * method. 143 * 144 * <P>The matrix is required to be an object that implements the <CODE>Matrix</CODE> 145 * interface. It is also expected to be totally monotone, and the number of rows 146 * should be greater than or equals to the number of columns. If it is not, the the 147 * result is unpredictable and can lead to an ArrayIndexOutOfBoundsException.</P> 148 * 149 * <P>This method does not return the maximum values itself, but just the indexes of 150 * their rows. Note that the array of column maxima (the computation result) must be 151 * created beforehand and its size must be equal to the number of columns of the 152 * matrix.</P> 153 * 154 * <P>To prevent problems with concurrent access, this method is declared 155 * <CODE>synchronized</CODE>.</P> 156 * 157 * @param matrix the matrix that will have its column maxima computed 158 * @param col_maxima the array of column maxima (indexes of the rows containing 159 * maximum values of each column); this is the computation result 160 * @see #computeColumnMaxima(int[]) 161 */ 162 public synchronized void computeColumnMaxima (Matrix matrix, int[] col_maxima) 163 { 164 int i; 165 166 this.matrix = matrix; 167 168 // create an array of column indexes 169 numcols = matrix.numColumns(); 170 col = new int [numcols]; 171 for (i = 0; i < numcols; i++) 172 col[i] = i; 173 174 // create an array of row indexes 175 numrows = matrix.numRows(); 176 row = new int [numrows]; 177 for (i = 0; i < numrows; i++) 178 row[i] = i; 179 180 // instantiate an helper array for 181 // backward reference of rows 182 row_position = new int [numrows]; 183 184 computeColumnMaxima (col_maxima); 185 } 186 187 /** 188 * This method implements the SMAWK algorithm to compute the column maxima of a given 189 * matrix. It uses the arrays of row and column indexes to performs all operations on 190 * this 'fake' copy of the original matrix. 191 * 192 * <P>The first step is to reduce the matrix to a quadratic size (if necessary). It 193 * then delete all odd columns and recursively computes column maxima for this matrix. 194 * Finally, using the information computed for the odd columns, it searches for 195 * column maxima of the even columns. The column maxima are progressively stored in 196 * the <CODE>col_maxima</CODE> array (each recursive call will compute a set of 197 * column maxima).</P> 198 * 199 * @param col_maxima the array of column maxima (the computation result) 200 */ 201 protected void computeColumnMaxima (int[] col_maxima) 202 { 203 int original_numrows, original_numcols, c, r, max, end; 204 205 original_numrows = numrows; 206 207 if (numrows > numcols) 208 { 209 // reduce to a quadratic size by deleting 210 // rows that contain no maximum of any column 211 reduce (); 212 } 213 214 // base case: matrix has only one row (and one column) 215 if (numrows == 1) 216 { 217 // so the first column's maximum is the only row left 218 col_maxima[col[0]] = row[0]; 219 220 if (original_numrows > numrows) 221 { 222 // restore rows of original matrix (deleted on reduction) 223 restoreRows (original_numrows); 224 } 225 226 return; 227 } 228 229 // save the number of columns before deleting the odd ones 230 original_numcols = numcols; 231 232 deleteOddColumns (); 233 234 // recursively computes max rows for the remaining even columns 235 computeColumnMaxima (col_maxima); 236 237 restoreOddColumns (original_numcols); 238 239 // set up pointers to the original index for all rows 240 for (r = 0; r < numrows; r++) 241 row_position[row[r]] = r; 242 243 // compute max rows for odd columns based on the result of even columns 244 for (c = 1; c < numcols; c = c + 2) 245 { 246 if (c < numcols - 1) 247 // if not last column, search ends 248 // at next columns' max row 249 end = row_position[col_maxima[col[c + 1]]]; 250 else 251 // if last columnm, search ends 252 // at last row 253 end = numrows - 1; 254 255 // search starts at previous columns' max row 256 max = row_position[col_maxima[col[c - 1]]]; 257 258 // check all values until the end 259 for (r = max + 1; r <= end; r++) 260 { 261 if (valueAt(r, c) > valueAt(max, c)) 262 max = r; 263 } 264 265 col_maxima[col[c]] = row[max]; 266 } 267 268 if (original_numrows > numrows) 269 { 270 // restore rows of original matrix (deleted on reduction) 271 restoreRows (original_numrows); 272 } 273 } 274 275 /** 276 * This is a helper method to simplify the call to the <CODE>valueAt</CODE> method 277 * of the matrix. It returns the value at row <CODE>r</CODE>, column <CODE>c</CODE>. 278 * 279 * @param r the row number of the value being retrieved 280 * @param c the column number of the value being retrieved 281 * @return the value at row <CODE>r</CODE>, column <CODE>c</CODE> 282 * @see Matrix#valueAt 283 */ 284 protected final int valueAt (int r, int c) 285 { 286 return matrix.valueAt (row[r], col[c]); 287 } 288 289 /** 290 * This method simulates a deletion of odd rows by manipulating the <CODE>col</CODE> 291 * array of indexes. In fact, nothing is deleted, but the indexes are moved to the end 292 * of the array in a way that they can be easily restored by the 293 * <CODE>restoreOddColumns</CODE> method using a reverse approach. 294 * 295 * @see #restoreOddColumns 296 */ 297 protected void deleteOddColumns () 298 { 299 int tmp; 300 301 for (int c = 2; c < numcols; c = c + 2) 302 { 303 // swap column c with c/2 304 tmp = col[c / 2]; 305 col[c / 2] = col[c]; 306 col[c] = tmp; 307 } 308 309 numcols = ((numcols - 1) / 2 + 1); 310 } 311 312 /** 313 * Restores the <CODE>col</CODE> array of indexes to the state it was before the 314 * <CODE>deleteOddColumns</CODE> method was called. It only needs to know how many 315 * columns there was originally. The indexes that were moved to the end of the array 316 * are restored to their original position. 317 * 318 * @param original_numcols the number of columns before the odd ones were deleted 319 * @see #deleteOddColumns 320 */ 321 protected void restoreOddColumns (int original_numcols) 322 { 323 int tmp; 324 325 for (int c = 2 * ((original_numcols - 1) / 2); c > 0; c = c - 2) 326 { 327 // swap back column c with c/2 328 tmp = col[c / 2]; 329 col[c / 2] = col[c]; 330 col[c] = tmp; 331 } 332 333 numcols = original_numcols; 334 } 335 336 /** 337 * This method is the key component of the SMAWK algorithm. It reduces an n x m matrix 338 * (n rows and m columns), where n >= m, to an n x n matrix by deleting m - n rows 339 * that are guaranteed to have no maximum value for any column. The result is an 340 * squared submatrix matrix that contains, for each column c, the row that has the 341 * maximum value of c in the original matrix. The rows are deleted with the 342 * <CODE>deleteRow</CODE>method. 343 * 344 * <P>It uses the total monotonicity property of the matrix to identify which rows can 345 * safely be deleted. 346 * 347 * @see #deleteRow 348 */ 349 protected void reduce () 350 { 351 int k = 0, reduced_numrows = numrows; 352 353 // until there is more rows than columns 354 while (reduced_numrows > numcols) 355 { 356 if (valueAt(k, k) < valueAt(k + 1, k)) 357 { 358 // delete row k 359 deleteRow (reduced_numrows, k); 360 reduced_numrows --; 361 k --; 362 } 363 else 364 { 365 if (k < numcols - 1) 366 { 367 k++; 368 } 369 else 370 { 371 // delete row k+1 372 deleteRow (reduced_numrows, k+1); 373 reduced_numrows --; 374 } 375 } 376 } 377 378 numrows = reduced_numrows; 379 } 380 381 /** 382 * This method simulates a deletion of a row in the matrix during the 383 * <CODE>reduce</CODE> operation. It just moves the index to the end of the array in a 384 * way that it can be restored afterwards by the <CODE>restoreRows</CODE> method 385 * (nothing is actually deleted). Deleted indexes are kept in ascending order. 386 * 387 * @param reduced_rows the current number of rows in the reducing matrix 388 * @param k the index of the row to be deleted 389 * @see #restoreRows 390 */ 391 protected void deleteRow (int reduced_rows, int k) 392 { 393 int r, saved_row = row[k]; 394 395 for (r = k + 1; r < reduced_rows; r++) 396 row[r - 1] = row[r]; 397 398 for (r = reduced_rows - 1; r < (numrows - 1) && row[r+1] < saved_row; r++) 399 row[r] = row[r+1]; 400 401 row[r] = saved_row; 402 } 403 404 /** 405 * Restores the <CODE>row</CODE> array of indexes to the state it was before the 406 * <CODE>reduce</CODE> method was called. It only needs to know how many rows there 407 * was originally. The indexes that were moved to the end of the array are restored to 408 * their original position. 409 * 410 * @param original_numrows the number of rows before the reduction was performed 411 * @see #deleteRow 412 * @see #reduce 413 */ 414 protected void restoreRows (int original_numrows) 415 { 416 int r, r2, s, d = numrows; 417 418 for (r = 0; r < d; r++) 419 { 420 if (row[r] > row[d]) 421 { 422 s = row[d]; 423 for (r2 = d; r2 > r; r2--) 424 row[r2] = row[r2-1]; 425 row[r] = s; 426 d++; 427 if (d > original_numrows - 1) break; 428 } 429 } 430 431 numrows = original_numrows; 432 } 433 434 /** 435 * This is a simpler method for calculating column maxima. It does the same job as 436 * <CODE>computeColumnMaxima</CODE>, but without complexity of the SMAWK algorithm. 437 * 438 * <P>The matrix is required to be an object that implements the <CODE>Matrix</CODE> 439 * interface. It is also expected to be monotone. If it is not, the result is 440 * unpredictable but, unlike <CODE>computeColumnMaxima</CODE>, it cannot lead to an 441 * ArrayIndexOutOfBoundsException.</P> 442 * 443 * <P>This method does not return the maximum values itself, but just the indexes of 444 * their rows. Note that the array of column maxima (the computation result) must be 445 * created beforehand and its size must be equal to the number of columns of the 446 * matrix.</P> 447 * 448 * <P>It takes advantage of the monotone property of the matrix only (SMAWK explores 449 * the stronger constraint of total monotonicity), and therefore has a worst case time 450 * complexity of O(n * m), where n is the number of rows and m is the number of 451 * columns. However, this method tends to be faster for small matrices because it 452 * avoids recursions and row and column manipulations.</P> 453 * 454 * @param matrix the matrix that will have its column maxima computed 455 * @param col_maxima the array of column maxima (indexes of the rows containing 456 * maximum values of each column); this is the computation result 457 * @see #naiveComputeRowMaxima 458 */ 459 public static void naiveComputeColumnMaxima (Matrix matrix, int col_maxima[]) 460 { 461 int max_row = 0; 462 //int last_max = 0; 463 464 for (int c = 0; c < matrix.numColumns(); c ++) 465 { 466 for (int r = max_row; r < matrix.numRows(); r++) 467 if (matrix.valueAt(r,c) > matrix.valueAt(max_row,c)) 468 max_row = r; 469 470 col_maxima[c] = max_row; 471 472 // uncomment the following code to raise an exception when 473 // the matrix is not monotone 474 /* 475 if (max_row < last_max) 476 throw new IllegalArgumentException ("Non totally monotone matrix."); 477 last_max = max_row; 478 max_row = 0; 479 */ 480 } 481 } 482 483 /** 484 * This is a simpler method for calculating row maxima. It does not use the SMAWK 485 * algorithm. 486 * 487 * <P>The matrix is required to be an object that implements the <CODE>Matrix</CODE> 488 * interface. It is also expected to be monotone. If it is not, the result is 489 * unpredictable but, unlike <CODE>computeColumnMaxima</CODE>, it cannot lead to an 490 * ArrayIndexOutOfBoundsException.</P> 491 * 492 * <P>This method does not return the maximum values itself, but just the indexes of 493 * their columns. Note that the array of row maxima (the computation result) must be 494 * created beforehand and its size must be equal to the number of columns of the 495 * matrix.</P> 496 * 497 * <P>It takes advantage of the monotone property of the matrix only (SMAWK explores 498 * the stronger constraint of total monotonicity), and therefore has a worst case time 499 * complexity of O(n * m), where n is the number of rows and m is the number of 500 * columns. However, this method tends to be faster for small matrices because it 501 * avoids recursions and row and column manipulations.</P> 502 * 503 * @param matrix the matrix that will have its row maxima computed 504 * @param row_maxima the array of row maxima (indexes of the columns containing 505 * maximum values of each row); this is the computation result 506 * @see #naiveComputeColumnMaxima 507 */ 508 public static void naiveComputeRowMaxima (Matrix matrix, int row_maxima[]) 509 { 510 int max_col = 0; 511 //int last_max = 0; 512 513 for (int r = 0; r < matrix.numRows(); r++) 514 { 515 for (int c = max_col; c < matrix.numColumns(); c ++) 516 if (matrix.valueAt(r,c) > matrix.valueAt(r,max_col)) 517 max_col = c; 518 519 row_maxima[r] = max_col; 520 521 // uncomment the following code to raise an exception when 522 // the matrix is not monotone 523 /* 524 if (max_col < last_max) 525 throw new IllegalArgumentException ("Non-monotone matrix."); 526 last_max = max_col; 527 max_col = 0; 528 */ 529 } 530 } 531 532 /** 533 * Prints the current state of the matrix (reflecting deleted rows and columns) in the 534 * standard output. It can be used internally for debugging. 535 */ 536 protected void printMatrix () 537 { 538 int r, c; 539 540 System.out.print("row\\col\t| "); 541 for (c = 0; c < numcols; c++) 542 System.out.print(col[c] + "\t"); 543 544 for (r = 0; r < numrows; r++) 545 { 546 System.out.print(row[r] + "\n\t| "); 547 for (c = 0; c < numcols; c++) 548 System.out.print(matrix.valueAt(r,c) + "\t"); 549 } 550 551 } 552 553 /** 554 * Prints the contents of an object implementing the matrix interface in the standard 555 * output. It can be used for debugging. 556 * 557 * @param matrix a matrix 558 */ 559 public static void printMatrix (Matrix matrix) 560 { 561 for (int r = 0; r < matrix.numRows(); r++) 562 { 563 for (int c = 0; c < matrix.numColumns(); c++) 564 System.out.print(matrix.valueAt(r,c) + "\t"); 565 System.out.print("\n"); 566 } 567 } 568 }neobio-0.0.20030929/doc/src-html/neobio/alignment/PairwiseAlignment.html 0000644 0002656 0002032 00000052132 07727746662 024750 0 ustar tillea admin
001 /* 002 * PairwiseAlignment.java 003 * 004 * Copyright 2003 Sergio Anibal de Carvalho Junior 005 * 006 * This file is part of NeoBio. 007 * 008 * NeoBio is free software; you can redistribute it and/or modify it under the terms of 009 * the GNU General Public License as published by the Free Software Foundation; either 010 * version 2 of the License, or (at your option) any later version. 011 * 012 * NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 013 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 014 * PURPOSE. See the GNU General Public License for more details. 015 * 016 * You should have received a copy of the GNU General Public License along with NeoBio; 017 * if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, 018 * Boston, MA 02111-1307, USA. 019 * 020 * Proper attribution of the author as the source of the software would be appreciated. 021 * 022 * Sergio Anibal de Carvalho Junior mailto:sergioanibaljr@users.sourceforge.net 023 * Department of Computer Science http://www.dcs.kcl.ac.uk 024 * King's College London, UK http://www.kcl.ac.uk 025 * 026 * Please visit http://neobio.sourceforge.net 027 * 028 * This project was supervised by Professor Maxime Crochemore. 029 * 030 */ 031 032 package neobio.alignment; 033 034 import java.io.Serializable; 035 036 /** 037 * This class is the product of a pairwise alignment, generated by one subclasses of 038 * {@linkplain PairwiseAlignmentAlgorithm}. It contains the two sequences strings with 039 * gaps, a score tag line, and a score value. It is typically displayed in three rows as 040 * in the following example of an alignment between parts of two protein sequences: 041 * 042 * <CODE><BLOCKQUOTE><PRE> 043 * MDEIHQLEDMFTVDSETLRKVVKHFILPHD-----MRTTKHQEELWSFIAELDSLKDFMVEQE // sequence 1 044 * M +I E +FTV +ETL+ V KHFILP D MRTT++ +ELW FIA DSLK F+ EQ // score tag line 045 * MQQIENFEKIFTVPTETLQAVTKHFILP-DATETLMRTTQNPDELWEFIA--DSLKAFIDEQF // sequence 2 046 * </PRE></BLOCKQUOTE></CODE> 047 * 048 * <P>Each column has one character of each sequence and a score tag. The same character 049 * is displayed in all three rows when a column has an exact match (character of sequences 050 * 1 and 2 are equal). When a mismatch occurs (substitution of different characters), the 051 * score tag is left blank. A '+' in the score line signals a partial match (a 052 * substitution of similar characters). The difference between a partial match and a 053 * mismatch is that the score of a partial match is positive whereas the score of a 054 * mismatch is zero or negative (each case is determined by the scoring scheme).</P> 055 * 056 * <P>Gaps are usually represented by dashes ('-') and have a blank score tag. Insertions 057 * have dashes in sequence 1 and the inserted character in sequence 2. Deletions, by 058 * contrast, have the deleted character in sequence 1 and dashes in sequence 2.</P> 059 * 060 * <P>Each column carries a score value for the corresponding operation (as defined by the 061 * scoring scheme). The overall score of a pairwise alignment is the sum of all columns 062 * scores values.</P> 063 * 064 * <P>When the scoring schemes does not support partial matches, a match is usually 065 * signaled by a '|' character.<P> 066 * 067 * <P>Note that these special characters are defined by the 068 * <CODE>PairwiseAlignmentAlgorithm</CODE> class. Consult that class specification for the 069 * actual configuration. For instance, an alignment between two DNA fragmens may look like 070 * this:</P> 071 * 072 * <CODE><BLOCKQUOTE><PRE> 073 * A--C--TAAAAAGCA--TT-AATAATAAA-A 074 * | | |||| ||| || ||||| ||| | 075 * AAGCCCTAAACCGCAAGTTTAATAA-AAATA 076 * </PRE></BLOCKQUOTE></CODE> 077 * 078 * <P>This class is serializable, so it can be saved to a file (or any other output). It 079 * overrides the default <CODE>equals</CODE> method of the <CODE>Object</CODE> class to 080 * allow a proper comparsion of alignments produced by different algorithms or even 081 * different runs of the same algorithm. However, it does not override the 082 * <CODE>hashCode</CODE> method as it is generally the case to maintain the contract for 083 * the <CODE>hashCode</CODE> method (which states that equal objects must have equal hash 084 * codes). Hence, as it is, its use in a hash table is not supported.</P> 085 * 086 * @author Sergio A. de Carvalho Jr. 087 * @see PairwiseAlignmentAlgorithm 088 * @see PairwiseAlignmentAlgorithm#MATCH_TAG 089 * @see PairwiseAlignmentAlgorithm#APPROXIMATE_MATCH_TAG 090 * @see PairwiseAlignmentAlgorithm#MISMATCH_TAG 091 * @see PairwiseAlignmentAlgorithm#GAP_TAG 092 * @see PairwiseAlignmentAlgorithm#GAP_CHARACTER 093 * @see ScoringScheme 094 * @see ScoringScheme#isPartialMatchSupported 095 */ 096 public class PairwiseAlignment implements Serializable 097 { 098 /** 099 * First gapped sequence. 100 * 101 * @serial 102 */ 103 protected String gapped_seq1; 104 105 /** 106 * The score tag line. 107 * 108 * @serial 109 */ 110 protected String score_tag_line; 111 112 /** 113 * Second gapped sequence. 114 * 115 * @serial 116 */ 117 protected String gapped_seq2; 118 119 /** 120 * The overall score value for this alignment. 121 * 122 * @serial 123 */ 124 protected int score; 125 126 /** 127 * Creates a <CODE>PairwiseAlignment</CODE> instance with the specified gapped 128 * sequences, score tag line and score value. 129 * 130 * @param gapped_seq1 the first gapped sequence 131 * @param score_tag_line the score tag line 132 * @param gapped_seq2 the second gapped sequence 133 * @param score the overall score value for this alignment 134 */ 135 public PairwiseAlignment (String gapped_seq1, String score_tag_line, 136 String gapped_seq2, int score) 137 { 138 this.gapped_seq1 = gapped_seq1; 139 this.score_tag_line = score_tag_line; 140 this.gapped_seq2 = gapped_seq2; 141 this.score = score; 142 } 143 144 /** 145 * Returns the first gapped sequence. 146 * 147 * @return first gapped sequence 148 */ 149 public String getGappedSequence1 () 150 { 151 return gapped_seq1; 152 } 153 154 /** 155 * Returns the score tag line. 156 * 157 * @return score tag line 158 */ 159 public String getScoreTagLine () 160 { 161 return score_tag_line; 162 } 163 164 /** 165 * Returns the second gapped sequence. 166 * 167 * @return second gapped sequence 168 */ 169 public String getGappedSequence2 () 170 { 171 return gapped_seq2; 172 } 173 174 /** 175 * Returns the score for this alignment. 176 * 177 * @return overall score for this alignment 178 */ 179 public int getScore () 180 { 181 return score; 182 } 183 184 /** 185 * Returns a four-line String representation of this alignment in the following 186 * order: first gapped sequence, score tag line, second gapped sequence and the 187 * score value. 188 * 189 * @return a String representation of this scoring matrix 190 */ 191 public String toString () 192 { 193 return gapped_seq1 + "\n" + score_tag_line + "\n" 194 + gapped_seq2 + "\nScore: " + score; 195 } 196 197 /** 198 * Compares this object to the specified object. The result is <CODE>true</CODE> if 199 * and only if the argument is not <CODE>null</CODE> and is an 200 * <CODE>PairwiseAlignment</CODE> object that contains the same values as this object, 201 * i.e. the same gapped sequences, the same score tag line and the same score. 202 * 203 * @param obj the object to compare with 204 * @return <CODE>true</CODE> if objects are the same, <CODE>false</CODE> otherwise 205 */ 206 public boolean equals (Object obj) 207 { 208 if (!(obj instanceof PairwiseAlignment)) 209 return false; 210 211 PairwiseAlignment another_pa = (PairwiseAlignment) obj; 212 213 if (this.score != another_pa.score) 214 return false; 215 216 if (!this.gapped_seq1.equals(another_pa.gapped_seq1)) 217 return false; 218 219 if (!this.score_tag_line.equals(another_pa.score_tag_line)) 220 return false; 221 222 if (!this.gapped_seq2.equals(another_pa.gapped_seq2)) 223 return false; 224 225 return true; 226 } 227 }neobio-0.0.20030929/doc/src-html/neobio/alignment/InvalidSequenceException.html 0000644 0002656 0002032 00000017260 07727746664 026271 0 ustar tillea admin
001 /* 002 * InvalidSequenceException.java 003 * 004 * Copyright 2003 Sergio Anibal de Carvalho Junior 005 * 006 * This file is part of NeoBio. 007 * 008 * NeoBio is free software; you can redistribute it and/or modify it under the terms of 009 * the GNU General Public License as published by the Free Software Foundation; either 010 * version 2 of the License, or (at your option) any later version. 011 * 012 * NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 013 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 014 * PURPOSE. See the GNU General Public License for more details. 015 * 016 * You should have received a copy of the GNU General Public License along with NeoBio; 017 * if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, 018 * Boston, MA 02111-1307, USA. 019 * 020 * Proper attribution of the author as the source of the software would be appreciated. 021 * 022 * Sergio Anibal de Carvalho Junior mailto:sergioanibaljr@users.sourceforge.net 023 * Department of Computer Science http://www.dcs.kcl.ac.uk 024 * King's College London, UK http://www.kcl.ac.uk 025 * 026 * Please visit http://neobio.sourceforge.net 027 * 028 * This project was supervised by Professor Maxime Crochemore. 029 * 030 */ 031 032 package neobio.alignment; 033 034 /** 035 * Signals that the sequence does not comply with the specification (see 036 * {@linkplain CharSequence} or {@linkplain FactorSequence} for details). 037 * 038 * @author Sergio A. de Carvalho Jr. 039 * @see CharSequence 040 * @see FactorSequence 041 */ 042 public class InvalidSequenceException extends Exception 043 { 044 /** 045 * Constructs an <CODE>InvalidSequenceException</CODE> with null as its 046 * error detail message. 047 */ 048 public InvalidSequenceException () 049 { 050 super(); 051 } 052 053 /** 054 * Constructs an <CODE>InvalidSequenceException</CODE> with the specified 055 * detail message. 056 * 057 * @param message an error message 058 */ 059 public InvalidSequenceException (String message) 060 { 061 super(message); 062 } 063 064 /** 065 * Constructs an <CODE>InvalidSequenceException</CODE> with the specified 066 * cause (and a detail message that typically contains the class and detail message 067 * of cause). 068 * 069 * @param cause a cause 070 */ 071 public InvalidSequenceException (Throwable cause) 072 { 073 super(cause); 074 } 075 076 /** 077 * Constructs an <CODE>InvalidSequenceException</CODE> with the specified 078 * detail message and cause. 079 * 080 * @param message an error message 081 * @param cause a cause 082 */ 083 public InvalidSequenceException (String message, Throwable cause) 084 { 085 super(message, cause); 086 } 087 }neobio-0.0.20030929/doc/src-html/neobio/alignment/CrochemoreLandauZivUkelsonLocalAlignment.html 0000644 0002656 0002032 00000214271 07727746662 031411 0 ustar tillea admin
001 /* 002 * CrochemoreLandauZivUkelsonLocalAlignment.java 003 * 004 * Copyright 2003 Sergio Anibal de Carvalho Junior 005 * 006 * This file is part of NeoBio. 007 * 008 * NeoBio is free software; you can redistribute it and/or modify it under the terms of 009 * the GNU General Public License as published by the Free Software Foundation; either 010 * version 2 of the License, or (at your option) any later version. 011 * 012 * NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 013 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 014 * PURPOSE. See the GNU General Public License for more details. 015 * 016 * You should have received a copy of the GNU General Public License along with NeoBio; 017 * if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, 018 * Boston, MA 02111-1307, USA. 019 * 020 * Proper attribution of the author as the source of the software would be appreciated. 021 * 022 * Sergio Anibal de Carvalho Junior mailto:sergioanibaljr@users.sourceforge.net 023 * Department of Computer Science http://www.dcs.kcl.ac.uk 024 * King's College London, UK http://www.kcl.ac.uk 025 * 026 * Please visit http://neobio.sourceforge.net 027 * 028 * This project was supervised by Professor Maxime Crochemore. 029 * 030 */ 031 032 package neobio.alignment; 033 034 /** 035 * This class implements the <B>local</B> pairwise sequence alignment algorithm (with 036 * linear gap penalty function) due to Maxime Crochemore, Gad Landau and Michal 037 * Ziv-Ukelson (2002). 038 * 039 * <P>This implementation derives from the paper of M.Crochemore, G.Landau and 040 * M.Ziv-Ukelson, <I>A Sub-quadratic Sequence Alignment Algorithm for Unrestricted Scoring 041 * Matrices</I> (available here as 042 * <A HREF="doc-files/Crochemore_Landau_Ziv-Ukelson_algorithm.pdf">PDF</A> or 043 * <A HREF="doc-files/Crochemore_Landau_Ziv-Ukelson_algorithm.pdf">Postscript</A>).</P> 044 * 045 * <P>For a general description of the algorithm, please refer to the specification of the 046 * abstract {@linkplain CrochemoreLandauZivUkelson} superclass.</P> 047 * 048 * <P>This class consist mainly of methods that:</P> 049 * 050 * <LU> 051 * <LI>create and compute all information of a block (see {@link #createBlock createBlock} 052 * and its variants); 053 * <LI>compute the output border of a block (see {@link #computeOutputBorder 054 * computeOutputBorder}; 055 * <LI>locate the score of a high scoring global alignment in the block table (see {@link 056 * #locateScore locateScore}; 057 * <LI>build an optimal global alignment from the information stored in the block table 058 * (see {@link #buildOptimalAlignment buildOptimalAlignment}. 059 * </LU> 060 * 061 * <P>This algorithm works essentially in the same way as the global alignment version. 062 * The main differences is that an aptimal path can either be contained entirely in a 063 * block (called <B>C-path</B>) or be a block-crossing path. A block-crossing path 064 * consists of a (possibly empty) <B>S-path</B> (a path that starts inside a block and 065 * ends in its output border), followed by any number of paths that cross a block from its 066 * input border to its output border, and ending in an <B>E-path</B> (a path that starts 067 * in the input border of a block and ends inside the block).</P> 068 * 069 * <P>Therefore, it is necessary to compute extra information to keep track of these 070 * possibilities. This is accomplished by using an instance of a {@linkplain 071 * LocalAlignmentBlock} (which extends the {@linkplain AlignmentBlock} class) for every 072 * block in the block table.</P> 073 * 074 * @see CrochemoreLandauZivUkelson 075 * @see CrochemoreLandauZivUkelsonLocalAlignment 076 * @author Sergio A. de Carvalho Jr. 077 */ 078 public class CrochemoreLandauZivUkelsonLocalAlignment extends CrochemoreLandauZivUkelson 079 { 080 /** 081 * A constant that indicates that the best path ending at a given entry of the output 082 * border is a block-crossing path (one that starts outside the block). 083 */ 084 protected static final byte TYPE_CROSSING_PATH = 0; 085 086 /** 087 * A constant that indicates that the best path ending at a given entry of the output 088 * border is a S-path (one that starts inside the block). 089 */ 090 protected static final byte TYPE_S_PATH = 1; 091 092 /** 093 * A constant that indicates that the high scoring path ending in a given block is a 094 * C-path, i.e. one that starts inside the block. 095 */ 096 protected static final byte TYPE_C_PATH = 2; 097 098 /** 099 * A constant that indicates that the high scoring path ending in a given block is an 100 * E-path, i.e. one that starts at its input border. 101 */ 102 protected static final byte TYPE_E_PATH = 3; 103 104 /** 105 * The score of the high scoring local alignment found. 106 */ 107 protected int max_score; 108 109 /** 110 * The row index of a block (in the block table) where the high scoring local 111 * alignment ends. 112 */ 113 protected int max_row; 114 115 /** 116 * The column index of a block (in the block table) where the high scoring local 117 * alignment ends. 118 */ 119 protected int max_col; 120 121 /** 122 * The type of the high scoring local alignment found. 123 */ 124 protected byte max_path_type; 125 126 /** 127 * If the high scoring local alignment ends in an E-path at a block B, this field 128 * contains the index of the entry in the input border of B that where the E-path 129 * starts. 130 */ 131 protected int max_source_index; 132 133 /** 134 * Creates and computes all information of an alignment block. This method works 135 * essentially in the same way as its global alignment counterpart. Its main job is to 136 * compute the DIST column for the block. It then request the 137 * <CODE>computeOutputBorder</CODE> method to compute the block's output border. It 138 * also computes all S, C and E-paths of this block. Finally, it checks if the C-path 139 * of this block is higher than the highest score found so far. 140 * 141 * @param factor1 factor of the first sequence 142 * @param factor2 factor of the second sequence 143 * @param row row index of the block in the block table 144 * @param col column index of the block in the block table 145 * @return the computed block 146 * @throws IncompatibleScoringSchemeException if the scoring scheme is not compatible 147 * with the sequences being aligned 148 */ 149 protected AlignmentBlock createBlock (Factor factor1, Factor factor2, int row, 150 int col) throws IncompatibleScoringSchemeException 151 { 152 LocalAlignmentBlock block, left_prefix, diag_prefix, top_prefix; 153 int size, lr, lc, max, ins_E, del_E; 154 int score_ins, score_sub, score_del, ins, del, sub; 155 156 lr = factor1.length(); 157 lc = factor2.length(); 158 size = lr + lc + 1; 159 160 block = new LocalAlignmentBlock (factor1, factor2, size); 161 162 // retrieve pointers to prefixes 163 left_prefix = (LocalAlignmentBlock) getLeftPrefix (block); 164 diag_prefix = (LocalAlignmentBlock) getDiagonalPrefix (block); 165 top_prefix = (LocalAlignmentBlock) getTopPrefix (block); 166 167 // compute scores 168 score_ins = scoreInsertion (factor2.getNewChar()); 169 score_sub = scoreSubstitution (factor1.getNewChar(), factor2.getNewChar()); 170 score_del = scoreDeletion (factor1.getNewChar()); 171 172 // compute block's data 173 for (int i = 0; i < size; i++) 174 { 175 ins = sub = del = ins_E = del_E = Integer.MIN_VALUE; 176 177 if (i < size - 1) 178 { 179 ins = left_prefix.dist_column[i] + score_ins; 180 ins_E = left_prefix.E_path_score[i]; 181 } 182 183 if ((i > 0) && (i < size - 1)) 184 { 185 sub = diag_prefix.dist_column[i - 1] + score_sub; 186 } 187 188 if (i > 0) 189 { 190 del = top_prefix.dist_column[i - 1] + score_del; 191 del_E = top_prefix.E_path_score[i - 1]; 192 } 193 194 block.dist_column[i] = max = max (ins, sub, del); 195 196 if (max == ins) 197 block.direction[i] = LEFT_DIRECTION; 198 else if (max == sub) 199 block.direction[i] = DIAGONAL_DIRECTION; 200 else 201 block.direction[i] = TOP_DIRECTION; 202 203 block.E_path_score[i] = max = max (ins_E, block.dist_column[i], del_E); 204 205 if (max == ins_E) 206 { 207 block.E_path_ancestor[i] = left_prefix.E_path_ancestor[i]; 208 block.E_path_ancestor_index[i] = left_prefix.E_path_ancestor_index[i]; 209 } 210 else if (max == block.dist_column[i]) 211 { 212 block.E_path_ancestor[i] = block; 213 block.E_path_ancestor_index[i] = i; 214 } 215 else 216 { 217 block.E_path_ancestor[i] = top_prefix.E_path_ancestor[i - 1]; 218 block.E_path_ancestor_index[i] = top_prefix.E_path_ancestor_index[i - 1]; 219 } 220 221 if (i < lc) 222 { 223 block.S_path_score[i] = left_prefix.S_path_score[i]; 224 } 225 else if (i == lc) 226 { 227 ins = left_prefix.S_path_score[i-1] + score_ins; 228 sub = diag_prefix.S_path_score[i-1] + score_sub; 229 del = top_prefix.S_path_score[i] + score_del; 230 231 block.S_path_score[i] = max = max (0, ins, sub, del); 232 233 if (max == ins) 234 block.S_direction = LEFT_DIRECTION; 235 else if (max == sub) 236 block.S_direction = DIAGONAL_DIRECTION; 237 else if (max == del) 238 block.S_direction = TOP_DIRECTION; 239 else 240 block.S_direction = STOP_DIRECTION; 241 } 242 else 243 { 244 block.S_path_score[i] = top_prefix.S_path_score[i - 1]; 245 } 246 } 247 248 computeOutputBorder (block, row, col, size, lc, lr); 249 250 ins = left_prefix.C; 251 del = top_prefix.C; 252 block.C = max = max (ins, block.S_path_score[lc], del); 253 254 if (block.C > max_score) 255 { 256 // assert block.C == block.S_path_score[lc]; => always true 257 max_score = block.C; 258 max_row = row; 259 max_col = col; 260 max_path_type = TYPE_C_PATH; 261 } 262 263 return block; 264 } 265 266 /** 267 * Creates the root block. This is a special case of the <CODE>createBlock</CODE> 268 * method. No information is actually computed. 269 * 270 * @param factor1 factor of the first sequence 271 * @param factor2 factor of the second sequence 272 * @return the root block 273 */ 274 protected AlignmentBlock createRootBlock (Factor factor1, Factor factor2) 275 { 276 // resets the variables that keep track 277 // of the high scoring alignment 278 max_row = max_col = max_score = 0; 279 max_path_type = TYPE_C_PATH; 280 281 return new LocalAlignmentBlock (factor1, factor2); 282 } 283 284 /** 285 * Creates and computes all information of an alignment block of the first column of 286 * the block table. This is a special case of the <CODE>createBlock</CODE> method. 287 * 288 * @param factor1 factor of the first sequence 289 * @param factor2 factor of the second sequence 290 * @param col column index of the block in the block table 291 * @return the computed block 292 * @throws IncompatibleScoringSchemeException if the scoring scheme is not compatible 293 * with the sequences being aligned 294 * @see #createBlock createBlock 295 */ 296 protected AlignmentBlock createFirstRowBlock (Factor factor1, Factor factor2, int col) 297 throws IncompatibleScoringSchemeException 298 { 299 LocalAlignmentBlock block, left_prefix; 300 int size, lr, lc, score_ins; 301 302 lr = 0; // factor1.length(); 303 lc = factor2.length(); 304 size = lr + lc + 1; 305 306 block = new LocalAlignmentBlock (factor1, factor2, size); 307 308 // retrieve a pointer to left prefix 309 left_prefix = (LocalAlignmentBlock) getLeftPrefix (block); 310 311 // compute insertion's score 312 score_ins = scoreInsertion (factor2.getNewChar()); 313 314 // compute block's data 315 for (int i = 0; i < lc; i++) 316 { 317 block.dist_column[i] = left_prefix.dist_column[i] + score_ins; 318 block.direction[i] = LEFT_DIRECTION; 319 block.S_path_score[i] = left_prefix.S_path_score[i]; 320 321 block.E_path_score[i] = left_prefix.E_path_score[i]; 322 block.E_path_ancestor[i] = left_prefix.E_path_ancestor[i]; 323 block.E_path_ancestor_index[i] = left_prefix.E_path_ancestor_index[i]; 324 if (block.dist_column[i] > block.E_path_score[i]) 325 { 326 block.E_path_score[i] = block.dist_column[i]; 327 block.E_path_ancestor[i] = block; 328 block.E_path_ancestor_index[i] = i; 329 } 330 } 331 332 // last position 333 block.E_path_score[lc] = block.dist_column[lc] = 0; 334 block.direction[lc] = STOP_DIRECTION; 335 336 block.E_path_ancestor[lc] = block; 337 block.E_path_ancestor_index[lc] = lc; 338 339 block.S_direction = LEFT_DIRECTION; 340 block.S_path_score[lc] = left_prefix.S_path_score[lc - 1] + score_ins; 341 if (block.S_path_score[lc] <= 0) 342 { 343 block.S_path_score[lc] = 0; 344 block.S_direction = STOP_DIRECTION; 345 } 346 347 computeOutputBorder (block, 0, col, size, lc, lr); 348 349 block.C = max (left_prefix.C, block.S_path_score[lc]); 350 351 if (block.C > max_score) 352 { 353 max_score = block.C; 354 max_row = 0; 355 max_col = col; 356 max_path_type = TYPE_C_PATH; 357 } 358 359 return block; 360 } 361 362 /** 363 * Creates and computes all information of an alignment block of the first column of 364 * the block table. This is a special case of the <CODE>createBlock</CODE> method. 365 * 366 * @param factor1 factor of the first sequence 367 * @param factor2 factor of the second sequence 368 * @param row row index of the block in the block table 369 * @return the computed block 370 * @throws IncompatibleScoringSchemeException if the scoring scheme is not compatible 371 * with the sequences being aligned 372 * @see #createBlock createBlock 373 */ 374 protected AlignmentBlock createFirstColumnBlock (Factor factor1, Factor factor2, 375 int row) throws IncompatibleScoringSchemeException 376 { 377 LocalAlignmentBlock block, top_prefix; 378 int size, lr, lc, score_del; 379 380 lr = factor1.length(); 381 lc = 0; // factor2.length(); 382 size = lr + lc + 1; 383 384 block = new LocalAlignmentBlock (factor1, factor2, size); 385 386 // retrieve a pointer to top prefix 387 top_prefix = (LocalAlignmentBlock) getTopPrefix (block); 388 389 // compute deletion's score 390 score_del = scoreDeletion (factor1.getNewChar()); 391 392 // first position 393 block.E_path_score[0] = block.dist_column[0] = 0; 394 block.direction[0] = STOP_DIRECTION; 395 396 block.E_path_ancestor[0] = block; 397 block.E_path_ancestor_index[0] = 0; 398 399 block.S_direction = TOP_DIRECTION; 400 block.S_path_score[0] = top_prefix.S_path_score[0] + score_del; 401 if (block.S_path_score[0] <= 0) 402 { 403 block.S_path_score[0] = 0; 404 block.S_direction = STOP_DIRECTION; 405 } 406 407 // compute block's data 408 for (int i = 1; i < size; i++) 409 { 410 block.dist_column[i] = top_prefix.dist_column[i - 1] + score_del; 411 block.direction[i] = TOP_DIRECTION; 412 block.S_path_score[i] = top_prefix.S_path_score[i - 1]; 413 414 block.E_path_score[i] = top_prefix.E_path_score[i - 1]; 415 block.E_path_ancestor[i] = top_prefix.E_path_ancestor[i - 1]; 416 block.E_path_ancestor_index[i] = top_prefix.E_path_ancestor_index[i - 1]; 417 if (block.dist_column[i] > block.E_path_score[i]) 418 { 419 block.E_path_score[i] = block.dist_column[i]; 420 block.E_path_ancestor[i] = block; 421 block.E_path_ancestor_index[i] = i; 422 } 423 } 424 425 computeOutputBorder (block, row, 0, size, lc, lr); 426 427 block.C = max (block.S_path_score[lc], top_prefix.C); 428 429 if (block.C > max_score) 430 { 431 max_score = block.C; 432 max_row = row; 433 max_col = 0; 434 max_path_type = TYPE_C_PATH; 435 } 436 437 return block; 438 } 439 440 /** 441 * Computes the output border of a block. This method works essentially in the same 442 * way as its global alignment counterpart: 443 * 444 * <LU> 445 * <LI>Retrieve the block's input border; 446 * <LI>Retrieve the block's complete DIST matrix; 447 * <LI>Create an interface to the {@linkplain OutMatrix OUT} matrix from the input 448 * border and DIST matrix; 449 * <LI>Use {@linkplain Smawk SMAWK} to compute all column maxima of the OUT matrix 450 * (SMAWK finds the index of the row that contains the maximum value of a column); 451 * <LI>Assemble the output border by extracting the maximum values of each column of 452 * the OUT matrix using the information obtained in the previous step. 453 * </LU> 454 * 455 * <P>However, it also check if there is a better path starting inside the block (an 456 * S path) and oupdate the output border accordingly. It also checks if this block has 457 * any path of score higher than the maximum score found so far. 458 * 459 * @param block the block for which the output border is to be computed 460 * @param row row index of the block in the block table 461 * @param col column index of the block in the block table 462 * @param dim dimension of the output border 463 * @param lc number of columns of the block 464 * @param lr number of row of the block 465 */ 466 protected void computeOutputBorder (LocalAlignmentBlock block, int row, int col, int 467 dim, int lc, int lr) 468 { 469 int[] input = assembleInputBorder (dim, row, col, lr); 470 471 int[][] dist = assembleDistMatrix (block, dim, row, col, lc); // (AlignmentBlock) 472 473 // build an interface to the OUT matrix 474 out_matrix.setData (dist, input, dim, lc); 475 476 // compute source_path using SMAWK 477 smawk.computeColumnMaxima(out_matrix, block.source_path); 478 479 // update output border 480 for (int i = 0; i < dim; i++) 481 { 482 block.path_type[i] = TYPE_CROSSING_PATH; 483 block.output_border[i] = out_matrix.valueAt(block.source_path[i], i); 484 485 // check if there is a better path starting inside the block 486 // (if there is a path of equal score, preference is given 487 // to the S-path because it ends sooner) 488 if (block.S_path_score[i] >= block.output_border[i]) 489 { 490 block.output_border[i] = block.S_path_score[i]; 491 block.path_type[i] = TYPE_S_PATH; 492 } 493 494 // check if this block contains a score higher 495 // than the best path found so far 496 if (input[i] + block.E_path_score[i] > max_score) 497 { 498 max_score = input[i] + block.E_path_score[i]; 499 max_row = row; 500 max_col = col; 501 max_source_index = i; 502 max_path_type = TYPE_E_PATH; 503 } 504 } 505 } 506 507 /** 508 * Builds an optimal local alignment between the loaded sequences after the block 509 * table has been computed by tracing a path back in the block table. 510 * 511 * @return an optimal global alignment 512 * @throws IncompatibleScoringSchemeException If the scoring scheme is not compatible 513 * with the loaded sequences. 514 * @see CrochemoreLandauZivUkelson#traverseBlock 515 */ 516 protected PairwiseAlignment buildOptimalAlignment () 517 throws IncompatibleScoringSchemeException 518 { 519 LocalAlignmentBlock block; 520 StringBuffer gapped_seq1, tag_line, gapped_seq2; 521 522 gapped_seq1 = new StringBuffer(); 523 tag_line = new StringBuffer(); 524 gapped_seq2 = new StringBuffer(); 525 526 block = (LocalAlignmentBlock) block_table[max_row][max_col]; 527 528 if (max_path_type == TYPE_C_PATH) 529 { 530 // a C-path is essentially an S-path 531 traverseS_Path (block, gapped_seq1, tag_line, gapped_seq2); 532 } 533 else 534 { 535 traverseBlockCrossingPath (block, gapped_seq1, tag_line, gapped_seq2); 536 } 537 538 return new PairwiseAlignment (gapped_seq1.toString(), tag_line.toString(), 539 gapped_seq2.toString(), locateScore()); 540 } 541 542 /** 543 * Traverses a series of block crossing paths to retrieve an optimal alignment. A 544 * block-crossing path consists of a (possibly empty) <B>S-path</B> (a path that 545 * starts inside a block and ends in its output border), followed by any number of 546 * paths that cross a block from its input border to its output border, and ending in 547 * an <B>E-path</B> (a path that starts in the input border of a block and ends inside 548 * the block). 549 * 550 * @param block the block to be traversed 551 * @param gapped_seq1 the StringBuffer to where the gapped sequence 1 is written to 552 * @param tag_line the StringBuffer to where the tag_line is written to 553 * @param gapped_seq2 the StringBuffer to where the gapped sequence 2 is written to 554 * @throws IncompatibleScoringSchemeException If the scoring scheme is not compatible 555 * with the loaded sequences. 556 */ 557 protected void traverseBlockCrossingPath (LocalAlignmentBlock block, 558 StringBuffer gapped_seq1, StringBuffer tag_line, StringBuffer gapped_seq2) 559 throws IncompatibleScoringSchemeException 560 { 561 LocalAlignmentBlock ancestor; 562 int source, dest, ancestor_source; 563 int row, col; 564 565 row = max_row; 566 col = max_col; 567 568 // recover the E-path 569 source = max_source_index; 570 ancestor = block.E_path_ancestor[source]; 571 ancestor_source = block.E_path_ancestor_index[source]; 572 traverseBlock (ancestor, ancestor_source, gapped_seq1, tag_line, gapped_seq2); 573 574 // now recover crossing paths 575 while (true) 576 { 577 if (row == 0) 578 { 579 col = col - 1; 580 dest = block_table[row][col].factor2.length(); 581 } 582 else if (col == 0) 583 { 584 row = row - 1; 585 dest = 0; 586 } 587 else 588 { 589 if (source < block.factor1.length()) 590 { 591 col = col - 1; 592 dest = block_table[row][col].factor2.length() + source; 593 } 594 else if (source == block.factor1.length()) 595 { 596 row = row - 1; col = col - 1; 597 dest = block_table[row][col].factor2.length(); 598 } 599 else 600 { 601 row = row - 1; 602 dest = source - block.factor1.length(); 603 } 604 } 605 606 // check if has reached the root block 607 if (!(row > 0 || col > 0)) break; 608 609 block = (LocalAlignmentBlock) block_table[row][col]; 610 611 if (block.path_type[dest] == TYPE_S_PATH) 612 { 613 // last part, an S-path, and we're done 614 ancestor = (LocalAlignmentBlock) block.ancestor[dest]; 615 traverseS_Path (ancestor, gapped_seq1, tag_line, gapped_seq2); 616 break; 617 } 618 619 source = block.source_path[dest]; 620 ancestor = (LocalAlignmentBlock) block.ancestor[dest]; 621 ancestor_source = source; 622 623 if (dest > block.factor2.length()) 624 ancestor_source -= (block.factor1.length() - ancestor.factor1.length()); 625 626 traverseBlock (ancestor, ancestor_source, gapped_seq1, tag_line, gapped_seq2); 627 } 628 } 629 630 /** 631 * Traverses an S-path of a block to retrieve a part of an optimal alignment from the 632 * new vertex of a block to entry in its input border. This method is essentially 633 * similar to the <CODE>traverseBlock</CODE>. The only difference is that it uses 634 * the information of the <CODE>S_direction field</CODE> of the 635 * <CODE>LocalAlignmentBlock</CODE> class. 636 * 637 * @param block the block to be traversed 638 * @param gapped_seq1 the StringBuffer to where the gapped sequence 1 is written to 639 * @param tag_line the StringBuffer to where the tag_line is written to 640 * @param gapped_seq2 the StringBuffer to where the gapped sequence 2 is written to 641 * @throws IncompatibleScoringSchemeException If the scoring scheme is not compatible 642 * with the loaded sequences. 643 */ 644 protected void traverseS_Path (LocalAlignmentBlock block, StringBuffer gapped_seq1, 645 StringBuffer tag_line, StringBuffer gapped_seq2) 646 throws IncompatibleScoringSchemeException 647 { 648 char char1, char2; 649 650 while (block.S_direction != STOP_DIRECTION) 651 { 652 char1 = block.factor1.getNewChar(); 653 char2 = block.factor2.getNewChar(); 654 655 switch (block.S_direction) 656 { 657 case LEFT_DIRECTION: 658 gapped_seq1.insert (0, GAP_CHARACTER); 659 tag_line.insert (0, GAP_TAG); 660 gapped_seq2.insert (0, char2); 661 662 block = (LocalAlignmentBlock) getLeftPrefix (block); 663 break; 664 665 case DIAGONAL_DIRECTION: 666 gapped_seq1.insert (0, char1); 667 if (char1 == char2) 668 if (useMatchTag()) 669 tag_line.insert (0, MATCH_TAG); 670 else 671 tag_line.insert (0, char1); 672 else if (scoreSubstitution(char1, char2) > 0) 673 tag_line.insert (0, APPROXIMATE_MATCH_TAG); 674 else 675 tag_line.insert (0, MISMATCH_TAG); 676 gapped_seq2.insert(0, char2); 677 678 block = (LocalAlignmentBlock) getDiagonalPrefix (block); 679 break; 680 681 case TOP_DIRECTION: 682 gapped_seq1.insert (0, char1); 683 tag_line.insert (0, GAP_TAG); 684 gapped_seq2.insert (0, GAP_CHARACTER); 685 686 block = (LocalAlignmentBlock) getTopPrefix (block); 687 break; 688 } 689 } 690 } 691 692 /** 693 * Returns the score of the high scoring local alignment in the block table. 694 * 695 * @return the score of the highest scoring local alignment 696 */ 697 protected int locateScore () 698 { 699 return max_score; 700 } 701 }neobio-0.0.20030929/doc/src-html/neobio/alignment/OutMatrix.html 0000644 0002656 0002032 00000040572 07727746662 023267 0 ustar tillea admin
001 /* 002 * OutMatrix.java 003 * 004 * Copyright 2003 Sergio Anibal de Carvalho Junior 005 * 006 * This file is part of NeoBio. 007 * 008 * NeoBio is free software; you can redistribute it and/or modify it under the terms of 009 * the GNU General Public License as published by the Free Software Foundation; either 010 * version 2 of the License, or (at your option) any later version. 011 * 012 * NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 013 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 014 * PURPOSE. See the GNU General Public License for more details. 015 * 016 * You should have received a copy of the GNU General Public License along with NeoBio; 017 * if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, 018 * Boston, MA 02111-1307, USA. 019 * 020 * Proper attribution of the author as the source of the software would be appreciated. 021 * 022 * Sergio Anibal de Carvalho Junior mailto:sergioanibaljr@users.sourceforge.net 023 * Department of Computer Science http://www.dcs.kcl.ac.uk 024 * King's College London, UK http://www.kcl.ac.uk 025 * 026 * Please visit http://neobio.sourceforge.net 027 * 028 * This project was supervised by Professor Maxime Crochemore. 029 * 030 */ 031 032 package neobio.alignment; 033 034 /** 035 * Implements an interface to the OUT matrix of a block. This class is used by the 036 * {@linkplain CrochemoreLandauZivUkelson} and subclasses to enconde the OUT matrix 037 * from the input border and DIST matrix of an {@linkplain AlignmentBlock}. 038 * 039 * <P>The OUT matrix defined as <CODE>OUT[i,j] = I[i] + DIST[i,j]</CODE> where I is the 040 * input border array and DIST is the DIST matrix.</P> 041 * 042 * <P>The output border of a block is computed from the OUT matrix by taking the maximum 043 * value of each column. Note that this class <B>does not compute the OUT matrix</B>, it 044 * just stores the necessary information to retrieve a value at any position of the 045 * matrix.</P> 046 * 047 * <P>It implements the Matrix interface so that the SMAWK algorithm can be used to 048 * compute its column maxima.</P> 049 * 050 * <P>For more information on how this class is used, please refer to the specification 051 * of the <CODE>CrochemoreLandauZivUkelson</CODE> and its subclasses. 052 * 053 * @author Sergio A. de Carvalho Jr. 054 * @see CrochemoreLandauZivUkelson 055 * @see CrochemoreLandauZivUkelsonGlobalAlignment 056 * @see CrochemoreLandauZivUkelsonLocalAlignment 057 * @see AlignmentBlock 058 * @see Smawk 059 */ 060 public class OutMatrix implements Matrix 061 { 062 /** 063 * The length of the longest sequence (number of characters) being aligned. It needs 064 * to be set only once per alignment. 065 */ 066 protected int max_length; 067 068 /** 069 * The maximum absolute score that the current scoring scheme can return. It needs 070 * to be set only once per alignment. 071 */ 072 protected int max_score; 073 074 /** 075 * The DIST matrix of a block. 076 */ 077 protected int[][] dist; 078 079 /** 080 * The input border of a block. 081 */ 082 protected int[] input_border; 083 084 /** 085 * The dimension of the OUT matrix. 086 */ 087 protected int dim; 088 089 /** 090 * The number of columns of the block. 091 */ 092 protected int lc; 093 094 /** 095 * Initialised this OUT matrix interface. This method needs to be executed only once 096 * per alignment. 097 * 098 * @param max_length the length of the longest sequence (number of characters) being 099 * aligned 100 * @param max_score the maximum absolute score that the current scoring scheme can 101 * return 102 */ 103 public void init (int max_length, int max_score) 104 { 105 this.max_length = max_length; 106 this.max_score = max_score; 107 } 108 109 /** 110 * Sets this interface's data to represent an OUT matrix for a block. This method 111 * is typically executed once for each block being aligned. 112 * 113 * @param dist the DIST matrix 114 * @param input_border the input border 115 * @param dim the dimension of the OUT matrix 116 * @param lc the number of columns of the block 117 */ 118 public void setData (int[][] dist, int[] input_border, int dim, int lc) 119 { 120 this.dist = dist; 121 this.input_border = input_border; 122 this.dim = dim; 123 this.lc = lc; 124 } 125 126 /** 127 * Returns the value at a given position of the matrix. In general it returns the 128 * value of <CODE>DIST[col][row] + input_border[row]</CODE>. However, special cases 129 * occur for its upper right and lower left triangular parts. 130 * 131 * @param row row index 132 * @param col column index 133 * @return the value at row <CODE>row</CODE>, column <CODE>col</CODE> of this OUT 134 * matrix 135 */ 136 public int valueAt (int row, int col) 137 { 138 // The DIST matrix is indexed by [column][row] 139 140 if (col < lc) 141 { 142 if (row < dim - (lc - col)) 143 return dist[col][row] + input_border[row]; 144 else 145 // lower left triangle entries 146 return - (max_length + row + 1) * max_score; 147 } 148 else if (col == lc) 149 { 150 return dist[col][row] + input_border[row]; 151 } 152 else 153 { 154 if (row < (col - lc)) 155 // upper right triangle entries 156 return Integer.MIN_VALUE + row; 157 else 158 return dist[col][row - (col - lc)] + input_border[row]; 159 } 160 } 161 162 /** 163 * Returns the number of rows of this OUT matrix. 164 * 165 * @return the number of rows of this OUT matrix 166 */ 167 public int numRows () 168 { 169 return dim; 170 } 171 172 /** 173 * Returns the number of columns of this OUT matrix. 174 * 175 * @return the number of columns of this OUT matrix 176 */ 177 public int numColumns () 178 { 179 return dim; 180 } 181 }neobio-0.0.20030929/doc/src-html/neobio/alignment/FactorSequence.html 0000644 0002656 0002032 00000067415 07727746664 024251 0 ustar tillea admin
001 /* 002 * FactorSequence.java 003 * 004 * Copyright 2003 Sergio Anibal de Carvalho Junior 005 * 006 * This file is part of NeoBio. 007 * 008 * NeoBio is free software; you can redistribute it and/or modify it under the terms of 009 * the GNU General Public License as published by the Free Software Foundation; either 010 * version 2 of the License, or (at your option) any later version. 011 * 012 * NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 013 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 014 * PURPOSE. See the GNU General Public License for more details. 015 * 016 * You should have received a copy of the GNU General Public License along with NeoBio; 017 * if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, 018 * Boston, MA 02111-1307, USA. 019 * 020 * Proper attribution of the author as the source of the software would be appreciated. 021 * 022 * Sergio Anibal de Carvalho Junior mailto:sergioanibaljr@users.sourceforge.net 023 * Department of Computer Science http://www.dcs.kcl.ac.uk 024 * King's College London, UK http://www.kcl.ac.uk 025 * 026 * Please visit http://neobio.sourceforge.net 027 * 028 * This project was supervised by Professor Maxime Crochemore. 029 * 030 */ 031 032 package neobio.alignment; 033 034 import java.io.Reader; 035 import java.io.BufferedReader; 036 import java.io.IOException; 037 038 /** 039 * This class builds a list of factors of a character sequence as induced by its 040 * Lempel-Ziv (LZ78) factorisation. Each factor is enconded as the longest factor 041 * previously seen plus one character. 042 * 043 * <P>The input can come from any source, provided it is encapsulated in a proper 044 * <CODE>Reader</CODE> instance. The stream is expected to be ready (i.e. the next 045 * <CODE>read</CODE> operation must return the first character of the sequence) and it is 046 * not closed when its end is reached, so the client is allowed to reset it and maybe use 047 * it for another purpose.</P> 048 * 049 * <P>Sequences can contain letters only although lines started with the 050 * <CODE>COMMENT_CHAR</CODE> character ('>') are regarded as comments and are completely 051 * skipped. White spaces (including tabs, line feeds and carriage returns) are also 052 * ignored throughout.</P> 053 * 054 * <P>This class uses a {@linkplain Trie} to keep track of a list of factors. Each node of 055 * the trie contains a {@linkplain Factor} of the text. As the sequence is read from the 056 * input, the trie is traversed as far as possible. When a leaf node is reached (which 057 * means that the longest prefix of the input has been found), two tasks are 058 * accomplished:</P> 059 * 060 * <UL> 061 * <LI>a new <CODE>Factor</CODE> is created with the character at the current position of 062 * the input and the leaf node's factor; 063 * <LI>a new node is added to the trie with the character at the current position of the 064 * input; 065 * </UL> 066 * 067 * <P>Each factor also receives a serial number according to the order they are found and 068 * a pointer to the next factor (in that order) for fast access. This pointer, together 069 * with the factor's ancestor pointer forms a doubly-linked list of factors. The original 070 * text can then be reconstructed simply by following the linked list and writing out its 071 * factors.</P> 072 * 073 * <P>As an example, the sequence <CODE>ACTAAACCGCATTAATAATAAAA</CODE> is parsed into the 074 * following 12 factors:</P> 075 * 076 * <CODE><BLOCKQUOTE><PRE> 077 * 0 ( , ) = empty 078 * 1 (0,A) = A 079 * 2 (0,C) = C 080 * 3 (0,T) = T 081 * 4 (1,A) = AA 082 * 5 (1,C) = AC 083 * 6 (2,G) = CG 084 * 7 (2,A) = CA 085 * 8 (3,T) = TT 086 * 9 (4,T) = AAT 087 * 10 (9,A) = AATA 088 * 11 (4,A) = AAA 089 * 090 * serial # (prefix, new char) = factor text 091 * </PRE></BLOCKQUOTE></CODE> 092 * 093 * <P>This class is used by {@linkplain CrochemoreLandauZivUkelson} algorithm to speed up 094 * the classic dynamic programming approach to sequence alignment.</P> 095 * 096 * @author Sergio A. de Carvalho Jr. 097 * @see Factor 098 * @see Trie 099 * @see CrochemoreLandauZivUkelson 100 */ 101 public class FactorSequence 102 { 103 /** 104 * The character used to start a comment line in a sequence file. When this character 105 * is found, the rest of the line is ignored. 106 */ 107 protected static final char COMMENT_CHAR = '>'; 108 109 /** 110 * A pointer to the root factor, the one that starts the list of factors. 111 */ 112 protected Factor root_factor; 113 114 /** 115 * The numbers of character represented by this sequence. 116 */ 117 protected int num_chars; 118 119 /** 120 * The numbers of factors generated by the LZ78 parsing of the sequence. 121 */ 122 protected int num_factors; 123 124 /** 125 * Creates a new instance of a <CODE>FactorSequence</CODE>, loading the sequence data 126 * from the <CODE>Reader</CODE> input stream. A doubly-linked list of factors is built 127 * according to its LZ78 factorisation. 128 * 129 * @param reader source of characters for this sequence 130 * @throws IOException if an I/O exception occurs when reading the input 131 * @throws InvalidSequenceException if the input does not contain a valid sequence 132 */ 133 public FactorSequence (Reader reader) 134 throws IOException, InvalidSequenceException 135 { 136 BufferedReader input = new BufferedReader(reader); 137 Trie root_node, current_node, new_node = null; 138 Factor current_factor, last_factor, new_factor; 139 int ch; 140 char c; 141 142 // create root factor and the root node of the trie 143 root_factor = new Factor (); 144 root_node = new Trie (root_factor); 145 num_factors = 1; 146 num_chars = 0; 147 148 current_node = root_node; 149 last_factor = root_factor; 150 151 // read characters from the input 152 while ((ch = input.read()) != -1) 153 { 154 c = (char) ch; 155 156 if (c == COMMENT_CHAR) 157 // it's a comment line: skip it! 158 input.readLine(); 159 160 // accept letters only 161 else if (Character.isLetter(c)) 162 { 163 num_chars++; 164 165 // walk down the trie as far as possible 166 new_node = current_node.spellDown(c); 167 168 if (new_node != null) 169 { 170 current_node = new_node; 171 } 172 else 173 { 174 // the longest factor of the input has been found, 175 // now create a new factor from the current node's factor 176 current_factor = (Factor) current_node.getData(); 177 new_factor = new Factor (current_factor, num_factors, c); 178 179 // add the new character to the trie as well 180 current_node.add (new_factor, c); 181 182 // set up a pointer from the last factor to the new one 183 last_factor.setNext (new_factor); 184 last_factor = new_factor; 185 186 // restart at the root of the trie 187 current_node = root_node; 188 189 num_factors++; 190 } 191 } 192 193 // anything else, except whitespaces, will throw an exception 194 else if (!Character.isWhitespace(c)) 195 throw new InvalidSequenceException 196 ("Sequences can contain letters only."); 197 } 198 199 // if new_node is not null, the last factor is actually 200 // not a new factor but a factor already created 201 if (new_node != null) 202 { 203 // no new node is created, just point the last_factor to an 204 // existing one that represents the last characters of the text 205 last_factor.setNext((Factor) new_node.getData()); 206 207 num_factors++; 208 } 209 210 // check if read anything useful! 211 if (num_factors <= 1) 212 throw new InvalidSequenceException ("Empty sequence."); 213 } 214 215 /** 216 * Returns the root factor, the one that starts the list of factors. 217 * 218 * @return root factor 219 */ 220 public Factor getRootFactor () 221 { 222 return root_factor; 223 } 224 225 /** 226 * Returns the number of factors produced by the LZ78 parsing of the text. 227 * 228 * @return number of factors 229 */ 230 public int numFactors() 231 { 232 return num_factors; 233 } 234 235 /** 236 * Returns the number of characters of the original sequence. 237 * 238 * @return number of characters of the original sequence 239 */ 240 public int numChars () 241 { 242 return num_chars; 243 } 244 245 /** 246 * Reconstructs the sequence from the list of factors induced by the LZ78 parsing of 247 * the text. 248 * 249 * @return the original sequence 250 */ 251 public String toString () 252 { 253 StringBuffer buf = new StringBuffer(); 254 Factor node; 255 256 node = root_factor.getNext(); 257 258 for (int i = 1; i < numFactors(); i++) 259 { 260 buf.append(node); 261 262 node = node.getNext(); 263 } 264 265 return buf.toString(); 266 } 267 268 /** 269 * Returns a string representation of the actual list of factors produced by the LZ78 270 * parsing of the text. Each factor is printed out in a separate line, in the order 271 * they appear in the text, with its serial number, its ancestor's serial number, its 272 * new character, length and a string representation of the factor itself. 273 * 274 * @return a string representation of the list of factors 275 */ 276 public String printFactors () 277 { 278 StringBuffer buf = new StringBuffer(); 279 Factor factor; 280 281 factor = root_factor.getNext(); 282 283 for (int i = 1; i < numFactors(); i++) 284 { 285 buf.append (factor.getSerialNumber() + "\t<"); 286 buf.append (factor.getAncestor().getSerialNumber() + " ,\t"); 287 buf.append (factor.getNewChar() + ">\t"); 288 buf.append (factor.length() + "\t" + factor + "\n"); 289 290 factor = factor.getNext(); 291 } 292 293 buf.append(numFactors() + " factors\n"); 294 295 return buf.toString(); 296 } 297 }neobio-0.0.20030929/doc/packages.html 0000644 0002656 0002032 00000001412 07727746666 016121 0 ustar tillea admin
Frame version
Non-frame version.
|
NeoBio API | ||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||
Hierarchy For All Packages
- Package Hierarchies:
- neobio.alignment, neobio.gui, neobio.textui
Class Hierarchy
- class java.lang.Object
- class neobio.alignment.AlignmentBlock
- class neobio.alignment.LocalAlignmentBlock
- class neobio.alignment.CharSequence
- class java.awt.Component (implements java.awt.image.ImageObserver, java.awt.MenuContainer, java.io.Serializable)
- class java.awt.Container
- class javax.swing.JComponent (implements java.io.Serializable)
- class javax.swing.JInternalFrame (implements javax.accessibility.Accessible, javax.swing.RootPaneContainer, javax.swing.WindowConstants)
- class neobio.gui.PairwiseAlignmentFrame
- class javax.swing.JInternalFrame (implements javax.accessibility.Accessible, javax.swing.RootPaneContainer, javax.swing.WindowConstants)
- class java.awt.Window (implements javax.accessibility.Accessible)
- class java.awt.Dialog
- class javax.swing.JDialog (implements javax.accessibility.Accessible, javax.swing.RootPaneContainer, javax.swing.WindowConstants)
- class neobio.gui.AboutDialog
- class javax.swing.JDialog (implements javax.accessibility.Accessible, javax.swing.RootPaneContainer, javax.swing.WindowConstants)
- class java.awt.Frame (implements java.awt.MenuContainer)
- class javax.swing.JFrame (implements javax.accessibility.Accessible, javax.swing.RootPaneContainer, javax.swing.WindowConstants)
- class neobio.gui.NeoBio
- class javax.swing.JFrame (implements javax.accessibility.Accessible, javax.swing.RootPaneContainer, javax.swing.WindowConstants)
- class java.awt.Dialog
- class javax.swing.JComponent (implements java.io.Serializable)
- class java.awt.Container
- class neobio.alignment.Factor
- class neobio.alignment.FactorSequence
- class neobio.textui.NeoBio
- class neobio.alignment.OutMatrix (implements neobio.alignment.Matrix)
- class neobio.alignment.PairwiseAlignment (implements java.io.Serializable)
- class neobio.alignment.PairwiseAlignmentAlgorithm
- class neobio.alignment.CrochemoreLandauZivUkelson
- class neobio.alignment.CrochemoreLandauZivUkelsonGlobalAlignment
- class neobio.alignment.CrochemoreLandauZivUkelsonLocalAlignment
- class neobio.alignment.NeedlemanWunsch
- class neobio.alignment.SmithWaterman
- class neobio.alignment.CrochemoreLandauZivUkelson
- class neobio.textui.RandomFactorSequenceGenerator
- class neobio.textui.RandomSequenceGenerator
- class neobio.alignment.ScoringScheme
- class neobio.alignment.BasicScoringScheme
- class neobio.alignment.ScoringMatrix
- class neobio.alignment.Smawk
- class java.lang.Throwable (implements java.io.Serializable)
- class java.lang.Exception
- class neobio.alignment.IncompatibleScoringSchemeException
- class neobio.alignment.InvalidScoringMatrixException
- class neobio.alignment.InvalidSequenceException
- class java.lang.Exception
- class neobio.alignment.Trie
- class neobio.alignment.AlignmentBlock
Interface Hierarchy
- interface neobio.alignment.Matrix
|
|
||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||
NeoBio is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. NeoBio is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with NeoBio; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
neobio-0.0.20030929/doc/stylesheet.css 0000644 0002656 0002032 00000002460 07727746676 016365 0 ustar tillea admin /* Javadoc style sheet */ /* Define colors, fonts and other style attributes here to override the defaults */ /* Page background color */ body { background-color: #FFFFFF } /* Table colors */ .TableHeadingColor { background: #CCCCFF } /* Dark mauve */ .TableSubHeadingColor { background: #EEEEFF } /* Light mauve */ .TableRowColor { background: #FFFFFF } /* White */ /* Font used in left-hand frame lists */ .FrameTitleFont { font-size: 10pts; font-family: Helvetica, Arial, san-serif } .FrameHeadingFont { font-size: 10pts; font-family: Helvetica, Arial, san-serif } .FrameItemFont { font-size: 10pts; font-family: Helvetica, Arial, san-serif } /* Example of smaller, sans-serif font in frames */ /* .FrameItemFont { font-size: 10pt; font-family: Helvetica, Arial, sans-serif } */ /* Navigation bar fonts and colors */ .NavBarCell1 { background-color:#EEEEFF;}/* Light mauve */ .NavBarCell1Rev { background-color:#00008B;}/* Dark Blue */ .NavBarFont1 { font-family: Arial, Helvetica, sans-serif; color:#000000;} .NavBarFont1Rev { font-family: Arial, Helvetica, sans-serif; color:#FFFFFF;} .NavBarCell2 { font-family: Arial, Helvetica, sans-serif; background-color:#FFFFFF;} .NavBarCell3 { font-family: Arial, Helvetica, sans-serif; background-color:#FFFFFF;}