Aritmética

``is''

Valor is Expresión =$>$ evalúa expresión y unifica el resultado a valor

$ X is 3 + 5.
X = 8
$ 8 is 3 + 5.
yes
$ 3 + 5 is 3 + 5.
no

Expresión debe de evaluar a algo (si no falla) X is 5 + Y solo si ``Y'' tiene un valor asignado

``is'' no es función de asignación X is X + 1 falla!!

suma(X,Y,Z) :- Z is X + Y.

Asumiendo que X y Y tiene valores asignados (luego vemos como podemos asegurar esto).

Otros operadores matemáticos: -, *, /, mod, >, <, >=, =<, =:=, =\=

Factorial: Idea: fact(n) = n*fact(n-1).

factorial(N,F) :-
    N > 0,
    N1 is N - 1,
    fact(N1,F1),
    F is N * F1.
factorial(0,1).

Podemos mejorarlo si añadimos uno (o dos) argumentos extras. Una forma manteniendo un contador hacia arriba (desde 0 hasta N), la otra manteniendo un contador hacia abajo (desde N hasta 0).

fact(N,F) :- fact(0,N,1,F).

fact(I,N,T,F) :-
      I < N,
      I1 is I + 1,
      T1 is T * I1,
      fact(I1,N,T1,F).
fact(N,N,F,F).

Alternativamente:

fact(N,F) :- fact(N,1,F).

fact(N,T,F) :-
     N > 0,
     T1 is T * N,
     N1 is N - 1,
     fact(N1,T1,F).
fact(0,F,F).

Un ejemplo parecido en donde se puede usar un argumento extra para guardar resultados intermedios: suma todos los elementos de una lista

sumalista([],0).
sumalista([H|T],Res) :-
     sumalista(T,Res1),
     Res is Res1 + H.

sumalista(L,R) :- sumalista(L,0,R).

sumalista([H|T],Inter,R) :-
    Inter1 is Inter + H,
    sumalista(T,Inter1,R).
sumalista([],R,R).

Al usar ``is'' muchas veces depende del uso que le demos al programa. Por ejemplo si queremos obtener la longitud de una lista de elementos.

• Conocemos N y queremos construir listas (al reves marca error)

  long([H|T],N) :- 
         N > 0,
         N1 is N - 1,
         long(T,N1).
  long([],0).
  

• Conocemos la lista y queremos conocer la longitud (al reves se cicla)

  long([H|T],N) :- 
         long(T,N1),
         N is N1 + 1.
  long([],0).
  

Usando sucesor el código es más sencillo y se puede usar de las dos formas:

long([H|T],s(N)) :- 
       long(T,N).
long([],0).