Upload
hema-kuppi
View
29
Download
4
Tags:
Embed Size (px)
Citation preview
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 Programprogram gcd(input, output);var i,j: integerbegin 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 ; beginread ( i , j ) ; whilei <> j do if i > jthen i := i - j else j:= j - i ; writeln ( i) end . Grammarprogram PROGRAM identifier ( identifier more_identifiers): block .whereblock labels constants types variables subroutines BEGIN statement more_statements ENDmore_identifiers identifiers more_identifiers | e e empty string
Programming Language SyntaxPrecisionRules (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 moreoccurrences)
Chomsky grammars (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
TheoryDFA = deterministic finite automatonQ (finite set of states), (an alphabet of input symbols), qQ (an initial state),
FQ (distinguished final states), and :QQ(transition function)
NFA – transition function is multivalued – impliesguessing
Regular expressionsDPDA – deterministic pushdown automata – stack
Q, , q, F, (finite set of stack symbols), ZAnother 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 Derivations and Parse Trees Another Example: slope * x + interceptexpression 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
AmbiguityRevised 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 grammarsPascal scanner
Finite automatonLexical errorsComments (pragmas) – significant commands to compilerParsing
Top Down versus Bottom UpLL – left to right scan, left-most derivation – top down Manual or parser-generator construction Predictive parsing LL(k) – look ahead k tokensExample 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 Errors
Panic mode, Phrase-level recovery, Context-sensitivelook-ahead,
Exception-based recovery, Error productions Table-Driven Parsing Predict sets Writing Grammars 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 treeS(X0) =f(A(X1),f(X2)…A(Xn)
Intrinsic attributes - synthesized attribute forleaf nodedetermined outside parse tree (e.g., typefrom symbol table of a variable)
Inherited attributes – passed down parse treeI(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 = QxE
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,QQ’/{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 consistentsemantics)
Boolean (logicals), characters, integers (unsigned integers called
cardinals)Ordinals or discrete typesrationals, reals, complex numbers, decimals ordinals and those immediately above – scalar or simple Enumeration types Type weekday = (sun,mon,tue,wed,thu,fri,sat); Can be index types in Pascal Subrange types 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) CastsArrays Addressing Slices and Operations
Array AddressingUnions (Variant records)SetsPointers References
Array AddressingLet
c = the size of an element (ArrayElementType) in memory unitsk = dimensionality of array (number of dimensions)
Consider ArrayElementType b[L1:U1, … Lk:Uk];Note Lj Ij Uj
Nj= number of elements in array b along dimension j = Uj - Lj+ 1 N = number of elements in array b = j=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=1
k-1 (r=t+1k [Ur – Lr +1] (It – Lt)) + (Ik – Lk)
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=2
k (r=1t-1 [Ur – Lr +1] (It – Lt)) + (I1 – L1)
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. Initializea. Input integer nb. parameter = n parameter is of type
integerc. 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 thena. factorial := 1b. go to step 4
elsea. parameter := parameter –1b. returnaddress = 3 switch – 0step 3
recursive callerc. go to step 1
3. factorial := factorial * (parameter + 1)4.
a. pop(parameter,returnaddress)b. if returnaddress = 3 then go to step 3c. 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); }
LispS-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 symbolsOperators 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 argumentsin 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 andare global
(load ‘file-name) ; enter lisp program from fileConditionals 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 clispSOURCE CODE IN FILE kraft
(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 6TERMINAL 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
SOURCE CODE IN FILE powerset
(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 listI/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 F, f: O --> O;Example: +: <1,2> 3
F = set of functional forms to make new functionsD = set of definitions to define functions in F and to assign names to
them
(Primitive) Functions Selector s:x x=<x1,…,xn> & 1sn & s integer xs ; Tail tl:x x=<x1> ; x=<x1,…,xn> & 2n <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> & yz F; Null null:x x= T; x F; ( = <> = empty sequence) Reverse reverse:x x= ; x=<x1,…,xn> <xn,…,x1>; Distribute from left (right) distl:x x=<y,> ; x=<y,<z1,…,zn>>
<<y,z1>,…,<y,zn>>; distr:x x=<,y> ; x=<<y1,…,yn>,z>
<<y1,z>,…,<yn,z>>; Length length:x x=<x1,…,xn> n; x=> 0;
Transpose trans:x x=<,…,> ; x=<x1,…,xn> &xi=<xi1,…,xim> i 1in
& yj=<x1j,…,xnj> j 1jm <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 & z0 yz;
Booleanand: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, > <y>; x=<y,<z1,…,zn>
<y,z1,…,zn>; apndr:x x=<,z > <z>; x=<<y1,…,yn>,z>
<y1,…,yn,z>; Right Selectors; right tail sr: x=<x1,…,xn> & 1sn & s integer xn-s+1; tlr:x x=<x1> ; x=<x1,…,xn> & 2n <x1…,xn-1>; Rotate left (right)
rotl:x x= ; x=<x1> <x1>; x=<x1,…,xn> & 2n <x2,…xn,x1>;
rotr:x x= ; x=<x1> <x1>; x=<x1,…,xn> & 2n <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> & 2n
f:<x1,f:<x2,…,xn>>; Example: /+:<4,5,6> = +:<4, /+:<5,6>> = +:<4,+:<5,/+:<6>>>
= +:<4,+:<5,6>=+:<4,11>=15 Apply to all f:x x= ; 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 (*) 0 trans Matrix Multiplication def MM (IP) 0 (distl) 0 distr 0
[1,trans 0 2]Bonus Homework Problems
1. Evaluate the followinga) 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 ( 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 constantupper-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 rulespredecessor(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 happenspred1(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.
SOURCE CODE IN FILE kraftmain(X,Y) :- add(X,Y,Z),write(X),write(‘ ‘),write(Y),
write(‘ ‘),write(Z),nl.add(A,B,C) := C is A + B.
TERMINAL
prologconsult(kraft).tell(kraftout).main(3,4).told.halt.
DATA IN FILE kraftout AFTER PROGRAM EXECUTION 3 4 7
List StuffList
[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).
Arithmeticis assignment operator + - * / ** // modlength([],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.
Monkey and Banana Problemstate(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).
Word ProblemThere 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 Queens 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. nocut instantiations before cut stay as is and cannot be changedf(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 commentpublic 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 bytecodeExecution: java Welcome1 File: Welcome4.java// A welcome program in Java in a dialog boximport javax.swing.JOptionPane; // import JOptionPane classpublic 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 programimport 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 secondinteger" );
// read in the two numbers as stringsnumber1 = 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 fourthparameter
System.exit ( 0 ); }}
File: WelcomeApplet.java// WecomeApplet.java - A first welcome applet in Javaimport javax.swing.JApplet; // import JApplet classimport java.awt.Graphics; // import Graphics classpublic 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 numbersimport java.awt.Graphics; // import Graphics classimport javax.swing; // import JApplet packagepublic 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 stringsnumber1 = 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.classFile: Addition.Applet.html<html><applet code="AdditionApplet.class" width=300 height=50></applet></html>Execution: appletviewer AdditionApplet.html
AWK (Aho, Weinberger, Kernighan) InterpretiveNo 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 separatorExample 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