Merge pull request norvig#70 from pronoiac/images

Images

Author: norvig

docs/chapter10.md

@@ -156,8 +156,6 @@ Here is the disassembled code for f from Allegro Common Lisp for a Motorola 6800
 | `26:` | `unlk` | `a6` |
 | `28:` | `rtd` | `#8` |
 
-![t0010](images/B9780080571157500108/t0010.png)
-
 This may look intimidating at first glance, but you don't have to be an expert at 68000 assembler to gain some appreciation of what is going on here.
 The instructions labeled 0-8 (labels are in the leftmost column) comprise the typical function preamble for the 68000.
 They do subroutine linkage and store the new function object and constant vector into registers.
@@ -206,8 +204,6 @@ Contrast this to the code for `g`, which has no declarations and is compiled at
 | `82:` | `unlk` | `a6` | |
 | `84:` | `rtd` | `#8` | |
 
-![t0015](images/B9780080571157500108/t0015.png)
-
 See how much more work is done.
 The first four instructions ensure that the right number of arguments have been passed to `g`.
 If not, there is a jump to `wnaerr` (wrong-number-of-arguments-error).
@@ -339,8 +335,6 @@ We can see what these compile into for the TI Explorer, but remember that your c
 | `    11 PUSH` | `LOCAL|0` | `; D` |
 | `    12 RETURN CALL-4` | `FEF|3` | `; #'LIST*` |
 
-![t0025](images/B9780080571157500108/t0025.png)
-
 With the regular argument list, we just push the four variables on the argument stack and branch to the list function.
 ([Chapter 22](B9780080571157500224.xhtml) explains why a tail-recursive call is just a branch statement.)
 
@@ -365,8 +359,6 @@ Let's compare with optional arguments:
 | `  33 PUSH` | `ARG|3` | ; `D` |
 | `  34 TAIL-REC CALL-4` | `FEF|4` | ; `#'LIST` |
 
-![t0030](images/B9780080571157500108/t0030.png)
-
 Although this assembly language may be harder to read, it turns out that optional arguments are handled very efficiently.
 The calling sequence stores the number of optional arguments on top of the stack, and the `DISPATCH` instruction uses this to index into a table stored at location `FEF|5` (an offset five words from the start of the function).
 The result is that in one instruction the function branches to just the right place to initialize any unspecified arguments.
@@ -400,8 +392,6 @@ Unfortunately, keyword arguments don't fare as well:
 | `  33 PUSH` | `LOCAL|4` | |
 | `  34 RETURN CALL-4` | `FEF|6` | ;`#'LIST` |
 
-![t0035](images/B9780080571157500108/t0035.png)
-
 It is not important to be able to read all this assembly language.
 The point is that there is considerable overhead, even though this architecture has a specific instruction `(%STORE-KEY-WORD-ARGS)` to help deal with keyword arguments.
 
@@ -427,8 +417,6 @@ First, here's the assembly code for reg, to give you an idea of the minimal call
 | `38:` | `unlk` | `a6` | |
 | `40:` | `rtd` | `#10` | |
 
-![t0040](images/B9780080571157500108/t0040.png)
-
 Now we see that `&rest` arguments take a lot more code in this system:
 
 !!!(table)
@@ -460,8 +448,6 @@ Now we see that `&rest` arguments take a lot more code in this system:
 | `62`: | `move.l` | `#4,dl` | |
 | `64` | `jmp` | `(a4)` | |
 
-![t0045](images/B9780080571157500108/t0045.png)
-
 The loop from 20-26 builds up the `&rest` list one cons at a time.
 Part of the difficulty is that cons could initiate a garbage collection at any time, so the list has to be built in a place that the garbage collector will know about.
 The function with optional arguments is even worse, taking 34 instructions (104 bytes), and keywords are worst of all, weighing in at 71 instructions (178 bytes), and including a loop.
@@ -491,8 +477,6 @@ The inline proclamation should allow the compiler to compile a call to key as a
 | `  14 PUSH CALL-1` | `FEF|3` | `; #'SORT` |
 | `  15 TAIL-REC CALL-4` | `FEF|4` | `; #'NO-KEY` |
 
-![t0050](images/B9780080571157500108/t0050.png)
-
 The overhead only comes into play when the keywords are not known at compile time.
 In the following example, the compiler is forced to call key, not `no-key`, because it doesn't know what the keyword `k` will be at run time:
 
@@ -507,8 +491,6 @@ In the following example, the compiler is forced to call key, not `no-key`, beca
 | `  13 PUSH` | `ARG|2` | ; `Y` |
 | `  14 TAIL-REC CALL-4` | `FEF|4` | ; `#'KEY` |
 
-![t0055](images/B9780080571157500108/t0055.png)
-
 Of course, in this simple example I could have replaced `no-key` with `list`, but in general there will be some more complex processing.
 If I had proclaimed `no-key` inline as well, then I would get the following:
 
@@ -524,8 +506,6 @@ If I had proclaimed `no-key` inline as well, then I would get the following:
 | `  14 PUSH CALL-1` | `FEF|3` | `; #'SORT` |
 | `  15 TAIL-REC CALL-4` | `FEF|4` | `; #'LIST` |
 
-![t0060](images/B9780080571157500108/t0060.png)
-
 If you like, you can define a macro to automatically define the interface to the keyword-less function:
 
 ```lisp

docs/chapter11.md

@@ -489,10 +489,13 @@ We will build a single uniform data base of clauses, without distinguishing rule
 The simplest representation of clauses is as a cons cell holding the head and the body.
 For facts, the body will be empty.
 
-![f11-01-9780080571157](images/B978008057115750011X/f11-01-9780080571157.jpg)     
-Figure  11.1
-!!!(span) {:.fignum}
-Glossary for the Prolog Interpreter
+| []() |
+|---|
+| ![f11-01](images/chapter11/f11-01.jpg) |
+| Figure 11.1: Glossary for the Prolog Interpreter |
+
+(ed: this should be a markdown table)
+
 ```lisp
 ;; Clauses are represented as (head . body) cons cells
 (defun clause-head (clause) (first clause))

docs/chapter12.md

@@ -96,10 +96,13 @@ This section presents the compiler summarized in [figure  12.1](#f0010).
 At the top level is the function `prolog-compile`, which takes a symbol, looks at the clauses defined for that symbol, and groups the clauses by arity.
 Each symbol/arity is compiled into a separate Lisp function by `compile-predicate`.
 
-![f12-01-9780080571157](images/B9780080571157500121/f12-01-9780080571157.jpg)     
-Figure  12.1
-!!!(span) {:.fignum}
-Glossary for the Prolog Compiler
+| []() |
+|---|
+| ![f12-01](images/chapter12/f12-01.jpg) |
+| Figure 12.1: Glossary for the Prolog Compiler |
+
+(ed: this should be a markdown table)
+
 ```lisp
 (defun prolog-compile (symbol &optional
             (clauses (get-clauses symbol)))
@@ -752,8 +755,6 @@ The first column is the unification call, the second is the generated code, and
 | 11 | `(= ?x (f ? x))` | `nil` | `-` |
 | 12 | `(= ?x ?)` | `t` | `-` |
 
-![t0015](images/B9780080571157500121/t0015.png)
-
 From this table we can craft our new version of `compile-unify`.
 The first part is fairly easy.
 It takes care of the first three cases in this table and makes sure that `compile-unify-variable` is called with a variable as the first argument for the other cases.
@@ -1289,8 +1290,6 @@ The following table shows times in seconds to execute these routines on lists of
 | `irev 20` | .22 | .010 | 22 | .028 | .0005 |
 | `irev 100` | 9.81 | .054 | 181 | .139 | .0014 |
 
-![t0020](images/B9780080571157500121/t0020.png)
-
 This benchmark is too small to be conclusive, but on these examples the Prolog compiler is 16 to 181 times faster than the Prolog interpreter, slightly faster than interpreted Lisp, but still 17 to 90 times slower than compiled Lisp.
 This suggests that the Prolog interpreter cannot be used as a practical programming tool, but the Prolog compiler can.
 
@@ -1436,7 +1435,9 @@ Note that these are only binary connectives, not the *n*-ary special forms used
 Also, this definition negates most of the advantage of compilation.
 The goals inside an and or or will be interpreted by `call`, rather than being compiled.
 
-We can also define `not,` or at least the normal Prolog `not,` which is quite distinct from the logical `not.` In fact, in some dialects, `not` is written \+, which is supposed to be ![u12-07-9780080571157](images/B9780080571157500121/u12-07-9780080571157.jpg) , that is, "can not be derived." The interpretation is that if goal G can not be proved, then (`not G` ) is true.
+We can also define `not,` or at least the normal Prolog `not,` which is quite distinct from the logical `not.`
+In fact, in some dialects, `not` is written \+, which is supposed to be ⊬, that is, "can not be derived."
+The interpretation is that if goal G can not be proved, then (`not G` ) is true.
 Logically, there is a difference between (`not G` ) being true and being unknown, but ignoring that difference makes Prolog a more practical programming language.
 See [Lloyd 1987](B9780080571157500285.xhtml#bb0745) for more on the formal semantics of negation in Prolog.
 

docs/chapter13.md

@@ -502,8 +502,6 @@ A third style, the *data-driven* or *generic* style, fills in only one box at a
 | `interest` | *generic* | | |
 | `...` | | | |
 
-![t0010](images/B9780080571157500133/t0010.png)
-
 In this table there is no particular organization to either axis; both messages and classes are listed in random order.
 This ignores the fact that classes are organized hierarchically: both limited-account and password-account are subclasses of account.
 This was implicit in the definition of the classes, because both `limited-account` and `password-account` contain accounts as components and delegate messages to those components.

docs/chapter14.md

@@ -79,7 +79,7 @@ Here is a statement in a typical slot-filler frame language:
 
 This is equivalent to the logical formula:
 
-∃p: person(p) ![images](images/B9780080571157500145/cap.png) name(p,Jan) ![images](images/B9780080571157500145/cap.png) age(p,32)
+∃p: person(p) ∧ name(p,Jan) ∧ age(p,32)
 
 The frame notation has the advantage of being easier to read, in some people's opinion.
 However, the frame notation is less expressive.
@@ -108,7 +108,7 @@ This is easy to show: assuming the computer's memory has *n* bits, and the equat
 
 b0=0∧b1=0∧b2=1...∧bn=0
 
-![si1_e](images/si1_e.gif)
+![si1_e](images/chapter14/si1_e.gif)
 
 Once we can represent a state of the computer, it becomes possible to represent any computer program in predicate calculus as a set of axioms that map one state onto another.
 Thus, predicate calculus is shown to be a *sufficient* language for representing anything that goes on inside a computer-it can be used as a tool for analyzing any program from the outside.
@@ -121,7 +121,7 @@ For example, we may want to manipulate numbers inside the computer by using the
 
 x=y=>yxy=x
 
-![si2_e](images/B9780080571157500145/si2_e.gif)
+![si2_e](images/chapter14/si2_e.gif)
 
 Predicate calculus also serves another purpose: as a tool that can be used *by* a program rather than *on* a program.
 All programs need to manipulate data, and some programs will manipulate data that is considered to be in predicate calculus notation.
@@ -236,7 +236,7 @@ His problem concerned three colored blocks, but we will update it to deal with t
 Suppose that a certain Eastern European country, *E*, has just decided if it will remain under communist rule or become a democracy, but we do not know the outcome of the decision.
 *E* is situated between the democracy *D* and the communist country *C*:
 
-![u14-02-9780080571157](images/B9780080571157500145/u14-02-9780080571157.jpg)     
+![u14-02](images/chapter14/u14-02.jpg)
 
 The question is: Is there a communist country next to a democracy?
 Moore points out that the answer is "yes," but discovering this requires reasoning by cases.
@@ -556,10 +556,11 @@ To create the index, we essentially superimpose the list structure of all the ke
 At each position in the tree, we create an index of the keys that have either an atom or a variable at that position.
 [Figure 14.1](#f0010) shows the discrimination tree for the six keys.
 
-![f14-01-9780080571157](images/B9780080571157500145/f14-01-9780080571157.jpg)     
-Figure 14.1
-!!!(span) {:.fignum}
-Discrimination Tree with Six Keys
+| []() |
+|---|
+| ![f14-01](images/chapter14/f14-01.jpg) |
+| Figure 14.1: Discrimination Tree with Six Keys |
+
 Consider the query `(p ?y c)`.
 Either the `p` or the `c` could be used as an index.
 The `p` in the predicate position retrieves all six keys.

docs/chapter15.md

@@ -43,7 +43,7 @@ We will speak of a polynomial's *main variable, coefficients,* and *degree.* In
 
 5xx3+bxx2+cxx+1
 
-![si1_e](images/B9780080571157500157/si1_e.gif)
+![si1_e](images/chapter15/si1_e.gif)
 
 the main variable is *x,* the degree is 3 (the highest power of *x*), and the coefficients are 5, *b, c* and 1.
 We can define an input format for polynomials as follows:
@@ -103,10 +103,13 @@ The word "polynomial" is used ambiguously to refer to both the mathematical conc
 
 A glossary for the canonical simplifier program is given in [figure  15.1](#f0010).
 
-![f15-01-9780080571157](images/B9780080571157500157/f15-01-9780080571157.jpg)     
-Figure  15.1
-!!!(span) {:.fignum}
-Glossary for the Symbolic Manipulation Program
+| []() |
+|---|
+| ![f15-01](images/chapter15/f15-01.jpg) |
+| Figure 15.1: Glossary for the Symbolic Manipulation Program |
+
+*(ed: should be a markdown table)*
+
 The functions defining the type `polynomial` follow.
 Because we are concerned with efficiency, we proclaim certain short functions to be compiled inline, use the specific function `svref` (simple-vector reference) rather than the more general aref, and provide declarations for the polynomials using the special form the.
 More details on efficiency issues are given in [Chapter 9](B9780080571157500091.xhtml).
@@ -541,11 +544,11 @@ For example:
 
 ∫ax2+bxdx=ax33+bx22+c.
 
-![si2_e](images/B9780080571157500157/si2_e.gif)
+![si2_e](images/chapter15/si2_e.gif)
 
 Write a function to integrate polynomials and install it in `prefix->canon`.
 
-**Exercise  15.2 [m]** Add support for *definite* integrais, such as ∫abydx !!!(span) {:.hiddenClass} ![si3_e](images/B9780080571157500157/si3_e.gif).
+**Exercise  15.2 [m]** Add support for *definite* integrals, such as ∫abydx !!!(span) {:.hiddenClass} ![si3_e](images/chapter15/si3_e.gif).
 You will need to make up a suitable notation and properly install it in both `infix->prefix` and `prefix->canon`.
 A full implementation of this feature would have to consider infinity as a bound, as well as the problem of integrating over singularises.
 You need not address these problems.
@@ -859,19 +862,19 @@ The binomial theorem states that
 
 a+bn=Σi=0nn!i!n-i!aibn-i
 
-![si4_e](images/B9780080571157500157/si4_e.gif)
+![si4_e](images/chapter15/si4_e.gif)
 
 for example,
 
 a+b3=b3+3ab2+3a2b+a3
 
-![si5_e](images/B9780080571157500157/si5_e.gif)
+![si5_e](images/chapter15/si5_e.gif)
 
 We can use this theorem to compute a power of a polynomial all at once, instead of computing it by repeated multiplication or squaring.
 Of course, a polynomial will in general be a sum of more than two components, so we have to decid`e` how to split it into the *a* and *b* pieces.
 There are two obvious ways: either eut the polynomial in half, so that *a* and *b* will be of equal size, or split off one component at a time.
 Fateman shows that the latter method is more efficient in most cases.
-In other words, a polynomial k1xn+k2xn-1+k3xn-2+... !!!(span) {:.hiddenClass} ![si6_e](images/B9780080571157500157/si6_e.gif) will be treated as the sum *a + b* where *a*=  *k*1*xn* and *b* is the rest of the polynomial.
+In other words, a polynomial k1xn+k2xn-1+k3xn-2+... !!!(span) {:.hiddenClass} ![si6_e](images/chapter15/si6_e.gif) will be treated as the sum *a + b* where *a*=  *k*1*xn* and *b* is the rest of the polynomial.
 
 Following is the code for binomial exponentiation.
 It is somewhat messy, because the emphasis is on efficiency.
@@ -984,8 +987,6 @@ The following table compares the times for `r15-test` with the three versions of
 | 7 | iterative `poly^n` | .98 | 28 |
 | 8 | binomial `poly^n` | .23 | 120 |
 
-![t0010](images/B9780080571157500157/t0010.png)
-
 As we remarked earlier, the general techniques of memoization, indexing, and compilation provide for dramatic speed-ups.
 However, in the end, they do not lead to the fastest program.
 Instead, the fastest version was achieved by throwing out the original rule-based program, replacing it with a canonical-form-based program, and fine-tuning the algorithms within that program, using mathematical analysis.
@@ -1072,7 +1073,7 @@ For example, the following three expressions are all equivalent  :
 
 sinxcosx-π2eix-e-ix2i
 
-![si7_e](images/B9780080571157500157/si7_e.gif)
+![si7_e](images/chapter15/si7_e.gif)
 
 If we are interested in assuring we have a canonical form, the safest thing is to allow only *e**x*** and log(*x*).
 All the other functions can be defined in terms of these two.

docs/chapter16.md

@@ -93,12 +93,12 @@ After that we will return to the main core of EMYCIN, !!!(span) {:.smallcaps} th
 Finally, we will show how to add some medical knowledge to EMYCIN !!!(span) {:.smallcaps} to reconstruct MYCIN.
 !!!(span) {:.smallcaps} A glossary of the program is in [figure  16.1](#f0010).
 
-![f16-01-9780080571157](images/B9780080571157500169/f16-01-9780080571157.jpg)     
-Figure  16.1
-!!!(span) {:.fignum}
-Glossary for the EMYCIN
-!!!(span) {:.smallcaps}
-Program
+| []() |
+|---|
+| ![f16-01](images/chapter16/f16-01.jpg) |
+| Figure 16.1: Glossary for the EMYCIN Program |
+
+*(ed: this could be a markdown table)*
 
 ## 16.1 Dealing with Uncertainty
 {:#s0010}
@@ -132,7 +132,7 @@ combine (A, B) =
 
 A+B-AB;A,B>0A+B+AB;A,B<0A+B1-minAB;otherwise
 
-![si1_e](images/B9780080571157500169/si1_e.gif)
+![si1_e](images/chapter16/si1_e.gif)
 
 According to this formula, combine(.60,.40) = .76, which is a compromise between the extremes of .60 and 1.00.
 It is the same as the probability p(A or B), assuming that A and B are independent.
@@ -648,10 +648,11 @@ Finally, there is a level for organisms found in each culture.
 The current organism is stored under both the `organism` and `current-instance` keys.
 The context tree is shown in [figure  16.2](#f0015).
 
-![f16-02-9780080571157](images/B9780080571157500169/f16-02-9780080571157.jpg)     
-Figure  16.2
-!!!(span) {:.fignum}
-A Context Tree
+| []() |
+|---|
+| ![f16-02](images/chapter16/f16-02.jpg) |
+| Figure 16.2: A Context Tree |
+
 ```lisp
 (defun new-instance (context)
 ```