[CAML] Aiuto su automi

[Marco89__1]

Salve a tutti!

Avrei bisogno di una mano con un esercizio in CAML, in pratica usando gli automi dovrei verificare se date 2 lettere in input e una lista di parole , il programma mi restituisca TRUE se esse sono presenti almeno una volta nelle parole altrimenti FALSE se non sono presenti. Devo usare la funzione member?

Grazie,

Marco

[hamming_burst]

con le convenzioni Caml ci sono delle restrizioni. I moduli (meglio librerie) non sono molto potenti per funzionalità, quindi bisogna sporcarsi un po' le mani.
In questo caso String.contains non esiste, ma c'è qualcosa che si avvicina utilizzando

value index_char: string -> char -> int
    index_char s c returns the position of the leftmost occurrence of character c in string s. Raise Not_found if c does not occur in s. 

value rindex_char: string -> char -> int
    rindex_char s c returns the position of the rightmost occurrence of character c in string s. Raise Not_found if c does not occur in s. 

utilizziamo index_char. Ma l'inconveniente è che quando non c'è occorrenza lancia un'eccezione, quindi non abbiamo più una restituizione "elegante" di un booleano, ma poco cambia catturiamo l'eccezione con un try-with e via.

Quindi:

let string_doubleconf c1 c2 string = (index_char string c1)>0 && (index_char string c2)>0;

index_char restituendo un intero non è compatibile con un AND, quindi lo convertiamo con un un trick.

il try-with sostituisce if-then-else, il programma è equivalente.

let rec progCaml a b s_list = 
  match s_list with
    [] -> false
  | x::xs -> try
                (string_doubleconf a b x)
	     with
              Not_found -> prog a b xs;;

dovrebbe esser corretto, non ho tempo di valutarlo. prova te così vedi se è tutto chiaro.

EDIT:
l programma formalizzato così è corretto, valutandolo abb flash mi riporta due errori, uno sintattico l'altro diciamo formale. A te sistemarlo.

[Marco89__1]

EDIT: provo in questo modo!

[Marco89__1]

Sto provando così:

let string_doubleconf c1 c2 string = (index_char string c1)>0 && (index_char string c2)>0;;

let rec progCaml a b s_list = 
  match s_list with
    [] -> false
  | x::xs -> try
                (string_doubleconf a b x)
        with
              Not_found -> progCaml a b xs;;

progCaml 'i' 'c' ["ciao";"lei";"lui"];;

ma esce un "syntax error" su : progCaml 'i' 'c' ["ciao";"lei";"lui"] (precisamente sulla lettera 'i')

sbaglio qualcosa?

[hamming_burst]

tema esce un "syntax error" su : progCaml 'i' 'c' ["ciao";"lei";"lui"] (precisamente sulla lettera 'i')

è perchè utilizzi gli apostrofi invece che gli accenti gravi (gli stessi per gli exec da shell in linux).
vedi: http://caml.inria.fr/pub/docs/manual-ca ... de3.2.html parte sui char.

prova con:

progCaml `i` `c` ["ciao";"lei";"lui"];;

c'è ancora un errore da trovare, qui ti tornerà false (invece che true).
invece:

progCaml `i` `e` ["ciao";"lei";"lui"];;

tornerà correttamente true.
____________________
Il codice corretto:

let string_doubleconf c1 c2 string = (index_char string c1)>=0 && (index_char string c2)>=0;;
let rec progCaml a b s_list = 
  match s_list with
    [] -> false
  | x::xs -> try
                (string_doubleconf a b x)
	     with
              Not_found -> progCaml a b xs;;

[Marco89__1]

Cavolo non avevo notato gli accenti!!

Adesso funziona tutto! provo un po' di casi comunque grazie mille a hamming_burst, senza il tuo aiuto non ce l'avrei fatta! Grazie anche a apatriarca

[apatriarca]

Il programma adesso funziona.. ma non dovevi comunque farlo implementando l'automa a stati finiti? Percui non credo che il lavoro sia effettivamente finito..

[Marco89__1]

No il lavoro non è finito adesso vedo come implementare gli automi!

[Marco89__1]

Sto provando a risolvere il problema però il link che dove sono spiegati gli automoi fa riferimento a OCAML ( link).

Dovrebbe essere diverso in CAML no?

[hamming_burst]

Non fissarti su di un esempio, quello che ti ho proposto nel link è il primo risultato valido di google. Sì, è scritto in OCaml ed utilizza un costrutto presente solo in esso, esportarlo è un casino (almeno con le tue conoscenze, se non sai cosa sia il polimorfismo la vedo dura...).
Ma il tipo automata è esportabile senza problemi, e se leggi bene le tue dispense sotto: Grafi che rappresentano macchine a stati, implementa esattamente quello.

Speravo che leggendoti le dispense sugli automi (il tuo docente te le ha datte appositamente, e sono scritte piuttosto bene) capissi che bisogna prima comprendere come strutturare l'automa, partendo dal programma in Caml scritto in precedenza, e poi implementarlo. Prima una fase di studio e poi una fase di implementazioni, come scritto per gradi. Anche in progetti reali si fa così (molto in generale...).

Non è complicato te lo mostro direttamente, non avendo molto tempo e voglia di girarci intorno.



Partiamo da una versione più semplice, sai che gli automi lavorano su letterali, quindi su un flusso singolo di lettere (simboli). Dobbiamo immaginare che le strutture dati complesse siano trasformati diciamo in una lunga stringa.

Quindi fissiamo due caratteri speciali come terminatori: uno per le stringhe facciamo il NULL - \0 come in C, ed uno per la lista []. Convertiamo teoricamente (ma anche dopo in pratica) la lista di stringhe in una stringa.

es. ["S1";"S2";"S3"] -> S1\0S2\0S3\0[]

a e b sono i caratteri di input per il confronto, sono dimboli denotabili non hanno significato semantico di 'a' e 'b'.

Non lo descrivo, vorrei che provassi a comprederlo te leggendoti le dispense ed il programma in Caml, è esattamente la riproposizione di esso, prova a scrivere qui cosa accade e i dubbbi. Ti ho dato tutto, tocca a te ora.

[size=85]Si può minimizzare meglio mi pare, per il momento utilizza questa formalizzazione.[/size]

[Marco89__1]

faccio un Up del topic dopo un po' di tempo..

ancora non sono riuscito ad andare avanti, ho visto che ci sono 2 utenti che se la cavano abbastanza bene con gli automi..potete aiutarmi?

[Marco89__1]

faccio un altro UP..