DiscreteMath_FP_Report_ClassA_Mathmaniacs_2009

Prolog source code

specialEvent(scomdex-pameran-komputer, surabaya-expo, 11, 2, 7, family, computer).
specialEvent(surabaya-sale, tunjungan-plaza, 11, 9, 21, family, shopping).
specialEvent(surabaya-book-fair, surabaya-expo, 11, 16, 29, student, music).
specialEvent(kids-carnaval, tugu-pahlawan, 11, 29, 29, children, art).
specialEvent(music-concert, tunjungan-plaza, 12, 1, 3, adolescent, music).
specialEvent(food-festival, pakuwon-city, -1, -1, -1, family, restaurant).
specialEvent(music-by-request, surabaya-radio, -1, -1, -1, adolescent, music).
specialEvent(education-expo,surabaya-expo, 12, 7, 12, family ,education).
specialEvent(surabaya-real-estate-expo, pakuwon-city, 12, 1, 31, adult, property).

foodAvailableAt(kids-carnaval, cheap).
foodAvailableAt(surabaya-book-fair, medium).
foodAvailableAt(surabaya-real-estate-expo, expensive).
foodAvailableAt(education-expo, medium).
foodAvailableAt(food-festival, cheap).
foodAvailableAt(music-concert, medium).
foodAvailableAt(music-by-request, medium).

distance(surabaya-expo, tunjungan-plaza, 5).
distance(surabaya-expo, tugu-pahlawan, 7).
distance(surabaya-expo, pakuwon-city, 12).
distance(surabaya-expo, surabaya-radio, 8).
distance(tunjungan-plaza, tugu-pahlawan, 4).
distance(tunjungan-plaza, pakuwon-city, 12).
distance(tunjungan-plaza, surabaya-radio, 3).
distance(tugu-pahlawan,pakuwon-city,10).
distance(tugu-pahlawan, surabaya-radio, 5).
distance(pakuwon-city, surabaya-radio, 8).

/*************************************
* U T I L I T Y   F U N C T I O N S *
*************************************/

near(X,Y) :- X = Y ;  (distance(X,Y,D), D =< 5) ; (distance(Y,X,D), D =< 5).

getDates(E,M,Ds,De)  :- specialEvent(E,_,M,Ds,De,_,_).
allYearEvent(E)      :- specialEvent(E,_,-1,-1,-1,_,_).
suitableForKids(E)   :- specialEvent(E,_,_,_,_,family,_).

/*************************************
* E N D U S E R   F U N C T I O N S *
*************************************/

getEvents(E,P,C,G)    :- specialEvent(E,P,_,_,_,C,G).
partyEvents(E,M,D,P) :- getEvent(E,Ep,family,G),
near(P,Ep),
G \= shopping,
getDates(E,Em,Ds,De),
(allYearEvent(E) ; (Ds =< D, De >= D, Em =:= M)).

nearEvents(E,P)      :- near(P,X), getEvent(E,X,_,_).
foodAvailable(E,T)   :- foodAvailableAt(E,T) ;
(getEvent(E,_,T,G), G = restaurant).

/*************************************
* E X A M P L E   Q U E R I E S *
*************************************/

Here are some examples of how you would use the program:

* Is there anything suitable for a party for someone whose birthday is on the 1st October in or near Surabay Expo.

? partyEvents(X,11,1,surabaya-expo).

* Is there food available at the music-concert, if so how expensive is it?

? foodAvailable(music-concert, P).

* List all events in or near tunjungan-plaza.

? nearEvents(E, tunjungan-plaza).

* Get all adult events in pakuwon-city

?getEvents(E, pakuwon-city,adult,_).

*/

Now we meet again for the exercise 3. After exercise 2, we are really sure that you guys can solve this problem easily

So, are we ready to rumble? We will show you every step and there is screenshots as additional suplements. So don’t worry, it will be easy

Exercise 3

Using the person clauses given, find the professions of all those over 40..

The person clause is :

person(john,smith,45,london,doctor).
person(martin,williams,33,birmingham,teacher).
person(henry,smith,26,manchester,plumber).
person(jane,wilson,62,london,teacher).
person(mary,smith,29,glasgow,surveyor).

Answer :

To find the profession is quite easy just look at the source code below :

find_prof:-person(_,_,Age,_,Prof),Age>40,
write(‘The proffesion above age 40 is ‘),write(Prof),nl,fail.
find_prof.
person(john,smith,45,london,doctor).
person(martin,williams,33,birmingham,teacher).
person(henry,smith,26,manchester,plumber).
person(jane,wilson,62,london,teacher).
person(mary,smith,29,glasgow,surveyor).

We will explain you a little bit about the source code. Just a little bit, because we know that you guys already dig it . It is quite easy to find the profession with age above 40. You just simply write the rules like above. The find_prof rule means you have to find the profession from the person rules given.

Okhaii, let’s go to the Prolog program

1. First of all, you have to write down the following program to notepad, and save as .pl file. For this exercise, we will save it as loop3.pl

2. Open your Prolog, click File>Consult and find the file you’ve just saved it. After you successfully open it, Prolog will manage to show you a successful quote just like the screenshot show.

3. Let’s proof the question, try the command on your Prolog :

find_prof.

After you hit enter, the result will come as shown on the screenshot.

Okhaaiii then, we think it is enough for this time .

Have you enjoy our tutorials? If there is any questions prior to the tutorials, please leave your comment right here. We will accomodate the answer as soon as possible.

Till we meet again with the next tutorials

Best Regards,

Mathmaniacs

Now we meet again for the exercise 2. After exercise 1, we are really sure that you guys can solve this problem easily

So, are we ready to rumble? We will show you every step and there is screenshots as additional suplements. So don’t worry, it will be easy

Exercise 2

Define and test a predicate to read in a series of characters input by the user and output all of those before the first new line or ? character.

Answer :

Well, first of all we have to make the rule for Prolog program. The source code will be like this :

go:-repeat,get0(X),stop(X).
stop(13):-nl.
stop(63):-nl,repeat,get0(X),X=:=13.
stop(X):-put(X),fail.

We will explain you a little bit about the source code. Just a little bit, because we know that you guys already dig it . The first line is to input the program from user (get0 predicate), then loop it (repeat predicate). After that the get0 predicate will convert it to ASCII numeric. The second and third line is using stop(13) and stop(63)  predicate. Stop is a predicate to stop the process of the program, so if we use stop(13) means that the program will end when user input a blank character, while stop(63) means that the program will end when user input “?” character. The last line is using ‘put’ predicate. It means the program will display the character that have been inputted by user, converted to ASCII.

Okhaii, let’s go to the Prolog program

1. First of all, you have to write down the following program to notepad, and save as .pl file. For this exercise, we will save it as loop2.pl

2. Open your Prolog, click File>Consult and find the file you’ve just saved it. After you successfully open it, Prolog will manage to show you a successful quote just like the screenshot show.

3. Let’s proof the question, try the command on your Prolog :

go.

After you hit enter, you can type just like the question wanted.

Try to type a name, for example type : Novan.

Then, type : Hari?Alfie.

After you hit enter, the result will come as shown on the screenshot.

Okhaaii then, that is enough for Exercise 2. We will continue for the next exercise on the next post, so enjoy!

Now we meet again for the fifth tutorial now after you learned about Loops in our Literature Review, it is the time to implement your thoughts to Prolog Program

So, are we ready to rumble? We will show you every step and there is screenshots as additional suplements. So don’t worry, it will be easy

Excercise 1

Define a predicate to output the values of the squares of the integers from N1 to N2 inclusive and test it with N1 = 6 and N2 = 12.

Answer :

We can find a squared integer from the first input number until the last input number.

Here is the source code :

output_square(N1,N2):-N1>N2.
output_square(N1,N2):- write(N1),write(‘ square is ‘),Square is N1*N1,
write(Square),nl,M is N1+1,output_square(M,N2).

We will explain you a little bit about the source code. Just a little bit, because we know that you guys already dig it . The first line is output_square. It uses to continue the loop if the N1 greater than N2. Second line is the loop session. If the first number (N1) reach the last number (N2) then the program will stop. The last line is to produce the product number M, if it is success, then it will continue by adding N1 with 1 so the program will continue until it reach the end of the last number (N2).

Okhaii, let’s go to the Prolog program

1. First of all, you have to write down the following program to notepad, and save as .pl file. For this exercise, we will save it as loop1.pl

2. Open your Prolog, click File>Consult and find the file you’ve just saved it. After you successfully open it, Prolog will manage to show you a successful quote just like the screenshot show.

3. Let’s proof the question, try the command on your Prolog :

output_square(6,12).

After you hit enter, the result will come as shown on the screenshot.

Okhaaii then, that is enough for Exercise 1. We will continue for the next exercise on the next post, so enjoy!

Now we have entered our third Literature Review. This time we will discuss about Loops in Prolog. So take your time and enjoy the review

LOOPS

6.1 Lopping a Fixed Number of Times

Many programming languages provide ‘for loops’ which enable a set of instructions to be executed a fixed number of times. No such facility is available in Prolog (directly), but a similar effect can be obtained using recursion, as shown in the example programs below.

loop(0).

loop(N):-N>0,write(‘The value is: ‘),write(N),nl,

M is N-1,loop(M).

The loop predicate is defined in terms of itself. The second clause can be thought of as: ‘to loop from N, first write the value of N, then subtract one to give M, then loop from M‘. This process clearly needs to be terminated and this is achieved by the first clause: ‘when the argument is zero, do nothing (and hence stop)’. The first clause can be regarded as a terminating condition for the recursion.

?- loop(6).

The value is: 6

The value is: 5

The value is: 4

The value is: 3

The value is: 2

The value is: 1

Yes

Note the use of the two goals M is N-1,loop(M) in the second clause for the loop predicate. The obvious alternative of loop(N-1) will not work. Prolog only evaluates expressions such as N-1 when evaluating goals with functor is or one of the relational operators, as described in Chapter 4. If N-1 is used as an argument of a predicate it is taken to mean the term with infix operator – (i.e. a minus sign) and arguments N and 1. This is most unlikely to be what is intended!

Example 2

The next program outputs integers from First to Last inclusive.

/* output integers from First to Last inclusive */

output_values(Last,Last):- write(Last),nl,

write(‘end of example’),nl.

output_values(First,Last):-First=\=Last,write(First),

nl,N is First+1,output_values(N,Last).

Here output_values has two arguments, which can be read as ‘output the integers from First to Last inclusive’. The loop terminates when both arguments are the same.

?- output_values(5,12).

5

6

7

8

9

10

11

12

end of example

yes

Example 3

Define a predicate to find the sum of the integers from 1 to N (say for N = 100).

It is natural to think of this procedurally, i.e. start with 1, then add 2, then add 3, then add 4, … , then add 100. However the process is much easier to program if reexpressed declaratively in terms of itself.

The sum of the first 100 integers is the sum of the first 99 integers, plus 100.

The sum of the first 99 integers is the sum of the first 98 integers, plus 99.

The sum of the first 98 integers is the sum of the first 97 integers, plus 98.

…………………………………………………………………………….

The sum of the first 3 integers is the sum of the first 2 integers, plus 3.

The sum of the first 2 integers is the sum of the first 1 integers, plus 2.

The sum of the first 1 integers is one.

There are two distinct cases to consider: the general case: ‘the sum of the first N integers is the sum of the first N-1 integers, plus N’ and the terminating case: ‘the sum of the first 1 integers is 1′. This leads directly to the recursive definition:

/* sum the integers from 1 to N (the first argument)

inclusive */

sumto(1,1).

sumto(N,S):-N>1,N1 is N-1,sumto(N1,S1),S is S1+N.

?- sumto(100,N).

N = 5050

?- sumto(1,1).

yes

Note that using the additional variable N1 for holding the value of N-1 is essential. Writing sumto(N-1,S1) etc. instead would not work correctly. N-1 is a term, not a numerical value.

Example 4

Define a predicate to output the squares of the first N integers, one per line.

This can most easily be programmed if first recast in a recursive form, as follows.

To output the squares of the first N integers, output the squares of the first N-1 and then output N²

To output the squares of the first N-1 integers, output the squares of the first N-2 and then output (N-1)²

To output the squares of the first N-2 integers, output the squares of the first N-3 and then output (N-2)²

……………………………………………………………………………………….

To output the squares of the first 3 integers, output the squares of the first 2 and then output 3²

To output the squares of the first 2 integers, output the squares of the first 1 and then output 2²

To output the squares of the first 1 integers, output the number 1

Here the general case is ‘to output the squares of the first N integers, output the squares of the first N-1 and then output N²’ and the terminating case is ‘to output the squares of the first 1 integers, output the number 1′. This leads to the following two-clause program.

/* output the first N squares, one per line */

writesquares(1):-write(1),nl.

writesquares(N):-N>1,N1 is N-1,writesquares(N1),

Nsq is N*N,write(Nsq),nl.

?- writesquares(6).

1

4

9

16

25

36

yes

Example 5

The following program reads the first 6 terms from a specified file and writes them to the current output stream. It uses a ‘counting down’ method, in a similar way to Example 1.

read_six(Infile):-seeing(S),see(Infile),

process_terms(6),seen,see(S).

process_terms(0).

process_terms(N):-N>0,read(X),write(X),nl,N1 is N-1,

process_terms(N1).

6.2 Lopping Until a Condition Is Satisfied

Many languages have an ‘until loop’ which enables a set of instructions to be executed repeatedly until a given condition is met. Again, no such facility is available directly in Prolog, but a similar effect can be obtained in several ways.

6.2.1 Recursion

The first example below shows the use of recursion to read terms entered by the user from the keyboard and output them to the screen, until end is encountered.

go:-loop(start). /* start is a dummy value used to get

the looping process started.*/

loop(end).

loop(X):-X\=end,write(‘Type end to end’),read(Word),

write(‘Input was ‘),write(Word),nl,loop(Word).

?- go.

Type end to end: university.

Input was university

Type end to end: of.

Input was of

Type end to end: portsmouth.

Input was portsmouth

Type end to end: end.

Input was end

yes

Using the disjunction operator ;/2 which was defined in Section 4.4 the above program can be rewritten as a single clause.

loop:-write(‘Type end to end’),read(Word),

write(‘Input was ‘),write(Word),nl,

(Word=end;loop).

The ‘disjunctive goal’ (Word=end;loop) succeeds if variable Word is bound to the atom end. If not, the system attempts to satisfy the goal loop recursively.

?- loop.

Type end to end: university.

Input was university

Type end to end: of.

Input was of

Type end to end: portsmouth.

Input was portsmouth

Type end to end: end.

Input was end

yes

This recursive program repeatedly prompts the user to enter a term until either yes or no is entered.

get_answer(Ans):-write(‘Enter answer to question’),

nl,get_answer2(Ans).

get_answer2(Ans):-

write(‘answer yes or no’),

read(A),

((valid(A),Ans=A,write(‘Answer is ‘),

write(A),nl);get_answer2(Ans)).

valid(yes). valid(no).

?- get_answer(Myanswer).

Enter answer to question

answer yes or no: maybe.

answer yes or no: possibly.

answer yes or no: yes.

Answer is yes

Myanswer = yes

6.2.2 Using the ‘repeat’ Predicate

Another method that is often used is based on the built-in predicate repeat. The goal repeat does not repeat anything; it merely succeeds whenever it is called. The great value of repeat is that it also succeeds (as many times as necessary) on backtracking. The effect of this, as for any other goal succeeding, is to change the order of evaluating goals from ‘right to left’ (i.e. backtracking) back to ‘left-to-right’. This can be used to create a looping effect, as shown in the examples below.

get_answer(Ans):-

write(‘Enter answer to question’),nl,

repeat,write(‘answer yes or no’),read(Ans),

valid(Ans),write(‘Answer is ‘),write(Ans),nl.

valid(yes). valid(no).

The first five goals in the body of get_answer will always succeed. Evaluating the fifth goal: read(Ans) will prompt the user to enter a term. If the term input is anything but yes or no, say unsure, the following goal valid(Ans) will fail. Prolog will then backtrack over read(Ans) and write(‘answer yes or no’), both of which are unresatisfiable, i.e. will always fail on backtracking.

Backtracking will then reach the predicate repeat and succeed, causing evaluation to proceed forward (left-to-right) again, with write(‘answer yes or no’) and read(Ans) both succeeding, followed by a further evaluation of valid(Ans).

Depending on the value of Ans, i.e. the user’s input, the valid(Ans) goal will either fail, in which case Prolog will backtrack as far as repeat, as before, or it will succeed in which case the final three goals write(‘Answer is’), write(Ans) and nl will all succeed. The overall effect is that the two goals write(‘answer yes or no’) and read(Ans) are called repeatedly until the terminating condition valid(Ans) is satisfied, effectively creating a loop between repeat and valid(Ans).

?- get_answer(X).

Enter answer to question

answer yes or no: unsure.

answer yes or no: possibly.

answer yes or no: no.

answer is no

X = no

Logic Programing With Prolog

Goals to the left of repeat in the body of a clause will never be reached on backtracking.

The next program reads a sequence of terms from a specified file and outputs them to the current output stream until the term end is encountered.

readterms(Infile):-

seeing(S),see(Infile),

repeat,read(X),write(X),nl,X=end,

seen,see(user).

In a similar way to the previous program, this effectively defines a loop between the goals repeat and X=end.

If file myfile.txt contains the lines

‘first term’. ‘second term’.

‘third term’. ‘fourth term’.

‘fifth term’. ‘sixth term’.

‘seventh term’.

‘eighth term’.

end.

calling readterms will produce the following output

?- readterms(‘myfile.txt’).

first term

second term

third term

fourth term

fifth term

sixth term

seventh term

eighth term

end

yes

This program shows how to implement a menu structure which loops back repeatedly to request more input. Entering go at the prompt causes Prolog to output a menu from which the user can choose activities one at a time until option d is chosen. Note that all inputs are terms and so must be followed by a full stop character.

go:- write(‘This shows how a repeated menu works’),

menu.

menu:-nl,write(‘MENU’),nl,

write(‘a. Activity A’),nl,write(‘b. Activity B’),nl,

write(‘c. Activity C’),nl,write(‘d. End’),nl,

read(Choice),nl,choice(Choice).

choice(a):-write(‘Activity A chosen’),menu.

choice(b):-write(‘Activity B chosen’),menu.

choice(c):-write(‘Activity C chosen’),menu.

choice(d):-write(‘Goodbye!’),nl.

choice(_):-write(‘Please try again!’),menu.

?- go.

This shows how a repeated menu works

MENU

a. Activity A

b. Activity B

c. Activity C

d. End

: b.

Activity B chosen

MENU

a. Activity A

b. Activity B

c. Activity C

d. End

: xxx.

Please try again!

MENU

a. Activity A

b. Activity B

c. Activity C

d. End

: d.

Goodbye!

Yes

6.3 Backtracking with Failure

As the name implies, the predicate fail always fails, whether on ‘standard’ evaluation left-to-right or on backtracking. Advantage can be taken of this, combined with Prolog’s automatic backtracking, to search through the database to find all the clauses with a specified property.

6.3.1 Searching the Prolog Database

Supposing the database contains clauses such as

dog(fido).

dog(fred).

dog(jonathan).

Each dog clause can be processed in turn using the alldogs predicate defined below.

alldogs:-dog(X),write(X),write(‘ is a dog’),nl,fail.

alldogs.

Calling alldogs will cause dog(X) to be matched with the dog clauses in the database. Initially X will be bound to fido and ‘fido is a dog’ will be output. The final goal in the first clause of the alldogs predicate will then cause evaluation to fail. Prolog will then backtrack over nl and the two write goals (all of which are unresatisfiable) until it reaches dog(X). This goal will succeed for a second time causing X to be bound to fred.

This process will continue until fido, fred and jonathan have all been output, when evaluation will again fail. This time the call to dog(X) will also fail as there are no further dog clauses in the database. This will cause the first clause for alldogs to fail and Prolog to examine the second clause of alldogs. This will succeed and evaluation will stop.

The effect is to loop through the database finding all possible values of X that satisfy the goal dog(X).

?- alldogs.

fido is a dog

fred is a dog

jonathan is a dog

yes

Note the importance of the second clause of the alldogs predicate. It is there to ensure that, after the database has been searched, the goal succeeds. With only the first line, any call to alldogs will eventually fail.

alldogs:-dog(X),write(X),write(‘ is a dog’),nl,fail.

?- alldogs.

fido is a dog

fred is a dog

jonathan is a dog

no

The next program is designed to search a database containing clauses representing the name, age, place of residence and occupation of a number of people.

If the database contains these five clauses

person(john,smith,45,london,doctor).

person(martin,williams,33,birmingham,teacher).

person(henry,smith,26,manchester,plumber).

person(jane,wilson,62,london,teacher).

person(mary,smith,29,glasgow,surveyor).

The names of all the teachers can be found using the allteachers predicate.

allteachers:-person(Forename,Surname,_,_,teacher),

write(Forename),write(‘ ‘),write(Surname),nl,

fail.

allteachers.

The effect of using backtracking with failure in this case is to find all the teachers in the database.

?- allteachers.

martin williams

jane wilson

yes

If the second clause of allteachers were omitted, both teachers would still be found but the evaluation of allteachers would end with failure. This is of little or no importance when a goal is entered at the system prompt, but if allteachers were used as a goal in the body of a rule it would obviously be desirable to ensure that it always succeeded.

It should be noted that it is not always necessary to use ‘backtracking with failure’ to search the database. For example, the predicate somepeople/0 defined below will find all the people in the database given previously, down to williams, using only standard backtracking.

somepeople:-person(Forename,Surname,_,_,_),

write(Forename),write(‘ ‘),write(Surname),nl,

Surname=williams.

somepeople.

The goal Surname=williams succeeds if the variable Surname is bound to williams. If not, it fails. The effect is to search the database down to and including the person clause with second argument williams.

?- somepeople.

john smith

martin williams

yes

6.3.2 Finding Multiple Solutions

Backtracking with failure can also be used to find all the ways of satisfying a goal. Suppose that a predicate findroute(Town1,Town2,Route) finds a route Route between two towns Town1 and Town2. The details of this predicate are irrelevant here. It may be assumed that Town1 and Town2 are atoms and that Route is a list.

Backtracking with failure can then be used to find all possible routes between Town1 and Town2 and write out each one on a separate line, as follows:

find_all_routes(Town1,Town2):-

findroute(Town1,Town2,Route),

write(‘Possible route: ‘),write(Route),nl,fail.

find_all_routes(_,_).

Now we meet again for the exercise 2. After exercise 1, we are really sure that you guys can solve this problem easily

So, are we ready to rumble? We will show you every step and there is screenshots as additional suplements. So don’t worry, it will be easy

Exercise 2

Define a predicate copyterms which reads all the terms in a text file and outputs them as terms to another text file one by one on separate lines. The output file should be in a format suitable for use as the input file in a subsequent call of copyterms. Thus for example if the input file contained

‘first term’. ‘second term’.
‘third term’.
fourth. ‘fifth term’.
sixth.

The output file would contain

‘first term’.
‘second term’.
‘third term’.
fourth.
‘fifth term’.
sixth.

Answer :

1. First of all, you have to write down the following input to notepad, and save as txt file. This is because we wanted to create the input file. Write it down and save it to C:/ path with infile.txt name.

2. Now let’s make the rule of prolog. Open your notepad again, write down this predicate

copyterms(Infile,Outfile):-
seeing(S),telling(T),
see(Infile),tell(Outfile),
copy,
seen,see(S),told,tell(T).
copy:-read(X),process(X).
process(end_of_file).
process(X):-
X\=end_of_file,
write(X),write(‘.’),nl,copy.

save it to your notepad, and name it as inout.pl

3. Open your Prolog, click File>Consult and find the file you’ve just saved it. After you successfully open it, Prolog will manage to show you a successful quote just like the screenshot show.

4. Let’s proof the question, try the command on your Prolog :

copyterms(‘C:/infile.txt’,'C:/outfile.txt’).

After you hit enter, it will display just like the screenshot below. It means, with the command you have successfully make an output file from the input infile.txt you made before.

5. Now let’s check the result of the file named outfile.txt. Go to the C:/ path, and you will find the file. Open it, and it will display just like the screenshot below.

Easy, right? That is all for the exercise. We will continue with the next post for the Exercise 3. So enjoy

Now we meet again for the fourth tutorial now after you learned about Input and Output in our Literature Review, it is the time to implement your thoughts to Prolog Program

So, are we ready to rumble? We will show you every step and there is screenshots as additional suplements. So don’t worry, it will be easy

Excercise 1

Define a predicate makelower/0 which reads in a line of characters from the keyboard and outputs it again as a single line with any upper case letters converted to lower case. (The ASCII values of the characters a, z, A and Z are 97, 122, 65 and 90, respectively.). Thus the following would be a typical use of makelower:
?- makelower.
: This is an Example 123 inCLUDing numbers and symbols +-*/@[] XYz
this is an example 123 including numbers and symbols +-*/@[] xyz

Answer :

Well, first of all we have to make the rule for Prolog program. The source code will be like this :

makelower:- get0(X),process(X).
process(13).
process(X):- X=\=13,case(X,Y),put(Y),makelower.
case(X,Y):- X > 64, X < 91, Y is X+32.
case(X,Y):- Y is X+0.

We use the get0 to convert the input character. Then, we use case (X,Y) to conclude the range of ASCII.

Okhaii, let’s go to the Prolog program

1. First of all, you have to write down the following program to notepad, and save as .pl file. For this exercise, we will save it as makelower.pl

2. Open your Prolog, click File>Consult and find the file you’ve just saved it. After you successfully open it, Prolog will manage to show you a successful quote just like the screenshot show.

3. Let’s proof the question, try the command on your Prolog :

makelower.

After you hit enter, you can type just like the question wanted.

This is an Example 123 inCLUDing numbers and symbols +-*/@[] XYz

After you hit enter, the result will come as shown on the screenshot.

Okhaaii then, that is enough for Exercise 1. We will continue for the next exercise on the next post, so enjoy!

• Outputting Terms

The main built-in predicate provided for outputting terms is write/1, the write/1 predicate takes a single argument, which must be a valid Prolog term. The built-in predicate nl/0  has also been used many times, evaluating a nl goal causes a new line to be output to the current output stream.

Examples :

?- write(26),nl.

26

yes

?- write(‘a string of characters’),nl.

a string of characters

yes

Note that atoms that have to be quoted on input (e.g. ‘Paul’, ‘hello world’) are not quoted when output using  write. If it is important to output the quotes, the writeq/1  predicate can be used. It is identical to write/1 except that atoms that need quotes for input are output between quotes (other atoms are not).

Examples :

?- writeq(‘a string of characters’),nl.

‘a string of characters’

yes

?-writeq(dog),nl.

dog

yes

• Inputting Terms

The built-in predicate read/1 is provided to input terms. It takes a single argument, which must be a variable. In the input stream, the term must be followed by a dot (‘.’) and at least one white space character, such as space or newline.

Note that for input from the keyboard (only) a prompt character such as a colon will usually be displayed to indicate that user input is required. It may be necessary to press the ‘return’ key before Prolog will accept the input. Both of these do not apply to input from files. If the variable is unbound (which is usually the case) it is bound to the input value.

Examples :

?- read(X

: jim.

X = jim

?- read(X

: 26.

X = 26

If the argument variable is already bound (which for most users is far more likely to occur by mistake than by design), the goal succeeds if and only if the input term is identical to the previously bound value.

Examples :

?- X=fred,read(X).

: jim.

no

?- X=fred,read(X).

: fred.

X = fred

• Input and Output Using Characters

Although input and output of terms is straightforward, the use of quotes and full stops can be cumbersome and is not always suitable. it is necessary to know about the ASCII value of a character.

All printing characters and many non-printing characters (such as space and tab) have a corresponding ASCII (American Standard Code for Information Interchange) value, which is an integer from 0 to 255.

• Outputting Characters

Characters are output using the built-in predicate  put/1. The predicate takes a single argument, which must be a number from 0 to 255 or an expression that evaluates to an integer in that range.

Evaluating a  put goal causes a single character to be output to the current output stream. This is the character corresponding to the numerical value (ASCII value) of its argument, for examples :

?- put(97),nl.

a

yes

?- put(122),nl.

z

yes

• Inputting Characters

Two built-in predicates are provided to input a single character: get0/1 and get/1. The get0 predicate takes a single argument, which must be a variable. Evaluating a get0 goal causes a character to be read from the current input stream. The variable is then unified with the ASCII value of this character.

Note that for input from the keyboard (only) a prompt character such as a colon will usually be displayed to indicate that user input is required. It may be necessary to press the ‘return’ key before Prolog will accept the input. Both of these also apply to the get predicate described below but do not apply to input from files.

Assuming the argument variable is unbound (which will usually be the case), it bound to the ASCII value of the input character.

Examples :

?- get0(N).

: a

N = 97

?- get0(N).

: Z

N = 90

If the argument variable is already bound, the goal succeeds if and only if it has a numerical value that is equal to the ASCII value of the input character. Examples :

?- get0(X).

: a

X = 97

?- M is 41,get0(M).

: )

M = 41

The get predicate takes a single argument, which must be a variable. Evaluating a get goal causes the next non-white-space character (i.e. character with an ASCII value less than or equal to 32) to be read from the current input stream. The variable is then unified with the ASCII value of this character in the same way as for get0.

Examples :

?- get(X).

: Z

X = 90

?- get(M).

:           Z

M = 90

Using Characters : Examples

The predicate readin is defined recursively. This proses goes on indefinitely until aa * character is read. Example :

Readin :- get0(X),proses(X).

Proses (42).

Proses (X) :- X=\=42, write (X) ,nl, readdin.

?- readin.

*Prolog Example *

80

114

108

32

69

120

97

109

112

108

101

Yes

The next example is the extended version of one above.  The count predicate is defined wiht two arguments which can be read as the numbe of characters counted so far and the total number of the character before the *. Example :

go (Total) :- count(0,Total.

count(Oldcount, Result).

process($(42,Oldcount, Oldcount).

process((X,Output,Result) :- X=|\ = 42,New is Oldcount + 1 (Vew,result).

?- go(T).

:The time has come the walrus said*

T=33

?- got(T).

:*

T=0.

The final example is a recursive program, based on the previous two that read in a series of characters ending with * and count the number of vowels. the two arguments of the count predicate can be interpreted as ‘the number of vowels so far’ and ‘the total number of vowels’. The three arguments of the process predicate can be read as ‘the ASCII value of an input character’, ‘the number of vowels up to but not including that character’ and ‘the total number of vowels’, respectively. The first two arguments of the processChar predicate can be interpreted in the same way as for process, but the third argument is ‘the number of vowels up to and including the character (first argument)’.

Go (Vowels) :-count (0,Vowels).

count(Oldvowels,Totvowels):-

get0(X),process(X,Oldvowels,Totvowels).

process(42,Oldvowels,Oldvowels).

process(X,Oldvowels,Totalvowels):-

X=\=42,processChar(X,Oldvowels,New),

count(New,Totalvowels).

processChar(X,Oldvowels,New):-vowel(X),

New is Oldvowels+1.

processChar(X,Oldvowels,Oldvowels).

vowel(65). /* A */

vowel(69). /* E */

vowel(73). /* I */

vowel(79). /* O */

vowel(85). /* U */

vowel(97). /* a */

vowel(101). /* e */

vowel(105). /* i */

vowel(111). /* o */

vowel(117). /* u */

?- go(Vowels).

: In the beginning was the word*

Vowels = 8

?- go(Vowels).

: pqrst*

Vowels = 0

Input and Output Using Files

Prolog takes all input from the current input stream and writes all output to the current output  stream. By default both of these are the stream named user, denoting the user’s terminal, i.e. keyboard for input and screen for output.

File Output: Changing the Current Output Stream

The current output stream can be changed using the tell/1 predicate. This takes a single argument,  which is an atom or variable representing a file name, e.g. tell(‘outfile.txt’).

Output to a File

Although the above definition of tell states that ‘any existing file with the same name is deleted’, there is another possibility, which is important for some applications, namely that the file is not deleted and any output is placed after the end of the existing contents of the file. Both the ‘overwrite’ and the ‘append’ options are likely to be available in any practical implementation of Prolog but may involve using a different predicate (e.g. open) instead of or as well as tell.

File Input: Changing the Current Input Stream

The current input stream can be changed using the see/1 predicate. This takes a single argument, which is an atom or variable representing a file name, e.g. see(‘myfile.txt’).

Reading from Files: End of File

If the end of file is encountered while evaluating the goal get(X) or get0(X), variable X will be bound to a ‘special’ numerical value. As ASCII values must be in the range 0 to 255 inclusive, this will typically be -1, but may vary from one implementation of Prolog to another.

Reading from Files: End of Record

Typically the end of a line of input at the user’s terminal will be indicated by the character with ASCII value 13. The end of a record in a file will generally be indicated by two ASCII values: 13 followed by 10.

readline:-get0(X),process(X).

process(13).

process(X):-X=\=13,put(X),nl,readline.

?- readline.

: Prolog test

Pr

ol

og

t

est

yes

Using Files: Examples

Example 1

Adapt the final program given in Section 5.6 only the first line of the previous program needs to be changed, to:

go(Vowels):-see(‘myfile.txt’),count(0,Vowels),seen.

Example 2

Define a predicate readterms to read the first four terms from a specified file and output them to another specified file, one per line. A suitable definition is given below.

readterms(Infile,Outfile):-

see(Infile),tell(Outfile),

read(T1),write(T1),nl,read(T2),write(T2),nl,

read(T3),write(T3),nl,read(T4),write(T4),nl,

seen,told.

Assuming the contents of file textfile.txt are the three lines:

‘first term’. ‘second term’.

‘third term’.

‘fourth term’. ‘fifth term’.

using readterms gives the following brief output:

?- readterms(‘textfile.txt’,'outfile.txt’).

Yes

and creates a file with four lines of text

first term

second term

third term

fourth term

Although the definition of readterms above is correct as far as it goes, the final two terms (seen and told) will cause the current input and output streams to be set to user. This could cause problems if readterms were used as a subgoal in a larger program where the current input and output streams were not necessarily both user when it was called. Using these conventions, the revised definition of readterms is as follows:

readterms(Infile,Output):-

seeing(S),see(Infile),telling(T),tell(Outfile),

read(T1),write(T1),nl,read(T2),write(T2),nl,

read(T3),write(T3),nl,read(T4),write(T4),nl,

seen,see(S),told,tell(T).

Example 3

Define a predicate copychars to copy characters input (as a single line) at the user’s terminal to a specified file, until the character ! is entered (this character should not be copied). The rest of the task is left to copy_characters, which is defined recursively in a similar way to readin in the first example in Section 5.6.

copychars(Outfile):- telling(T),tell(Outfile),

copy_characters,told,tell(T).

copy_characters:-get0(N),process(N).

/* 33 is ASCII value of character ! */

process(33).

process(N):-N=\=33,put(N),copy_characters.

Using copychars as follows

?- copychars(‘myfile.txt’).

: abxyz!

yes

will place the characters abxyz in file myfile.txt.

Background of the idea :

A program that helps to show some events that has been occured, is happening and will happend in the future in different locations.

Detail explanation of the idea :

First we should collect some events from the past, now and future and then write them in the facts of prolog. Example :

Events :

1. Computer Exhibition “Scomdex” in Surabaya Expo at November 2nd-7th 2009.

2. Surabaya Sale, discounts in some malls in  Surabaya including Tunjungan Plaza for remembering the anniversary of Surabaya City at November 9th-21st 2009.

3. Surabaya Book Fair in Surabaya Expo at November 16th-29th 2009

4. Kindergarten and Elementary Carnaval in Tugu Pahlawan at  November 29th 2009.

5. Music Concert in Tunjungan Plaza for teenagers at December 1st-3rd 2009.

6. Food Festival everyday in Pakuwon City in east Surabaya.

7. Music By Request, online in some Radio Stations in Surabaya everyday at 07.00 PM.

8. Education Expo, giving valuable experience for student in Surabaya Expo at December 7th-12nd.

9. Surabaya Real Estate Property Exhibition for executives in Pakuwon City at December 1st-31st 2009.

from the facts above then we create the rules that showing

1. How expensive the food available on each events;

2. How far between each event locations.

From the facts and rules created above we can make syntax to determine such as :

1. find some events at specific times, dates and locations.

2. find the cheaper prise of the food available in each events.

3. list all events with some classifications such as only for adults, family, teenagers, kids etc.

4. list the events that near with specific locations.

Benefit :

From the program we can make easy to get some information about events that have been occured, is happening and will happend in Surabaya area.