home *** CD-ROM | disk | FTP | other *** search
/ Black Box 4 / BlackBox.cdr / proglang / pie2.arj / PIEDOC.DOC < prev    next >
Text File  |  2000-01-01  |  37KB  |  957 lines
  1.  
  2.  
  3.  
  4.  
  5.  
  6.  
  7.      PIE is a public domain Prolog Interpreter.  You are encouraged to share
  8. this program with others.  To start PIE go to the subdirectory where PIE is
  9. installed and issue the command "PIE" followed by <ENTER>.  PIE will load and
  10. you will be facing the "Goal:" prompt.  PIE will execute whatever valid
  11. command you give it.  I recommend that you first load and execute the
  12. demonstration programs that are included with PIE.  These programs are as
  13. follows:
  14.  
  15. piedemo.pro        To load "piedemo.pro" issue the command
  16.                    "consult("piedemo.pro")" followed by <ENTER>.  You can
  17.                    execute "piedemo.pro" by issuing the command "start"
  18.                    followed by <ENTER>.  The program "piedemo.pro" will
  19.                    demonstrate some of PIE's graphics capability.
  20.  
  21. chem.pro           To load "chem.pro" issue the command "consult("chem.pro")"
  22.                    followed by <ENTER>.  You can execute the program
  23.                    "chem.pro" by issuing the command "start(1) followed by
  24.                    <ENTER>.  The program "chem.pro" defines an organic
  25.                    molecule and analyzes it by looking for functional groups.
  26.  
  27. eliza.pro          To load "eliza.pro" issue the command
  28.                    "consult("eliza.pro")" followed by <ENTER>.  Execute
  29.                    "eliza.pro" by issuing the command "converse" followed by
  30.                    <ENTER>.  The program "eliza.pro" mimics a psychologist and
  31.                    allows the user to interact with it.  Don't ever call it a
  32.                    jerk though.  It will take offense to that insult.
  33.  
  34. turtle.pro         To load "turtle.pro" issue the command
  35.                    "consult("turtle.pro")" followed by <ENTER>.  To execute
  36.                    "turtle.pro" issue the command "start followed by <ENTER>.
  37.                    The program "turtle.pro" will mimic an etch-a-scetch.
  38.                    Press 'l' to go left, press 'r' to go right, press 'u' to
  39.                    go up, press 'd' to go down or press '*' to quit.
  40.  
  41. object.pro         To load "object.pro" issue the command
  42.                    "consult("object.pro")" followed by <ENTER>.  To execute
  43.                    "object.pro" issue the command "start" followed by <ENTER>.
  44.                    The program "object.pro" is a whimsical demonstration of
  45.                    object oriented programming in Prolog.
  46.  
  47.      Other useful commands when you are just starting with PIE include the
  48. following:
  49.  
  50. retract(_),fail    To clear a program out of memory.  Issue this command to
  51.                    clear the memory before consulting a new program.
  52.  
  53. edit("<filename>") This command loads a program into the full screen editor so
  54.                    that you can modify it.  If you exit the editor with the
  55.                    F10 key PIE will consult the edited program so that it can
  56.                    be run.
  57.  
  58. trace              This command should be issued before running a program if
  59.                    you want to trace the execution of the program step by
  60.                    step.  For example the command "trace,start" will execute
  61.  
  62.  
  63.  
  64.  
  65.  
  66.  
  67.                    the "start" command and allow you to trace it's execution.
  68.                    The trace command does not work well with graphics programs
  69.                    since it is a text oriented feature.
  70.  
  71. system             This command allows you to shell out to DOS and execute DOS
  72.                    commands.  Type "exit" followed by <ENTER> to return to
  73.                    PIE.
  74.  
  75. halt               The "halt command exits PIE and returns you to DOS.
  76.  
  77. Introduction to Prolog
  78.  
  79.      While I will provide some instuction in Prolog programming this
  80. documentation is not intended to be a complete guide on the subject.  For that
  81. I recommend the book "Prolog Programming in Depth" by Michael A. Covington,
  82. Donald Nute and Andre Vellino.
  83.      To program your first Prolog program type the command:
  84.  
  85.      edit("first.pro")
  86.  
  87. and press <ENTER>.  This command will put you in the programming text editor.
  88. Now type the following lines:
  89.  
  90.      hello:-
  91.           write("Hello World"),
  92.           nl,
  93.           readchar(_).
  94.  
  95. and press the F10 key to return to the goal prompt.  Be very careful since one
  96. little mistake can cause the program to crash.  If you entered the program
  97. correctly the interpreter will say:
  98.  
  99.      true
  100.      1 Solution
  101.  
  102. To run this program type "hello" and press <ENTER>.  The program will execute
  103. and print the words "Hello World" on the screen and wait for you to press a
  104. key.
  105.      Now type the command "edit("first.pro")" and press <ENTER>.  Now change
  106. your program to the following:
  107.  
  108.      hello:-
  109.           write("Hello World"),
  110.           nl,
  111.           readchar(_),
  112.           introduce.
  113.  
  114.      introduce:-
  115.           write("What is your name?"),
  116.           readln(Name),
  117.           write("Hello ",Name),
  118.           readchar(_).
  119.  
  120.  
  121.  
  122.  
  123.  
  124.                                     - 2 -
  125.  
  126.  
  127.  
  128.  
  129.  
  130.  
  131. and press the F10 key to return to the goal prompt.  Notice that the routine
  132. named "introduce" is called the same way as the built-in commands (called
  133. predicates) are.  In effect programming in Prolog is building new predicates
  134. and calling them from other predicates.  The readln predicate uses the
  135. variable "Name".  Note that all variable names must begin with a capital
  136. letter.  Also make sure that the periods and commas are in their correct
  137. locations.  Run your program by issuing the command "hello" and pressing
  138. <ENTER>.  The program will do the following:
  139.  
  140.     -  write "Hello World"
  141.  
  142.     -  wait for you to press the space bar
  143.  
  144.     -  ask for your name
  145.  
  146.     -  wait for you to enter the name and press <ENTER>
  147.  
  148.     -  write "Hello" to you
  149.  
  150.      To trace the execution of the program you can issue the command
  151. "trace,hello" and press <ENTER>.  The interpreter will allow you to single
  152. step though the program one step at a time.  Press the <SPACE> bar to execute
  153. each command.  When you are back to the goal prompt issue the command
  154. "edit("first.pro")" and press <ENTER>.  Now change your program to:
  155.  
  156.      hello:-
  157.           write("Hello World"),
  158.           nl,
  159.           readchar(_),
  160.           introduce.
  161.  
  162.      introduce:-
  163.           write("What is your name?"),
  164.           readln(Name),
  165.           write("Hello ",Name),
  166.           readchar(_),
  167.           makelist(Name,[],List),
  168.           write(List),
  169.           readchar(_).
  170.  
  171.      makelist("",List,List):-!.
  172.  
  173.      makelist(Name,Accumulator,List):-
  174.           frontchar(Name,Char,Rest),
  175.           makelist(Rest,[Char|Accumulator],List).
  176.  
  177. and press the F10 key.  This program will take your name and separate it into
  178. a list of characters after it has gone through the greeting phase of the
  179. previous program.  The predicate makelist is different than the introduce and
  180. hello predicates in two ways.  First, it uses parameters passed from the
  181. introduce predicate.  The parameters are as follows:
  182.  
  183. Name               The name variable is bound to the name you typed in.
  184.  
  185.  
  186.  
  187.  
  188.                                     - 3 -
  189.  
  190.  
  191.  
  192.  
  193.  
  194.  
  195. []                 The empty brackets signify that this list is an empty list.
  196.  
  197. List               This will be the variable that will contain the list of
  198.                    characters in your name.  At this point of the program it
  199.                    has not been bound to a value and is therefore considered a
  200.                    free variable.
  201.  
  202. The second difference is that it consists two clauses.  Predicates can have
  203. any number of different clauses.  The first clause:
  204.  
  205.      makelist("",List,List):-!.
  206.  
  207. signals that your name has been completely separated into a list of charaters
  208. with the first parameter being empty quote marks.  The second parameter
  209. represented by the variable List contains the list of characters that are in
  210. your name in reverse order.  The third parameter contains the List variable
  211. which is bound to the list characters found in your name.  By placing a bound
  212. variable in the position of the third parameter that parameter becomes bound
  213. and that list will be returned to the calling predicate.  The '!' tells the
  214. interpreter that it is not to try to execute the makelist predicate again at
  215. this time.
  216.      If the makelist predicate has not removed all of the characters then the
  217. first clause of the makelist predicate will fail.  Failure in Prolog is not a
  218. serious occurance and Prolog will simply go on to process another clause.  The
  219. second clause of the makelist predicate:
  220.  
  221.      makelist(Name,Accumulator,List):-
  222.           frontchar(Name,Char,Rest),
  223.           makelist(Rest,[Char|Accumulator],List).
  224.  
  225. will remove the first character from your name and add that character to the
  226. list of characters it is adding to the Accumulator variable.  Notice the
  227. notation used in the last second parameter of the last line of the clause to
  228. represent a list.  The list is divided into two parts.  The first part is the
  229. head which consists of the first item of the list.  The second part consists
  230. of the rest of the list.  Lists are used in Prolog instead of arrays.
  231.      The last line of the second clause of the makelist predicate calls itself
  232. again.  This ability for a predicate to call itself is called recursion.  In
  233. the recursive call the first parameter is the Rest variable which is bound to
  234. your name minus the first character.  The second parameter is the list of
  235. characters that have been removed from your name.  The third parameter has not
  236. yet been bound to a list yet.  This will take place whenever the name has had
  237. all of it's characters removed and added to the list being accumulated in the
  238. second parameter.
  239.      To run this program issue the command "hello" and press <ENTER>.  The
  240. program will do the following:
  241.  
  242.     -  write "Hello World"
  243.  
  244.     -  wait for you to press the space bar
  245.  
  246.     -  ask for your name
  247.  
  248.     -  wait for you to enter the name and press <ENTER>
  249.  
  250.  
  251.  
  252.                                     - 4 -
  253.  
  254.  
  255.  
  256.  
  257.  
  258.  
  259.     -  write "Hello" to you
  260.  
  261.     -  write a list with the characters in your name in reverse order
  262.  
  263. You can learn much about Prolog by using the trace command to single step
  264. through this program.
  265.      This ends my short tutorial on Prolog.  Again, I can't over estimate the
  266. importance of obtaining a good book on Prolog programming techniques.
  267.  
  268.  
  269. Language Reference
  270.  
  271. !                  - The cut prevents backtracking or in other words, does not
  272.                    allow Prolog to try different solutions.  A cut is
  273.                    especially helpful in increasing the efficiency of
  274.                    programs.  For instance, a cut immediately before a tail
  275.                    recursive call will invoke tail recursion optimization
  276.                    which will greatly increase the efficiency of the program
  277.                    execution.
  278.  
  279. arg(N,TERM,ARGn)   This command provides a way to extract parts (called
  280.                    arguments) from a term.  For example the call:
  281.                    arg(3,[1,2,3,4,5,6],Arg)
  282.                    will extract the number '3' from the list and return it as
  283.                    the value of Arg.
  284.  
  285. assert(RULE)       - The assert command will place a copy of RULE at the end
  286.                    of Prolog's dynamic database.  This command is the same as
  287.                    the assertz(RULE) command.
  288.  
  289. asserta(RULE)      - The asserta command will place a copy of RULE at the
  290.                    beginning of Prolog's dynamic database.
  291.  
  292. assertz(RULE)      - The assertz command will place a copy of RULE at the end
  293.                    of Prolog's dynamic database.  This command is the same as
  294.                    the assert(RULE) command.
  295.  
  296. call(GOAL)         - The call(GOAL) predicate will execute the term specified
  297.                    in the variable in GOAL.  The call(GOAL) predicate will
  298.                    also accept a string which it will try to parse into an
  299.                    valid Prolog goal and execute it.  For example, both
  300.                    call("edit")
  301.                    and
  302.                    call(edit)
  303.                    will call the edit predicate.
  304.  
  305. char_int(CHAR,INT) - The char_int(CHAR,INT) predicate will convert a character
  306.                    to an integer that is equal to the ASCII value for that
  307.                    integer or convert an integer to the ASCII character that
  308.                    is represented by that integer.
  309.  
  310. char_real(CHAR,REAL)
  311.                    - The char_real is the same as the char_int predicate
  312.                    except that it handles real numbers instead of just
  313.  
  314.  
  315.  
  316.                                     - 5 -
  317.  
  318.  
  319.  
  320.  
  321.  
  322.  
  323.                    integers.  For most uses the char_real predicate is
  324.                    preferred.
  325.  
  326. clause(HEAD,BODY)  - return clauses from the database
  327.  
  328. clearwindow        - The clearwindow predicate clears the current window and
  329.                    sets the cursor to the upper left corner of that window.
  330.  
  331. colorsetup(Integer)
  332.                    - The colorsetup command will allow the user to
  333.                    interactively change the color of the current window if
  334.                    Integer is equal to '0' or the frame around the window if
  335.                    Integer is equal to '1'.
  336.  
  337. concat(STRING,STRING,STRING)
  338.                    - The concat predicate is used for combining and dividing
  339.                    strings.  For example:
  340.                    concat("Hello ","World",A)
  341.                    A will equal the string "Hello World".
  342.                    concat("Hello ",A,"Hello World")
  343.                    A will equal the string "World"
  344.                    concat(A,"World","Hello World")
  345.                    A will equal the string "Hello "
  346.  
  347. consult(FILENAME)  - The consult predicate will read in a file and add the
  348.                    clauses to Prolog's dynamic database.  This is the standard
  349.                    way to initially load a program.
  350.  
  351. consult_str(STRING)
  352.                    - The consult_str(STRING) predicate will parse the contents
  353.                    of the variable string and add the clauses to Prolog's
  354.                    dynamic database.
  355.  
  356. cursor(Row,Col)    - The cursor predicate allows the programmer to specify
  357.                    where on a given window the cursor will be located or it
  358.                    can be used to return the location of the cursor.
  359.  
  360. cutbacktrack(BTOP) - dynamic cut to designated backtrack point
  361.  
  362. date(YEAR,MONTH,DAY)
  363.                    - The date(YEAR,MONTH,DAY) predicate returns the system
  364.                    date.
  365.  
  366. debug              - debug will cause the tokens generated by the  scanner to
  367.                    be displayed if there is a error in parsing.
  368.  
  369. dir(Path,Filemask,Filename)
  370.                    - The dir(Path,Filemask, Filename) will call a directory
  371.                    function in the current window.  The user can move the
  372.                    cursor to scroll through the list of files and select one
  373.                    that will be returned in the Filename variable.  For
  374.                    example:
  375.                    dir("c:\pie","*.pro",Filename)
  376.  
  377.  
  378.  
  379.  
  380.                                     - 6 -
  381.  
  382.  
  383.  
  384.  
  385.  
  386.  
  387.                    will display a list of file names in the "c:\pie"
  388.                    subdirectory with the file extension of "*.pro".
  389.  
  390. display(TERM*)     - outputs functors in prefix notation
  391.  
  392. edit(File)         - The edit(File) predicate will allow the user to edit a
  393.                    program file specified by the File variable.  When the
  394.                    editor is exited the file is consulted into Prolog's
  395.                    dynamic database.
  396.  
  397. edit(pred/arity)   - edit selected predicate
  398.  
  399. edit_file(FILE)    The edit_file(FILE) predicate allows the user to edit a
  400.                    text file whose name is specified in the FILE variable.
  401.                    The file is not consulted after the editor is exited.
  402.  
  403. edit               - The edit command allows the user to edit the current
  404.                    clauses in the dynamic database.  When the editor is edited
  405.                    the clauses are consulted into Prolog's dynamic database.
  406.  
  407. eof                - If the eof predicate is true then the file pointer is at
  408.                    the end of the current seeing file.  Otherwise it fails.
  409.  
  410. existwindow(WindowNo)
  411.                    - The existwindow(WindoNo) predicate tests to see if the
  412.                    window whose number is specified in the WindoNo variable
  413.                    exists.
  414.  
  415. fail               - The fail predicate always fails and forces Prolog to
  416.                    backtrack.
  417.  
  418. file_str(FILENAME,STRING)
  419.                    - The file_string(FILENAME,STRING) predicate loads the
  420.                    contents of the file whose name is specified in the
  421.                    FILENAME variable into the STRING variable.
  422.  
  423. frontchar(STRING,CHAR,REST)
  424.                    - The frontchar(STRING,TOKEN,REST) predicate removes (or
  425.                    adds) the first character of a string.  This predicate is
  426.                    used to break strings into their component characters.
  427.  
  428. frontstr(REAL,STRING,FIRST,END)
  429.                    - The frontstr(REAL,STRING,FIRST,END) predicate will remove
  430.                    the first string with a length defined by the REAL variable
  431.                    from the original string.
  432.  
  433. fronttoken(STRING,TOKEN,REST)
  434.                    - The fronttoken(STRING,TOKEN,REST) predicate is used to
  435.                    break strings into tokens.  A token can either be a number,
  436.                    word or a symbol.  A common use for the fronttoken
  437.                    predicate is to remove a token from a string.  For example
  438.                    in the call:
  439.                    fronttoken("Hello there.",Token,Rest)
  440.  
  441.  
  442.  
  443.  
  444.                                     - 7 -
  445.  
  446.  
  447.  
  448.  
  449.  
  450.  
  451.                    the variable Token will equal "Hello" and the variable rest
  452.                    will equal " there.".
  453.  
  454. functor(TERM,FUNCTOR,ARITY)
  455.                    - returns the functor and arity of a term or build a new
  456.                    functor.
  457.  
  458. getbacktrack(BTOP) - gets backtrack point for dynamic cut.
  459.  
  460. help               - The help predicate displays the help file in the current
  461.                    window.  Press the F10 or <ESCAPE> key to exit.
  462.  
  463. integer(TERM)      - tests the trerm to see if it is an integer.
  464.  
  465. REAL is EXPRESSION - The is predicate evaluates arithmetic expressions.  The
  466.                    arithmetic expression must be on the right side and the
  467.                    answer must be on the left.  The full range of math
  468.                    operators is listed below:
  469.  
  470.                    +             - plus
  471.  
  472.                    -             - minus
  473.  
  474.                    *             - multiplication
  475.  
  476.                    /             - division
  477.  
  478.                    mod           - modulo
  479.  
  480.                    abs           - absolute value
  481.  
  482.                    cos           - cosine (units are in radians)
  483.  
  484.                    sin           - sine (units are in radians)
  485.  
  486.                    tan           - tangent (units are in radians)
  487.  
  488.                    arctan        - arctangent (units are in radians)
  489.  
  490.                    exp           - returns e raised to a power
  491.  
  492.                    ln            - natural logarithm
  493.  
  494.                    log           - logarithm
  495.  
  496.                    sqrt          - square root
  497.  
  498.                    round         - round
  499.  
  500.                    trunc         - truncate
  501.  
  502. list(pred)         - list all clauses for pred.
  503.  
  504. list(pred/arity)   - list selected arity.
  505.  
  506.  
  507.  
  508.                                     - 8 -
  509.  
  510.  
  511.  
  512.  
  513.  
  514.  
  515. list               - list all clauses.
  516.  
  517. makewindow(WinNo,ScrAtt,FAtt,FString,Row,Col,Height,Width)
  518.                    - The
  519.                    makewindow(Winno,ScrAtt,FAtt,FString,Row,Height,Width)
  520.                    predicate will create a window with the following
  521.                    attributes:
  522.  
  523.                    Winno         - The window number.  The programmer should
  524.                                  start numbering windows from 4 since numbers
  525.                                  1 - 3 are used for the system windows.
  526.  
  527.                    ScrAtt        - Defines the screen color inside of the
  528.                                  window.
  529.  
  530.                    FAtt          - Defines the color of the frame around the
  531.                                  window.
  532.  
  533.                    FString       - This is the string that is displayed at the
  534.                                  top of the window.  This string is
  535.                                  automatically centered.
  536.  
  537.                    Row           - Specifies the row where the top of the
  538.                                  window starts relative to the whole screen.
  539.  
  540.                    Col           - Specifies the column where the left of the
  541.                                  window starts relative to the whole screen.
  542.  
  543. nl                 - The nl predicate outputs a carriage return and linefeed
  544.                    to the current output device whether that is the screen or
  545.                    the telling file.
  546.  
  547. nonvar(TERM)       - tests to see if the term is bound.
  548.  
  549. not(GOAL)          - The not(GOAL) predicate reverses the success of the goal
  550.                    specified in the GOAL variable.  For example the call:
  551.                    not(true)
  552.                    is the same as the fail predicate.
  553.  
  554. notrace            - turns off tracing.
  555.  
  556. op(PRIORITY,ASSOC,OP)
  557.                    - returns operators, or changes operator precedence.
  558.  
  559. random(REAL)       - The random(REAL) predicate invokes the random number
  560.                    generator to generate a real number between or equal to
  561.                    zero and less than one.
  562.  
  563. randominit(INTEGER)
  564.                    - The randominit(INTEGER) reinitializes the random number
  565.                    generator.  The integer specified in the INTEGER variable
  566.                    is a seed number.  If randominit is not called before using
  567.                    the random predicate then Prolog will use 1 as the seed
  568.                    number for the random series.
  569.  
  570.  
  571.  
  572.                                     - 9 -
  573.  
  574.  
  575.  
  576.  
  577.  
  578.  
  579. read(TERM)         - The read(TERM) predicate will read a term from the
  580.                    current input device into the TERM variable.  Normally the
  581.                    current input device is the keyboard but can directed to a
  582.                    file with the see predicate.
  583.  
  584. readchar(CHAR)     - The readchar(CHAR) reads a character from the current
  585.                    input device into the CHAR variable.
  586.  
  587. readln(LINE)       - The readln(LINE) reads a string from the current input
  588.                    device until a carriage return is encountered.  The string
  589.                    is read into the LINE variable.
  590.  
  591. real(TERM)         - tests to see if the term is a real.
  592.  
  593. reconsult(FILENAME)
  594.                    - The reconsult(FILENAME) retracts all of the current terms
  595.                    in the Prolog database and consults the contents of the
  596.                    file specified in the FILENAME variable.
  597.  
  598. removewindow       - The removewindow predicate removes the current window.
  599.                    Don't remove the system windows or PIE may act strangely.
  600.  
  601. repeat             - The repeat predicate is always true and provides an
  602.                    infinite number of potential solutions.
  603.  
  604. repeat(GOAL)       - The repeat(GOAL) predicate is always true unless the goal
  605.                    specified in the GOAL variable fails.  This predicate will
  606.                    provide multiple solutions until some condition is met.
  607.                    For example:
  608.                    repeat(not(eof))
  609.                    will generate new solutions until the end of the seeing
  610.                    file is reached.
  611.  
  612. resizewindow       - The resizewindow predicate provides the user with a way
  613.                    to interactively resize the current window.  Press the F10
  614.                    key to exit this function.
  615.  
  616. retract(TERM)      - The retract(TERM) predicate allows the programmer or user
  617.                    to remove clauses from Prolog's dynamic database.  This
  618.                    facility provides a program a means to remove part of
  619.                    itself while it is executing and reclaim the memory used by
  620.                    the removed clauses.
  621.  
  622. save(FILENAME)     - The save(FILENAME) will save the clauses in Prolog's
  623.                    dynamic database into a file specified by the FILENAME
  624.                    variable.
  625.  
  626. scr_char(ROW,COL,CHAR)
  627.                    - The scr_char(ROW,COL,CHAR) will print a character
  628.                    specified by the CHAR variable at the location on the
  629.                    screen specified by the ROW and COL variable.
  630.  
  631.  
  632.  
  633.  
  634.  
  635.  
  636.                                     - 10 -
  637.  
  638.  
  639.  
  640.  
  641.  
  642.  
  643. searchstring(STRING,SEARCHSTRING,LOCATION)
  644.                    - The searchstring(STRING,SEARCHSTRING,LOCATION) will
  645.                    locate a string specified by the SEARCHSTRING variable in
  646.                    the string specified by the STRING variable.  The starting
  647.                    location of the string specified by the SEARCHSTRING
  648.                    variable is returned in the LOCATION variable.
  649.  
  650. see(FILENAME)      - The see(FILENAME) predicate opens the file whose name is
  651.                    specified by the FILENAME variable and redirects the input
  652.                    to this file.
  653.  
  654. seeing(FILENAME)   - The seeing(FILENAME) predicate will return in the
  655.                    FILENAME variable the name of the current file being used
  656.                    for input.
  657.  
  658. seen               - The seen predicate will close the file currently being
  659.                    used for input and redirect the input to the keyboard.
  660.  
  661. shiftwindow(No)    - The shiftwindow(No) predicate will change the current
  662.                    window to the window specified by the No predicate.  The
  663.                    window shifted to will be automatically moved to the
  664.                    foreground.
  665.  
  666. storage            - The storage predicate will write to the current output
  667.                    device a description of the system's use of the different
  668.                    memory areas.
  669.  
  670. str_atom(STRING,ATOM)
  671.                    - The str_atom(STRING,ATOM) predicate will convert between
  672.                    a string specified in the STRING variable and an atom
  673.                    specified in the ATOM variable.
  674.  
  675. str_int(STRING,INT)
  676.                    - The str_int(STRING,INT) predicate converts between a
  677.                    string specified in the STRING variable and an integer
  678.                    specified in the INT variable.
  679.  
  680. str_len(STRING,LENGTH)
  681.                    - The str_len(STRING,LENGTH) predicate will return the
  682.                    length of a string specified by the STRING variable.  It
  683.                    will also return a string of blanks of a length specified
  684.                    by the LENGTH predicate.
  685.  
  686. substring(STRING,START,LENGTH,SUBSTRING)
  687.                    - The substring(STRING,START,LENGTH,SUBSTRING) predicate
  688.                    will extract a substring returned in the SUBSTRING variable
  689.                    from a string specified by the STRING variable starting at
  690.                    a location specified in the START variable with a length
  691.                    specified by the LENGTH variable.  For example, the call:
  692.                    substring("ABEKAT",5,2,SUBSTRING)
  693.                    will return the string "AT" in the SUBSTRING variable.
  694.  
  695. system             - The system command allows the user to access the
  696.                    operating system from within a Prolog program.
  697.  
  698.  
  699.  
  700.                                     - 11 -
  701.  
  702.  
  703.  
  704.  
  705.  
  706.  
  707. system(Command,VideoReset,Error)
  708.                    - The system(Command,VideoReset,Error) command provides a
  709.                    method for a Prolog program to execute a DOS command from
  710.                    within a Prolog program.  The DOS command is specified as a
  711.                    string in the Command variable.  The VideoReset variable
  712.                    will specify whether or not the screen will be reset when
  713.                    the DOS command is executed.  If the VideoReset variable
  714.                    equals 0 the screen is not reset.  The number 1 will cause
  715.                    the screen to be reset.  Any DOS errors that are returned
  716.                    by the system are returned in the Error variable.
  717.  
  718. tell(FILENAME)     - The tell(FILENAME) opens a file whose name is specified
  719.                    by the FILENAME variable and redirect the programs output
  720.                    to that file.
  721.  
  722. telling(FILENAME)  - The telling(FILENAME) will return the name of the current
  723.                    output file in the FILENAME variable.
  724.  
  725. TERM =.. LIST      - univ; conversion between term and list
  726.  
  727. TERM == TERM       - testing for true equality
  728.  
  729. TERM =< TERM       - less than or equal
  730.  
  731. TERM = TERM        - unify two terms
  732.  
  733. TERM < TERM        - integer less than
  734.  
  735. TERM >= TERM       - greater than or equal
  736.  
  737. TERM >< TERM       - different evaluated values
  738.  
  739. TERM > TERM        - integer greater than
  740.  
  741. TERM \== TERM      - not true equality
  742.  
  743. TERM \= TERM       - test whether unify
  744.  
  745. time(HOUR,MIN,SEC,HUNDREDS)
  746.                    - The time(HOUR,MIN.SEC,HUNDREDS) predicate will set or
  747.                    return the system time.
  748.  
  749. told               - The told predicate closes the current output file and
  750.                    redirects the programs output to the screen.
  751.  
  752. trace              - The trace predicate turns on the Prolog's tracing
  753.                    facility which allows the user to single step through the
  754.                    programs execution with a display of the calls to the
  755.                    predicates in the program execution.
  756.  
  757. true               - The true predicate simply is true and always succeeds.
  758.  
  759. var(TERM)          - tests to see if the TERM variable is free.
  760.  
  761.  
  762.  
  763.  
  764.                                     - 12 -
  765.  
  766.  
  767.  
  768.  
  769.  
  770.  
  771. VAR                - calls the predicate to which VAR is bound.
  772.  
  773. window_str(String) - The window_str(STRING) will write or read a string
  774.                    specified or returned in the STRING variable.
  775.  
  776. write(TERM*)       - The write(TERM*) is Prolog's standard way of writing to
  777.                    the current output device.  Any number of terms can be used
  778.                    with the write predicate.
  779.  
  780.  
  781.  
  782. Math operators
  783. =============================
  784.  
  785. +         - plus
  786. -         - minus
  787. *         - multiplication
  788. /         - division
  789. mod       - modulo
  790. abs       - absolute value
  791. cos       - cosine (units are in radians)
  792. sin       - sine (units are in radians)
  793. tan       - tangent (units are in radians)
  794. arctan    - arctangent (units are in radians)
  795. exp       - returns e raised to a power
  796. ln        - natural logarithm
  797. log       - logarithm
  798. sqrt      - square root
  799. round     - round
  800. trunc     - truncate
  801.  
  802. Graphics System
  803.      The graphics are based on a virtual screen.  The lower left hand corner
  804. is 0,0 and the upper right hand is 32000,32000.  It does not matter what
  805. graphic adapter is used, the screen coordinates are the same.  In addition to
  806. the normal lines, dots, ellipses etc., there are also turtle graphics commands
  807. and Bezier curves.  The graphics predicates are as follows:
  808.  
  809. angle(Angle)-(i)(o)
  810.                    - The angle(ANGLE) predicate allows the programmer to set
  811.                    or read the current angle the "turtle" is facing.  If the
  812.                    "turtle" is facing to the right the angle will equal 0.  If
  813.                    the "turtle" is facing straight up the angle is 90.
  814.  
  815. beep               - The beep predicate simply beeps the computer.
  816.  
  817. bezier(X1,Y1,CX1,CY1,CX2,CY2,X2,Y2)-(i,i,i,i,i,i,i,i)
  818.                    -
  819.                    The bezier(X1,Y1,CX1,CY1,CX2,CY2,X2,Y2) predicate draws a
  820.                    Bezier curve with the end points X1,Y1 and X2,Y2 and with
  821.                    the control points CX1,CY1 and CX2,CY2.
  822.  
  823. bkcolor(Color)-(i) - The bkcolor(Color) predicate sets the background color to
  824.                    the color specified by the Color variable.
  825.  
  826.  
  827.  
  828.                                     - 13 -
  829.  
  830.  
  831.  
  832.  
  833.  
  834.  
  835. circle(X,Y,Radius)-(i,i,i)
  836.                    - The circle(X,Y,Radius) draws a circle with a center at
  837.                    the coordinates specified by the X and Y variables and with
  838.                    a radius specified by the Radius variable.
  839.  
  840. closegraph         - The closegraph predicate closes the graphics system.
  841.  
  842. dot(X,Y)-(i,i)     - The dot(X,Y) predicate makes a dot at the location with
  843.                    the coordinates specified by X and Y variables.
  844.  
  845. dot                - makes a dot at the current location.
  846.  
  847. draw(GraphicsDriver,GraphMode)-(i,i)
  848.                    - sets the computer to graphics mode using the driver
  849.                    specified in GraphicsDriver and the graphics mode specified
  850.                    by GraphMode.
  851.  
  852. draw(GraphMode)-(i)
  853.                    - sets the computer to graphics mode specified by
  854.                    GraphMode.  The graphics driver is automatically called.
  855.  
  856. draw               - sets the computer to graphics mode.  The graphics driver
  857.                    and mode are automatically determined.
  858.  
  859. drawpoly(Pointlist)-(i,i,...i,i)
  860.                    - draws a polygon with the point pairs specified.
  861.  
  862. elipse(X,Y,StAngle,EdAngle,Xradius,Yradius)-(i,i,i,i,i,i)
  863.                    - draws an ellipse centered at X,Y starting at StAngle and
  864.                    ending at EdAngle with X and Y radii of Xradius and
  865.                    Yradius.
  866.  
  867. ellipse(X,Y,Xradius,Yradius)-(i,i,i,i)
  868.                    - draws an ellipse centered at X,Y with X and Y radii of
  869.                    Xradius and Yradius.
  870.  
  871. fillstyle(Fillpattern,Fillcolor)-(i,i)(o,o)
  872.                    - sets or returns the Fillpattern and Fillcolor.
  873.  
  874. floodfill(X,Y)-(i,i)
  875.                    - floodfills an area with a pattern.
  876.  
  877. line(X1,Y1,X2,Y2)-(i,i,i,i)
  878.                    - makes a line from X1,Y1 to X2,Y2.
  879.  
  880. lineto(X,Y)-(i,i)  - makes a line from the current location to X,Y.
  881.  
  882. move(Steps)-(i)    - moves the turtle a certain number of steps in the
  883.                    direction specified by the current angle.  Negative numbers
  884.                    moves the turtle backwards.
  885.  
  886. outtext(Text)-(i)  - writes Text to the screen at the current location and in
  887.                    the current font and color
  888.  
  889.  
  890.  
  891.  
  892.                                     - 14 -
  893.  
  894.  
  895.  
  896.  
  897.  
  898.  
  899. outtext(X,Y,Text)-(i,i,i)
  900.                    - writes Text to the screen at X,Y in the current font and
  901.                    color
  902.  
  903. pendown(Status)-(i)
  904.                    - reports the marking status of the turtle.  The number 0
  905.                    means the pen is up and 1 means the pen is down.
  906.  
  907. pendown            - causes the turtle to start making marks when it is moved
  908.                    with the move predicate.
  909.  
  910. penpos(X,Y)-(i,i)(o,o)
  911.                    - sets or returns current pen location.
  912.  
  913. penup              - causes the turtle to stop making marks when it is moved.
  914.  
  915. rectangle(X1,Y1,X2,Y2)-(i,i,i,i)
  916.                    - draws a rectangle with the upper left corner located at
  917.                    X1,Y1 and the lower right corner located at X2,Y2.
  918.  
  919. settextstyle(Font,Direction,Charsize)-(i,i,i)
  920.                    - sets the current font, Direction, and Charsize.  The
  921.                    fonts are specified as: 0 = default bitmapped, 1 = triplex,
  922.                    2 = small, 3 = sans serif, 4 = gothic.  Direction is
  923.                    specified as: 0 = horizontal (default) and 1 = vertical.
  924.                    Charsize is an integer that specifies a magnification
  925.                    factor.
  926.  
  927. smooth(Setting)-(i)(o)
  928.                    - sets or returns the smoothing value for the bezier
  929.                    curves.  A higher number increases the smoothness of the
  930.                    curves but increases the time taken to draw the curves.
  931.                    The default value is 5.
  932.  
  933. sound(Duration,Frequency)-(i,i)
  934.                    - produces a sound with the specified Duration and
  935.                    Frequency.
  936.  
  937. text               - closes the graphics system and restores the text mode.
  938.  
  939. turn(Angle)-(i)    - turns the turtle the degrees specified in Angle.
  940.                    Positive angles turn the turtle left and negative angles
  941.                    turn the turtle right.
  942.  
  943.  
  944.  
  945.  
  946.  
  947.  
  948.  
  949.  
  950.  
  951.  
  952.  
  953.  
  954.  
  955.  
  956.                                     - 15 -
  957.