/* Last edited on 2005-10-20 16:06:02 by stolfi */ double get_prob_event_a_priori(char *vev, double o->avgLenC, double o->avgLenN); int conta_pontos(char *s); void get_freqi(char *tupla, char *vev, double freq, double *cont_ia, double *cont_it, double *cont_CN, double *cont_ig); int criar_vetor(int JJ, tfreq **vfreq, int tam_vfreq); void desaloca_vfreq(tfreq **vfreq, int tam_vfreq); double get_freq_tupla(char *tupla, char *vev, int tam_vfreq, tfreq *vfreq); void compute_scores( double **score_DEFN, double **score_CN, double **score_DEF, double *labProb, char *lab, int lab.nel, int type ); /* Calcula a quantidade de vezes que a predição feita para a sequencia obteve sucesso ou fracasso */ /**************************************************************************** * Procedimento para criar o vetor que vai guardar as frequencias * ****************************************************************************/ int criar_vetor(int JJ, tfreq **vfreq, int tam_vfreq){ int cnt, cnt_prob; tfreq *vfreq_aux; vfreq_aux = *vfreq; vfreq_aux = (tfreq *) malloc(tam_vfreq * sizeof(tfreq)); if (vfreq_aux ==NULL){ printf("Erro na alocacao de memoria,vfreq nao pode ser criado!"); return(1); } for(cnt=0; cnt < tam_vfreq; cnt++){ vfreq_aux[cnt].tupla = (char *) malloc((JJ+1)* sizeof(char)); /* rotulo da tupla */ strcpy(vfreq_aux[cnt].tupla,"\0"); vfreq_aux[cnt].prob = (tprob *) malloc (tam_vfreq * sizeof(tprob));/*rotulo de cada event e sua probabilidade*/ for (cnt_prob=0; cnt_prob < tam_vfreq; cnt_prob++){ vfreq_aux[cnt].prob[cnt_prob].event = (char *) malloc((JJ+1) * sizeof(char)); /* rotulo do event */ strcpy(vfreq_aux[cnt].prob[cnt_prob].event,"\0"); /* limpa o valor do rotulo */ vfreq_aux[cnt].prob[cnt_prob].valor = 0.0; } } *vfreq = vfreq_aux; return(0); } /**************************************************************************** * Procedimento para liberar o espaco de memoria ocupado por vfreq * ****************************************************************************/ void desaloca_vfreq(tfreq **vfreq, int tam_vfreq){ int cnt, cnt_prob; tfreq *vfreq_aux; vfreq_aux = *vfreq; for (cnt=0; cnt < tam_vfreq;cnt++){ for (cnt_prob=0; cnt_prob < tam_vfreq; cnt_prob++) free(vfreq_aux[cnt].prob[cnt_prob].event); free(vfreq_aux[cnt].prob); free(vfreq_aux[cnt].tupla); } free(vfreq_aux); } /**************************************************************************** * Procedimento que retorna a frequencia condicional F(tupla|event), * * procurando na tabela {vfreq} de tamanho {tam_freq}. * * A tupla deve ter o mesmo tamanho {JJ} das entradas da tabela. * ****************************************************************************/ double get_freq_tupla(char *tupla, char *event, int tam_vfreq, tfreq *vfreq){ double freq; /* variavel que guardara' a frequencia da tupla passada como parametro */ int cnt, ind; freq = 0.0; /* percorre o vfreq para pesquisar se a tupla esta' em vfreq */ for(cnt=0; cnt < tam_vfreq; cnt++){ if (strcmp(vfreq[cnt].tupla,tupla)==0){/* testa se e' igual a tupla passada como parametro */ for(ind=0; ind < tam_vfreq; ind++){ /* busca o event correspondente ao passado por parametro */ if (strcmp(vfreq[cnt].prob[ind].event,event)==0) return(vfreq[cnt].prob[ind].valor); } } } /* Se não achou, supõe que a freqüência é zero: */ return 0.0; } /**************************************************************************** * Procedimento que retorna a probabilidade a priori de um event. ****************************************************************************/ double get_prob_event_a_priori(char *event, double o->avgLenC, double o->avgLenN){ double prob; char *p = event; /* Proxima letra do event. */ int coding; /* 1 se letra anterior era DEF, 0 se era I. */ double probI = o->avgLenN/(o->avgLenN + o->avgLenC); /* Pr(janela inicia em I) */ double probC = o->avgLenC/(o->avgLenN + o->avgLenC); /* Pr(janela começa em E,F ou G. */ double probIC = 1.0/o->avgLenN; /* Pr(I ser seguido de E,F ou G). */ double probCI = 1.0/o->avgLenC; /* Pr(E,F ou G ser seguido de I). */ if ((*p) == 'I') { prob = probI; coding = 0; } else { prob = probC/3; coding = 1; } p++; while ((*p) != '\0'){ if (coding) { if ((*p) == 'I'){ prob *= probCI; coding = 0; }else{ prob *= (1.0 - probCI); coding = 1; } }else{ if ((*p) == 'I'){ prob *= (1.0 - probIC); coding = 0; }else{ prob *= probCN/3; coding = 1; } } p++; } return prob; } /**************************************************************************** * Devolve o número de caracteres '.' na cadeia {s}. * ****************************************************************************/ int conta_pontos(char *s){ int n = 0; while((*s) != '\0') { if ((*s) == '.') { n++; } s++; } return n; } /************************************************************************* * Percorre o vetor com as probabilidades encontradas e conta quantas * * vezes o preditor errou ou acertou ao rotular uma base. Monta um vetor, * * cada posição é determinada por duas variaveis: linha e coluna. A linha * * indica o event verdadeiro da base e a coluna o event previsto pelo * * preditor. * * Se {type==0}, arredonda as probabilidades para um-1-e-o-resto-0 * * Se {type==1}, soma as probabilidades sem arredondar. * *************************************************************************/ void compute_scores(double **score_DEFN, double **score_CN, double **score_DEF, double *labProb, char *lab, int lab.nel, int type){ int cnt, i; int lin_DEFN = 0, lin_CN = 0, lin_DEF = 0; int col_DEFN = 0, col_CN = 0, col_DEF = 0; fprintf(stderr, "calculando scores... "); /* Inicializa scores */ for(cnt = 0; cnt < 16; cnt++){ (*score_DEFN)[cnt] = 0; } for(cnt = 0; cnt < 4; cnt++){ (*score_CN)[cnt] = 0; } for(cnt = 0; cnt < 9; cnt++){ (*score_DEF)[cnt] = 0; } if (lab != NULL){ for(i = 0; i < lab.nel; i++){ switch(lab.el[i]){ /* A linha indica o gabarito para a base */ case 'I': lin_DEFN = 0; lin_CN = 0; break; case 'E': lin_DEFN = 1; lin_CN = 1; lin_DEF = 0; break; case 'F': lin_DEFN = 2; lin_CN = 1; lin_DEF = 1; break; case 'G': lin_DEFN = 3; lin_CN = 1; lin_DEF = 2; break; } double prob_i = labProb[4 * i + 0]; double prob_c = labProb[4 * i + 1] + labProb[4 * i + 2] + labProb[4 * i + 3]; /* soma = Pr(C) = Pr(E) + Pr(F) + Pr(G) */ if (prob_i + prob_c != 0.0){ /* Tira as primeiras bases que não foram rotuladas */ if (type == 0) { /* Determina a coluna para as tabelas {score_DEFN} e {score_DEF}: */ int col_DEFN = 0; int col_DEF = 1; for (cnt = 1; cnt < 4; cnt++){ if (labProb[4 * i + cnt] > labProb[4 * i + col_DEFN]) { col_DEFN = cnt; } if (labProb[4 * i + cnt] > labProb[4 * i + col_DEF]) { col_DEF = cnt; }} (*score_DEFN)[4 * lin_DEFN + col_DEFN] += 1; /* Determina a coluna para a tabela {score_CN}: */ col_CN = (prob_i > prob_c ? 0 : 1); (*score_CN)[2 * lin_CN + col_CN] += 1; /* Determina se o event tem janela para a tabela {score_DEF}: */ if (lin_CN != 0) { (*score_DEF)[3 * lin_DEF + (col_DEF - 1)] += 1; } } else { for (col_DEFN = 0; col_DEFN < 4; col_DEFN++){ (*score_DEFN)[4 * lin_DEFN + col_DEFN] += labProb[4 * i + col_DEFN]; } if ((lin_CN != 0) && (prob_c != 0)) { for(col_DEF = 1; col_DEF < 4; col_DEF++){ /* Normalizar o valor das probabilidades de {score_DEF}: */ (*score_DEF)[3 * lin_DEF + (col_DEF - 1)] += (labProb[4 * i + col_DEF]/ prob_c); } } (*score_CN)[2 * lin_CN + 0] += prob_i; (*score_CN)[2 * lin_CN + 1] += prob_c; } } } } } /* struct usada para guardar um event e sua probabilidade de ocorrencia para uma determinada tupla */ typedef struct TPROB{ char *event; /* guarda o rotulo de um determinado event */ double valor; /* guarda o valor da probabilidade para esse determinado event */ }tprob; /* struct usada para caregar os dados do arquivo com as frequencias de ocorrencia das triplas no arquivo de treinamento, posteriormente o valor da frequencia serah transformada em probabilidade */ typedef struct TFREQ{ char *tupla; /* guarda o rotulo da tripla */ tprob *prob; /* aponta para uma fila onde estao guardados os eventos validos com suas respectivas probabilidades para esta tupla */ }tfreq; /* struct que guarda o valor dos dados de uma tupla da sequencia de entrada. Serah usado para montar uma fila que guardarah os dados de cada tupla da sequencia de entrada na ordem em que aparecem no arquivo, para a construcao da matriz em tons de cinza*/ typedef struct TNO{ char *event; /* rotulo do event de maior probabilidade dentre todos os considerados para a tupla */ double prob; /* valor da maior probabilidade dos eventos considerados para a tupla */ double prob_exon; /* guarda a probabilidade da tupla pertencer ao event rotulado como exon */ struct TNO *prox; /* ponteiro para o proximo da lista */ }tno;