INPUT AND OUTPUT in Prolog.

Prolog has facilities to enable input and output either of terms or of characters. Using terms is simpler . Note that, like many other built-in predicates, those for input and output described in this chapter are all unresatisfiable, i.e. they always fail when backtracking.

• Outputting Terms

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. The built-in predicate nl/0 has also been used many times previously in this book. It takes no arguments. 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

?- write([a,b,c,d,[x,y,z]]),nl.
[a,b,c,d,[x,y,z]]
yes

?- write(mypred(a,b,c)),nl.
mypred(a,b,c)
yes

?- write('Example of use of nl'),nl,nl,write('end of example'),nl.
Example of use of nl
end of example
yes

If it is important to output the quotes, the writeq/1 predicate can be used.

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

example :
?- read(X).
: jim.
X = jim

?- read(X).
: 26.
X = 26

?- read(X).
: mypred(a,b,c).
X = mypred(a,b,c)

?- read(Z).
: [a,b,mypred(p,q,r),[z,y,x]].
Z = [a,b,mypred(p,q,r),[z,y,x]]

• 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. 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.
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. The table below gives the numerical ASCII values corresponding to the main printable characters and some others.

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

?- get0(N).
: Z
N = 90

• Using Characters: Examples

The first example shows how to read in a series of characters from the keyboard finishing with * and to output their corresponding ASCII values one per line (for all characters excluding *). 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.)

The final example is a recursive program, based on the previous two, which shows how to read in a series of characters ending with * and count the number of vowels. Characters are read in one by one until a character with ASCII value 42 (signifying *) is encountered.
Here 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)'.
Predicate vowel tests for one of the 10 possible vowels (five upper case and five lower case), using their ASCII values.

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

• 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).
Note that the file corresponding to the previous current output stream remains open when a new current output stream is selected. Only the current output stream can be closed (using the told predicate described below).
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.

• 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').
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. Note that the file corresponding to the previous current input stream remains open when a new current input stream is selected. Only the current input stream can be closed (using the seen predicate described below).
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 .

INPUT AND OUTPUT in Prolog (Eercise 5)

Hei .. hei .. hei ..

Seperti yang sebelumnya , kali ini kita akan melanjutkan exercise yang selanjutnya .

Kali ini kita akan membahas exercise 5 .

Ok . let’s start from number 1 .

1. Pertama buatlah rule dahulu pada notepad .

2. Kemudian beri nama dan save dengan format .pl

3. Kemudian buka prolog , dan consult le tersebut .

4. Lalu ketik makelower pada PROLOG , kemudian enter .

5. Lalu ketiklah kata-kata terserah anda , maka yang keluar adalah seperti ini .

2.

1. Pertama buat rule pada notepad .

2. Kemudian save as dengan format .pl .

3. Lalu buka PROLOG dan consult file tersebut .

4. Setelah itu buat file baru dinotepad .

5. kemudian ketik copyterms(‘Infile.txt’,'Outfile.txt’). pada PROLOG.

6. Lalu tekan enter dan hasilnya adalah sebagai berikut .

3.

1. Buat rule pada notepad .

2. Save .pl

3. Kemudian buka prolog dan consult file tersebut

4. Lalu buat file baru pada notepad yang isinya

5. Kemudian pada PROLOG tulisakan perintah readfile(‘testa.txt’).

6. Maka hasilnya adalah

4.

1. Buat rule pada notepad .

2. Kemudian save .pl

3. Buka prolog dan consult file tersebut .

4. Lalu buat file baru yang bernama in1.txt

5. Lalu buat lagi file baru yang bernama in2.txt,

6. Lalu ketik combine(‘in1.txt’,'in2.txt’,'out.txt’). pada prolog .

7. Maka hasil yang keluar adalh sebagai berikut .

5.

1. Pertama buatlah rule pada notead , kemudian save denganformat .pl

2. Kemudain buka PROLOG dan consult file tersebut .

3. lalu buat file bernama 1.txt pada notepad ,

4. kemudian buat lagi file bernama 2.txt

5. Lalu pada prolog ketik perintah compare(‘1.txt’,'2.txt’).

6. Maka hasilnya adalah sebagai berikut :