Pages: [1] 2   Go Down
Print
Author Topic: Check esercizio  (Read 2776 times)
0 Members e 1 Utente non registrato stanno visualizzando questa discussione.
Franco Barbanera
Moderator
Forumista Eroico
*****
Offline Offline

Posts: 3.079



WWW
« on: 02-01-2014, 14:41:11 »

Poiche' non ho ancora visto sul Forum una vostra proposta di soluzione
per l'esercizio Erlang che avevo dato a lezione l'ultima volta, l'ho fatto io stamattina.
A voi il compito di controllare la mia soluzione!
Quello che trova e rimedia ad eventuali errori presenti, o che lo trova corretto
e che lo testa su qualche esempio, avra' un esercizio dello scritto valutato
come svolto correttamente.

FB

Esercizio:
Si modifichi la soluzione dell'es. 14 (Actors and Erlang) in modo da trattare
automi su qualsiasi alfabeto.
Si suppone che un automa venga descritto da:
          a list of the symbols of the alphabet (represented as atoms);
          a list of the states (represented as numbers or atoms) where the first one is the initial state;
          a transition function, mapping state-symbol pairs to states or to the atom none (in case the transition
          function is undefined);
         a function mapping states to the atoms final or notfinal (describing whether a state is a final one or not).

Soluzione:

-module(regExprGen).
-export([manager/0,state/2,create/1]).

% Module for automata for regular languages on any alphabet.
%
% Each state is a process. Many strings can be parsed in parallel.
%
% create : creates an automaton together with its manager. Returns the PID of the manager.
%          An automaton is described by:
%          a list of the symbols of the alphabet (represented as atoms);
%          a list of the states (represented as numbers or atoms) where the first one is the initial state;
%          a transition function, mapping state-symbol pairs to states or to the atom none (in case the transition
%          function is undefined);
%          a function mapping states to the atoms final or notfinal (describing whether a state is a final one or not).
%          Example:
%          The automaton corresponding to the regular expression abc*+c(bb)*
%          and which has the following transition table.
%              a    b   c       Final States = q2, q3
%           0  1        3       < notfinal
%           1       2           < notfinal
%           2           2       < final
%           3       4           < final
%           4       3           < notfinal
%           is described by
%           [a,b,c]
%           [0,1,2,3,4]
%           transFun  (which is the function corresponding to the table above
%           finalFun  (which describes the final/notfinal column above)
%
%          In case the above table is represented as below, it is not difficult to
%          
%          
%          A parsing request can be sent to the manager by means of a triple {requestParsing,ID,List}
%          where ID is the PID of whom makes the request, and List is the string to be parsed.
%
%          For sake of simplicity a string is represented by the list of the atoms that represents symbols of the
%          alphabet.
%
%          The manager sends the request to the initial state and receives the answer that is then
%          delivered to whom made the request.
%          The original string to be parsed is kept through all the parsing process and sent back with the
%          answer in order one can send onother request even before one gets the answer of the previous request.
%
% manager : It is the function corresponding to the manager of the automaton.
%          Once spawned by the create function, the manager waits for the address of the initial state,
%          that the create function itself sends to it (This procedures is a simple trick necessary since
%          the manager and the initial state need the PID of each other.)
%
% state   : It is the function corresponding to a state. Its arguments are the PID of the manager
%           and one atom (final or nofinal) representing whether the spawned state is final or not.
%           Once spawned by the create function, a state waits for a triple of PIDs
%           corresponding, respectively, to the states it has to be connected to for the characters a, b, or c.
%           In case a state is not connected to another state for a particular character (and hence the
%           string has to be rejected), the corresponding element in the triple is the atom none instead of a PID.
%           (As for the manager, this trick is needed in order to have automata with cliques.          
%
%          



% The predefined function lists:nth(N,L) returns the N-th element of the list L
% (the prefix "lists:" denotes that the function list is from the module lists).

% La funzione position restituisce la posizione di un elemento in una lista (supponendo che
% l'elemento sia nella lista)

position(Elem,[Elem|_]) -> 1;
position(Elem,[_|Rest]) -> 1 + position(Elem,Rest).


% The function firstList2secondList takes two lists and returns a function that, given an element
% of the first list, returns the element of the second list having the same position.
% Notice the use of "fun" to denote an anonymous function.

firstList2secondlist(First,Second) ->
              fun(Elem) -> N = position(Elem,First);
                           lists:nth(N,Second)
              end.position(Elem,Rest).


% The function firstList2secondList takes two (non-empty and with the same length) lists and returns a function that, given an element
% of the first list, returns the element of the second list having the same position.
% Notice the use of "fun" to denote an anonymous function.

firstList2secondlist(First,Second) ->
              fun(Elem) -> N = position(Elem,First);
                           lists:nth(N,Second)
              end.

% alternative definition:
%
%firstList2secondlist([One|Ones],[Two|Twos]) ->
%             fun(X) -> if (X==One) -> Two;
%                          true     -> F = firstList2secondlist(Ones,Twos);
                                       F(X)
%                       end.
%             end.



 
% The following function returns the same transition function as TransFun, where
% pids are used instead of states. The pid-state correspondence is given by the
% two arguments PIDSList and StatesList

transFun2transFunPIDS(TransFun,PIDSList,StatesList) ->
             fun(PID,Char) -> state2pid = firstList2secondList(StatesList,PIDSList),
                              pid2state = firstList2secondList(PIDSList,StatesList),
                              state2pid(TransFun(pid2state(PID),Char))
             end.



% Aside: Notice that to use the same variable twice (or more) in argument patters is allowed in Erlang (similarly to
% what happens in Prolog). Such a thing is not allowed in Haskell.


create(CharsList,StatesList,TransFun,FinalFun) ->          %% we create the manager and the (process-)states. The PID of manager is returned.

                      IDmanager = spawn(exprReg,manager,[]),
                      StatesPIDS    = [spawn(exprReg,state,[IDmanager,FinalFun(State)]) || State <- StatesList],

                      %% we connect the manager to the initial state and the various states among themselves
                      %% according to the transition function that uses PIDS instead of names of states.

                      [QInit|_] = StatesPIDS,
                      TransFunPIDS = transFun2transFunPIDS(TransFun,StatesPIDS,StatesList),
                      IDmanager!QInit,
                      [IDQ!TransFunPIDS || IDQ <- StatesPIDS ],
                      IDmanager.
                      


manager() -> receive
               IDinitial -> loopmanager(IDinitial)
             end.                      
                  

loopmanager(IDinitial) ->
            
               receive

                   {requestParsing,ID,List} -> IDinitial ! {List,ID,List};
                                              
                   {accepted,ID,List}       -> ID ! {accepted,List};

                   {rejected,ID,List}       -> ID ! {rejected,List}

               end,
            
               loopmanager(IDinitial).




state(IDmanager,Final) -> receive
                             TransFunPIDS -> loop(TransFunPIDS,IDmanager,Final)
                          end.




 loop(TransFunPIDS,IDmanager,Final) ->
          
        
         receive

              {[],ID,List}          ->    if
                                             (Final == final)  -> IDmanager ! {accepted,ID,List};
                            
                                              true             -> IDmanager ! {rejected,ID,List}
                    
                                          end;

              {[ Char | Cs ],ID,List}  ->  Next = TransFunPIDS(self(),Char),
                                          
                                           if
                                              (Next == none)    ->  IDmanager ! {rejected,ID,List};

                                               true             ->  Next ! {Cs,ID,List}
                                           end
          end,
            
         loop(TransFunPIDS,IDmanager,Final).



                      

« Last Edit: 09-01-2014, 15:36:35 by Franco Barbanera » Logged
SixArt
Matricola
*
Offline Offline

Gender: Male
Posts: 51



« Reply #1 on: 03-01-2014, 15:53:32 »

Buongiorno,
ho provato ad eseguire il codice ma c'era qualche cosa da sistemare, e qualcosa ancora non va', andiamo in ordine:

1) Ho sistemato la definizione dell'export, ora è così:
Code:
-export([create/3,manager/0,state/2]).

2) Ho utilizzato la versione alternativa di firstList2secondlist e c'era la punteggiatura da sistemare e inoltre ho eliminato position perchè non era più necessaria.
Code:
firstList2secondlist([One|Ones],[Two|Twos]) ->
fun(Elem)-> if
(Elem == One)  -> Two;
true             -> F = firstList2secondlist(Ones,Twos), F(Elem)
end
end.

3) Arriviamo alla nota dolente, compilando tutto ancora sono presenti 2 errori la cui esistenza è dovuta a questa parte di codice
Code:
transFun2transFunPIDS(TransFun,PIDSList,StatesList) ->
fun(PID,Char) ->
state2pid = firstList2secondlist(PIDSList,StatesList),
pid2state = firstList2secondlist(StatesList,PIDSList),
state2pid(TransFun(pid2state(PID),Char))
end.

gli errori sono:
Code:
regExprGen.erl:20: function pid2state/1 undefined
regExprGen.erl:20: function state2pid/1 undefined

questo perchè non trova le definizioni di pid2state e state2pid che comunque sono associate alle funzioni che restituisce transFun2transFunPIDS. Non riesco a capire come si può risolvere questo problema, anche perchè cercando in rete non ho trovato molto (o forse sono io che non so cercare).

Qualche suggerimento??

Logged
Franco Barbanera
Moderator
Forumista Eroico
*****
Offline Offline

Posts: 3.079



WWW
« Reply #2 on: 03-01-2014, 17:21:01 »

Quote
state2pid = firstList2secondlist(PIDSList,StatesList),
pid2state = firstList2secondlist(StatesList,PIDSList),
state2pid(TransFun(pid2state(PID),Char))

Credo (spero...) che l'errore sia qui. E nel caso sarebbe abbastanza banale:
con "=" noi possiamo associare dei valori a delle variabili.
E "pid2state", non iniziando con una maiuscola, non e' una variabile...
Avrei dovuto scrivere

State2pid = firstList2secondlist(PIDSList,StatesList),
Pid2state = firstList2secondlist(StatesList,PIDSList),
State2pid(TransFun(Pid2state(PID),Char))

Vedi un po' ora come va e
fammi sapere.

FB
Logged
SixArt
Matricola
*
Offline Offline

Gender: Male
Posts: 51



« Reply #3 on: 03-01-2014, 20:45:38 »

Perfetto, così tutti gli errori sono andati via.
2 domande però mi nascono..

1) perchè in create mette charslist se non viene mai usata?
Code:
create(CharsList,StatesList,TransFun,FinalFun) ->
IDmanager = spawn(regExprGen,manager,[]),
StatesPIDS = [spawn(regExprGen,state,[IDmanager,FinalFun(State)]) || State <- StatesList],
[QInit|_] = StatesPIDS,
TransFunPIDS = transFun2transFunPIDS(TransFun,StatesPIDS,StatesList),
IDmanager!QInit,
[IDQ!TransFunPIDS || IDQ <- StatesPIDS ],
IDmanager.
serve a qualcosa o possiamo eliminarla?

2) stavo provando a creare l'automa per abc*+c(bb)* con tabella di transizione
Code:
                      a     b     c
         init      s1          s2
          s1             s3   
          s2             s4 
          s3                    s3
          s4                    s2

dove s2 e s3 sono finali

e quindi scrivendo nella shell questo:
Code:
regExprGen:create[par1,par2,par3,par4].

dove:
par1 = [a,b,c] le lettere ammesse
par2 = [init,s1,s2,s3,s4] i 5 stati possibili dell'automa
par3 = [[s1,none,s2],[none,s3,none],[none,s4,none],[none,none,s3],[none,none,s2]] le righe della tabella di transizione
par4 = [notfinal,notfinal,final,final,notfinal]

ma mi da questo errore
Code:
** exception error: bad function [notfinal,notfinal,final,final,notfinal]
     in function  regExprGen:'-create/4-lc$^0/1-0-'/3 (regExprGen.erl, line 28)
     in call from regExprGen:create/4 (regExprGen.erl, line 28)

come la passo la funzione degli stati finali???
Logged
Franco Barbanera
Moderator
Forumista Eroico
*****
Offline Offline

Posts: 3.079



WWW
« Reply #4 on: 03-01-2014, 22:02:31 »

Quote
1) perchè in create mette charslist se non viene mai usata?

Era in una versione preliminare.

Quote
serve a qualcosa o possiamo eliminarla?

se non serve...




Quote
par1 = [a,b,c] le lettere ammesse
par2 = [init,s1,s2,s3,s4] i 5 stati possibili dell'automa
par3 = [[s1,none,s2],[none,s3,none],[none,s4,none],[none,none,s3],[none,none,s2]] le righe della tabella di transizione
par4 = [notfinal,notfinal,final,final,notfinal]

guarda che par 3 e par4 devono essere funzioni!

Quote
come la passo la funzione degli stati finali???

Dopo tutta la programmazione funzionale che abbiamo fatto non siamo
in grado di definire due funzioni parziali (o,detta in altro modo,su un dominio finito)?

FB
[/quote]
Logged
SixArt
Matricola
*
Offline Offline

Gender: Male
Posts: 51



« Reply #5 on: 04-01-2014, 11:06:39 »

Quote
-Era in una versione preliminare.
Quote
-se non serve.
controllo meglio dopo per ora mi sto concentrando sul come passare le funzioni
Quote
guarda che par 3 e par4 devono essere funzioni!

Dopo tutta la programmazione funzionale che abbiamo fatto non siamo
in grado di definire due funzioni parziali (o,detta in altro modo,su un dominio finito)?

invece di provare a lavorare con il codice completo mi sto concentrando solo sulle 2 funzioni firstList2secondlist e transFun2transFunPIDS e per questo ho creato un file di test
Code:
-module(test).
-export([firstList2secondlist/2,transFun2transFunPIDS/3]).

firstList2secondlist([One|Ones],[Two|Twos]) ->
fun(Elem)-> if
(Elem == One)  -> Two;
true             -> F = firstList2secondlist(Ones,Twos), F(Elem)
end
end.

transFun2transFunPIDS(TransFun,PIDSList,StatesList) ->
fun(PID,Char) ->
State2pid = firstList2secondlist(PIDSList,StatesList),
Pid2state = firstList2secondlist(StatesList,PIDSList),
State2pid(TransFun(Pid2state(PID),Char))
end.

- firstList2secondlist funziona, se passo 2 liste mi restituisce una funzione dove passando un elemento presente nella prima lista restituisce l'elemento della seconda nella stessa posizione.

- transFun2transFunPIDS qui nascono i problemi. Bisogna passare una funzione che prende in input 2 parametri e ne restituisce 1. io ne ho creata una stupida che dovrebbe fare questo e lo fa.
Code:
-module(test2).
-export([transFun/2]).

transFun(A,B) ->
if
(A==2000) -> 5;
(B==5000) -> 4;
true        -> 1
end.

ma non riesco a capire come passarla come parametro, questa funzione l'ho provata sia inserita in un file a parte (test2 come qui nel codice) sia inserita nello stesso file delle altre funzioni.
Logged
Franco Barbanera
Moderator
Forumista Eroico
*****
Offline Offline

Posts: 3.079



WWW
« Reply #6 on: 05-01-2014, 18:25:15 »


ma non riesco a capire come passarla come parametro, questa funzione l'ho provata sia inserita in un file a parte (test2 come qui nel codice) sia inserita nello stesso file delle altre funzioni.

Quando apri l'interprete Erlang e' come se ti trovassi in un attore.
Puoi associare ad una variabile la tua funzione.
E poi passare il nome della variabile a cui e' associata la funzione
come parametro per la creazione del sistema.

Fammi sapere.

FB
Logged
SixArt
Matricola
*
Offline Offline

Gender: Male
Posts: 51



« Reply #7 on: 06-01-2014, 14:28:35 »

Ok, sono riuscito ad associare la funzione alla variabile però spuntano sempre errori strani che non dovrebbero spuntare in base ai parametri che passo.

Codice test2 che serve per creare la funzione transFun che prende 2 parametri e ne restituisce 1, che poi passiamo a transFun2transFunPIDS.
Code:
-module(test2).
-export([transFun/0]).

transFun() ->
fun(A,B) ->
if
(A==2000) -> 5;
(B==5000) -> 4;
true        -> 6
end
end.
Codice test dove ci sono solo le funzioni firstList2secondlist e transFun2transFunPIDS.
Code:
-module(test).
-export([firstList2secondlist/2,transFun2transFunPIDS/3]).

firstList2secondlist([One|Ones],[Two|Twos]) ->
fun(Elem)-> if
(Elem == One)  -> Two;
true             -> F = firstList2secondlist(Ones,Twos), F(Elem)
end
end.

transFun2transFunPIDS(TransFun,PIDSList,StatesList) ->
fun(PID,Char) ->
State2pid = firstList2secondlist(PIDSList,StatesList),
Pid2state = firstList2secondlist(StatesList,PIDSList),
State2pid(TransFun(Pid2state(PID),Char))
end.
Quello che non capisco è perchè mi da errore l'esecuzione della funzione restituita da transFun2transFunPIDS con input ad esempio 4 e 9. Di seguito la shell e la spiegazione dei comandi
Code:
%creo lista stati
1> StatesList = [1,2,3,4,5].
[1,2,3,4,5]

%creo lista pids
2> PIDSList = [6,7,8,9,10].
[6,7,8,9,10]

%compilo i 2 file
3> c(test).
{ok,test}
4> c(test2).
{ok,test2}

%associo la funzione restituita da transFun di test2 ad una variabile
5> TransFun = test2:transFun().
#Fun<test2.0.39981661>

%associo la funzione restituita da transFun2transFunPIDS di test ad una variabile
6> Transizione = test:transFun2transFunPIDS(TransFun,PIDSList,StatesList).
#Fun<test.1.72679986>

%provo Transizione con input 4 e 10
7> Transizione(4,9).
** exception error: no function clause matching test:firstList2secondlist([],[]) (test.erl, line 4)
     in function  test:'-firstList2secondlist/2-fun-0-'/5 (test.erl, line 7)


Quello che non capisco è perchè mi da quell'errore a runtime, facendomi i conti eseguendo Transizione(4,9) dovrebbe essere:
-State2Pid è l'associazione di firstList2secondlist con prima lista [6,7,8,9,10] e seconda [1,2,3,4,5]
-Pid2State è l'associazione di firstList2secondlist con prima lista [1,2,3,4,5] e seconda [6,7,8,9,10]
-State2pid(TransFun(Pid2state(PID),Char)) qui Pid2State(PID) con PID=4 dovrebbe dare 9, TransFun(9,4) dovrebbe dare 6 per come l'ho costruita e State2pid(6) dovrebbe dare 1.
perchè invece non funziona?

Come funzione FinalFun va bene la funzione restituita da firstList2secondlist con prima lista quella degli stati e seconda quella costituita da final/notfinal associati agli stati?
« Last Edit: 06-01-2014, 16:14:39 by SixArt » Logged
Franco Barbanera
Moderator
Forumista Eroico
*****
Offline Offline

Posts: 3.079



WWW
« Reply #8 on: 06-01-2014, 19:07:45 »

Quote
Come funzione FinalFun va bene la funzione restituita da firstList2secondlist con prima lista quella degli stati e seconda quella costituita da final/notfinal associati agli stati?

certo
Logged
SixArt
Matricola
*
Offline Offline

Gender: Male
Posts: 51



« Reply #9 on: 06-01-2014, 21:03:59 »

il problema ora è creare transFun, io ho provato con questa
Quote
%POSITION restituisce la posizione dell'elemento nella lista
position(Elem,[Elem|_]) ->1;
position(Elem,[_|Rest]) ->1+position(Elem,Rest).

%RETURN ELEMENT restituisce l'elemento della lista di posto Position
returnElem(Position,[Elem|Rest]) ->
   if (Position==1) -> Elem;
   true                -> returnElem(Position-1,Rest)
   end.
   
%MYTRANSFUN
myTransFun([Trans|TransList]) ->
   fun([Pids|PidsList],[States|StatesList],CharsList) ->
      fun(Pid,Char) ->
         Position = position(Char,CharsList),
         if
            (Pid==Pids) -> Lista = Trans;
            true           -> F = firstList2secondlist(PidsList,TransList), Lista = F(Pid)
         end;
      State = returnElem(Position,Lista),
      if (State==States) -> Pids;
      true           -> F2 = firstList2secondlist(StatesList,PidsList), F2(State)
      end;
      end
   end.

L'idea è quella di passare la tabella di transizione come lista di liste, dove ogni lista interna è una lista ad esempio uguale a questa [s1,none,none]. Viene restituita una funzione che riceve la lista dei pid, la lista degli stati e la lista dei caratteri (questa viene utilizzata in automatico dentro create). Viene poi restituita un'altra funzione che prende in input il pid e il carattere (questa è quella che volevamo per passarla a transFun2transFunPIDS).
Diciamo che calcola la posizione del carattere all'interno di charslist, poi in base al pid prende la lista di transizione appropriata dalla quale prendiamo lo stato a cui saltare usando la posizione precedentemente calcolata. In fine ci calcoliamo il pid di questo stato.
Può andare una funzione di questo tipo?

Comunque mi da un errore che non riesco a levare
Code:
regExprGen.erl:27: syntax error before: State

Ovviamente ho sistemato anche l'export e create nel seguente modo
Code:
-export([create/4,manager/0,state/2,firstList2secondlist/2,position/2, returnElem/2,myTransFun/1]).

%CREATE crea l'automa
create(CharsList,StatesList,TransFun,FinalFun) ->
IDmanager = spawn(regExprGen,manager,[]),
StatesPIDS = [spawn(regExprGen,state,[IDmanager,FinalFun(State)]) || State <- StatesList],
[QInit|_] = StatesPIDS,
TransFunPIDS = transFun2transFunPIDS(TransFun(StatesPIDS,StatesList,CharsList),StatesPIDS,StatesList),
IDmanager!QInit,
[IDQ!TransFunPIDS || IDQ <- StatesPIDS ],
IDmanager.
Logged
SixArt
Matricola
*
Offline Offline

Gender: Male
Posts: 51



« Reply #10 on: 07-01-2014, 18:50:26 »

Con la sistemazione di oggi sono riuscito a fare la funzione di transizione, il codice completo è:
Code:
-module(regExprGen).
-export([create/3,manager/0,state/2,firstList2secondlist/2,myTransFun/2]).

%POSITION
position(Elem,[Elem|_]) ->1;
position(Elem,[_|Rest]) ->1+position(Elem,Rest).



%RETURN ELEMENT
returnElem(Position,[Elem|Rest]) ->
if (Position==0) -> Elem;
true                -> returnElem(Position-1,Rest)
end.


%MYTRANSFUN
myTransFun(TransList,CharsList) ->
fun(PID,Char) ->
returnElem(position(Char,CharsList),returnElem(PID,TransList))
end.




%FIRSTLIST2SECONDLIST restituisce una funzione che dato un elemento della prima lista restituisce quello della seconda nella stessa posizione
firstList2secondlist([One|Ones],[Two|Twos]) ->
fun(Elem)-> if
(Elem == One)  -> Two;
true             -> F = firstList2secondlist(Ones,Twos), F(Elem)
end
end.


%TRANSFUN2TRANSFUNPIDS ci dice in che stato passare
transFun2transFunPIDS(TransFun,PIDSList,StatesList) ->
fun(PID,Char) ->
State2pid = firstList2secondlist(StatesList,PIDSList),
Pid2state = firstList2secondlist(PIDSList,StatesList),
State2pid(TransFun(Pid2state(PID),Char))
end.



%CREATE crea l'automa
create(StatesList,TransFun,FinalFun) ->
IDmanager = spawn(regExprGen,manager,[]),
StatesPIDS = [spawn(regExprGen,state,[IDmanager,FinalFun(State)]) || State <- StatesList],
[QInit|_] = StatesPIDS,
TransFunPIDS = transFun2transFunPIDS(TransFun,StatesPIDS,StatesList),
IDmanager!QInit,
[IDQ!TransFunPIDS || IDQ <- StatesPIDS ],
IDmanager.


%MANAGER
manager() -> receive
IDinitial -> loopmanager(IDinitial)
end.



%LOOPMANAGER
loopmanager(IDinitial) -> receive
{requestParsing,ID,List} -> IDinitial ! {List,ID,List};
        {accepted,ID,List}       -> ID ! {accepted,List};
{rejected,ID,List}       -> ID ! {rejected,List}
end,
        loopmanager(IDinitial).



%STATE
state(IDmanager,Final) -> receive
TransFunPIDS -> loop(TransFunPIDS,IDmanager,Final)
end.



%LOOP
loop(TransFunPIDS,IDmanager,Final) -> receive
{[],ID,List}          ->    if
                                    (Final == final)  -> IDmanager ! {accepted,ID,List};
                                         true             -> IDmanager ! {rejected,ID,List}
                                    end;
{[ Char | Cs ],ID,List}  ->  Next = TransFunPIDS(self(),Char),
                                    if
                                    (Next == none)    ->  IDmanager ! {rejected,ID,List};
                                         true             ->  Next ! {Cs,ID,List}
    end
end,
loop(TransFunPIDS,IDmanager,Final).
e non da errore in fase di compilazione.

Ora come faccio a passare la stringa da controllare all'attore dopo aver creato l'automa??
questo è quello che faccio però non so come proseguire
Code:
1> c(regExprGen). %compilo
{ok,regExprGen}
2> CharsList = [a,b].
[a,b]
3> StatesList = [0,1,2,3,4].
[0,1,2,3,4]
4> TransList = [[1,2],[none,4],[none,3],[3,none],[none,1]].
[[1,2],[none,4],[none,3],[3,none],[none,1]]
5> FinalList = [notfinal,final,notfinal,final,notfinal].
[notfinal,final,notfinal,final,notfinal]
6> FinalFun = regExprGen:firstList2secondlist(StatesList,FinalList).
#Fun<regExprGen.1.98855822>
7> TransFun = regExprGen:myTransFun(TransList,CharsList).
#Fun<regExprGen.0.98855822>
8> IDmanager = regExprGen:create(StatesList,TransFun,FinalFun).
<0.45.0>
9>

l'automa se è fatto bene accetta tutte le stringe della forma a(bb)*+bba*
Logged
Franco Barbanera
Moderator
Forumista Eroico
*****
Offline Offline

Posts: 3.079



WWW
« Reply #11 on: 08-01-2014, 08:59:19 »

Beh, ora invii al manager una richiesta di parsing attraverso una send.
E poi attenti il risultato mediante una receive.

FB
Logged
SixArt
Matricola
*
Offline Offline

Gender: Male
Posts: 51



« Reply #12 on: 08-01-2014, 09:06:18 »

Beh, ora invii al manager una richiesta di parsing attraverso una send.
E poi attenti il risultato mediante una receive.

con questa riga di shell
Code:
IDmanager = regExprGen:create(StatesList,TransFun,FinalFun).
ottengo l'ID del manager giusto?

il manager è in receive ma come faccio a inviare la stringa da analizzare?
Code:
IDmanager!abb.
non sembra funzionare, o almeno in output mi da sempre la stringa stessa.
« Last Edit: 08-01-2014, 09:45:28 by SixArt » Logged
Franco Barbanera
Moderator
Forumista Eroico
*****
Offline Offline

Posts: 3.079



WWW
« Reply #13 on: 08-01-2014, 13:08:59 »

 Per fare il parsing dopo aver creato il sistema e il manager
devi fare la segunte send

  IDmanager!{requestParsing,self(),[a,c,a,a]}

e poi aspettare il risultato con

receive

   {X,[a,c,a,a]} -> true

end.

E poi vedere se associato ad X ci sia l'atomo accepted o rejected.

Fammi sapere.

FB
 
Logged
SixArt
Matricola
*
Offline Offline

Gender: Male
Posts: 51



« Reply #14 on: 08-01-2014, 14:09:15 »

Quote
Per fare il parsing dopo aver creato il sistema e il manager
devi fare la segunte send
IDmanager!{requestParsing,self(),[a,c,a,a]}
Il manager e tutto il sistema non viene creato in automatico con create?
E inoltre il PID del manager non è quello restituito?

la richiesta di parsing io l'ho fatta così
IDmanager!{requestParsing,self(),[a,c,a,a]}.
ma come mi metto in attesa del risultato??

io avevo pensato di fare {X,List} = IDmanager!{requestParsing,self(),[a,c,a,a]}.
ma mi da errore. 
Logged
Pages: [1] 2   Go Up
Print
Jump to: