| V I S U A L I Z Z A D I S C U S S I O N E |
| juniorjak |
Inserito il - 17/06/2007 : 02:29:19
Salve a tutti, nessuno di voi ha realizzato la trasformazione delle produzioni da monotone a contestuali? Sono riuscito a combinare qualcosa ma non mi funziona perfettamente, inoltre volevo sapere se qualcuno ha implementato la funzione per verificare che la G sia CS, quest'ultima mi funziona abbastanza bene credo...se qualcuno vuole confrontare...
bye |
| 8 U L T I M E R I S P O S T E (in alto le più recenti) |
| t_l_b |
Inserito il - 25/06/2007 : 08:01:00
certo  |
| RigorMortis |
Inserito il - 24/06/2007 : 19:33:17
dannato tlb... ^_^
passato l'orale alla fine? |
| t_l_b |
Inserito il - 22/06/2007 : 11:51:13
Citazione:
Messaggio inserito da juniorjak
Citazione:
Messaggio inserito da t_l_b
se lo implementi bene funziona sicuro..
si infatti va a meraviglia :) ho provato con produzioni belle grandi... nessun problema :)
felice per te...
cmq se hai bisogno di qualcosa mandami un mp... |
| juniorjak |
Inserito il - 21/06/2007 : 17:24:15
Citazione:
Messaggio inserito da t_l_b
se lo implementi bene funziona sicuro..
si infatti va a meraviglia :) ho provato con produzioni belle grandi... nessun problema :)
|
| t_l_b |
Inserito il - 19/06/2007 : 14:32:52
se lo implementi bene funziona sicuro.. |
| juniorjak |
Inserito il - 17/06/2007 : 22:03:47
Citazione:
Messaggio inserito da t_l_b
da monotona a cs si fa seguendo l'algoritmo che c'è sul libro di semeraro...
ma infatti ho fatto così... |
| t_l_b |
Inserito il - 17/06/2007 : 10:34:18
int is_CS(Grammar *g)
{
Word *l;
Word *r;
Production *p;
int s=0;
int m=1;
int cs=-1;
int i=0; //contatore
int j=0; // "
int k=0; // "
int z=0; // "
if(g == NULL) return cs;
while(i<g->numprod && m==1)
{
p=&g->productions[i];
l=&p->left;
r=&p->right;
/*assegna a m valore 1 se la produzione cosiderata e' monotona
oppure è una lambda produzioni*/
if(l->length <= r->length || r->length==0) m=1;
else m=0;
i++;
}
i=0; p=0; l=0; r=0;
if(m==1)
{
cs=1;
while(i<g->numprod && cs==1)
{
p=&g->productions[i];
l=&p->left;
r=&p->right;
s=0;
/*se viene individuata una lambda produzione viene assegnato ad s
l'unico simbolo NT presente nella pt sx della produzione e viene
confrontato con ogni carattere della pt dx di ogni produzione*/
if((l->length==1 && (is_nonterminal(l->word[0]))) && r->length==0)
{
s=l->word[0];
p=0;
r=0;
while(k<g->numprod && cs==1)
{
p=&g->productions[k];
r=&p->right;
while (((z<r->length || r->length==0)&& z<r->length) && cs==1)
{
/*se s viene individuato nella parte destra
di una qualsiasi produzione a cs viene assegnato 0*/
if(s==r->word[j]) cs=0;
j++;
z++;
}
k++;
}
}
i++;
}
}
else cs=0;
return cs;
}
**********************************
questa funzione implementata da me funziona sicuro (l'ha testata lops  )...
potresti renderla più elegante facendo il controllo sui contesti e
chiamando funzioni esterne per il controllo sulla monotonia... |
| t_l_b |
Inserito il - 17/06/2007 : 09:58:13
da monotona a cs si fa seguendo l'algoritmo che c'è sul libro di semeraro...
|
