CSc 4101 Fall 2007 Notes
1. Why
Study
Choosing
language to use, Easier to learn new languages, Understand obscure features
(e.g., .* in C++), Choose among alternative ways to express things (e.g., x*x
versus x^2 versus x**2), Make good use of debuggers and assemblers and linkers
and related tools, Simulate features in languages that lack them (e.g.,
iterators in Clu and Icon)
2. Environments
Tools
– debuggers, assemblers, preprocessors, compilers, linkers, style checkers,
configuration management, software engineering tools, tracers, breakpoints,
steppers, windows – Visual Studio and .Net
3. Interpretation
Compilers
versus Interpreters, Hybrids
Fortran
libraries and linker (link editor)
Intermediates
– Assemblers, Preprocessors, Intermediate code (e.g., P-code)
4. Compilers
and Computing Theory
Scanner
– lexical analysis, Parser – syntax analysis, Semantic analysis – intermediate
code generation, Machine-independent code improvement (optional), Target code
generation, Machine-specific code improvement (optional); Symbol table
An Example Program
program
gcd(input, output);
var
i,j: integer
begin
read(i,j)
while i<>j do
if i>j then i := i - j
else j := j – 1;
writeln(i)
end.
Its Tokens (Lexemes)
program gcd ( input , output ) ;
var i , j : integer ; begin
read ( i , j ) ; while
i <> j do if i > j
then i := i - j else j
:= j - i ; writeln ( i
) end .
program à PROGRAM identifier (
identifier more_identifiers): block .
where
block à labels constants types
variables subroutines BEGIN statement
more_statements END
more_identifiers à identifiers more_identifiers | e eè empty string
Programming Language Syntax
Precision
Rules
(Production rules or productions)
digit
à 0 | 1 | 2 | 3 | 4 | 5 | 6 |
7 | 8 | 9
nonzerodigit
à 1 | 2 | 3 | 4 | 5 | 6 | 7 |
8 | 9
natural_number
à nonzerodigit digit*
è Kleene star (meta-symbol meaning 0 or more
occurrences)
(S,T,N,S) - S is alphabet, T is set of terminals (words), N is set of nonterminals
(parts of speech), and S is
an element of N and is the start symbol
Rules
– Concatenation, Alternation (choice among alternatives – may use |),
Repetition
(*)
Regular
grammar – uses only those rules
Lexical
analysis
Regular expressions: a
character, empty string, two regular expressions concatenated together, two
regular expressions in alternation (|), or a regular expression followed by the
Kleene star (*)
Context-free
grammars –
add recursion
Parsers
Context-sensitive grammars and General
grammars
Theory
DFA = deterministic finite automaton
Q
(finite set of states), S (an alphabet of input symbols), qeQ (an initial state),
FÍQ (distinguished final states), and d:Q´SàQ
(transition function)
NFA – transition function is multivalued – implies
guessing
Regular expressions
DPDA – deterministic pushdown automata – stack
Q, S, q, F, G (finite set of stack symbols), ZeG
Another Example - Tokens
digit
à 0 | 1 | 2 | 3 | 4 | 5 | 6 |
7 | 8 | 9
unsigned_integer
à digit digit*
unsigned_number
à unsigned_integer
((. unsigned_integer)
| e)
((e (+|-|e) unsigned_integer) | e)
Another Example - Context-free Grammar
expression
à identifier | number | - expression
|
( xpression
) |
expression operator
expression
operator
à - | + | * | /
identifier_list
à identifier | identifier_list
, identifier
Another Example: slope * x + intercept
expression è expression
operator expression è expression operator identifier
è
expression
+ identifier è expression operator expression
+ identifier
è
expression operator identifier + identifier
è
expression
* identifier + identifier è identifier * identifier + identifier
è
slope * x +
intercept
Revised
grammar
Precedence (*, / before +,-) Associativity
– breaking precedence ties
2^3^4 with ^ implying exponentiation
left à (2^3)^4 = 8^4 = 2^12 = 4096 right
à 2^(3^4)
= 2^81
Scanning lexical
analysis
Deterministic finite automaton (dfa) – recognizes tokens
Note: parser is a deterministic push-down automaton (dpa)
for
context-free grammars
Pascal
scanner
Finite automaton
Lexical errors
Comments (pragmas) – significant commands to compiler
Parsing
Top
Down versus Bottom Up
LL –
left to right scan, left-most derivation – top down
Manual or parser-generator
construction
Predictive parsing
LL(k) – look ahead k tokens
Example
id_list à id id_list_tail
id_list_tail à , id id_list_tail | ;
Figure
id(A), id(B), id(C)
Recursive Descent
$$
end pseudo-token
grammar
program à stmt_list $$
stmt_list à stmt stmt_list | e
stmt à id := expr | read
id | write expr
expr à term term_tail
term_tail à add_op term
term_tail | e
term à factor factor_tail
factor_tail à mult_op factor factor_tail |
e
factor à ( expr )
| id | literal
add_op à + | -
mult_op à * | /
recursive
descent program – (LL(1) parse)
read A
read B
sum := A + B
write sum
write sum / 2
parse tree
Panic
mode, Phrase-level recovery, Context-sensitive
look-ahead,
Exception-based recovery, Error
productions
Predict sets
Ambiguity (e.g., dangling else)
LR – left to
right scan, right-most derivation
SLR, LALR, full LR subclasses
Number of tokens for look-ahead (e.g.,
1)
Stack
Semantic Analysis
Static –
structural
Attribute
grammars
Rule X0 à X1 X2 … Xn
Parse tree:
X0
| | … |
X1 X2
… Xn
A(Xj) – some attribute of
symbol Xj
Synthesized
attributes – passed up parse tree
S(X0) =f(A(X1),f(X2)…A(Xn)
Intrinsic
attributes - synthesized attribute
for
leaf node
determined outside parse tree (e.g., type
from symbol table of a variable)
Inherited
attributes – passed down parse
tree
I(Xj) =f(A(X0),f(X1)…A(Xj-1)
Example Grammar
assign à var expr
expr
à
var + var | var
var à A | B | C
actual_type
– synthesized, intrinsic for a variable
expected_type
– inherited, depends on left-hand-
side (lhs) of assignment statement
Dynamic – meaning
Operational
– simulation on target machine
Example: C statement
for (expr1; expr2; expr3) { … }
Operational semantics
expr1;
loop: if expr2 = 0 goto out
…
expr3;
goto loop
out:
Axiomatic
– proof of correctness (logic)
Assertions
- logical predicates
Axiom – logical statement assumed to be true
Inference
rule – method of inferring truth of one
assertion on the basis of other assertions
pre-
and post- conditions
Px precondition defined by
axiom P = QxàE
P computed as Q with all instances of x replaced by E
A=b/2–1 (a<10 postcondition)
– substitute
b/2-1 in a<10 to get b<22
Sum = 2*x+1 {sum>1
postcondition } è
{x>10 precondition}
but
weakest precondition {x>0}
Sequences of statements
{P}S{Q} {P}S{Q},P’èP,QèQ’/{P’}S{Q}
Logical pretest loops – loop invariants
While (y<>x) do y=y+1 end
{y=x precondition}
{y<=x loop invariant}
Kraft example: Linear Search
void function ls(list x, list_type key,
k int answer)
{
int i;
for (i=1;
i<=length(x); i++)
if (key ==
x[i]) then {
return (i);
break
};
return(0)
}
loop invariant – ls returns
index of first
occurrence of key or 0 if key not in list
Denotational - recursive function theory
bin_num à 0 | 1 | bin_num
0 | bin_num 1
Mbin(x) = meaning of x
Mbin(‘0’)= 0, Mbin(‘1’)=1, Mbin(bin_num ‘0’)=2*Mbin(bin_num),
Mbin(bin_num
‘1’)=2* Mbin(bin_num)+
Data Types
Type – set
of values an entity can take
Declaration and Definition – Name of entity and name of type
Denotational –
set of values
domain
Constructive
– small collection of built-in types (primitives
or predefined -
e.g.,
Boolean, integer, character, real) or composite
(constructor, e.g.,
record,
array, set)
Abstract
(interface, set of operations, mutually consistent
semantics)
Boolean (logicals),
characters, integers (unsigned integers called
cardinals)
Ordinals or
discrete types
rationals, reals, complex
numbers, decimals
ordinals and those immediately above – scalar or simple
Type weekday = (sun,mon,tue,wed,thu,fri,sat);
Can be index types in Pascal
Type test_scores = 0..100;
Composites
Arrays, Sets, Files, Lists, Pointers
Orthogonality
Type Checking
Equivalence – same type
Compatility – operations allowed
Inference – type determined from constitutent parts
of an expression
Conversion (coercion)
Casts
Addressing
Slices and Operations
Array Addressing
Unions (Variant records)
Pointers
References
Array Addressing
Let
c = the
size of an element (ArrayElementType) in memory units
k =
dimensionality of array (number of dimensions)
Consider
ArrayElementType b[L1:U1, … Lk:
Note
Lj £ Ij £ Uj
Nj= number of elements in
array b along dimension j = Uj - Lj+ 1
N = number of elements in array b = Pj=1k Nj
Then
Address(b[I1, …, Ik])
= Address(b[L1, …, Lk]) + {c * factor}
For row-major order, storing and
retrieving the first row, then the second row, and so on, with the leftmost
subscript moving the slowest going across linear memory and the rightmost
subscript moving the fastest, we have
factor = åt=1k-1 (Pr=t+1k [
For column-major order, storing and
retrieving the first column, then the second column, and so on, with the
rightmost subscript moving the slowest going across linear memory and the
leftmost subscript moving the fastest, we have
factor = åt=2k (Pr=1t-1 [
Recursion and the Activation
Record (and the
Run-Time Stack)
An Example for Factorials (n!, where n is a nonnegative integer) */
#include <stdio.h>
int facit(int);
int facrecur(int);
int facrecursim(int);
int stackparm[101]; int stackra[101];
int top = 0; /* run-time stack as array */
void main() {
int n;
printf (“input n, the
factorial number desired as a nonnegative
integer\n”); scanf(“%d”,&n);
printf
(“iterative factorial %d = %d! = %d\n”, n, n, facit(n));
printf(“\n”);
printf
(“recursive factorial %d = %d! = %d\n”, n, n,
facrecur(n)); printf(“\n”);
printf (“simulated recursive factorial %d =
%d! = %d\n”, n,
n,
facrecursim(n)); printf(“\n”);
}
int facit (int n) {
int i; int prod = 1;
for (i = n; i ³ 1; i--) { prod
*= i; }
return (prod);
}
int facrecur (int n) {
if (n == 0) return (1);
else return (n *
facrecur(n-1));
}
/* Factorial Via Simulated Recursion
0. Initialize
a. Input integer n
b. parameter = n parameter
is of type integer
c. returnaddress := 0 switch - 0 ® main program
d. create stack stack hold
return-address
and parameter
e. top = 0 run-time stack
initially
empty
1.
push(parameter,returnaddress) (call)
2. If parameter = 0 then
a. factorial := 1
b. go to step 4
else
a. parameter := parameter –1
b. returnaddress = 3 switch – 0®step 3
recursive caller
c. go to step 1
3. factorial := factorial * (parameter + 1)
4.
a. pop(parameter,returnaddress)
b. if returnaddress = 3 then go to step 3
c. else go to main program */
void push (int *parm, int *ra) {
top += 1;
stackparm[top] = *parm;
stackra[top] = *ra;
}
void pop (int *parm, int *ra) {
*parm = stackparm[top];
*ra = stackra[top];
top -= 1;
}
int facrecursim (int n) {
int parm; int ra = 0; int
step = 0; int fac;
parm = n;
while (step != 4) {
push (&parm,
&ra);
if (parm == 0) {
fac = 1; step = 4; }
else { parm -= 1;
ra = 3; }
}
while (ra == 3) {
if (step != 4)
fac *= (parm + 1);
pop(&parm,
&ra); step = 0;
}
return (fac);
}
Lisp
S-expression (symbols)
Atom – x, 1, “a”
List – (a b c)
Sublists
- (a (b c) (d (e (f g) h))) - sub
Evaluation – first element of
list assumed to be an
operator, remainder are operands
-
every operator is
a function returning a value
-
side effects –
print, assignment
(+
5 3) à 8 (+ 3 5
9 11) à 28 (* (+ 2 3) (+ 4 6)) à 50
; comment
postponed (controlled) evaluation of
symbols
Operators
exit, load, +, -, 1+, 1-, *, /
(set ‘x 4) or (setq x 4) ; assignment
quote
car,. cdr ; breakdown lists
(car ‘(a b c)) à a (car
(‘(a b) c d e)) à (a b) ; head of list
(cdr ‘(a b c)) à (b c) ;
tail of list (caaadddr)
cons, list, append ; put lists together
(cons Elem List) à (Elem List)
(list Elem1 Elem2 … ElemN) à (Elem1 Elem2 … ElemN)
(append List1 List2 … ListN) à (elements of list arguments
in order)
(cons ‘a ‘(b c)) à (a b c) (list
‘a ‘(b c) ‘d) à (a (b c) d)
(append ‘(a b) ‘(c d) ‘(e f))
à (a b c d e f)
car, cdr, cons, list, append not
destructive
nil à () ; empty
list, also indicator of “false”
Functions (user defined)
(defun function-name (list of formal
parameters)
(defun add3 (x) (+ x 3)) à add3
formal
parameters called “bound” variables and are local
(pass by value)
other
variables used locally are called “free” variables and
are global
(load ‘file-name) ; enter lisp program from file
Conditionals
Predicates – return t for true or nil
for false
atom, listp, null, numberp,
typep
(member Elem List) – return
tail of list beginning with first
occurrence of Element
(cond ( (predicate) (statement(s)) ) ) ; note use of cond
; Examples (note recursion at work):
(defun fac (n) ; recursive factorial
(n!)
(cond ( (not (integerp n)) nil)
( (< n 0) nil)
( (equal n 0) 1 )
( t (* n (fac (1- n))))))
(defun
mylength (l)
(cond ( (not (listp l) nil)
( (null l) 0 )
( t (1+ (mylength (cdr l))))))
(defun mylengthwithif (l)
(if (null l) 0 (1+
(mylength (cdr l)))))
(defun mymember (e l))
(cond ((atom l) nil)
((null l) nil)
((equal e (car l)) t )
( t (mymember e (cdr l)))))
(defun mypower (b n)
(cond ((or (not (numberp b)) (not (numberp n))) nil)
((< n 0) (/ 1.0 (mypower b
(* -1 n))))
(
t (* b (mypower b (1- n))))))
Using clisp
(defun
arithmetic (x)
(+
x (* x x) ) )
(defun
main ()
(setq
of (open “kraftout” :direction :output) )
(setq
iof (open “kraftin” :direction :input) )
(terpri
of)
(setq
z (read iof) )
(setq
y (arithmetic z) )
(print
y of) )
DATA IN FILE kraftin
6
TERMINAL
clisp
(load
‘kraft)
(main)
(exit)
DATA IN FILE kraftout AFTER PROGRAM EXECUTION
42
Another
example: powerset in Lisp
powerset
is the set of subsets of a given set
(defun long (l)
(cond
((null l) 0)
(
t (1+ (long (cdr l))))))
(defun add (e l)
(cond
((or (atom l) (null l)) nil))
(
t (cons (cons e (car l))
(add e (cdr l))))))
(defun power (l)
(cond (
(not (listp l)) nil)
( ( null l) (list l))
((equal
(long l) 1) (list l (cdr l)))
(
t (append (add (car l) (power (cdr l)))
(power (cdr l))))) )
TERMINAL
clisp
(load
‘powerset)
(setq z
‘(a b c)
(power
z))
(exit)
à ((A B C) (A B) (A C) (A) (B C) (B) (C) () )
Iteration
defun sum-of-ints (n) ; example of for command
(do ((i n (1- i))
(result 0 (+ i result)))
((zerop i) result)))
(prog1 (car stack) (setq stack (cdr
stack)) ; note use of prog1
; prog1
evaluates expressions but returns result of first one
Property Lists ;
databases (of sorts)
(setf (get ‘chair3 ‘color) ‘blue)
(get ‘chair3 ‘color) à blue
Advanced Lisp
(defun sum-loop (func n) ; apply to use function
as argument
(do ((i n (1- i))
(result 0 (+(apply func (list i)) result)))
((zerop i) result)))
(sum-loop ‘sqrt 5)
(defun squared (n) (* n n)) (sum-loop ‘squared 5)
(sum-loop (lambda (x) (* x x)) 5)
;
lambda for unnamed functions
(setq x ‘(cons ‘a ‘(b c))) (eval x) à (a b c) ;
eval to evaluate a symbol
(mapcar ‘1+ (100 200 300)) à (101 201 301)
(mapcar ‘+ ‘(1 2 3) ‘(100 200 300)) à (101 202 303)
;
mapcar to use an operator on a list
I/O
(setq x (read)) (a b c) x à (a b c)
(prog1 (print ‘enter) (setq x (read)) à same result as above
; can use
car and cdr to get individual elements of x
(loop ;
use of loop and let to to read a number n and print Ön
(print ‘number >)
(let ((in (read)))
(if (equal in ‘end)
(return nil))
(print (sqrt
(in))))
Strings “characters”
List Representation (cons list)
Double linked list – left pointer
points to value, right pointer points to remainder
of list
dotted pair (a) = (a . nil) (a b c)
= (a . (b . (c . nil)))
Equality (setq x ‘(a b c)) (setq y (cdr x)) (setq
z ‘(b c))
(equal y z) à t (eq y z) à nil
; eq means
same object not just same value
; eql works like eq
except if symbols are numbers of same type
and value
Functional Programming (FP) – Backus (Everything is a function, returning a
value; no assignment)
FP
= (O,F,F,D),
where:
O = set of objects, either atoms (e.g.,
numbers or symbols), sequences
(lists, denoted by <…>), or
the bottom symbol ^ which means
“undefined”;
F = set of functions, where, for each f e F, f: O --> O;
Example: +: <1,2> à 3
F = set of functional forms to make new functions
D = set of definitions to define functions in F and to
assign names to
them
(Primitive) Functions
Selector
s:x @ x=<x1,…,xn>
& 1£s£n & s integer à xs ; ^
Tail
tl:x @ x=<x1> à F; x=<x1,…,xn> & 2£n à <x2,…,xn>; ^
Identity
id: x @ x
Atom
atom: x @ (x is an atom) à T; x¹^ à F; ^
Equals
eq:x @ x=<y,z> & y=z à T; x=<y,z>
& y¹z à F; ^
Null
null:x @ x=F à T; x¹^ à F; ^ (F = <> = empty sequence)
Reverse
reverse:x @ x=F à F; x=<x1,…,xn> à <xn,…,x1>;
^
Distribute
from left (right)
distl:x @ x=<y,F> à F; x=<y,<z1,…,zn>> à
<<y,z1>,…,<y,zn>>;
^
distr:x @ x=<F,y> à F; x=<<y1,…,yn>,z> à
<<y1,z>,…,<yn,z>>;
^
Length
length:x @ x=<x1,…,xn>
à n; x=F> à 0;^
Transpose trans:x @ x=<F,…,F> à F; x=<x1,…,xn> &
xi=<xi1,…,xim>
"i 1£i£n
& yj=<x1j,…,xnj>
"j 1£j£m à <y1,…,ym>;^
Arithmetic
+:x @ x=<y,z> & y,z numbers à y+z; ^
-:x @ x=<y,z> & y,z numbers à y+z; ^
*:x @ x=<y,z> & y,z numbers à y*z; ^
¸:x @ x=<y,z> & y,z numbers & z¹0à y¸z;
^
Boolean
and:x @ x=<T,T> à T; x=<T,F> È <F,T> È <F,F> à F; ^
or:x @ x=<F,F> à F; x=<T,F> È <F,T> È <T,T> à T; ^
not:x @ x=T à F;
x=F à T; ^
Append
left (right)
apndl:x @ x=<y,F > à <y>; x=<y,<z1,…,zn> à
<y,z1,…,zn>;^
apndr:x @ x=<F,z > à
<z>; x=<<y1,…,yn>,z>
à
<y1,…,yn,z>;^
Right
Selectors; right tail
sr: @ x=<x1,…,xn> & 1£s£n & s integer à xn-s+1; ^
tlr:x @ x=<x1>
à F; x=<x1,…,xn>
& 2£n à <x1…,xn-1>;
^
Rotate
left (right)
rotl:x @ x=F à F; x=<x1>
à <x1>; x=<x1,…,xn> &
2£n à
<x2,…xn,x1>; ^
rotr:x @ x=F à
F; x=<x1>à <x1>; x=<x1,…,xn>
& 2£n à
<xn,x1,…xn>;
^
Functional Forms
Composition
(f 0 g):x @ f(g:x))
Construction [f1,…,fn]:x @ <f1:x,…,fn:x>
Condition
(p --> f; g):x @ (p:x)=T à f:x; (p:x)=F à
(g:x); ^
Constant
┐x:y @ y=^ à ^; x
Insert
/f:x @ x=<x1> à x1;
x=<x1,…,xn> & 2£n à
f:<x1,f:<x2,…,xn>>; ^
Example: /+:<4,5,6> = +:<4, /+:<5,6>> =
+:<4,+:<5,/+:<6>>>
= +:<4,+:<5,6>=+:<4,11>=15
Apply
to all af:x @ x=F à F; x=<x1,…,xn>à
<f:x1,…,f:xn>>;
^
Binary
to Unary (bu f x):y @ f:<x,y>
While
(while p f):x @ (p:x)=T à
(while p f): (f:x); (p:x)=F à x; ^
Definitions def l @ r where l is a symbol (function name) and r is an
expression
Example:
def last @ (null 0 tl --> 1;last
0 tl)
Sample Programs
Factorial
def eq0
@ eq 0 [id, ┐0]
def sub1 @ - 0 [id, ┐1]
def ! @ (eq0 à ┐1; * 0 [id, ! 0 sub1])
Inner
Product def IP @ (/+) 0 (a*) 0 trans
Matrix
Multiplication def MM @ (aaIP) 0 (adistl) 0 distr 0
[1,trans 0 2]
Bonus Homework Problems
1. Evaluate
the following
a) 3 0 tl: <a,b,c,d>
b) tl 0 2: <a,b,c>
c) length 0 distl 0 reverse: <<1,2,3,4,5>,a>
d) (/+) 0 (a length): <<1>,<2,3>,<4,5,6>>
2.
Write a non-recursive FP program to compute the mean of a sequence of numbers (remember that the mean is the sum of the sequence
divided by the number of numbers in the sequence).
x
(read)) à same result as above
; can use
car and cdr to get individual elements of x
(loop ;
use of loop and let to to read a number n and print Ön
(print ‘number >)
(let ((in (read)))
(if (equal in ‘end)
(return nil))
(print (sqrt
(in))))
Prolog Logic
Programming
Facts relation-name(arguments).
lower-case first letter à constant
upper-case first letter à variable
parent(pam,bob). parent(tom,bob). parent(tom,liz).
parent(bob,ann).
parent(bob,pat). parent(pam,jim).
pam tom
| /
\
bob liz
/
\
ann pat
\
jim
Queries ?
relation-name(arguments).
? parent(bob,pat).
yes
? parent(liz,pat). no
?
parent(X,liz). X=tom
? parent(bob,X). X=ann ; X=pat
? parent(X,Y).
, à AND ; à OR
Rules relation-name(arguments)
:- relation-name(arguments),
[…,relation-name(arguments)].
offspring(X,Y) :- parent(Y,X).
grandparent(X,Z) :- parent(X,Y),Parent(Y,Z).
Recursive rules
predecessor(X,Z) :- parent(X,Z).
predecessor(X,Z) :- parent(X,Y),predecessor(Y,Z).
Problem – does order make
a difference? Bonus – run this and tell what
happens
pred1(X,Z) :- parent(X,Z). pred1(X,Z) :-
parent(X,Y),pred1(Y,Z).
pred2(X,Z) :-
parent(X,Y),pred2(Y,Z). pred2(X,Z) :-
parent(X,Z).
pred3(X,Z) :- parent(X,Z). pred3(X,Z) :-
pred3(X,Y),parent(Y,Z).
pred4(X,Z) :-
pred4(X,Y),parent(Y,Z). pred4(X,Z) :-
parent(X,Z).
Declarative meaning versus
Procedural Goals Matching (Scanning)
Instantiation of variables
Structures date(Day,Month,Year) line(point(1,7),point(2,5)).
Horn clauses in logic Backtracking
Problem –
suppose we add gender (e.g., male(jim). and female(ann). facts to our knowledge
base, then add the rule sister(X,Y) :- parent(Z,X),parent(Z,Y),female(X). What weird thing can happen? ann is ann’s sister! Welcome to Prolog world.
main(X,Y) :-
add(X,Y,Z),write(X),write(‘ ‘),write(Y),
write(‘ ‘),write(Z),nl.
add(A,B,C) := C is A + B.
TERMINAL
prolog
consult(kraft).
tell(kraftout).
main(3,4).
told.
halt.
DATA IN FILE kraftout AFTER
PROGRAM EXECUTION
3 4 7
List Stuff
[a,b,c,d]
[a|b,c,d] à a is head of list (car), [b,c,d] is tail of list (cdr)
[a, b| c, [d, e], f] allowed
Functions
member(X,[X|_]).
member(X,[_|Y]) :- member(X,Y).
concatenate([[,L,L).
concatenate([X|L1],L2,[X|L3]) :-
concatenate(L1,L2,L3).
delete(X,[X|L],L).
delete([X,[H|L1],[H|L2]) :-
delete(X,L1,L2).
add(X,L,L1) -: delete(X,L1,L).
sublist(S,L) :-
concatenate(L1,L2,L),concatenate(S,L3,L2).
permute([],[]).
permute([X|L],P) :-
permute(L,L1),add(X,L1,P).
Arithmetic
is è assignment operator +
- * / ** // mod
length([],0).
length([_|Tail],L) :- length(Tail,N), L is N +1.
gcd(X,X,X). gcd(X,Y,D) :- X < Y, Y1 is Y - X,
gcd(X,Y1,D).
gcd(X,Y,D) :- Y < X, gcd(Y,X,D).
mypower(B,0,1.0).
mypower(B,N,P) :- N < 0,M is -N,mypower(B,M,Q),P is
1.0/Q.
mypower(B,N,P) :- M is N-1, mypower(B,M,Q), P is B *
Q.
state(monkey-horizontal-position,monkey-verticalposition,box-position,possession)
actions
–walk, push, climb, grasp
_ à unnamed variable nl
à newline write nl
and write always true
move(state(middle,onbox,middle,hasnot),grasp,state(middle,onbox,middle,has)).
move(state(P,onfloor,P,H),climb,state(P,onbox,P,H)).
move(state(P1,onfloor,P1,H),push(P1,P2),state(P2,onfloor,P2,H)).
move(state(P1,onfloor,B,H),walk(P1,P2),state(P2,onfloor,B,H)).
canget(state(_,_,_,has),[]).
canget(State,[Action|Actions])
:-
move(State,Action,Newstate),canget(Newstate,Actions).
printactions([]).
printactions([X|Y])
:- write(X),nl,printactions(Y).
main(S,A)
:- canget(S,A),printactions(A).
There are five houses on a
block in a city, with a different man of a different nationality and who smokes
a different brand of cigarettes (politically incorrect) living in each house.
Each man has a different pet and drinks a different drink. Moreover, each house is a different
color. Now,7 just the facts: 1) the
Englishman lives in the red house, 2) the Spaniard has a dog, 3) the man living
in the green house prefers coffee, 4) the Ukranian drinks tea, 5) the man with
the snail smokes Winstons, 6) the man in the yellow house smokes Kools, 7) the
man who prefers orange juice also prefers Lucky Strikes to smoke, 8) the
Japanese man prefers to smoke Parliaments, 9) the man in the middle house
prefers milk, 10) the man in the first house is a Norwegian, 11) one house has
a zebra, 12) one house has a man who prefers water, 13) the man who has a fox
lives next to the man who smokes Chesterfields, 14) the man who has a horse
lives next to the man who smokes Kools, 15) the Norwegian lives next to a blue
house, and 16) the green house is to the immediate right of the ivory
house. Now, who lives where, who has
which pet and which drink and which cigarette brand, and what color are the
houses?
Answer:
the first house is yellow with the Norwegian,
a fox, with water and Kools; the second house is blue with the Ukranian, a
horse, with tea and Chesterfields; the third house is red with the Englishman,
a snail, with milk and Winstons; the fourth house is ivory with the Spaniard, a
dog, with orange juice and Lucky Strikes; the fifth house is green with the
Japanese, a zebra, with coffee and Parliaments
puzzle :-
Houses =
[_,_,house(_,_,_,milk,_),_,_],
Houses = [house(_,norwegian,_,_,_),_,_,_,_],
memberp(house(red,english,_,_,_),Houses),
memberp(house(_,spanish,dog,_,_),Houses),
memberp(house(green,_,_,coffee,_),Houses),
memberp(house(_,ukranian,_,tea,_),Houses),
memberp(house(_,_,snail,_,winston),Houses),
memberp(house(yellow,_,_,_,kools),Houses),
memberp(house(_,_,_,orangejuice,luckystrikes),Houses),
memberp(house(_,japanese,_,_,parliaments),Houses),
memberp(house(_,_,zebra,_,_),Houses),
memberp(house(_,_,_,water,_),Houses),
nexto(house(_,_,_,_,chesterfields),house(_,_,fox,_,_),Houses),
nexto(house(_,_,_,_,kools),house(_,_,horse,_,_),Houses),
nexto(house(_,norweigian,_,_,_),house(blue,_,_,_,_),Houses),
rightof(house(green,_,_,_,_),house(ivory,_,_,_,_),Houses),
printhouses(Houses).
memberp(X,[X|_]).
memberp(X,[_|Y]) :- memberp(X,Y).
nexto(X,Y,[X,Y|_]).
nexto(X,Y,[Y,X|_]).
nexto(X,Y,[_|Z])
:- nexto(X,Y,Z).
rightof(X,Y,[Y,X|_]).
rightof(X,Y,[_|Z])
:- rightof(X,Y,Z).
printhouses([]).
printhouses([X|Y])
:- write(X),nl,printhouses(Y).
8
Eight
queens – put eight queens on a 8x8 chessboard where no queen can attack another
queen – remembering that queens can move up or down, left or right, and
diagonally as much as they like.
answer(L)
:- template(L),solution(L),write(L),nl.
template([1/Y1,2/Y2,3/Y3,4/Y4,5/Y5,6/Y6,7/Y7,8/Y8]).
solution([]).
solution([X/Y|Others])
:- solution(Others),member(Y,[1,2,3,4,5,6,7,8]),
noattack(X/Y,Others).
noattack(_,[]).
noattack(X/Y,[X1/Y1|Others])
:- Y =\= Y1,Y1-Y =\= X1-X, Y1-Y
=\= X-X1,
noattack(X/Y,Others).
member(X,[X|_]).
member(X,[Y|L])
:- member(X,L).
Controlling
backtracking (the cut !)
f(X,0) :- X<3. f(X,2) :- 3=<X, X<6. f(X,4):-6=<X. ?f(1,Y),2<Y. no
cut à instantiations before cut stay as is and cannot be
changed
f(X,0) :- X<3,!. f(X,2) :- X<6,!. f(X,4).
max(X,Y,X) :-X>=Y,!. max(X,Y,Y).
Suppose we have a
programming contest and players are winners if they win every match, fighters
if they win some and lose some, and sportsman if the lose all contests. Beat(X,Y) implies player X played and beat
(won) player Y.
Class(X,fighter) :- beat(X,_),beat(_,X),!. class(X,winner)
:- beat(X,_),!.
Class(X,sportsman)
:- beat(_,X).
Suppose
mary likes all animals but snakes.
likes(mary,X) :- snake(X),!,fail. likes(mary,X) :- animal(X).
or likes(mary,X)
:- animal(X), not snake(X).
Or,
different(X,X) :- !,fail. different(X,Y).
; can use to make sure ann is not her
own sister as before
different(X,Y) :- X = Y,!,fail ; true.
Java Tutorial
File: Welcome1.java
//
A first program in Java comment
public
class Welcome1 { // class definition for Welcome1
{
public static void main( String args[]
)
// needed - main
{
System.out.println( "Welcome to Java Programming!" );
// System.out = main output object,
// println =
method for that object
} // end of main
} // end of Welcome1 class
Compiler: javac Welcome1.java è Welcome1.class =
fle with bytecode
Execution:
java Welcome1
File: Welcome4.java
//
A welcome program in Java in a dialog box
import
javax.swing.JOptionPane; // import
JOptionPane class
public
class Welcome4
{
public static void main( String args[]
)
{
JoptionPane.showMessageDialog(
null,"Welcome\nto\nJava\nProgramming!"
);
//
ShowMessageDialog = method for JOptionPane class
….null first argument
System.exit ( 0 ); // terminate the program
}
}
File: Addition.java
//
An addition program
import
javax.swing.JOptionPane;
public
class Addition {
public static void main( String args[]
)
String firstNumber,
secondNumber; // numbers entered
by user
int number1,
number2,
sum; //
local variables - integers
firstNumber =
JOptionPane.showInputDialog( "Enter
first integer" );
secondNumber =
JOptionPane.showInputDialog( "Enter
second
integer" );
//
read in the two numbers as strings
number1 = Integer.parseInt( firstNumber );
number2 = Integer.parseInt( secondNumber );
//
convert numbers from strings to integers
{ sum
= number1 + number2;
// add the numbers
JoptionPane.showMessageDialog(
null,"The sum is " + sum,
"Results", JOptionPane,PLAIN_MESSAGE );
//
display results, null is first parameter, "Results"
is the title of the
// display box, PLAIN_MESSAGE is fourth
parameter
System.exit ( 0 );
}
}
File: WelcomeApplet.java
//
WecomeApplet.java - A first welcome applet in Java
import
javax.swing.JApplet; // import
JApplet class
import
java.awt.Graphics; // import
Graphics class
public
class WelcomeApplet extends JApplet { //
extension of class - inheritance
{
public void paint( Graphics g ) // defintion of object g's paint method
{
g.drawstring( "Welcome
to Java Programming!", 25, 25 );
// drawstring
method and numbers are coordinates
}
}
Compiler: javac WelcomeApplet.java è WelcomeApplet.class
File:
WelcomeApplet.html
<html><applet
code="WelcomeApplet.class"
width=300 height=30></applet></html>
Execution:
appletviewer WelcomeApplet.html
File: AdditionApplet.java
//
AdditionApplet.java – An ddition program with two floating
//
point numbers
import
java.awt.Graphics; // import
Graphics class
import
javax.swing; //
import JApplet package
public
class AdditionApplet extends Japplet {
double sum;
public void init()
{
String firstNumber,
secondNumber;
double number1,
number2;
firstNumber =
JOptionPane.showInputDialog( "Enter
first real number" );
secondNumber =
JOptionPane.showInputDialog
( "Enter second real number" );
//
read in the two numbers as strings
number1 = Double.parseDouble( firstNumber );
number2 = Double.parseDouble( secondNumber );
//
convert numbers from strings to double reals
{ sum
= number1 + number2;
}
public void paint( Graphics g ) // draw results
{
g.drawRect( 15, 10, 270, 20
); // coordinates
g.drawstring( "The sum
is " + sum, 25, 25 );
}
}
Compiler: javac AdditionApplet.java è AdditionApplet.class
File:
Addition.Applet.html
<html><applet
code="AdditionApplet.class"
width=300 height=50></applet></html>
Execution:
appletviewer AdditionApplet.html
AWK (Aho, Weinberger, Kernighan) Interpretive
No
declarations – type determined in context
awk –f programfilename datafilename [ >
outputfilename ] nawk
BEGIIN{ … } { /* pattern section … }
End{ … }
order
important but not all sections needed
C based ; only needed if more than one
statement on
a line
Example: BEGIN{ print “Hello World!; exit}
Example: BEGIN{ i = 75; j = 30;
while(i >= j) {
If
(i > j) i -= j
Else
j -= i
}
print “The greatest common divisor” \
“of 75 and 30 is “ i
exit
}
Example { arg1 = $1; arg2 = $2
while(arg1 >= arg2) {
If
(arg1 > arg2) arg1 -= arg2
Else
arg2 -= arg1
}
print “The greatest common divisor
of” $1 \
“and “ $2 is “ arg1
}
Example BEGIN{ sum_of_squares = 0 }
# This
line is optional - default – numerical variables
# initialize automatically to 0, character variables
to the # null string
{ sum_of_squares +=
$1*$1 }
# Default internal loop to read input data and process
it # – one line at a time
END{ root_mean_square = sqrt(sum_of_squares)
/ NR
print root_mean_square
}
Internal variables
$i = the ith field of current record
$0 = entire current record
NR = number of records read
to this point
$NF =
number of fields in the current record
FS =
input field separator
RS =
input record separator
OFS =
output field separator
ORS = output record separator
Example BEGIN{ FS = “;” }
{ print NR, $0 } # prints file with line numbers
# , à standard spacing, lack of comma means
concatenation
Patterns assume a match before each statement in
pattern
(middle) section
Assumed true if no
pattern present
Default action if
no statement present is to print
current line
Boolean - ==, !=,
>, >=, <, <=
Match - ~, !~ match means presence of pattern
in target
Example { NF >= 2
for (i=1; i<=NF; i++) sum[i]+= $i
cnt++
}
END{ for
(i=1; i<=NF; i++)
printf “%g “,
sum[i]
printf “\n”
print cnt “ records with 2 or more fields”
}
| alternation a|b means ‘a’ or ‘b’
+ one or more a+ means one or more ‘a’
? means zero or one a? means one or zero ‘a’
occurrences
* means zero or more a* means zero or more ‘a’
occurrences
^ means beginning anchor so
^a means field begins
with ‘a’
$ means ending anchor so a$
means field ends with ‘a’
. means any character
[…] means class [a-z] means any lower-case letter
[ab]
means ‘a’ or ‘b’
Exanples
$2 ~ /a/ means match true if ‘a’ in field $2
$3 !~ /b/ means match true if no ‘b’ in field $3
$4 ~
/^this$|^that$/ means match true if field $4 =
‘this’ or field $4 = ‘that’
/start/,/stop/ means to start action if ‘start’
ccurs and keep doing it until ‘stop’
occurs
Logical connectives || OR $$
AND
Quiz: what do these programs
do?
{ length > 69 }
{ /don/ }
{ !/!/ }
{ /hello/,/goodbye/
}
{ $1 != prev {
print; prev = $1 }
More exit,
length(.), sqrt(.), log(.), exp(.), int(.), next, substr(.,.,.), index(..),
split(.,.), printf format, whle, for, concatenation operations, files, arrays
Applications
In
Unix, date must be reformatted
Counting
words