Comment puis-je simuler une boucle while en Prolog par immuable conditions?

Donc, fondamentalement, je suis en train de simuler un code C en Prolog.

Il est facile de simuler boucle while en Prolog est Ici le cas:

Code C:

int a = 1;

while(N)
{
  N--;
  a++; 
}

Prologue code:

prolog_while(0) : !
prolog_while(N, A) :
   N1 is N -1,
   A1 is A + 1,
prolog_while(N1, A1).

Un problème est comment faire pour simuler une boucle while en Prolog par immuable conditions?

Est ici le cas:

int n = 1;
int a = 1;

while(1)
{
   if (N==0)
     goto while_end;
   else
    {
        N--; A++;
    }       
}

while(1)
{
   if (N==0)
     break;
   else
    {
        N--; A++;
    }       
}

Je sais que c'est un peu bizarre, mais, fondamentalement, ce genre de C code est automatiquement généré par une source de l'outil d'analyse de code, donc je m'en occupe...

En gros comment puis-je simuler dans le Prologue? Est-il faisable?

Quelqu'un pourrait-il me donner un peu d'aide?

===================mise à jour============

J'ai essayé d'écrire quelques Prologue du code dans ce sens, mais, fondamentalement, je ne sais toujours pas comment gérer test de la clause.

main :- loop_entry(2, 1), write(N), nl, write(A), nl.

do(A, N, A1, N1) :- A1 is (A + 1), N1 is (N - 1).
test(N) :- ...                 <----- # How to write this part?
loop_entry(N, A) :-
    test(N),
    do(A, N, A1, N1),
    loop_entry(N1,A1).

Comment vous attendez-vous main/1 de travail? Les variables N et A ne sont pas instanciés n'importe où, donc write/1 ne finissent par écrit le nom de l'anonyme variable--quelque chose comme _G978. Plus important encore, la coupe de l'opérateur ! ne signifie pas false, et ne fonctionne pas comme un "break" pour N = 0 -> ! ne fonctionne pas pour induire l'échec de test/1.

OriginalL'auteur lllllllllllll | 2014-04-05

prolog while-loop

8

Le moyen le plus évident de faire une boucle infinie en Prolog est avec repeat/0, et il ressemble à ceci:
```
while(1)
    do_something();
```
devient
```
repeat,
do_something.
```
Le vrai problème devient alors: qu'il n'y a pas de solution évidente analogique à goto ou break en Prolog. Donc, je serais enclin à chercher un modèle comme ceci:
```
while(1) {
  if (test)
    break;
  do_something();
}
```
et la convertir en Prolog comme ceci:
```
loop_entry :-
  test,
  do_something,
  loop_entry.
```
Vous aurez bien sûr besoin d'ajouter vos variables locales en tant que paramètres à loop_entry/0 et de mettre en œuvre test, mais de cette façon, lorsque test échoue, la boucle naturellement.

Suivant votre exemple avec N et A conduit à ce genre de chose:
```
loop_entry(N, A) :-
  N > 0,
  succ(N0, N),
  succ(A, A1),
  loop_entry(N0, A1).
```
Le "test" dans ce cas est simplement N > 0. Si ce n'est pas vrai, le prédicat échouera et vous pouvez aller sur avec vie le Prologue.

Edit #2. Si vous souhaitez que les résultats (N et A) puis ajouter des paramètres supplémentaires pour les valeurs que vous souhaitez retourner et d'en ajouter un alinéa:
```
loop_entry(N, A, ResultN, ResultA) :-
  N > 0, !, 
  succ(N0, N),
  succ(A, A1),
  loop_entry(N0, A1, ResultN, ResultA).
loop_entry(N, A, N, A).
```
Vous pouvez ajouter un cut après que la condition ou de les mettre à l'inverse de la condition dans cette nouvelle clause.

Salut Daniel, merci pour votre réponse, j'ai essayé d'écrire un échantillon prologue code suivez votre réponse, mais je ne sais toujours pas comment gérer test l'article...
J'ai édité la réponse à montrer comment le faire.
Salut Daniel, Merci pour votre réponse, mais, fondamentalement, comment puis-je obtenir les résultats(je veux dire en finale A et N), parce que quand N = 0, N >0 échoue et tous les précédents appel récursif de loop_entry seront vouées à l'échec et puis prolog programme va échouer....
Je suis désolé, mais je ne suis pas très familier avec Prolog, pardonnez-moi si je pose une question stupide...
J'ai édité la réponse encore une fois. 🙂 Garder la foi, vous allez y arriver.

OriginalL'auteur Daniel Lyons

Pas très différent de votre prolog_while prédicat:

prolog_while(N, A) :-
    ( N==0 ->
         true
    ;
         N1 is N -1,
         A1 is A + 1,
         prolog_while(N1, A1)
    ).

Mais plus probablement, vous voulez que la valeur finale d'Un être à la disposition de l'appelant de ce prédicat, donc vous devez le retourner via un argument supplémentaire:

prolog_while(N, A, AFinal) :-
    ( N==0 ->
         AFinal = A
    ;
         N1 is N -1,
         A1 is A + 1,
         prolog_while(N1, A1, AFinal)
    ).

OriginalL'auteur jschimpf

1

De la Logtalk de la bibliothèque standard:
```
:- meta_predicate(whiledo(0, 0)).
whiledo(Condition, Action) :-
    (   call(Condition) ->
        \+ \+ call(Action),
        whiledo(Condition, Action)
    ;   true
    ).
```
Pour les autres traditionnels des constructions en boucle, voir:
https://github.com/LogtalkDotOrg/logtalk3/blob/master/library/loopp.lgt
https://github.com/LogtalkDotOrg/logtalk3/blob/master/library/loop.lgt

Z = 1, whiledo(Z < 4,Z=Z+1) semble toujours à l'échec. Est-il une documentation qui explique comment utiliser ce prédicat?
Non pas que le but Z=Z+1 (ou Z is Z+1, ce que vous avez voulu écrire) est toujours faux. Ainsi, la définition ci-dessus n'est pas utilisable dans ce cas. Mais voir l'autre "boucle" méta-prédicats dans les liens dans ma réponse. E. g. loop::forto(Z, 1, 4, write(Z)) va écrire 1234.

OriginalL'auteur Paulo Moura

Afin de mettre en œuvre tout en boucles dans le Prologue, j'ai écrit un petit interprète pour un langage impératif.

À l'aide de cet interprète, tandis que la boucle peut être écrit comme ceci:

:- initialization(main).
:- set_prolog_flag('double_quotes','chars').

main :-
    imperative_statements((
        A=1,
        N=0,
        while(A<50,(
            A=A+2,
            N=N-1
        ))
        D = increment_var(1)
    )),
    writeln(A),
    writeln(N),
    writeln(D).

increment_var(A,B) :-
    imperative_statements((
        B=A,
        while(B<50,(
            B=B*2
        ))
    )).

print(A,true) :-
    writeln(A).

imperative_statements(A) :-
    term_variables(A,Names),
    length(Names,L),
    length(Input,L),
    length(Output,L),
    set_var(A,Names,Input,Output),
    Names=Output.

set_var(A,Names,Input) :-
    length(Input,L),
    length(Output,L),
    set_var(A,Names,Input,Output),
    Names=Output.

set_var((A,B),Var_names,Input,Output) :-
        set_var(A,Var_names,Input,Output1),
        set_var(B,Var_names,Output1,Output).

set_var(Name=Value,Var_names,Input,Output) :-
    get_var(Value,[Var_names,Input],Value1),
    set_var_(Name=Value1,Var_names,Input,Output).

set_var_(_,[],[],[]).
set_var_(Name=Value1,[Name1|Name2],[Var1|Var2],[Output1|Output2]) :-
    (Name==Name1,Output1=Value1;
    Name \== Name1,Output1=Var1),
    set_var_(Name=Value1,Name2,Var2,Output2).

set_var(while(A,B),Names,Vars,Result) :-
    get_var(A,[Names,Vars],A1),
    (((A1==true)->(set_var(B,Names,Vars,Result1),set_var(while(A,B),Names,Result1,Result)));
    A1==false,Vars=Result).

get_var(Name,[[Name1],[Var1]],Output) :-
    var(Name),Name==Name1,
    Output=Var1.
get_var(Name,[[Name1|Name2],[Var1|Var2]],Output) :-
    var(Name),(Name==Name1,get_var(Name,[[Name1],[Var1]],Output);
    Name \== Name1,get_var(Name,[Name2,Var2],Output)).

get_var([],_,[]).
get_var([Name1|Name2],Vars,[Name3|Name4]) :-
    get_var(Name1,Vars,Name3),
    get_var(Name2,Vars,Name4).

get_var(Name,_,Name) :-
    number(Name);atom(Name).
get_var(A+B,Vars,Output) :-
    get_var(A,Vars,A1),
    get_var(B,Vars,B1),
    Output is A1+B1.
get_var(A-B,Vars,Output) :-
    get_var(A,Vars,A1),
    get_var(B,Vars,B1),
    Output is A1-B1.
get_var(A*B,Vars,Output) :-
    get_var(A,Vars,A1),
    get_var(B,Vars,B1),
    Output is A1*B1.
get_var(A/B,Vars,Output) :-
    get_var(A,Vars,A1),
    get_var(B,Vars,B1),
    Output is A1/B1.
get_var(A**B,Vars,Output) :-
    get_var(A,Vars,A1),
    get_var(B,Vars,B1),
    Output is A1**B1.

get_var((A,B),Vars,Result) :-
    get_var([A,B],Vars,[A1,B1]),
    (A1,B1,Result=true;([A1,B1]=[true,false];[A1,B1]=[false,true]),Result=false).

get_var((A;B),Vars,Result) :-
    (get_var(A,Vars,A1),call(A1);
    get_var(B,Vars,B1),call(B1)) -> (Result = true);
    (get_var(A,Vars,A1),A1=false,Result=false).

get_var(A<B,Vars,Result) :-
    get_var(B>A,Vars,Result).
get_var(A>B,Vars,Result) :-
    %comparison of variables
    get_var([A,B],Vars,[A1,B1]),
    (A1>B1,Result=true;A1<B1,Result=false).

get_var(A==B,Vars,Result) :-
    %comparison of variables
    get_var([A,B],Vars,[A1,B1]),
    (A1==B1,Result=true;A1\=B1,Result=false).

get_var(Input,Vars,Output1) :-
    (\+number(Input)),
    Input =.. [Name|Params],
    \+member(Name,['=',==,'->',not,'[|]',',',';',+,-,*,/,**,^,writeln]),
    length(Params,Params_length),
    Params_length > 0,
    get_var(Params,Vars,Params1),
    append([Name|Params1],[Output1],Input0),
    Input1 =.. Input0,
    call(Input1).

Merci Anderson. Cela fait beaucoup de sens pour moi.

OriginalL'auteur Anderson Green

Vous devez vous connecter pour publier un commentaire.