/*
* Load a desktop style data file and create the levels array
*/
static void load_datafile() {
gchar *filename = gc_file_find_absolute("click_on_letter/default-$LOCALE.desktop");
clear_levels();
// Reset the alphabet to match the current locale
alphabet = get_alphabet();
/* create level array */
levels = g_array_sized_new (FALSE, FALSE, sizeof (Level), 10);
if ( filename )
{
load_desktop_datafile(filename);
}
else if ( ! filename && alphabet[0] == 'a')
{
/* This is a LATIN based language, let's fallback to english */
filename = gc_file_find_absolute("click_on_letter/default-en.desktop");
if( filename )
load_desktop_datafile(filename);
else
// Should not happens but in case let's create the level for LATIN
create_level_from_alphabet(alphabet);
}
else
{
// No data file and no latin character set
create_level_from_alphabet(alphabet);
}
g_free(filename);
}
Ensemble* etats_accessibles( const Automate * automate, int etat ){
Ensemble * res = creer_ensemble(NULL, NULL, NULL);
Ensemble * etape = creer_ensemble(NULL, NULL, NULL);
ajouter_element(etape, etat);
Ensemble_iterateur it_lettre;
Ensemble_iterateur it_etat;
// Tant que des états sont à traiter
while (taille_ensemble(etape) > 0)
{
Ensemble * trouves = creer_ensemble(NULL, NULL, NULL);
for(
it_lettre = premier_iterateur_ensemble( get_alphabet( automate ) );
! iterateur_ensemble_est_vide( it_lettre );
it_lettre = iterateur_suivant_ensemble( it_lettre )
){
for(
it_etat = premier_iterateur_ensemble(etape);
! iterateur_ensemble_est_vide( it_etat );
it_etat = iterateur_suivant_ensemble( it_etat )
){
// on ajoute les voisins aux éléments trouvés
ajouter_elements(trouves, voisins(automate,
get_element(it_etat),
get_element(it_lettre)
));
}
}
etape = creer_difference_ensemble(trouves, res);
ajouter_elements(res, etape);
}
return res;
}
Automate* copier_automate( const Automate* automate ){
Automate * res = creer_automate();
Ensemble_iterateur it1;
// On ajoute les états de l'automate
for(
it1 = premier_iterateur_ensemble( get_etats( automate ) );
! iterateur_ensemble_est_vide( it1 );
it1 = iterateur_suivant_ensemble( it1 )
){
ajouter_etat( res, get_element( it1 ) );
}
// On ajoute les états initiaux
for(
it1 = premier_iterateur_ensemble( get_initiaux( automate ) );
! iterateur_ensemble_est_vide( it1 );
it1 = iterateur_suivant_ensemble( it1 )
){
ajouter_etat_initial( res, get_element( it1 ) );
}
// On ajoute les états finaux
for(
it1 = premier_iterateur_ensemble( get_finaux( automate ) );
! iterateur_ensemble_est_vide( it1 );
it1 = iterateur_suivant_ensemble( it1 )
){
ajouter_etat_final( res, get_element( it1 ) );
}
// On ajoute les lettres
for(
it1 = premier_iterateur_ensemble( get_alphabet( automate ) );
! iterateur_ensemble_est_vide( it1 );
it1 = iterateur_suivant_ensemble( it1 )
){
ajouter_lettre( res, (char) get_element( it1 ) );
}
// On ajoute les transitions
Table_iterateur it2;
for(
it2 = premier_iterateur_table( automate->transitions );
! iterateur_ensemble_est_vide( it2 );
it2 = iterateur_suivant_ensemble( it2 )
){
Cle * cle = (Cle*) get_cle( it2 );
Ensemble * fins = (Ensemble*) get_valeur( it2 );
for(
it1 = premier_iterateur_ensemble( fins );
! iterateur_ensemble_est_vide( it1 );
it1 = iterateur_suivant_ensemble( it1 )
){
int fin = get_element( it1 );
ajouter_transition( res, cle->origine, cle->lettre, fin );
}
};
return res;
}
Automate *automate_accessible( const Automate * automate){
Automate* clone = copier_automate(automate);
Ensemble* etats = creer_ensemble(NULL, NULL, NULL);
Ensemble_iterateur it_etat;
Ensemble_iterateur it_lettre;
// On calcule l'ensemble des états accessibles
for(it_etat = premier_iterateur_ensemble(get_initiaux(automate));
! iterateur_ensemble_est_vide( it_etat );
it_etat = iterateur_suivant_ensemble( it_etat )){
ajouter_elements(etats, etats_accessibles(automate, get_element(it_etat)));
ajouter_element(etats, get_element(it_etat));
}
// On détermine les états qui ne sont pas accessibles => ceux qui sont dans get_etats mais pas dans etats
Ensemble* non_accessible = creer_difference_ensemble(get_etats(automate), etats);
// On parcourt l'ensemble obtenu
for(it_etat = premier_iterateur_ensemble(non_accessible);
! iterateur_ensemble_est_vide( it_etat );
it_etat = iterateur_suivant_ensemble( it_etat )){
const intptr_t etat_courant = get_element(it_etat);
// On cherche toutes les transitions partant d'un état
for(it_lettre = premier_iterateur_ensemble(get_alphabet(automate));
! iterateur_ensemble_est_vide( it_lettre );
it_lettre = iterateur_suivant_ensemble( it_lettre )){
Cle cle;
initialiser_cle( &cle, etat_courant, get_element(it_lettre));
Table_iterateur it = trouver_table( clone->transitions, (intptr_t) &cle );
// Si on trouve une transition partant d'un état non accessible
if( !iterateur_est_vide( it ) ){
delete_table( clone->transitions, (intptr_t) &cle); // on la supprime
}
}
// si c'est un état final, on pense à le supprimer
if (est_un_etat_final_de_l_automate(automate, etat_courant))
{
retirer_element(clone->finaux, etat_courant);
}
// si c'est un état initial, on pense à le supprimer
if (est_un_etat_initial_de_l_automate(automate, etat_courant))
{
retirer_element(clone->initiaux, etat_courant);
}
}
// On supprime tous les états non accessibles de l'automate
deplacer_ensemble(clone->etats, etats);
return clone;
}
void print_automate( const Automate * automate ){
printf("- Etats : ");
print_ensemble( get_etats( automate ), NULL );
printf("\n- Initiaux : ");
print_ensemble( get_initiaux( automate ), NULL );
printf("\n- Finaux : ");
print_ensemble( get_finaux( automate ), NULL );
printf("\n- Alphabet : ");
print_ensemble( get_alphabet( automate ), print_lettre );
printf("\n- Transitions : ");
print_table(
automate->transitions,
( void (*)( const intptr_t ) ) print_cle,
( void (*)( const intptr_t ) ) print_ensemble_2,
""
);
printf("\n");
}
static guint sounds_are_fine()
{
char *letter_str;
char *str2;
GcomprisProperties *properties = gc_prop_get();
gchar *text_mode_str = _("This activity will be played with questions displayed as text"
" instead of being spoken");
if(!properties->fx)
{
gchar *msg = g_strconcat( _("Error: this activity cannot be played with the\n"
"sound effects disabled.\nGo to the configuration"
" dialog to\nenable the sound"),
"\n", text_mode_str, NULL);
gc_dialog(msg, click_on_letter_next_level);
g_free(msg);
return(OK_NO_INIT);
}
alphabet = get_alphabet();
gchar *letter = g_new0(gchar, 8);
g_unichar_to_utf8(g_utf8_get_char(alphabet), letter);
letter_str = gc_sound_alphabet(letter);
g_free(letter);
str2 = gc_file_find_absolute("voices/$LOCALE/alphabet/%s", letter_str);
g_free(letter_str);
if (!str2)
{
gchar *msg2 = g_strdup_printf( _("Error: this activity requires that you first install\nthe packages with GCompris voices for the %s locale."),
gc_locale_get_name( gc_locale_get() ) );
gchar *msg = g_strconcat(msg2, "\n", text_mode_str, NULL);
g_free(msg2);
gc_dialog(msg, click_on_letter_next_level);
g_free(msg);
return (OK_NO_INIT);
}
return(OK);
}
gi::dfaEDSM* gi::dfaEDSM::to_canonical_dfaEDSM_from_red_states(){
//////////////////////////////////////////////////////////////
// - Pulisco l'automo dagli stati irragiungibili, aggiorno le transizioni
// Conto il numero effettivo di stati finali
int n_final_states = 0;
for (int i = 0; i < get_num_states(); ++i)
if (is_inside_red_states(i))
n_final_states++;
//TODO: Aggiungi la copia degli stati red e blue nei vectors
// Creo un nuovo automa senza stati irragiungibili
int count = 0;
dfaEDSM* finalDFA = new dfaEDSM(n_final_states, get_dim_alphabet(), get_alphabet());
map<int, int> updated_transition;
for (int i = 0; i < num_states; ++i) {
if (is_inside_red_states(i)) {
for (int j = 0; j <get_dim_alphabet() + 1; ++j) {
// Aggiungo lo stato al nuovo automa
finalDFA->get_ttable()[count][j] = ttable[i][j];
updated_transition[i] = count;
}
++count;
}
}
updated_transition[ND] = ND;
// if(updated_transition.size() <= 2){
// cout << "There is only one or zero red state. Returned a copy of originale dfa."<<endl;
// delete finalDFA;
// return new dfaEDSM(*this);
// }
bool stato_pozzo = false;
// Aggiorno le transizioni
for (int i = 0; i < finalDFA->get_num_states(); ++i)
for (int j = 0; j < finalDFA->get_dim_alphabet(); ++j) {
if (finalDFA->get_ttable()[i][j] == ND) // Rilevo che c'è una transizione mancante, quindi serve uno stato pozzo
stato_pozzo = true;
if(updated_transition.find(finalDFA->get_ttable()[i][j]) != updated_transition.end())
finalDFA->set_ttable_entry(i, j, updated_transition[ finalDFA->get_ttable()[i][j] ]);
else {
cerr << "Errore nell'aggiornamento delle stringhe"<<endl;
exit(EXIT_FAILURE);
}
}
// Stampo l'automa prima di applicare il pozzo e la minimizzazione
//finalDFA->print_dfa_with_color("AUTOMA FINALE PREPOZZO");
//finalDFA->print_dfa_dot("FINALEPREPOZZO", percorso.c_str());
//finalDFA->print_dfa_dot_mapped_alphabet("FINALE_PREPOZZO", (base_path + "pulito_pre_pozzo.dot").c_str());
//////////////////////////////////////////////////////////////
// Controllo stato pozzo
// - Se ci sono transizioni non definite le imposto tutte verso lo stato pozzo
if (stato_pozzo) {
dfaEDSM* finalDFAPozzo = new dfaEDSM(finalDFA->get_num_states() + 1, finalDFA->get_dim_alphabet(), finalDFA->get_alphabet(), 0);
int** table = finalDFAPozzo->get_ttable();
for (int i = 0; i < finalDFA->get_num_states(); ++i)
for (int j = 0; j < finalDFA->get_dim_alphabet() + 1; ++j) {
if (finalDFA->get_ttable()[i][j] == ND)
table[i][j] = finalDFA->get_num_states();
else
table[i][j] = finalDFA->get_ttable()[i][j];
}
for (int j = 0; j < finalDFA->get_dim_alphabet(); ++j)
table[finalDFA->get_num_states()][j] = finalDFA->get_num_states();
delete finalDFA;
finalDFA = finalDFAPozzo;
}
return finalDFA;
}
int test_execute_fonctions(){
BEGIN_TEST
int res = 1;
Automate * automate2;
Automate * automate;
Automate * result = NULL;
Ensemble * ens = NULL;
Ensemble * ens1 = NULL;
automate = creer_automate();
result = NULL;
ajouter_lettre( automate, 'a' );
if( result ) liberer_automate( result );
liberer_automate( automate );
automate = creer_automate();
result = NULL;
ajouter_etat_final( automate, 1 );
if( result ) liberer_automate( result );
liberer_automate( automate );
automate = creer_automate();
result = NULL;
ajouter_etat_initial( automate, 1 );
if( result ) liberer_automate( result );
liberer_automate( automate );
automate = creer_automate();
get_initiaux( automate );
liberer_automate( automate );
automate = creer_automate();
get_finaux( automate );
liberer_automate( automate );
automate = creer_automate();
get_alphabet( automate );
liberer_automate( automate );
automate = creer_automate();
result = NULL;
est_un_etat_initial_de_l_automate( automate, 1 );
if( result ) liberer_automate( result );
liberer_automate( automate );
automate = creer_automate();
result = NULL;
est_un_etat_final_de_l_automate( automate, 1 );
if( result ) liberer_automate( result );
liberer_automate( automate );
automate = creer_automate();
result = NULL;
est_une_lettre_de_l_automate( automate, 'a' );
if( result ) liberer_automate( result );
liberer_automate( automate );
automate = creer_automate();
ens = NULL;
ens1 = creer_ensemble( NULL, NULL, NULL );
ens = delta_star( automate, ens1, "aba" );
if( ens ) liberer_ensemble( ens );
liberer_ensemble( ens1 );
liberer_automate( automate );
automate = creer_automate();
result = NULL;
le_mot_est_reconnu( automate, "abaa" );
if( result ) liberer_automate( result );
liberer_automate( automate );
automate = creer_automate();
result = NULL;
result = mot_to_automate( "abbaa" );
if( result ) liberer_automate( result );
liberer_automate( automate );
automate = creer_automate();
ens = NULL;
ens = etats_accessibles( automate, 0 );
if( ens ) liberer_ensemble( ens );
liberer_automate( automate );
automate = creer_automate();
result = NULL;
result = automate_accessible( automate );
if( result ) liberer_automate( result );
liberer_automate( automate );
automate = creer_automate();
result = NULL;
result = miroir( automate );
if( result ) liberer_automate( result );
liberer_automate( automate );
automate = creer_automate();
result = NULL;
result = automate_co_accessible(automate );
if( result ) liberer_automate( result );
liberer_automate( automate );
automate = creer_automate();
result = NULL;
result = creer_automate_des_prefixes( automate );
if( result ) liberer_automate( result );
liberer_automate( automate );
automate = creer_automate();
result = NULL;
result = creer_automate_des_suffixes( automate );
if( result ) liberer_automate( result );
liberer_automate( automate );
automate = creer_automate();
result = NULL;
result = creer_automate_des_facteurs( automate );
if( result ) liberer_automate( result );
liberer_automate( automate );
automate = creer_automate();
result = NULL;
ens = creer_ensemble( NULL, NULL, NULL );
result = creer_automate_des_sur_mot(
automate, ens
);
if( result ) liberer_automate( result );
liberer_automate( automate );
liberer_ensemble( ens );
automate = creer_automate();
automate2 = creer_automate();
result = NULL;
result = creer_automate_de_concatenation( automate, automate2 );
if( result ) liberer_automate( result );
liberer_automate( automate );
liberer_automate( automate2 );
automate = creer_automate();
result = NULL;
result = creer_automate_des_sous_mots( automate );
if( result ) liberer_automate( result );
liberer_automate( automate );
return res;
}
int test_creer_automate(){
BEGIN_TEST;
int result = 1;
Automate * automate = creer_automate();
ajouter_lettre( automate, 'a' );
ajouter_lettre( automate, 'd' );
ajouter_etat( automate, 3 );
ajouter_etat_final( automate, 6 );
ajouter_transition( automate, 3, 'a', 5 );
ajouter_transition( automate, 3, 'b', 3 );
ajouter_etat_final( automate, 5 );
ajouter_etat_initial( automate, 3 );
TEST(
1
&& est_un_etat_de_l_automate( automate, 3)
&& est_un_etat_de_l_automate( automate, 5)
&& est_un_etat_de_l_automate( automate, 6)
, result
);
TEST(
1
&& ! est_un_etat_final_de_l_automate( automate, 3)
&& est_un_etat_final_de_l_automate( automate, 5)
&& est_un_etat_final_de_l_automate( automate, 6)
, result
);
TEST(
1
&& est_un_etat_initial_de_l_automate( automate, 3)
&& ! est_un_etat_initial_de_l_automate( automate, 5)
, result
);
TEST(
1
&& est_une_lettre_de_l_automate( automate, 'a')
&& est_une_lettre_de_l_automate( automate, 'b')
&& est_une_lettre_de_l_automate( automate, 'd')
&& ! est_une_lettre_de_l_automate( automate, 'c')
, result
);
TEST(
1
&& est_une_transition_de_l_automate( automate, 3, 'a', 5 )
&& est_une_transition_de_l_automate( automate, 3, 'b', 3 )
&& ! est_une_transition_de_l_automate( automate, 3, 'b', 5 )
&& ! est_une_transition_de_l_automate( automate, 3, 'a', 3 )
&& ! est_une_transition_de_l_automate( automate, 5, 'a', 3 )
&& ! est_une_transition_de_l_automate( automate, 5, 'b', 3 )
&& ! est_une_transition_de_l_automate( automate, 5, 'a', 5 )
&& ! est_une_transition_de_l_automate( automate, 5, 'b', 5 )
, result
);
const Ensemble* ens = get_initiaux( automate );
TEST(
1
&& ens
&& est_dans_l_ensemble( ens, 3 )
&& ! est_dans_l_ensemble( ens, 5 )
&& ! est_dans_l_ensemble( ens, 6 )
, result
);
ens = get_finaux( automate );
TEST(
1
&& ens
&& ! est_dans_l_ensemble( ens, 3 )
&& est_dans_l_ensemble( ens, 5 )
&& est_dans_l_ensemble( ens, 6 )
, result
);
ens = get_alphabet( automate );
TEST(
1
&& ens
&& est_dans_l_ensemble( ens, 'a')
&& est_dans_l_ensemble( ens, 'b')
&& ! est_dans_l_ensemble( ens, 'c')
&& est_dans_l_ensemble( ens, 'd')
, result
);
liberer_automate( automate );
return result;
}
void read_regexp_file(
char* filename, // Name of MEME file IN
int* num_motifs, // Number of motifs retrieved OUT
MOTIF_T* motifs // The retrieved motifs - NOT ALLOCATED!
) {
FILE* motif_file; // MEME file containing the motifs.
char motif_name[MAX_MOTIF_ID_LENGTH+1];
char motif_regexp[MAX_MOTIF_WIDTH];
ARRAY_T* these_freqs;
MOTIF_T* m;
int i;
//Set things to the defaults.
*num_motifs = 0;
// Open the given MEME file.
if (open_file(filename, "r", TRUE, "motif", "motifs", &motif_file) == 0)
exit(1);
//Set alphabet - ONLY supports dna.
set_alphabet(verbosity, "ACGT");
while (fscanf(motif_file, "%s\t%s", motif_name, motif_regexp) == 2) {
/*
* Now we:
* 1. Fill in new motif (preallocated)
* 2. Assign name
* 3. Convert regexp into frequency table.
*/
m = &(motifs[*num_motifs]);
set_motif_id(motif_name, m);
m->length = strlen(motif_regexp);
/* Store the alphabet size in the motif. */
m->alph_size = get_alph_size(ALPH_SIZE);
m->ambigs = get_alph_size(AMBIG_SIZE);
/* Allocate memory for the matrix. */
m->freqs = allocate_matrix(m->length, get_alph_size(ALL_SIZE));
//Set motif frequencies here.
for (i=0;i<strlen(motif_regexp);i++) {
switch(toupper(motif_regexp[i])) {
case 'A':
set_matrix_cell(i,alphabet_index('A',get_alphabet(TRUE)),1,m->freqs);
break;
case 'C':
set_matrix_cell(i,alphabet_index('C',get_alphabet(TRUE)),1,m->freqs);
break;
case 'G':
set_matrix_cell(i,alphabet_index('G',get_alphabet(TRUE)),1,m->freqs);
break;
case 'T':
set_matrix_cell(i,alphabet_index('T',get_alphabet(TRUE)),1,m->freqs);
break;
case 'U':
set_matrix_cell(i,alphabet_index('U',get_alphabet(TRUE)),1,m->freqs);
break;
case 'R': //purines
set_matrix_cell(i,alphabet_index('G',get_alphabet(TRUE)),1,m->freqs);
set_matrix_cell(i,alphabet_index('A',get_alphabet(TRUE)),1,m->freqs);
break;
case 'Y': //pyramidines
set_matrix_cell(i,alphabet_index('T',get_alphabet(TRUE)),1,m->freqs);
set_matrix_cell(i,alphabet_index('C',get_alphabet(TRUE)),1,m->freqs);
break;
case 'K': //keto
set_matrix_cell(i,alphabet_index('G',get_alphabet(TRUE)),1,m->freqs);
set_matrix_cell(i,alphabet_index('T',get_alphabet(TRUE)),1,m->freqs);
break;
case 'M': //amino
set_matrix_cell(i,alphabet_index('A',get_alphabet(TRUE)),1,m->freqs);
set_matrix_cell(i,alphabet_index('C',get_alphabet(TRUE)),1,m->freqs);
break;
case 'S': //strong
set_matrix_cell(i,alphabet_index('G',get_alphabet(TRUE)),1,m->freqs);
set_matrix_cell(i,alphabet_index('C',get_alphabet(TRUE)),1,m->freqs);
break;
case 'W': //weak
set_matrix_cell(i,alphabet_index('A',get_alphabet(TRUE)),1,m->freqs);
set_matrix_cell(i,alphabet_index('T',get_alphabet(TRUE)),1,m->freqs);
break;
case 'B':
set_matrix_cell(i,alphabet_index('G',get_alphabet(TRUE)),1,m->freqs);
set_matrix_cell(i,alphabet_index('T',get_alphabet(TRUE)),1,m->freqs);
set_matrix_cell(i,alphabet_index('C',get_alphabet(TRUE)),1,m->freqs);
break;
case 'D':
set_matrix_cell(i,alphabet_index('G',get_alphabet(TRUE)),1,m->freqs);
set_matrix_cell(i,alphabet_index('A',get_alphabet(TRUE)),1,m->freqs);
set_matrix_cell(i,alphabet_index('T',get_alphabet(TRUE)),1,m->freqs);
break;
case 'H':
set_matrix_cell(i,alphabet_index('A',get_alphabet(TRUE)),1,m->freqs);
set_matrix_cell(i,alphabet_index('C',get_alphabet(TRUE)),1,m->freqs);
set_matrix_cell(i,alphabet_index('T',get_alphabet(TRUE)),1,m->freqs);
break;
case 'V':
set_matrix_cell(i,alphabet_index('G',get_alphabet(TRUE)),1,m->freqs);
set_matrix_cell(i,alphabet_index('C',get_alphabet(TRUE)),1,m->freqs);
set_matrix_cell(i,alphabet_index('A',get_alphabet(TRUE)),1,m->freqs);
break;
case 'N':
set_matrix_cell(i,alphabet_index('A',get_alphabet(TRUE)),1,m->freqs);
set_matrix_cell(i,alphabet_index('C',get_alphabet(TRUE)),1,m->freqs);
set_matrix_cell(i,alphabet_index('G',get_alphabet(TRUE)),1,m->freqs);
set_matrix_cell(i,alphabet_index('T',get_alphabet(TRUE)),1,m->freqs);
break;
}
}
/* Compute values for ambiguous characters. */
for (i = 0; i < m->length; i++) {
these_freqs = get_matrix_row(i, m->freqs);
fill_in_ambiguous_chars(FALSE, these_freqs);
}
/* Compute and store the motif complexity. */
m->complexity = compute_motif_complexity(m);
//Move our pointer along to do the next motif.
(*num_motifs)++;
}
}
/*************************************************************************
* Calculate the odds score for each motif-sized window at each
* site in the sequence using the given nucleotide frequencies.
*
* This function is a lightweight version based on the one contained in
* motiph-scoring. Several calculations that are unnecessary for gomo
* have been removed in order to speed up the process.
* Scores sequence with up to two motifs.
*************************************************************************/
double score_sequence(
SEQ_T* seq, // sequence to scan (IN)
double *logcumback, // cumulative bkg probability of sequence (IN)
PSSM_PAIR_T* pssm_pair, // pos and neg pssms (IN)
int method, // method used for scoring (IN)
int last, //score only last <n> or
//score all if <n> is zero (IN)
BOOLEAN_T* isFeasible // FLAG indicated if there is at least one position
// where the motif could be matched against (OUT)
)
{
assert(pssm_pair != NULL);
assert(seq != NULL);
PSSM_T* pos_pssm = pssm_pair->pos_pssm;
assert(pos_pssm != NULL);
PSSM_T* neg_pssm = pssm_pair->neg_pssm;
int n_motifs = neg_pssm ? 2 : 1;
char* raw_seq = get_raw_sequence(seq);
int seq_length = get_seq_length(seq);
int w = get_num_rows(pos_pssm->matrix);
int n = seq_length - w + 1;
if (verbosity >= DUMP_VERBOSE) {
fprintf(stderr, "Debug n_motifs: %d seq_length: %d w: %d n: %d.\n", n_motifs, seq_length, w, n);
}
// Get alphabet;
char* alphabet = get_alphabet(FALSE);
int alph_size = get_alph_size(ALPH_SIZE);
// Dependent on the "last" parameter, change the starting point
int start;
int N_scored;
if (last > 0 && last < seq_length) {
start = seq_length - last;
N_scored = n_motifs * (last - w + 1); // number of sites scored
} else {
start = 0;
N_scored = n_motifs * n; // number of sites scored
}
// For each motif (positive and reverse complement)
double max_odds = 0.0;
double sum_odds = 0.0;
double requested_odds = 0.0;
int i;
if (verbosity >= HIGHER_VERBOSE) {
fprintf(stderr, "Starting scan at position %d .\n", start);
}
for (i=0; i<n_motifs; i++) { // pos (and negative) motif
PSSM_T* pssm = (i==0 ? pos_pssm : neg_pssm); // choose +/- motif
// For each site in the sequence
int seq_index;
for (seq_index = start; seq_index < n; seq_index++) { // site
double odds = 1.0;
// For each position in the motif window
int motif_position;
for (motif_position = 0; motif_position < w; motif_position++) { // column
int i_site = seq_index + motif_position;
char c = raw_seq[i_site];
// Check for gaps at this site
if (c == '-' || c == '.') { N_scored--; odds = 0; break; }
// Check for ambiguity codes at this site
int alph_index = alphabet_index(c, alphabet);
if (alph_index >= alph_size || alph_index < 0) { N_scored--; odds = 0; break; }
// multiple odds by value in appropriate motif cell
odds *= get_matrix_cell(motif_position, alph_index, pssm->matrix);
} // column
//
// Apply sequence-dependent background model.
//
if (logcumback) {
int i_site = seq_index;
double log_p = logcumback[i_site+w] - logcumback[i_site]; // log Pr(x | background)
//printf("log_p:: %g motif_pos %d\n", log_p, motif_position);
double adjust = exp(w*log(1/4.0) - log_p); // Pr(x | uniform) / Pr(x | background)
odds *= adjust;
}
// Add odds to growing sum.
sum_odds += odds; // sum of odds
if (odds > max_odds) max_odds = odds; // max of odds
} // site
} // motif
if (verbosity >= HIGHER_VERBOSE) {
fprintf(stderr, "Scored %d positions with the sum odds %f and the max odds %f.\n", N_scored, sum_odds, max_odds);
}
// has there been anything matched at all?
if (N_scored == 0){
if (verbosity >= NORMAL_VERBOSE) {
fprintf(stderr,"Sequence \'%s\' offers no location to match the motif against (sequence length too short?)\n",get_seq_name(seq));
}
*isFeasible = FALSE;
return 0.0;
// return odds as requested (MAX or AVG scoring)
} else if (method == AVG_ODDS) {
requested_odds = sum_odds / N_scored; // mean
} else if (method == MAX_ODDS) {
requested_odds = max_odds; // maximum
} else if (method == SUM_ODDS) {
requested_odds = sum_odds ; // sum
}
return(requested_odds);
} // score_sequence
int est_une_lettre_de_l_automate( const Automate* automate, char lettre ){
return est_dans_l_ensemble(get_alphabet(automate), lettre);
}
Automate * creer_automate_de_concatenation(
const Automate* automate1, const Automate* automate2
){
/**
* \par Implémentation
*
* On créé un automate, copie de automate1 avec comme états finaux ceux de automate2
*/
Automate* concat = copier_automate(automate1);
deplacer_ensemble(concat->finaux, automate2->finaux);
/**
* Puis on créé un modificateur qui nous permet de passer en paramètres de fonction
* l'automate de destination et une valeur de décalage des états.
* Cette valeur permet de ne pas avoir deux états avec la même valeur.
*/
int decalage = get_max_etat(automate1);
AutomateInt* modificateur = creer_automate_int();
modificateur->automate = concat;
modificateur->valeur = decalage;
/**
* On ajoute les transitions de l'automate 2 avec les états décalés.
*/
pour_toute_transition(automate2, incrementer_etats_transition, modificateur);
liberer_automate_int(modificateur);
/**
* Pour chaque état initial du second automate
*/
Ensemble_iterateur initial2;
for(
initial2 = premier_iterateur_ensemble(get_initiaux(automate2));
! iterateur_ensemble_est_vide( initial2 );
initial2 = iterateur_suivant_ensemble( initial2 )){
/**
* Pour chaque lettre de son alphabet
*/
Ensemble_iterateur lettre;
for(
lettre = premier_iterateur_ensemble(get_alphabet(automate2));
! iterateur_ensemble_est_vide(lettre);
lettre = iterateur_suivant_ensemble(lettre)){
Cle cle;
printf("initial2 : %d\n", (int) get_element(initial2));
printf("lettre : %c\n", (char) get_element(lettre));
initialiser_cle(&cle, (int) get_element(initial2), (char) get_element(lettre));
Table_iterateur destination = trouver_table(automate2->transitions, (intptr_t) &cle);
printf("avant clé\n");
print_cle(&cle);
printf("après clé\n");
if (!iterateur_est_vide(destination)){
AutomateTransition* modif_trans = creer_automate_transition();
modif_trans->automate = concat;
modif_trans->lettre = get_element(lettre);
Ensemble* destinations = (Ensemble*) get_valeur(destination);
Ensemble_iterateur etat_dest;
/**
* Pour chaque transition de la forme (i2, a2, q2), avec i2 intial, a2 lettre de l'alphabet
* et q2 état de l'automate2
*/
for(
etat_dest = premier_iterateur_ensemble(destinations);
! iterateur_ensemble_est_vide(etat_dest);
etat_dest = iterateur_suivant_ensemble(etat_dest)){
modif_trans->destination = get_element(etat_dest)+decalage;
/**
* On ajoute une transition dans l'automate de concaténation ayant pour origine
* un état initial, la lettre a2 et l'état q2
*/
pour_tout_element(get_finaux(automate1), simuler_epsilon_transition, modif_trans);
}
initialiser_cle(&cle, (int) get_element(initial2) + decalage, get_element(lettre));
delete_table(concat->transitions, (intptr_t) &cle);
liberer_automate_transition(modif_trans);
}
}
}
return concat;
}
void generate_ceq_logos(char *meme_path, char *output_dir) {
int i, dir_len, prefix_len, path_len;
ARRAY_T *background;
BOOLEAN_T has_reverse_strand;
char *path, *alphabet;
double logo_height, logo_width;
ARRAYLST_T *motifs;
MOTIF_T *motif;
motifs = arraylst_create();
logo_height = LOGOHEIGHT;
//make the path
dir_len = strlen(output_dir);
prefix_len = strlen(LOGO_PREFIX);
path_len = dir_len + 1 + prefix_len + MAX_MOTIF_ID_LENGTH + 1;
path = malloc(sizeof(char)*path_len);
strncpy(path, output_dir, path_len);
if (path[dir_len-1] != '/') {
path[dir_len] = '/';
path[++dir_len] = '\0';
}
strncpy(path+dir_len, LOGO_PREFIX, path_len - dir_len);
// Read all motifs into an array.
read_meme_file2(meme_path,
NULL, // bg file name
DEFAULT_PSEUDOCOUNTS,
REQUIRE_PSPM,
motifs,
NULL,//motif occurrences
&has_reverse_strand,
&background);
// global alphabet is set by read_meme_file
alphabet = get_alphabet(FALSE);
if (create_output_directory(output_dir, TRUE, (verbosity >= NORMAL_VERBOSE))) {
// Failed to create output directory.
exit(1);
}
for(i = 0; i < arraylst_size(motifs); i++) {
motif = (MOTIF_T*)arraylst_get(i, motifs);
logo_width = get_motif_length(motif);
if (logo_width > MAXLOGOWIDTH) logo_width = MAXLOGOWIDTH;
copy_and_sanatise_name(path+(dir_len+prefix_len), get_motif_id(motif), path_len - (dir_len + prefix_len));
CL_create2(
motif, // motif
"", // no title
NULL, // no second motif
"", // no x-axis label
FALSE, // no error bars
FALSE, // ssc
logo_height, // logo height (cm)
logo_width, // logo width (cm)
alphabet, // alphabet
0, // no offset to second motif
path, // output file path
"MEME (no SSC)" // program name
);
}
free_motifs(motifs);
free_array(background); // not used
free(path);
}
