![Page 1: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/1.jpg)
Scheme Tutorial
![Page 2: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/2.jpg)
Goals
• Combine several simple ideas into one compound idea to obtain complex ideas
• Bring two ideas together to obtain relations
• Seperate ideas from all other ideas that accompany them in real existence to obtain general ideas (this is called abstraction)
by John Locke, An Essay Concerning Human Understanding (1690)
![Page 3: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/3.jpg)
Features of LISP
• Recursive Functions of Symbolic Expressions and Their Computation by Machine (John McCarthy, 1960)
• LISP stands for LISt Processing
• An interpreted language (not efficient)
• Second oldest language (after FORTRAN)
• Designed to solve problems in the form of
symbolic differentiation & integration of algebraic expressions
![Page 4: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/4.jpg)
Features of LISP
• LISP’s ability
– to represent procedures as data
– to manipulate programs as data
• LISP is currently a family of dialects (share most of the original features)
• Scheme is a dialect of LISP (small yet powerful)
![Page 5: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/5.jpg)
Characteristics of SCHEME
• Supports functional programming - but not on an exclusive basis
• Functions are first class data objects
• Uses static binding of free names in procedures and functions
• Types are checked and handled at run time - no static type checking
• Parameters are evaluated before being passed - no lazyness
![Page 6: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/6.jpg)
Elements of Language
• Primitive expressions – simple expressions
• Means of combination – compound expressions
• Means of abstraction – compound objects can
be named and manipulated as units
![Page 7: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/7.jpg)
Scheme Expressions - 1
> 395
395
> (+ 137 349)
486
> (/ 10 6)
1.66667
![Page 8: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/8.jpg)
Scheme Expressions - 2
Prefix Notation
take arbitrary number of arguments
> (+ 21 35 12 7)
75
> (* 25 4 12)
1200
![Page 9: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/9.jpg)
Scheme Expressions - 3
Prefix Notation
allow combinations to be nested
> (+ (* 3 5) (- 10 6) )
19
> (* (+ 3 (- (+ 2 1) 5) (/ 4 2)) (* 3 2))
Read – Eval – Print loop
![Page 10: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/10.jpg)
Scheme Pretty-Printing
> (+ (* 3 (+ (* 2 4) (+ 3 5))) (+ (- 10 7) 6))
(+ (* 3
(+ (* 2 4)
(+ 3 5)))
(+ (- 10 7)
6))
> (load “e1.scm”)
![Page 11: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/11.jpg)
Scheme Naming
> (define size 2)
> size
2
> (* 5 size)
10
> (load “e2.scm”)
![Page 12: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/12.jpg)
Compound Procedures
> (define (square x) (* x x))
> (square 3)
9
(define (< name > < formal parameters >) < body > )
> (load “e3.scm”)
Substitution model for procedure application
![Page 13: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/13.jpg)
Conditional Expressions
> (define (abs x)
(cond ((> x 0) x)
((= x 0) 0)
((< x 0) (- x))))
> (define (abs x)
(cond ((< x 0) (- x))
(else x)))
![Page 14: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/14.jpg)
Conditional Expressions(cond (<p1> <e1>) (<p2> <e2>)
: (<pN> <eN>))
p is predicate either true (non-nil) or
false (nil)
e is consequent expression returns the value of it
![Page 15: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/15.jpg)
Conditional Expressions
> (define (abs x)
(if (< x 0)
(- x)
x))
(if <predicate> <consequent> <alternative>)
![Page 16: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/16.jpg)
Logical Operators
Primitive operators : < , > , =
Logical operators : and , or , not
> (define (>= x y)
(or (> x y) (= x y)))
Example: another definition of (>= x y)
Example: 5 < x < 10
![Page 17: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/17.jpg)
Proceduresdifferent than mathematical functions
x = the y such that y 0 and y2 = x
> (define (sqrt x)
(the y (and (>= y 0) (= (square y) x))))
Mathematics – declarative (what is)
Programs – imperative (how to)
Square Roots by Newton’s Method
> (load “e4.scm”) - 2 = 1.4142...
![Page 18: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/18.jpg)
Square Roots by Newton’s Method
break the problem into subproblems
how to tell whether a guess is good enough
how to improve a guess
how to calculate the average of two numbers
etc.
each of the above tasks is a procedure
![Page 19: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/19.jpg)
Square Roots by Newton’s Methodsqrt
sqrt-iter
good-enough?
square abs
improve
average
> (load “e4.scm”)
![Page 20: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/20.jpg)
Procedures – Black Box Abstractions
(define (square x)
(* x x))
(define (square x)
(exp (+ (log x) (log x))))
![Page 21: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/21.jpg)
Procedural Abstractions(define (square x) (* x x))
(define (square y) (* y y))
(define (square variable) (* variable variable))
parameter names that are local to the procedure
bound variables – change throughout the procedure does not change the meaning of the procedure
free variables – if a variable is not bound in the proc
(define (good-enough? guess x)
(< (abs (- (square guess) x)) .001))
![Page 22: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/22.jpg)
Internal DefinitionsEncapsulation – hiding details
> (load “e4.scm”)
Nesting definitions – block structure
> (load “e5.scm”)
Lexical scoping – not necessary to pass x explicitly
to internal procedures, so x becomes free variable
in the internal definitions
> (load “e6.scm”)
![Page 23: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/23.jpg)
Procedures
Procedure :
a pattern for the local evolution of
a computational process.
At each step,
the next state of the process is computed from
its current state according to the rules of
interpreting procedures.
![Page 24: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/24.jpg)
Linear Recursion(factorial 6)
(* 6 (factorial 5))
(* 6 (* 5 (factorial 4)))
(* 6 (* 5 (* 4 (factorial 3))))
(* 6 (* 5 (* 4 (* 3 (factorial 2)))))
(* 6 (* 5 (* 4 (* 3 (* 2 (factorial 1))))))
(* 6 (* 5 (* 4 (* 3 (* 2 1)))))
(* 6 (* 5 (* 4 (* 3 2))))
(* 6 (* 5 (* 4 6)))
(* 6 (* 5 24))
(* 6 120)
720 process does grow and shrink
![Page 25: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/25.jpg)
Linear Recursionn! = n * (n-1) * (n-2) ... 2 * 1
n! = n * (n-1)!
n! = n * ( (n-1) * (n-2)! )
n! = n * ( ... ( (n-1) * (n-2) * ... * 1! ) ) ... )
(define (factorial n)
(if (= n 1)
1
(* n (factorial (- n 1)))))
![Page 26: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/26.jpg)
Linear Iteration
(factorial 6)
(fact-iter 1 1 6)
(fact-iter 1 2 6)
(fact-iter 2 3 6)
(fact-iter 6 4 6)
(fact-iter 24 5 6)
(fact-iter 120 6 6)
(fact-iter 720 7 6)
720process does not grow and shrink
![Page 27: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/27.jpg)
Linear IterationProduct, counter = 1
do while counter < n
product = counter * product
counter = counter + 1
(define (factorial n)
(fact-iter 1 1 n))
(define (fact-iter product counter max-count)
(if (> counter max-count)
product
(fact-iter (* counter product)
(+ counter 1)
max-count)))
![Page 28: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/28.jpg)
Tree RecursionFibonacci numbers : 0, 1, 1, 2, 3, 5, 8, 13, 21, ...
0 if n = 0
Fib( n ) = 1 if n = 1
Fib(n-1) + Fib(n-2) otherwise
(define (fib n)
(cond ((= n 0) 0)
((= n 1) 1)
(else (+ (fib (- n 1))
(fib (- n 2))))))
![Page 29: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/29.jpg)
Tree Recursion
Fib(5)
Fib(4) Fib(3)
Fib(3) Fib(2) Fib(2) Fib(1)
Fib(2) Fib(1)
Fib(1) Fib(0)
Fib(1) Fib(0) Fib(1) Fib(0)
![Page 30: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/30.jpg)
Tree Recursion
For Fibonacci numbers,
Use linear iteration instead of tree recursion
(define (fib n)
(fib-iter 1 0 n))
(define (fib-iter a b count)
(if (= count 0)
b
(fib-iter (+ a b) a (- count 1))))
![Page 31: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/31.jpg)
Exponentiation – linear recursion
(define (expt b n)
(if (= n 0)
1
(* b (expt b (- n 1)))))
![Page 32: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/32.jpg)
Exponentiation – linear iteration
(define (expt b n)
(exp-iter b n 1))
(define (exp-iter b counter product)
(if (= counter 0)
product
(exp-iter b
(- counter 1)
(* b product))))
![Page 33: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/33.jpg)
Exponentiation – fast method
(define (fast-exp b n)
(cond ( (= n 0) 1)
( (even? n) (square (fast-exp b (/ n 2))))
(else (* b (fast-exp b (- n 1))))))
(define (even? n)
(= (remainder n 2) 0))
bn = (bn/2)2 if n is even
bn = b * bn-1 if n is odd
![Page 34: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/34.jpg)
Greatest Common Divisor
(define (gcd a b)
(if (= b 0)
a
(gcd b (remainder a b))))
GCD( a , b ) is defined to be the largest integer that evenly divides both a and b.
GCD( a , b ) = GCD( b , r ) where r is the remainder of a / b.
GCD(206, 40)=GCD(40,6)=GCD(6, 4)=GCD(4, 2)=GCD(2, 0)=2
![Page 35: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/35.jpg)
Higher-Order Procedures
Build abstractions by assigning names to common patterns
(define (cube x) (* x x x))
Procedures that manipulate data
i.e. accept data as argument and return data
What about procedures that manipulate procedures
i.e. accept procedures as argument and return procedures
Higher-Order Procedures
![Page 36: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/36.jpg)
Procedures as Parameters
(define (sum-cubes a b)
(if (> a b)
0
(+ (cube a) (sum-cubes (+ a 1) b))))
(define (sum-integers a b)
(if (> a b)
0
(+ a (sum-integers (+ a 1) b))))
![Page 37: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/37.jpg)
Procedures as Parameters
(define (<name> a b)
(if (> a b)
0
(+ (<term> a) (<name> (<next> a) b))))
![Page 38: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/38.jpg)
Procedures as Parameters(define (sum term a next b)
(if (> a b)
0
(+ (term a)
(sum term (next a) next b))))
(define (sum-cubes a b)
(define (inc x)
(+ x 1))
(sum cube a inc b))
![Page 39: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/39.jpg)
Procedures using LambdaLambda – define anonymous
(lambda (x) (+ x 1))
(lambda (<formal-parameters>) <body>)
(define (sum-cubes a b)
(sum (lambda (x) (* x x x))
a
(lambda (x) (+ x 1))
b))
![Page 40: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/40.jpg)
Procedures using Lambda
Lambda – define anonymous
(define (plus4 x) (+ x 4))
(define plus4 (lambda (x) (+ x 4))
![Page 41: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/41.jpg)
Lambda Calculus
A lambda expression describes a "nameless" function
Specifies both the parameter(s) and the mapping
Consider this function: cube (x) = x * x * x
Corresponding lambda expr: (x) x * x * x
Can be "applied" to parameter(s) by placing the parameter(s) after the expression
((x) x * x * x)(3)
The above application evaluates to 27
![Page 42: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/42.jpg)
Lambda Calculus
Based on notation (lambda (l) (car (car l)))
l is called a "bound variable"; think of it as a formal parameter name
Lambda expressions can be applied((lambda (l) (car (car l))) '((a b) c
d))
![Page 43: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/43.jpg)
Lambda Examples
> (define x 6)
> (lambda (x) (+ x 1))
> (define inc (lambda (x) (+ x 1)))
> (define same (lambda (x) (x)))
> (if (even? x) inc same)
> ((if (even? x) inc same) 5)
6
![Page 44: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/44.jpg)
Lambda Examples
> ((lambda(x) (+ x 1)) 3)
4
> (define fu-lst (list (lambda (x) (+ x 1)) (lambda (x) (* x 5))))
> fu-lst
(#<procedure> #<procedure>)
> ((second fu-lst) 6)
30
![Page 45: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/45.jpg)
Internal Definitions Internal definitions: the special form, LET
(let ( (x ‘(a b c))
(y ‘(d e f)) )
(cons x y))
* Introduces a list of local names (use define for top-level entities, but use let for internal definitions)
* Each name is given a value
![Page 46: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/46.jpg)
Using Let to Define Local Variables
f(x,y) = x(1 + xy)2 + y(1 – y) + (1 + xy)(1 – y)
a = 1 + xy
b = 1 – y
f(x,y) = xa2 + yb + ab
![Page 47: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/47.jpg)
Using Let to Define Local Variables
(define (f x y)
(define a (+ 1 (* x y)))
(define b (– 1 y))
(+ (* x (square a))
(* y b)
(* a b)))
![Page 48: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/48.jpg)
Using Let to Define Local Variables
(define (f x y)
(let ((a (+ 1 (* x y)))
(b (– 1 y)))
(+ (* x (square a))
(* y b)
(* a b)))
![Page 49: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/49.jpg)
Using Let to Define Local Variables
(define (f x y)
((lambda (a b)
(+ (* x (square a))
(* y b)
(* a b)))
(+ 1 (* x y))
(– 1 y)))
![Page 50: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/50.jpg)
Using Let to Define Local Variables
(let ((<var1> <exp1>)
(<var2> <exp2>)
:
(<varN> <expN>))
<body>)
![Page 51: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/51.jpg)
Procedures as Returned ValuesThe derivative of x3 is 3x2
Procedure : derivative
Argument : a function
Return value : another function
Derivative Procedure
If f is a function and dx is some number, then Df of f is the function whose value at any number x is given (limit of dx) by
f(x + dx) – f(x)D f(x) = ---------------------- dx
![Page 52: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/52.jpg)
Procedures as Returned Values
(define (deriv f dx)
(lambda (x)
(/ (- (f (+ x dx)) (f x))
(dx)))
> ((deriv cube .001) 5)
75.015
![Page 53: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/53.jpg)
PairsCompund Structure called Pair
<pair> constructor procedure “cons <head> <rest>”
<head> extractor procedure “car <pair>”
<rest> extractor procedure “cdr <pair>”
(cadr <arg>) = (car (cdr <arg>))
(cons 1 2)
1
2 Box & Pointer Representation
![Page 54: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/54.jpg)
Pairs (continued)(cons (cons 1 2) (cons 3 4))
1 2
3 4
(cons (cons 1 (cons 2 3)) 4)
1 2 3
4
![Page 55: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/55.jpg)
Hierarchical Data
Pairs enable us to represent hierarchical data
hierarchical data – data made up of parts
Data structures such as sequences and trees
![Page 56: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/56.jpg)
Data Structures
Lists
(list <a1> <a2> ... <aN>) is equal to
(cons <a1> (cons <a2> (cons ... (cons <aN> nil))...)
List Operations – append, delete, list, search, nth, len
Sets > (load “e8.scm”)
Trees > (load “e9.scm”)
![Page 57: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/57.jpg)
Symbols and Quote
(define a 1)
(define b 2)
(list a b) (1 2)
(list ‘a ‘b) (a b)
(car ‘(a b c)) a
(cdr ‘(a b c)) (b c)
![Page 58: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/58.jpg)
Data Abstraction
from Primitive Data to Compund Data
Real numbers – Rational numbers
Operations on primitive data : +, -, *, /
Operations on compound data : +rat, -rat, *rat, /rat
Generic operators for all numbers : add, sub, mul, div
![Page 59: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/59.jpg)
Rational Numbers
(define (make-rat n d) (cons n d))
(define (numer x) (car x))
(define (denom x) (cdr x))
(define (+rat x y)
(make-rat (+ (* (numer x) (denom y))
(* (denom x) (numer y))
(* (denom x) (denom y))))
![Page 60: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/60.jpg)
Use of Complex Numbers
Operations on compound data : +rat, -rat, *rat, /rat
+c -c *c /c
Complex arithmetic package
Rectangular representation Polar representation
List structure and primitive machine arithmetic
![Page 61: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/61.jpg)
Use of Numbers
Generic operators for all numbers : add, sub, mul, div
add sub mul div
Generic arithmetic package
List structure and primitive machine arithmetic
+rat –rat *rat /rat +c –c *c /c + – * /
Rectangular Polar
Complex arithmetic Real arithmetic
Rational arithmetic
![Page 62: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/62.jpg)
Complex Arithmetic - 1
z = x + i y where i2 = -1
Real coordinate is x
Imaginary coordinate is y
(define (make-rect x y) (cons x y))
(define (real-part z) (car z))
(define (imag-part z) (cdr z))
Im
Re
ry
xA
z = x + i y = r eiA
![Page 63: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/63.jpg)
Complex Arithmetic - 2z = x + i y = r eiA
Magnitude is r
Angle is A
(define (make-polar r a)
(cons (* r (cos a)) (* r (sin a))))
(define (magnitude z)
(sqrt (+ (square (car z)) (square (cdr z)))))
(define (angle z)
(atan (cdr z) (car z)))
![Page 64: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/64.jpg)
Complex Arithmetic - 3
(define (+c z1 z2)
(make-rect (+ (real-part z1) (real-part z2))
(+ (imag-part z1) (imag-part z2))))
(define (*c z1 z2)
(make-polar (* (magnitude z1) (magnitude z2))
(+ (angle z1) (angle z2))))
![Page 65: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/65.jpg)
Complex Arithmetic - 4
We may choose to implement complex numbers in polar form instead of rectangular form.
(define (make-polar r a) (cons r a))
(define (make-rect x y)
(cons (sqrt (+ (square x) (square y))) (atan y x)))
The discipline of data abstraction ensures that the
implementation of complex-number operators is
independent of which representation we choose.
![Page 66: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/66.jpg)
Manifest Types
A data object that has a type that can be recognized
and tested is said to have manifest type.
(define (attach-type type contents)
(cons type contents))
For complex numbers,
we have two types rectangular & polar
![Page 67: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/67.jpg)
Manifest Types
(define (type datum)
(if (not (atom? datum))
(car datum)
(error “Bad typed datum – Type ” datum)))
(define (contents datum)
(if (not (atom? datum))
(cdr datum)
(error “Bad typed datum – Contents ” datum)))
![Page 68: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/68.jpg)
Complex Numbers
(define (make-rect x y)
(attach-type ‘rect (cons x y)))
(define (make-polar r a)
(attach-type ‘polar (cons r a)))
(define (rect? z)
(eq? (type z) ‘rect))
(define (polar? z)
(eq? (type z) ‘polar))
![Page 69: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/69.jpg)
Complex Numbers(define (real-part z)
(cond ( (rect? z)
(real-part-rect (contents z)))
( (polar? z)
(real-part-polar (contents z)))))
(define (imag-part z)
(cond ( (rect? z)
(imag-part-rect (contents z)))
( (polar? z)
(imag-part-polar (contents z)))))
![Page 70: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/70.jpg)
Complex Numbers
(define (real-part-rect z) (car z))
(define (imag-part-rect z) (cdr z))
![Page 71: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/71.jpg)
Let Expressions
(let ((a 4) (b -3))
(let ((a-squared (* a a))
(b-squared (* b b)))
(+ a-squared b-squared)))
25
![Page 72: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/72.jpg)
Let Expressions
(let ((x 1))
(let ((x (+ x 1)))
(+ x x)))
4
![Page 73: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/73.jpg)
Let Expressions
Shadowing may be avoided by choosing different names for variables. The expression above could be rewritten so that the variable bound by the inner let is new-x.
(let ((x 1))
(let ((new-x (+ x 1)))
(+ new-x new-x)))
4
![Page 74: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/74.jpg)
Lambda Expressions
((lambda (x) (+ x x)) (* 3 4)) ⇒ 24
Because procedures are objects, we can establish a procedure as the value of a variable and use the procedure more than once.
(let ((double (lambda (x) (+ x x))))
(list (double (* 3 4))
(double (/ 99 11))
(double (- 2 7)))) (24 18 -10⇒ )
![Page 75: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/75.jpg)
Lambda Expressions
(let ((double-any (lambda (f x) (f x x))))
(list (double-any + 13)
(double-any cons 'a))) (26 (a . a))⇒
![Page 76: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/76.jpg)
Lambda Expressions
(define double-any
(lambda (f x)
(f x x)))
The variable double-any now has the same status as cons or the name of any other primitive procedure. We can use double-any as if it were a primitive procedure.
(double-any + 10) 20⇒
(double-any cons 'a) (a . a)⇒
![Page 77: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/77.jpg)
Lambda Expressions
(map abs '(1 -2 3 -4 5 -6)) (1 2 3 4 5 6)⇒
(map cons '(a b c) '(1 2 3)) ((a . 1) (b . 2) (c . 3))⇒
(map (lambda (x) (* x x)) '(1 -3 -5 7)) (1 9 25 49)⇒
![Page 78: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/78.jpg)
Lambda Expressions
(define map1
(lambda (p ls)
(if (null? ls)
'()
(cons (p (car ls))
(map1 p (cdr ls))))))
(map1 abs '(1 -2 3 -4 5 -6)) (1 2 3 4 5 6)⇒
![Page 79: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/79.jpg)
Lambda Expressions
(let ((x 'a))
(let ((f (lambda (y) (list x y))))
(f 'b))) (a b)⇒
The occurrence of x within the lambda expression refers to the x outside the lambda that is bound by the outer let expression.
The variable x is said to occur free in the lambda expression or to be a free variable of the lambda expression.
The variable y does not occur free in the lambda expression since it is bound by the lambda expression.
![Page 80: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/80.jpg)
Free & Bound Variables> (occurs-free? ’x ’x)
#t
> (occurs-free? ’x ’y)
#f
> (occurs-free? ’x ’(lambda (x) (x y)))
#f
> (occurs-free? ’x ’(lambda (y) (x y)))
#t
> (occurs-free? ’x ’((lambda (x) x) (x y)))
#t
> (occurs-free? ’x ’(lambda (y) (lambda (z) (x (y z)))))
#t
![Page 81: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/81.jpg)
Free & Bound VariablesWe can summarize these cases in the rules:
• If the expression e is a variable, then the variable x occurs free in e if and only if x is the same as e.
• If the expression e is of the form (lambda (y) e), then the variable x occurs free in e if and only if y is different from x and x occurs free in e.
• If the expression e is of the form (e1 e2), then x occurs free in e if and only if it occurs free in e1 or e2. Here, we use “or” to mean inclusive or, meaning that this includes the possibility that x occurs free in both e1 and e2. We will generally use “or” in this sense.
![Page 82: Scheme Tutorial. Goals Combine several simple ideas into one compound idea to obtain complex ideas Bring two ideas together to obtain relations Seperate](https://reader038.vdocuments.mx/reader038/viewer/2022110403/56649e7d5503460f94b809b5/html5/thumbnails/82.jpg)
Free & Bound Variables
(define occurs-free?
(lambda (var exp)
(cond
((symbol? exp) (eqv? var exp))
((eqv? (car exp) ’lambda)
(and (not (eqv? var (car (cadr exp))))
(occurs-free? var (caddr exp))))
(else
(or
(occurs-free? var (car exp))
(occurs-free? var (cadr exp)))))))