Newchalenger's Blog

Practical exercise 6 

(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. 

Here is the answer :

first open your notepad and type this code

then save as loop coba4.pl ( I name it like that because before I done it, I did some experiments)

load it in prolog and here is the result

it is so simple. 

(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.

this one is really the hardest of all, but thanks to some of  our friends we fnally figure it out

again, open your notepad and type this code :

save it. and load it in the prolog. here is the result

and finally number three

(3) Using the

person clauses given in Section 6.3.1, find the professions of all those over 40.

here is the source code :

and here is the result :

I’m sorry i didn’t included any explanations because i’m (the one who upload it) very tired already.  there is so many things to be done today. and tomorrow the hell is not over yet…. hahaha

and for my lecturer Mr. AM. I’m really sorry for being late to post this, it’s because there is so many things to do this day sir. I hope you could understand. thanks for reading this note.

Chapter 6 : Loops

             This chapter discusses about how to obtain the effect of a loop in prolog. Because there is no such a built-in operator that can directly gives us the effect of loop. But there is such a way to obtain it. Here we go

Here is the explanation of th subchapters in the chapter 6, including the examples:

Subchapter 1 : Looping a Fixed Number of Times

            Explain how to obtain the effect of loop in prolog

example 1 :

The following program outputs integers from a specified value down to 1.

 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. Here is the result:

?- 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

example 2 :

The next program outputs integers from First to Last inclusive.

Output :

?- output_values(5,12).

56789

10

11

12

end of example

example 3 :

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

 Output :

?- sumto(100,N).

N = 5050

?- sumto(1,1).

yes

example 4 :

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

?- writesquares(6).

149

16

25

36

yes

subchapter 2 : Looping Until a Condition Is Satisfied

2.1. Recursive

example :

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

 or 

The output is the same :

?- loop.

Type end to end: university.

Input was university

Type end to end: end.

Input was end

yes

2.2. Using the ‘repeat’ Predicate

repeat can be used to shorten the program

before:

 after 

the output is the same.

Subchapter 3 : Backtracking with Failure

            How to use the advantage of the predicate fail/0

3.1. searching the prolog database

 after the alldogs predicate has succeded, the fail/0 predicate will cause it to execute the predicate alldogs until the result is no. then the alldogs/0 predicate will cause the last line is is Yes not No because it considered as succeeded. Here is the output :

?- alldogs.

fido is a dog

fred is a dog

jonathan is a dog

yes

3.2. Finding Multiple Solutions

Backtracking with failure can also be used to find all the ways of satisfying a goal.

Example :

  I’m sorry, but the output was not listed.

Input and Output

1. 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. Evaluating the predicate causes the term to be written to the current output stream, which by default is the user’s screen. Another built-in predicate nl/0 which takes no arguments. Evaluating a nl goal causes a new line to be output to the current output stream. Example:

?- write(26),nl.

26

Yes

2. Inputting Terms

The built-in predicate read/1 is provided to input terms. It takes a single argument, which must be a variable. Evaluating it causes the next term to be read from the current input stream, which by default is the user’s keyboard. In the input stream, the term must be followed by a dot (‘.’) and at least one white space character, such as space or newline. The dot and white space characters are read in but are not considered part of the term. When a read goal is evaluated, the input term is unified with the argument variable. If the variable is unbound (which is usually the case) it is bound to the input value.

?- read(X).

: jim.

X = jim

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.

?- X=fred,read(X).

: fred.

X = fred

3. Input and Output Using Characters

The use of quotes and full stops can be cumbersome and is not always suitable. For example, it would be tedious to define a predicate (using read) which would read a series of characters from the keyboard and count the number of vowels. A much better approach for problems of this kind is to input a character at a time. To do this it is first necessary to know about the ASCII value of a character. Here is the table :

4. 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 example :

?- put(64),nl.

@

Yes

5. 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.

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

?- get0(N).

: a

N = 97

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.

?- get(X).

: Z

X = 90

6. Using Characters: Examples

The predicate readin is defined recursively. It causes a single character to be input and variable X to be bound to its (numerical) ASCII value. The action taken (the process(X) goal) depends on whether or not X has the value 42 signifying a * character. If it has, the evaluation of the goal stops. If not, the value of X is output, followed by a new line, followed by a further call to readin. This process goes on indefinitely until a * character is read. (In the example below, the ASCII values of characters P, r, o etc. are correctly shown to be 80, 114, 111 etc.)

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

process(42).

process(X):-X=\=42,write(X),nl,readin.

7. 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. The same facilities available for input and output from and to the user’s terminal either term by term or character by character are also available for input and output from and to files (e.g. files on a hard disk or a CD-ROM). The user may open and close input and output streams associated with any number of named files but there can only be one current input stream and one current output stream at any time. Note that no file can be open for both input and output at the same time (except user) and that the user input and output streams cannot be closed.

8. 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’). Evaluating a tell goal causes the named file to become the current output stream. If the file is not already open, a file with the specified name is first created (any existing file with the same name is deleted). The default current output stream is user, i.e. the  user’s terminal. This value can be restored either by using the told predicate or by tell(user). The built-in predicate told/0 takes no arguments. Evaluating a told goal causes the current output file to be closed and the current output stream to be reset to user, i.e. the user’s terminal. The built-in predicate telling/1 takes one argument, which must be a variable and will normally be unbound. Evaluating a telling goal causes the variable to be bound to the name of the current output stream.

9. File Input: Changing the Current Input Stream

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’). Evaluating a see goal causes the named file to become the current input stream. If the file is not already open it is first opened (for read access only). If it is not  possible to open a file with the given name, an error will be generated. The default current input stream is user, i.e. the user’s terminal. This value can be restored either by using the seen predicate or by see(user). The built-in predicate seen/0 takes no arguments. Evaluating a see goal causes the current input file to be closed and the current input stream to be reset to user, i.e. the user’s terminal. The built-in predicate seeing/1 takes  one argument, which must be a variable and will normally be unbound. Evaluating a seeing goal causes the variable to be bound to the name of the current input stream.

Fact, Rules, Predicate, and Variable in Prolog

Final Project week 3

Problems

how to solve it :

First, write the code number 1 given in the problem into notepad (or just copy paste) and then save it in extension “.pl”, the name of the file is up 2 u all. Ex: FP3.pl

And so does the number 2

(I save it with the name “FP3_2.pl”)

Open your prolog program and consult  the FP3.pl

Or just click it twice on the file FP3.pl

Now, let’s discuss number 1 first. After the database has been loaded, things we should do next is to solve this problems : find : (a) all the mammals, (b) all the carnivores that are mammals, (c) all the mammals with stripes, (d) whether there is a reptile that has a mane.

How do we solve it then? That’s easy, I’ll tell you then.

For the first problem, the way to find all the mammals is by typing this into your prolog program : “animal(mammal,X,_,_).” (I replace the third and the fourth with “_” because we won’t be needing that element) and press enter. This the first result:

the first output will be tiger. To show the another result just press “;”  (“;” means “or” in prolog) and press it again until the output is “no”.

And the result will be like this :

That’s it.

Now for the second problem. Type this into your prolog : “animal(mammal,X,carnivore,_).” (this time I replace the third element with carnivore because it will be used to find all the carnivores). And do the same steps as the first problem. The result will be like this

The same goes to the third problem. Type this into your prolog “animal(mammal,X,_,stripes).” (I assume this time you will understand why I type it like that)  And follow the previous steps. The result will be like this

For the fourth problem. It will be the same as the previous by typing this “animal(mammal,X,_,mane).”. But when you press “;” the result will be “no”. Why? Because there is only one animal that’s mammal and has a mane.

And it’s done

Time to discuss number 2. To solve the number 2, edit number 2’s code and add this rule “couple(X,Y):-person(X,male),person(Y,female).”

save it. After that load it into your prolog program.

Type “couple(X,Y).” and press enter. The first result will be

X = bill

Y = carol

To show the another result keep pressing “;” until the output is “ no”. and this is the result :

Actually it is the same like combinatorial, just like the final project week 2. Ok, that’s it for now. See ya next time. And greatest thanks to Mr. AM………

Practical Exercise 4

Problems

Given source code :

1. Convert the seven predicates used above to operator form and test your revised program. The output should be the same as the output from the program above. Include directives to define the operators in your program.
2. Define and test a predicate which takes two arguments, both numbers, and calculates and outputs the following values: (a) their average, (b) the square root of their product and (c) the larger of (a) and (b).

1)      The way to answer it goes like this :

Converting a predicate into an operator, can be done by entering a goal using the op predicate at the system prompt or by adding a new line in the program’s source code before it is loaded in prolog, for example :

This predicate takes three arguments :

1)      The first argument is the ‘operator precedence’, which is an integer from 0 upwards. The range of numbers used depends on the particular implementation. The lower the number, the higher the precedence. Operator precedence values are used to determine the order in which operators will be applied when more than one is used in a term. The most important practical use of this is for operators used for arithmetic, as will be explained later. In most other cases it will suffice to use an arbitrary value such as 150.

2)      The second argument should normally be one of the following three atoms:

• xfy meaning that the predicate is binary and is to be converted to an infix operator
• fy meaning that the predicate is unary and is to be converted to an prefix operator
• xf meaning that the predicate is unary and is to be converted to a postfix operator

Explanation : predicate that has 2 arguments is called binary, ex : likes(john,mary). Predicate that has 1 arguments is called unary, ex : dog(fido)

3)      The third argument specifies the name of the predicate that is to be converted to an operator.

So to convert the seven predicates used in the given source code we must add new lines to the source code just like explained before. It will be like this :

NB: I change the predicate “dog” into “isa_dog” because it will be easy for us to understand the meaning of why the predicate “dog” written like this “dog(fido)”.

The next step is changing the predicate form into operator form. For binary, it should be change to infix. So for predicate “chases(X,Y)” will be change to “X chases Y”. And for the unary can be change into either postfix and prefix operator. For example :

dog(fido) =>           – isa_dog fido (prefix)

- fido isa_dog (postfix)       (in this case I used the postfix one)

The rest of the code will be like this :

That’s it. All done……

And here is the full source code would likely be :

Save it and the load it into the prolog program. Type “X chases Y.”, I guarantee that the result will be the same as when you type “chases(X,Y).” from the loaded given source code.

The operator result                                                               The predicate result

2)      Time for number 2!

Open your notepad and get ready to write code. Firstly we must write a predicate with two arguments that aren’t bound with numerical value so that the program will be dynamic not static, like this : “numbers(A,B).”. Then write the code to do the operation mentioned in the problem no 2. Here is the code would likely be :

The first argument is the operation “C is (A,B)/2”, the second is the command to write “the average is : ”, the third is the command to write variable C after it has a value from the previous operations, and the last “nl” is to write a new line (the same as enter). The rest is the same.

And this is the full code would likely be :

Now time to test the program. Type “numbers(12,24).” And then enter. Here is the result :

That’s it for this time. See ya next time! And never forget our greatest thanks to Mr. AM our beloved Discrete Math lecturer and Mas Yasin our awesome tutor teacher (if not because of him helping us with this problems maybe we’ll have hard time to understand the number 1 problem, Arigatto Gozaimasu!).

——————-☺☻☺☻☺☻☺☻——————-