modele
Class OtherAlgorithmsStefan

java.lang.Object
  modele.OtherAlgorithmsStefan

public class OtherAlgorithmsStefan
extends java.lang.Object

This class to concentrate most part of algorithms and computing, as Stefan Eneglen implement them. Some conversion to new model and taken considerations of how works Stefan's implementation : ADN1cible are unaligned sequences, ADN1test are aligned sequences... Vector's have been removed, import of ADN1test and Matrice_ALN have been kept because problem of conversion have been identified on Matrice_ALN, Case, Alignement. all depends on first Matrice_ALN.
Conversion tested and work well as use in Black Box.
Better understanding after questions and answer with him.
Parameters in instance to permit MultiThreads : differents instances and computing.
Aim of this class is to have algorithms' implementation in the same place and not in modelization (but justification of being in these classes could be considered as "it is method of using instances of these classes"...).
Just use the constructor and the launch procedure. After that, use getResults() or getResultsHTML().

Since:

August 28, 2008, September 3, 2008

Version:

September 4, 2008

Author:

Gabriel Chandesris (2008), Stefan Engelen (2006)

See Also:

Algorithms, OtherAlgoStefanConverter, origincomment, AloneProcessus, OriginAlgorithmsStefan.calcul_Resultat(ADN1cible, ADN1test[], int, boolean, boolean), OriginAlgorithmsStefan.recherche_Palindrome(ADN1cible, int, int, int, ADN1test[], int, int, boolean, int), OriginAlgorithmsStefan.diviser_regner(Palindrome1cible[], ADN1cible, ADN1test[], int, int, int, int, boolean, int), OriginAlgorithmsStefan.recherche_Pseudonoeud(ADN1cible, Base[], ADN1test[], boolean, int, int), OriginAlgorithmsStefan.traitement_Incompatibilite(Palindrome1cible[], boolean, double, int, int), OriginAlgorithmsStefan.incompatibilite_plusieurs_choix(Vector, int, int, int, double, boolean, int), OriginAlgorithmsStefan.incompatibilite_un_choix(Palindrome1cible[], int, int), OriginAlgorithmsStefan.resultat_commun(Vector), OriginAlgorithmsStefan.verifier_Conservation_Alignement(ADN1cible, Palindrome1cible, Palindrome1test, double, ADN1test[]), OriginAlgorithmsStefan.verifier_Conservation_Commune(ADN1cible, Palindrome1cible, Palindrome1test, double, double, int, ADN1test[]), calcul_Resultat(Sequence, Sequence[], int, boolean, boolean), recherche_Palindrome(Sequence, int, int, int, Sequence[], int, int, boolean, int), diviser_regner(Palindrome[], Sequence, Sequence[], int, int, int, int, boolean, int), recherche_Pseudonoeud(Sequence, Base[], Sequence[], boolean, int, int), traitement_Incompatibilite(Palindrome[], boolean, double, int, int), incompatibilite_plusieurs_choix(PalindromeListeListe, int, int, int, double, boolean, int), incompatibilite_un_choix(Palindrome[], int, int), resultat_commun(PalindromeListeListe), verifier_Conservation_Alignement(Sequence, Palindrome, Palindrome, double, Sequence[]), verifier_Conservation_Commune(Sequence, Palindrome, Palindrome, double, double, int, Sequence[]), AlgorithmsStefan.calcul_Resultat(Sequence, Sequence[], int, boolean, boolean), AlgorithmsStefan.recherche_Palindrome(Sequence, int, int, int, Sequence[], int, int, boolean, int), AlgorithmsStefan.diviser_regner(Palindrome[], Sequence, Sequence[], int, int, int, int, boolean, int), AlgorithmsStefan.recherche_Pseudonoeud(Sequence, Base[], Sequence[], boolean, int, int), AlgorithmsStefan.traitement_Incompatibilite(Palindrome[], boolean, double, int, int), AlgorithmsStefan.incompatibilite_plusieurs_choix(PalindromeListeListe, int, int, int, double, boolean, int), AlgorithmsStefan.incompatibilite_un_choix(Palindrome[], int, int), AlgorithmsStefan.resultat_commun(PalindromeListeListe), AlgorithmsStefan.verifier_Conservation_Alignement(Sequence, Palindrome, Palindrome, double, Sequence[]), AlgorithmsStefan.verifier_Conservation_Commune(Sequence, Palindrome, Palindrome, double, double, int, Sequence[])

Field Summary

static int	ALIGNEMENTHELICE "Global attributes of work" Helix alignment is 3.
static int	ARN_MESSAGER "Global attributes of work" Messenger RNA is 2.
static int	ARN_STRUCTURAL "Global attributes of work" Structural RNA is 1.
private java.lang.String	bracketFile To get the result brackets File.
private boolean	chercher_pk "Global attribute with signification.
private int	decalage "Global attribute with signification.
private double	incertitude "Global attribute with signification.
static int	LONG_MUT "Global attributes of work" Mutation length is 2.
private boolean	more_predictions Searching much structures or not
private int	nb_prediction_max "Global attribute with signification.
static int	PROFILHELICE "Global attributes of work" Helix profile is 2.
private int	pseudonoeud "Global attributes of work" Current complexity of searching pseudoknots.
private java.lang.String	results To get the results of current computing (plain text).
private java.lang.String	resultsHTML To get the results of current computing (HTML to include).
private java.lang.String	rnavizFile To get the result RnaViz File.
static int	STRUCTURECOMMUNE "Global attributes of work" Common structure is 1.
private Sequence[]	tableauInitial "Global attribute with signification.
private ArbreExec	tableauPalindrome "Global attribute with signification.
private int	taille_boucle_min "Global attribute with signification.
private int	taille_pal_min "Global attribute with signification.
static int	TAUX_MUT "Global attributes of work" Mutation rate is 1.
private boolean	trouvePseudonoeud "Global attributes of work" Have pseudoknots been found in current step...
private int	typeARN "Global attribute with signification.
private int	typeCritere "Global attribute with signification.
private int	typeRecherche "Global attribute with signification.

Constructor Summary

OtherAlgorithmsStefan()
Default constructor.

OtherAlgorithmsStefan(int maximumPredictions, boolean morePredictions, boolean searchingPseudoknots)
Constructor with given maximal number of structures, if searching much structures and searching pseudoknots.

Method Summary

private void	calcul_Resultat(Sequence target, Sequence[] tableauSequences, int typeRecherche, boolean plusieurs_resultats, boolean chercher_pk) MAIN COMPUTING RESULTS "This method to launch search and compute all wanted results"
void	computing(SequenceListe[] tabsadn, Sequence target, boolean morePrediction, boolean searchPseudoknots) Computing the main algorithm made by Stefan Engelen.
private void	diviser_regner(Palindrome[] tabPal, Sequence target, Sequence[] tableauSequences, int debut, int fin, int erreur, int etape, boolean plusieurs_resultats, int nb_prediction) COMPATIBLE PALINDROME SEARCH Divide and Conquer procedure...
java.lang.String	getBracketFile()
int	getDecalage()
double	getIncertitude()
int	getNb_prediction_max()
Palindrome	getPalindrome(int pos_struct, int pos_pal) To get a specific palindrome in a specific structure.
int	getPseudonoeud()
PalindromeListeListe	getRecordingStructures(Sequence target) To get the recording structure in a good conversion format.
java.lang.String	getResults()
java.lang.String	getResultsHTML()
java.lang.String	getRnavizFile()
Palindrome[]	getStructure(int pos) To get a specific structure.
PalindromeListeListe	getStructures() To get structures from algorithm tree.
Sequence[]	getTableauInitial()
ArbreExec	getTableauPalindrome()
int	getTaille_boucle_min()
int	getTaille_pal_min()
int	getTypeARN()
int	getTypeCritere()
int	getTypeRecherche()
private static void	incompatibilite_plusieurs_choix(PalindromeListeListe listeTabPal, int pos_tab, int i, int j, double incertitude, boolean plusieurs_resultats, int nb_prediction_max) "Following methods sorted by use order in ADN1 Class". (2) Much choices to treat incompatibility.
private static Palindrome[]	incompatibilite_un_choix(Palindrome[] tabPalCibleTrier, int i, int j) "Following methods sorted by use order in ADN1 Class". (3) One choice in incompatibility to structure.
private void	initialiser() Initialization of algorithm.
boolean	isChercher_pk()
boolean	isMore_predictions()
boolean	isTrouvePseudonoeud()
void	launch(Sequence target, SequenceListe[] listes, boolean optimal) To launch the computing (target is automatically treated in the set).
private static Palindrome[][]	palindromes_communs(Palindrome[] tabPal1, Palindrome[] tabPal2, boolean struc_com) RESULT TREAMENT "Previous method variation [comparaison_palindrome] to find common palindromes between two predictions.
private void	recherche_Palindrome(Sequence target, int debut, int fin, int taille, Sequence[] tableauSequences, int erreur, int etape, boolean plusieurs_resultats, int nb_prediction) COMPATIBLE PALINDROME SEARCH "Methode qui recherche des palindromes dans une sequence d'ADN" This method search palindromes in DNA sequence.
private Palindrome[]	recherche_Point_Ancrage(Sequence target, int debut, int fin, int taille, double lmin, Sequence[] tableauSequences, int erreur) COMPATIBLE PALINDROME SEARCH "R=This method search anchor points at step i from palindrome search (on the subsequence i on starting sequence).
private void	recherche_Pseudonoeud(Sequence target, Base[] sequencepseudonoeud, Sequence[] tableauSequences, boolean plusieurs_resultats, int pos_struct, int nb_prediction) PSEUDOKNOTS SEARCH "This method for pseudoknots search : we launch search on each internal sequence of palindromes (form more external to more internal) as selection criteria decrease"
private void	resultat_commun(PalindromeListeListe vec) RESULT TREAMENT "This method compute a common result from vector of tab of palindromes" Here some inside code indications about conversion from Vector to PalindromeListe : Post-comments with "<=>" inside : left about Vector, right about <Object>Liste
void	setChercher_pk(boolean chercher_pk)
void	setDecalage(int decalage)
void	setIncertitude(double incertitude)
void	setMore_Predictions(boolean more_predictions)
void	setNb_prediction_max(int nb_prediction_max)
void	setPseudonoeud(int pseudonoeud)
void	setPseudonoeudPlusPlus()
void	setTableauInitial(Sequence[] tableauInitial)
void	setTableauPalindrome(ArbreExec tableauPalindrome)
void	setTaille_boucle_min(int taille_boucle_min)
void	setTaille_pal_min(int taille_pal_min)
void	setTrouvePseudonoeud(boolean trouvePseudonoeud)
void	setTypeARN(int typeARN)
void	setTypeCritere(int typeCritere)
void	setTypeRecherche(int typeRecherche)
private void	setValues(boolean optimal, int maximumPredictions, boolean morePredictions, boolean searchingPseudoknots) To be sure that good values are set as parameters...
static void	setValues(OtherAlgorithmsStefan computing, boolean optimal, int maximumPredictions, boolean morePredictions, boolean searchingPseudoknots) To be sure that good values are set as parameters...
private static PalindromeListeListe	traitement_Incompatibilite(Palindrome[] tabPalCible, boolean plusieurs_resultats, double incertitude, int nb_prediction, int nb_prediction_max) "Following methods sorted by use order in ADN1 Class". (1) "This method is about incompatibility between palindromes of same sequence, sorting palindromes by relevance (single and double mutations) then removing every palindrome incompatible with previous more relevant.
private void	traitement_Zone_Variable(Sequence target, int debut, int fin, int taille, Sequence[] tableauSequences, int erreur, int etape, boolean plusieurs_resultats, int nb_prediction) COMPATIBLE PALINDROME SEARCH "This method to search anchors points in a highly varible part of sequence"
private static Palindrome[]	trier_Palindrome_Comp(Palindrome[] tabPal) "Following methods sorted by use order in ADN1 Class". (4) "This method sort palindromes found at step i of target sequence from their relevance This method is used by the method that search compatible palindromes
private boolean	verifier_Conservation_Alignement(Sequence target, Palindrome palCourantReel, Palindrome palCourantFaux, double lmin, Sequence[] tableauSequences) COMPATIBLE PALINDROME SEARCH "this method compare palindromes found on each step of palindrome search to know if there are palindromes at the same place but they can be different (it is in that case they are relevant)This method compute in the same time the number of singles and compensatory (double) mutations.
private static boolean	verifier_Conservation_Commune(Sequence target, Palindrome palCourantReel, Palindrome palCourantFaux, double decalage, double lmin, int erreur, Sequence[] tableauSequences) COMPATIBLE PALINDROME SEARCH "this method compare palindromes found on each step of palindrome search to know if there are palindromes at the same place but they can be different (it is in that case they are relevant)This method compute in the same time the number of singles and compensatory (double) mutations.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

tableauPalindrome

private ArbreExec tableauPalindrome

"Global attribute with signification. "
A Palindrome Tree use in algorithm.

See Also:

ArbreExec, getTableauPalindrome(), getStructures(), getStructure(int), getPalindrome(int, int)

typeRecherche

private int typeRecherche

"Global attribute with signification. "
Search type (default is ALIGNEMENTHELICE / 3).

See Also:

ALIGNEMENTHELICE, PROFILHELICE, STRUCTURECOMMUNE, calcul_Resultat(Sequence, Sequence[], int, boolean, boolean)

chercher_pk

private boolean chercher_pk

"Global attribute with signification. "
Searching pseudoknots or not (default is true).

See Also:

calcul_Resultat(Sequence, Sequence[], int, boolean, boolean)

more_predictions

private boolean more_predictions

Searching much structures or not

typeCritere

private int typeCritere

"Global attribute with signification. "
Criteria type (defaul is TAUX_MUT : 2).

See Also:

TAUX_MUT, LONG_MUT, calcul_Resultat(Sequence, Sequence[], int, boolean, boolean)

typeARN

private int typeARN

"Global attribute with signification. "
RNA type (default is ARN_STRUCTURAL : 1).

See Also:

ARN_STRUCTURAL, ARN_MESSAGER, calcul_Resultat(Sequence, Sequence[], int, boolean, boolean)

incertitude

private double incertitude

"Global attribute with signification. "
(default is 0.0).

See Also:

calcul_Resultat(Sequence, Sequence[], int, boolean, boolean)

decalage

private int decalage

"Global attribute with signification. "
(default is 0).

See Also:

calcul_Resultat(Sequence, Sequence[], int, boolean, boolean)

taille_boucle_min

private int taille_boucle_min

"Global attribute with signification. "
Minimal length of loop (default is 4).

See Also:

calcul_Resultat(Sequence, Sequence[], int, boolean, boolean)

taille_pal_min

private int taille_pal_min

"Global attribute with signification. "
Minimal length of palindromes (default is 3).

See Also:

calcul_Resultat(Sequence, Sequence[], int, boolean, boolean)

nb_prediction_max

private int nb_prediction_max

"Global attribute with signification. "
Maximal number of predictions (default is 1).

See Also:

calcul_Resultat(Sequence, Sequence[], int, boolean, boolean)

tableauInitial

private Sequence[] tableauInitial

"Global attribute with signification. "
Recording sequence tests used (default is null).

See Also:

getTableauInitial()

pseudonoeud

private int pseudonoeud

"Global attributes of work"
Current complexity of searching pseudoknots. Start at 0.

trouvePseudonoeud

private boolean trouvePseudonoeud

"Global attributes of work"
Have pseudoknots been found in current step... Start at false.

ARN_STRUCTURAL

public static final int ARN_STRUCTURAL

"Global attributes of work"
Structural RNA is 1.

See Also:

Constant Field Values

ARN_MESSAGER

public static final int ARN_MESSAGER

"Global attributes of work"
Messenger RNA is 2.

See Also:

Constant Field Values

TAUX_MUT

public static final int TAUX_MUT

"Global attributes of work"
Mutation rate is 1.

See Also:

Constant Field Values

LONG_MUT

public static final int LONG_MUT

"Global attributes of work"
Mutation length is 2.

See Also:

Constant Field Values

STRUCTURECOMMUNE

public static final int STRUCTURECOMMUNE

"Global attributes of work"
Common structure is 1.

See Also:

Constant Field Values

PROFILHELICE

public static final int PROFILHELICE

"Global attributes of work"
Helix profile is 2.

See Also:

Constant Field Values

ALIGNEMENTHELICE

public static final int ALIGNEMENTHELICE

"Global attributes of work"
Helix alignment is 3.

See Also:

Constant Field Values

rnavizFile

private java.lang.String rnavizFile

To get the result RnaViz File.

bracketFile

private java.lang.String bracketFile

To get the result brackets File.

results

private java.lang.String results

To get the results of current computing (plain text).

resultsHTML

private java.lang.String resultsHTML

To get the results of current computing (HTML to include).

Constructor Detail

OtherAlgorithmsStefan

public OtherAlgorithmsStefan()

Default constructor.
Initialization, optimal is false, one structure, only one structures to find, searching pseudoknots.

OtherAlgorithmsStefan

public OtherAlgorithmsStefan(int maximumPredictions,
                             boolean morePredictions,
                             boolean searchingPseudoknots)

Constructor with given maximal number of structures, if searching much structures and searching pseudoknots.

Parameters:

maximumPredictions - (int) default is 1

morePredictions - (boolean) defult is false

searchingPseudoknots - (boolean) default is true

Method Detail

isChercher_pk

public boolean isChercher_pk()

isMore_predictions

public boolean isMore_predictions()

getDecalage

public int getDecalage()

getIncertitude

public double getIncertitude()

getNb_prediction_max

public int getNb_prediction_max()

getPseudonoeud

public int getPseudonoeud()

getTableauInitial

public Sequence[] getTableauInitial()

getTableauPalindrome

public ArbreExec getTableauPalindrome()

getTaille_boucle_min

public int getTaille_boucle_min()

getTaille_pal_min

public int getTaille_pal_min()

isTrouvePseudonoeud

public boolean isTrouvePseudonoeud()

getTypeARN

public int getTypeARN()

getTypeCritere

public int getTypeCritere()

getTypeRecherche

public int getTypeRecherche()

getRnavizFile

public java.lang.String getRnavizFile()

getBracketFile

public java.lang.String getBracketFile()

getResults

public java.lang.String getResults()

getResultsHTML

public java.lang.String getResultsHTML()

setChercher_pk

public void setChercher_pk(boolean chercher_pk)

setMore_Predictions

public void setMore_Predictions(boolean more_predictions)

setDecalage

public void setDecalage(int decalage)

setIncertitude

public void setIncertitude(double incertitude)

setNb_prediction_max

public void setNb_prediction_max(int nb_prediction_max)

setPseudonoeud

public void setPseudonoeud(int pseudonoeud)

setPseudonoeudPlusPlus

public void setPseudonoeudPlusPlus()

setTableauInitial

public void setTableauInitial(Sequence[] tableauInitial)

setTableauPalindrome

public void setTableauPalindrome(ArbreExec tableauPalindrome)

setTaille_boucle_min

public void setTaille_boucle_min(int taille_boucle_min)

setTaille_pal_min

public void setTaille_pal_min(int taille_pal_min)

setTrouvePseudonoeud

public void setTrouvePseudonoeud(boolean trouvePseudonoeud)

setTypeARN

public void setTypeARN(int typeARN)

setTypeCritere

public void setTypeCritere(int typeCritere)

setTypeRecherche

public void setTypeRecherche(int typeRecherche)

getStructures

public PalindromeListeListe getStructures()

To get structures from algorithm tree.

Returns:

(Vector)

See Also:

ArbreExec.getStructures(), OtherAlgoStefanConverter.getScreenToSee(SequenceListe[], Sequence, OtherAlgorithmsStefan, boolean), OtherAlgoStefanConverter.getScreenToSeeHTML(SequenceListe[], Sequence, OtherAlgorithmsStefan, boolean), calcul_Resultat(Sequence, Sequence[], int, boolean, boolean)

getStructure

public Palindrome[] getStructure(int pos)

To get a specific structure.

Parameters:

pos - (int)

Returns:

(Palindrome[])

getPalindrome

public Palindrome getPalindrome(int pos_struct,
                                int pos_pal)

To get a specific palindrome in a specific structure.

Parameters:

pos_struct - (int) position of the structure.

pos_pal - (int) position of palindrome in structure.

Returns:

(Palindrome)

See Also:

ArbreExec.getPalindrome(int, int)

launch

public void launch(Sequence target,
                   SequenceListe[] listes,
                   boolean optimal)

To launch the computing (target is automatically treated in the set).

Parameters:

target - (Sequence) target sequence

listes - (SequenceListe) set of homologuous sequences without target

optimal - (boolean) if computing is optimal or not

See Also:

OtherAlgoStefanConverter

initialiser

private void initialiser()

Initialization of algorithm. Set the tree to new ; the complexity of pseudoknots to 0 and the initial tab of sequences to null.

See Also:

tableauPalindrome, pseudonoeud, tableauInitial, OtherAlgorithmsStefan(), computing(SequenceListe[], Sequence, boolean, boolean)

setValues

private void setValues(boolean optimal,
                       int maximumPredictions,
                       boolean morePredictions,
                       boolean searchingPseudoknots)

To be sure that good values are set as parameters...
With current instance of computing algorithms...
Conversion and settings.

Parameters:

optimal - (boolean) if true : incertitude == 0.0 else : 0.05

maximumPredictions - (int) maximum number of predictions

morePredictions - (boolean) if wanted to found alternate structures

searchingPseudoknots - (boolean) if searching palindromes or not...

See Also:

setValues(OtherAlgorithmsStefan, boolean, int, boolean, boolean)

setValues

public static void setValues(OtherAlgorithmsStefan computing,
                             boolean optimal,
                             int maximumPredictions,
                             boolean morePredictions,
                             boolean searchingPseudoknots)

To be sure that good values are set as parameters...
Conversion and settings.

Parameters:

computing - (OtherAlgorithmsStefan)

optimal - (boolean) if true : incertitude == 0.0 else : 0.05

maximumPredictions - (int) maximum number of predictions

searchingPseudoknots - (boolean) if searching palindromes or not...

See Also:

setValues(boolean, int, boolean, boolean)

calcul_Resultat

private void calcul_Resultat(Sequence target,
                             Sequence[] tableauSequences,
                             int typeRecherche,
                             boolean plusieurs_resultats,
                             boolean chercher_pk)
                      throws java.lang.Exception

MAIN COMPUTING RESULTS
"This method to launch search and compute all wanted results"

Parameters:

target - (Sequence) target sequence

tableauSequences - (Sequence[]) target sequence at 0 then tests sequences...

typeRecherche - (int) 3 (very good default option) ALIGNEMENTHELICE

plusieurs_resultats - (boolean) (true for maybe some structures)

chercher_pk - (boolean) true (default is better to search and find pseudoKnots)

Throws:

java.lang.Exception - e

See Also:

typeRecherche, typeCritere, chercher_pk, nb_prediction_max, incertitude, decalage, typeARN, taille_boucle_min, taille_pal_min

recherche_Palindrome

private void recherche_Palindrome(Sequence target,
                                  int debut,
                                  int fin,
                                  int taille,
                                  Sequence[] tableauSequences,
                                  int erreur,
                                  int etape,
                                  boolean plusieurs_resultats,
                                  int nb_prediction)

COMPATIBLE PALINDROME SEARCH
"Methode qui recherche des palindromes dans une sequence d'ADN"
This method search palindromes in DNA sequence.

Parameters:

target - (Sequence) target sequence

debut - (int) begin analysis

fin - (int) end of analysis

taille - (int) lengt of target

tableauSequences - (Sequence[]) homologuous sequences

erreur - (int)

etape - (int) step

plusieurs_resultats - (boolean) much results

nb_prediction - (int) number of predictions

See Also:

diviser_regner(Palindrome[], Sequence, Sequence[], int, int, int, int, boolean, int), recherche_Point_Ancrage(Sequence, int, int, int, double, Sequence[], int), traitement_Zone_Variable(Sequence, int, int, int, Sequence[], int, int, boolean, int)

recherche_Point_Ancrage

private Palindrome[] recherche_Point_Ancrage(Sequence target,
                                             int debut,
                                             int fin,
                                             int taille,
                                             double lmin,
                                             Sequence[] tableauSequences,
                                             int erreur)

COMPATIBLE PALINDROME SEARCH
"R=This method search anchor points at step i from palindrome search (on the subsequence i on starting sequence). "

Parameters:

target - (Sequence) target

debut - (int) begin

fin - (int) end

taille - (int) length

lmin - (int)

tableauSequences - (Sequence[])

erreur - (int)

Returns:

(Palindrome[])

See Also:

recherche_Palindrome(Sequence, int, int, int, Sequence[], int, int, boolean, int), traitement_Zone_Variable(Sequence, int, int, int, Sequence[], int, int, boolean, int), verifier_Conservation_Commune(Sequence, Palindrome, Palindrome, double, double, int, Sequence[]), verifier_Conservation_Alignement(Sequence, Palindrome, Palindrome, double, Sequence[])

traitement_Zone_Variable

private void traitement_Zone_Variable(Sequence target,
                                      int debut,
                                      int fin,
                                      int taille,
                                      Sequence[] tableauSequences,
                                      int erreur,
                                      int etape,
                                      boolean plusieurs_resultats,
                                      int nb_prediction)

COMPATIBLE PALINDROME SEARCH
"This method to search anchors points in a highly varible part of sequence"

Parameters:

target - (Sequence) target sequence

debut - (int) begin

fin - (int) end

taille - (int) length

tableauSequences - (Sequence)

erreur - (int)

etape - (int) step

plusieurs_resultats - (boolean)

nb_prediction - (int)

See Also:

recherche_Palindrome(Sequence, int, int, int, Sequence[], int, int, boolean, int)

verifier_Conservation_Commune

private static boolean verifier_Conservation_Commune(Sequence target,
                                                     Palindrome palCourantReel,
                                                     Palindrome palCourantFaux,
                                                     double decalage,
                                                     double lmin,
                                                     int erreur,
                                                     Sequence[] tableauSequences)

COMPATIBLE PALINDROME SEARCH
"this method compare palindromes found on each step of palindrome search to know if there are palindromes at the same place but they can be different (it is in that case they are relevant)This method compute in the same time the number of singles and compensatory (double) mutations.
First is checking conservation in following common structure of test sequences.

Parameters:

target - (Sequence) target sequence

palCourantReel - (Palindrome)

palCourantFaux - (Palindrome)

decalage - (double)

lmin - (double)

erreur - (int)

tableauSequences - (Sequence) homologuous

Returns:

(boolean)

See Also:

recherche_Point_Ancrage(Sequence, int, int, int, double, Sequence[], int)

verifier_Conservation_Alignement

private boolean verifier_Conservation_Alignement(Sequence target,
                                                 Palindrome palCourantReel,
                                                 Palindrome palCourantFaux,
                                                 double lmin,
                                                 Sequence[] tableauSequences)

COMPATIBLE PALINDROME SEARCH
"this method compare palindromes found on each step of palindrome search to know if there are palindromes at the same place but they can be different (it is in that case they are relevant)This method compute in the same time the number of singles and compensatory (double) mutations.
Third...

Parameters:

target - (Sequence) target sequence

palCourantReel - (Palindrome)

palCourantFaux - (Palindrome)

lmin - (double)

tableauSequences - (Sequence[])

Returns:

(boolean)

See Also:

recherche_Point_Ancrage(Sequence, int, int, int, double, Sequence[], int), Matrice_ALN, ADN1test

diviser_regner

private void diviser_regner(Palindrome[] tabPal,
                            Sequence target,
                            Sequence[] tableauSequences,
                            int debut,
                            int fin,
                            int erreur,
                            int etape,
                            boolean plusieurs_resultats,
                            int nb_prediction)

COMPATIBLE PALINDROME SEARCH
Divide and Conquer procedure...

Parameters:

tabPal - (Palindrome[])

target - (Sequence) target sequence

tableauSequences - (Sequence[]) homologuous

debut - (int) begin

fin - (int) end

erreur - (int)

etape - (int) step

plusieurs_resultats - (boolean)

nb_prediction - (int)

See Also:

recherche_Palindrome(Sequence, int, int, int, Sequence[], int, int, boolean, int), PalindromeListe.sortByEndPositionGrowing(), Sequence.calcul_Taille(Palindrome)

recherche_Pseudonoeud

private void recherche_Pseudonoeud(Sequence target,
                                   Base[] sequencepseudonoeud,
                                   Sequence[] tableauSequences,
                                   boolean plusieurs_resultats,
                                   int pos_struct,
                                   int nb_prediction)

PSEUDOKNOTS SEARCH
"This method for pseudoknots search : we launch search on each internal sequence of palindromes (form more external to more internal) as selection criteria decrease"

Parameters:

target - (Sequence) target sequence

sequencepseudonoeud - (Base[])

tableauSequences - (Sequence[])

plusieurs_resultats - (boolean)

pos_struct - (int)

nb_prediction - (int)

See Also:

calcul_Resultat(Sequence, Sequence[], int, boolean, boolean)

resultat_commun

private void resultat_commun(PalindromeListeListe vec)

RESULT TREAMENT
"This method compute a common result from vector of tab of palindromes"
Here some inside code indications about conversion from Vector to PalindromeListe : Post-comments with "<=>" inside : left about Vector, right about <Object>Liste

Parameters:

vec - (Vector <=> PalindromeListeListe : Conversion not commented : same aim and easy to use / understand)

palindromes_communs

private static Palindrome[][] palindromes_communs(Palindrome[] tabPal1,
                                                  Palindrome[] tabPal2,
                                                  boolean struc_com)

RESULT TREAMENT
"Previous method variation [comparaison_palindrome] to find common palindromes between two predictions. Two palindromes are common as they are included one in the other"

Parameters:

tabPal1 - (Palindrome[])

tabPal2 - (Palindrome[])

struc_com - (boolean)

Returns:

(Palindrome[][])

See Also:

resultat_commun(PalindromeListeListe)

traitement_Incompatibilite

private static PalindromeListeListe traitement_Incompatibilite(Palindrome[] tabPalCible,
                                                               boolean plusieurs_resultats,
                                                               double incertitude,
                                                               int nb_prediction,
                                                               int nb_prediction_max)

"Following methods sorted by use order in ADN1 Class". (1)
"This method is about incompatibility between palindromes of same sequence, sorting palindromes by relevance (single and double mutations) then removing every palindrome incompatible with previous more relevant.
This method return a table of palindromes compatibles together.
notice problem when AAAAAAAAAAAUUUUUUUUUUUU as incompatibvility remove palindromes 2 by 2. "
The number of choices is important for the number of structures to get...

Parameters:

tabPalCible - (Palindrome[])

plusieurs_resultats - (boolean) much results

incertitude - (double) lack of precision

nb_prediction - (int) number of predictions

nb_prediction_max - (int) maximum number of predictions

Returns:

(Vector) vector of tables of palindromes (structure = table)

See Also:

recherche_Palindrome(Sequence, int, int, int, Sequence[], int, int, boolean, int)

incompatibilite_plusieurs_choix

private static void incompatibilite_plusieurs_choix(PalindromeListeListe listeTabPal,
                                                    int pos_tab,
                                                    int i,
                                                    int j,
                                                    double incertitude,
                                                    boolean plusieurs_resultats,
                                                    int nb_prediction_max)

"Following methods sorted by use order in ADN1 Class". (2)
Much choices to treat incompatibility.

Parameters:

listeTabPal - (Vector)

pos_tab - (int) position in table

i - (int)

j - (int)

incertitude - (double)

plusieurs_resultats - (boolean)

nb_prediction_max - (int) maximum number of predictions

See Also:

traitement_Incompatibilite(Palindrome[], boolean, double, int, int)

incompatibilite_un_choix

private static Palindrome[] incompatibilite_un_choix(Palindrome[] tabPalCibleTrier,
                                                     int i,
                                                     int j)

"Following methods sorted by use order in ADN1 Class". (3)
One choice in incompatibility to structure.

Parameters:

tabPalCibleTrier - (Palindrome[])

i - (int)

j - (int)

Returns:

(Vector) vector of tables of palindromes (structure = table)

See Also:

traitement_Incompatibilite(Palindrome[], boolean, double, int, int), incompatibilite_plusieurs_choix(PalindromeListeListe, int, int, int, double, boolean, int)

trier_Palindrome_Comp

private static Palindrome[] trier_Palindrome_Comp(Palindrome[] tabPal)

"Following methods sorted by use order in ADN1 Class". (4)
"This method sort palindromes found at step i of target sequence from their relevance
This method is used by the method that search compatible palindromes. "

Parameters:

tabPal - (Palindrome[])

Returns:

(Palindrome[])

See Also:

traitement_Incompatibilite(Palindrome[], boolean, double, int, int)

getRecordingStructures

public PalindromeListeListe getRecordingStructures(Sequence target)

To get the recording structure in a good conversion format.
Conversion and settings.

Parameters:

target - (Sequence) To compute Lmin from length

Returns:

(PalindromeListeListe)

See Also:

getRecordingStructures(Sequence)

computing

public void computing(SequenceListe[] tabsadn,
                      Sequence target,
                      boolean morePrediction,
                      boolean searchPseudoknots)

Computing the main algorithm made by Stefan Engelen.
Result is structures contained by adncible.
Not static because of need of some parameters in Processsus.
Conversion and settings.

Parameters:

tabsadn - (Vector) Vector of tabs of Sequences, target at position 0 !

target - (Sequence) target sequence

morePrediction - (boolean) if more than one structure as result or not

searchPseudoknots - (boolean) Searching pseudoknots or not

See Also:

OtherAlgoStefanConverter.conversionFrom(Sequence, SequenceListe[]), OtherAlgoStefanConverter.conversionFrom(Sequence, SequenceListe[], boolean), getRecordingStructures(Sequence), OtherAlgoStefanConverter.getScreenToSee(SequenceListe[], Sequence, OtherAlgorithmsStefan, boolean), OtherAlgoStefanConverter.getScreenToSeeHTML(SequenceListe[], Sequence, OtherAlgorithmsStefan, boolean)