计算Prolog中的多维数据集列表

Question

So I'm doing some Prolog in SWI-Prolog and I've come across a little snag. I must create a list of cubes, given an input list. The code I currently have is

cubes([Head|Tail],Cubes) :-
    cubes([Head|Tail],Cubes,[]).
cubes([Head|Tail],Cubes,ActualCubes) :-
    X is Head^3,
    append(ActualCubes,[X],NewCubes),
    cubes(Tail,Cubes,NewCubes).
cubes([Tail],Cubes,ActualCubes) :-
    X is Tail^3,
    append(ActualCubes,[X],NewCubes),
    Cubes is NewCubes.

When I run that it gives an error, specifically...

ERROR: '.'/2: Type error: `[]' expected, found `[8]' ("x" must hold one character)
   Exception: (7) cbList([1, 2], _G296, []) ? creep

I'm not entirely sure why this error is occurring but it seems to happen around the very last line, Cubes is NewCubes. Any help is appreciated :)

Answer 1

I think you are trying to exercise a pattern known as accumulator , rewriting a binary relation with an added argument that holds intermediary results.

Syntax errors apart, you should note that an accumulator it's useless here, because each element of a list is in relation only with the corresponding element of the other list.

library( apply ) has maplist /3 for such common case:

cube(N, C) :-
    C is N^3.
cubes(Ns, Cs) :-
    maplist(cube, Ns, Cs).

and library( clpfd ) has interesting features that allow (in integer domain) a better relational handling of arithmetic. Replace cube above with

:- [library(clpfd)].

cube(N, C) :-
    N ^ 3 #= C.

and you are allowed to write

?- cubes(X,[1,8,27]).
X = [1, 2, 3].

Answer 2

First, you're making different cubes predicates with differing numbers of arguments. This is bound to cause both conceptual and syntactical problems, so at that point, re-think what you're doing. In this case, try to expand the ways you can use pattern matching and recursion:

cubes([],[]).
cubes([H|T], [Y|Z]):-
        Y is H*H*H,
        cubes(T,Z).


betterCubes([],[]).
betterCubes([H|T], [Y|Z]):-
        ( 
          var(Y) , nonvar(H)    -> Y is H*H*H
        ; nonvar(Y) , var(H)    -> H is Y**(1.0/3.0) 
        ; nonvar(Y) , nonvar(H) -> H*H*H =:= Y
        ),
        betterCubes(T,Z).

Answer 3

In this case, one can also accomplish the desired goal with a difference list :

cubes( [] , [] ) .
cubes( [X|Xs] , [Y|Ys] ) :-
  Y is X*X*X ,
  cubes( Xs , Ys )
  .

The output list is built as we traverse the source list, recursing down. The final goal cubes([],[]) unifies the empty list [] with the tail of the output list, making it a correct list.

The other approach is to use an accumulator, which builds the output in reverse order, then reverses it:

cubes(Xs,Ys) :-
  cubes(Xs,[],T) ,
  reverse(T,Ys)
  .

cubes( [] , Ys, Ys ).
cubes( [X|Xs] , Ts , Ys ) :-
  T is X*X*X ,
  cubes( Xs , [T|Ts] , Ys )
  .

Both are (our should be) properly tail recursive.