13 "import collections\n",
14 "import unicodedata\n",
26 "sample_text = \"\"\"Continuing this process, we obtain better and better approximations to the square root.\n",
27 "Now let's formalize the process in terms of procedures. We start with a value for the radicand (the\n",
28 "number whose square root we are trying to compute) and a value for the guess. If the guess is good\n",
29 "enough for our purposes, we are done; if not, we must repeat the process with an improved guess. We\n",
30 "write this basic strategy as a procedure:\n",
31 "(define (sqrt-iter guess x)\n",
32 "(if (good-enough? guess x)\n",
34 "(sqrt-iter (improve guess x)\n",
36 "A guess is improved by averaging it with the quotient of the radicand and the old guess:\n",
37 "(define (improve guess x)\n",
38 "(average guess (/ x guess)))\n",
42 "(define (average x y)\n",
44 "We also have to say what we mean by ''good enough.'' The following will do for illustration, but it is\n",
45 "not really a very good test. (See exercise 1.7.) The idea is to improve the answer until it is close\n",
46 "enough so that its square differs from the radicand by less than a predetermined tolerance (here\n",
48 "(define (good-enough? guess x)\n",
49 "(< (abs (- (square guess) x)) 0.001))\n",
50 "Finally, we need a way to get started. For instance, we can always guess that the square root of any\n",
53 "(sqrt-iter 1.0 x))\n",
54 "If we type these definitions to the interpreter, we can use sqrt just as we can use any procedure:\"\"\"\n",
56 "small_text = '''A guess is improved by averaging it with the quotient of the radicand and the old guess:\n",
57 "(define (improve guess x)\n",
58 "((average guess (/ x guess)))'''\n",
60 "sentence_boundary = 'in terms of procedures. We start with 0.123 and some'\n",
62 "double_quotes = \"let's see how such a ''circular'' definition\""
75 "'!\"#$%&\\'()*+,-./:;<=>?@[\\\\]^_`{|}~'"
80 "output_type": "execute_result"
97 "'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&\\'()*+,-./:;<=>?@[\\\\]^_`{|}~'"
100 "execution_count": 4,
102 "output_type": "execute_result"
106 "string.ascii_letters + string.digits + string.punctuation"
111 "execution_count": 5,
119 "re.compile(r'[^abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789\\!\\\"\\#\\$\\%\\&\\\\'\\(\\)\\*\\+\\,\\-\\.\\/\\:\\;\\<\\=\\>\\?\\@\\[\\\\\\]\\^_\\`\\{\\|\\}\\~]+',\n",
123 "execution_count": 5,
125 "output_type": "execute_result"
129 "token_pattern = re.compile(r'[^{}]+'.format(re.escape(string.ascii_letters + string.digits + string.punctuation)))\n",
135 "execution_count": 6,
143 "re.compile(r'(\\d+\\.\\d+|\\w+\\'\\w+|[\\!\\\"\\#\\$\\%\\&\\\\'\\(\\)\\*\\+\\,\\-\\.\\/\\:\\;\\<\\=\\>\\?\\@\\[\\\\\\]\\^_\\`\\{\\|\\}\\~]+(?=\\w)|(?<=\\w)[\\!\\\"\\#\\$\\%\\&\\\\'\\(\\)\\*\\+\\,\\-\\.\\/\\:\\;\\<\\=\\>\\?\\@\\[\\\\\\]\\^_\\`\\{\\|\\}\\~]+|[\\!\\\"\\#\\$\\%\\&\\\\'\\(\\)\\*\\+\\,\\-\\.\\/\\:\\;\\<\\=\\>\\?\\@\\[\\\\\\]\\^_\\`\\{\\|\\}\\~]+$)',\n",
147 "execution_count": 6,
149 "output_type": "execute_result"
153 "punctuation_pattern = re.compile('(\\d+\\.\\d+|\\w+\\'\\w+|[{0}]+(?=\\w)|(?<=\\w)[{0}]+|[{0}]+$)'.format(re.escape(string.punctuation)))\n",
154 "punctuation_pattern"
159 "execution_count": 7,
167 "['', '((', 'average']"
170 "execution_count": 7,
172 "output_type": "execute_result"
176 "re.split(r'(\\(+(?=\\w))', '((average')"
181 "execution_count": 8,
224 "execution_count": 8,
226 "output_type": "execute_result"
230 "[ch for gp in [re.split(punctuation_pattern, t) for t in re.split(token_pattern, small_text)]\n",
231 " for ch in gp if ch]"
236 "execution_count": 9,
257 "execution_count": 9,
259 "output_type": "execute_result"
263 "[ch for gp in [re.split(punctuation_pattern, t) for t in re.split(token_pattern, sentence_boundary)]\n",
264 " for ch in gp if ch]"
269 "execution_count": 10,
277 "[\"let's\", 'see', 'how', 'such', 'a', \"''\", 'circular', \"''\", 'definition']"
280 "execution_count": 10,
282 "output_type": "execute_result"
286 "[ch for gp in [re.split(punctuation_pattern, t) for t in re.split(token_pattern, double_quotes)]\n",
287 " for ch in gp if ch]"
292 "execution_count": 11,
309 " 'approximations',\n",
484 " 'illustration',\n",
525 " 'predetermined',\n",
618 "execution_count": 11,
620 "output_type": "execute_result"
624 "[ch for gp in [re.split(punctuation_pattern, t) for t in re.split(token_pattern, sample_text)]\n",
625 " for ch in gp if ch]"
630 "execution_count": 12,
636 "def tokenise(text):\n",
637 " return [ch for gp in [re.split(punctuation_pattern, t) for t in re.split(token_pattern, text)]\n",
638 " for ch in gp if ch]"
643 "execution_count": 13,
660 " 'approximations',\n",
835 " 'illustration',\n",
876 " 'predetermined',\n",
969 "execution_count": 13,
971 "output_type": "execute_result"
975 "tokenise(sample_text)"
980 "execution_count": 14,
1006 " 'approximation',\n",
1017 " 'approximation',\n",
1059 " 'abstraction',\n",
1079 " 'Abstractions',\n",
1167 "execution_count": 14,
1169 "output_type": "execute_result"
1173 "tokenise(\"\"\"Exercise 1.8. Newton's method for cube roots is based on the fact that if y is an approximation to the\n",
1174 "cube root of x, then a better approximation is given by the value\n",
1176 "Use this formula to implement a cube-root procedure analogous to the square-root procedure. (In\n",
1177 "section 1.3.4 we will see how to implement Newton's method in general as an abstraction of these\n",
1178 "square-root and cube-root procedures.)\n",
1180 "1.1.8 Procedures as Black-Box Abstractions\n",
1181 "Sqrt is our first example of a process defined by a set of mutually defined procedures. Notice that the\n",
1182 "definition of sqrt-iter is recursive; that is, the procedure is defined in terms of itself. The idea of\n",
1183 "being able to define a procedure in terms of itself may be disturbing; it may seem unclear how such a\n",
1184 "''circular'' definition could make sense at all, much less specify a well-defined process to be carried\n",
1189 "cell_type": "code",
1190 "execution_count": 15,
1196 "def find_counts_of_sentence(tokens, counts, tuple_size):\n",
1197 " for i in range(len(tokens)-(tuple_size)):\n",
1198 " counts[tuple(tokens[i:i+tuple_size])].update([tokens[i+tuple_size]])\n",
1199 " counts[tuple(tokens[-tuple_size:])].update(None)\n",
1204 "cell_type": "code",
1205 "execution_count": 16,
1211 "def find_counts(sentences, tuple_size=2):\n",
1212 " counts = collections.defaultdict(collections.Counter)\n",
1213 " starts = collections.Counter()\n",
1214 " for sentence in sentences:\n",
1215 " counts = find_counts_of_sentence(sentence, counts, tuple_size)\n",
1216 " starts[tuple(sentence[:tuple_size])] += 1\n",
1217 " return starts, counts"
1221 "cell_type": "code",
1222 "execution_count": 17,
1228 "def sentences(tokens):\n",
1231 " for i in range(len(tokens)):\n",
1232 " if tokens[i] == '.':\n",
1233 " sents += [sent + [tokens[i]]]\n",
1236 " sent += [tokens[i]]\n",
1241 "cell_type": "code",
1242 "execution_count": 18,
1250 "[['Continuing',\n",
1259 " 'approximations',\n",
1434 " 'illustration',\n",
1475 " 'predetermined',\n",
1516 "execution_count": 18,
1518 "output_type": "execute_result"
1522 "sentences(tokenise(sample_text))"
1526 "cell_type": "code",
1527 "execution_count": 19,
1535 "(Counter({('Continuing', 'this'): 1}),\n",
1536 " defaultdict(collections.Counter,\n",
1537 " {(',', 'we'): Counter({'obtain': 1}),\n",
1538 " ('Continuing', 'this'): Counter({'process': 1}),\n",
1539 " ('and', 'better'): Counter({'approximations': 1}),\n",
1540 " ('approximations', 'to'): Counter({'the': 1}),\n",
1541 " ('better', 'and'): Counter({'better': 1}),\n",
1542 " ('better', 'approximations'): Counter({'to': 1}),\n",
1543 " ('obtain', 'better'): Counter({'and': 1}),\n",
1544 " ('process', ','): Counter({'we': 1}),\n",
1545 " ('root', '.'): Counter(),\n",
1546 " ('square', 'root'): Counter({'.': 1}),\n",
1547 " ('the', 'square'): Counter({'root': 1}),\n",
1548 " ('this', 'process'): Counter({',': 1}),\n",
1549 " ('to', 'the'): Counter({'square': 1}),\n",
1550 " ('we', 'obtain'): Counter({'better': 1})}))"
1553 "execution_count": 19,
1555 "output_type": "execute_result"
1559 "one_s_starts, one_s_counts = find_counts([sentences(tokenise(sample_text))[0]])\n",
1560 "one_s_starts, one_s_counts"
1564 "cell_type": "code",
1565 "execution_count": 20,
1573 "(Counter({('(', 'See', 'exercise'): 1,\n",
1574 " ('Continuing', 'this', 'process'): 1,\n",
1575 " ('If', 'the', 'guess'): 1,\n",
1576 " ('Now', \"let's\", 'formalize'): 1,\n",
1577 " ('We', 'start', 'with'): 1,\n",
1578 " ('We', 'write', 'this'): 1}),\n",
1579 " defaultdict(collections.Counter,\n",
1580 " {(\"''\", 'good', 'enough'): Counter({\".''\": 1}),\n",
1581 " ('(', 'See', 'exercise'): Counter({'1.7': 1}),\n",
1582 " ('(', 'abs', '(-'): Counter({'(': 1}),\n",
1583 " ('(', 'average', 'guess'): Counter({'(/': 1}),\n",
1584 " ('(', 'average', 'x'): Counter({'y': 1}),\n",
1587 " '('): Counter({'average': 1,\n",
1591 " ('(', 'good', '-'): Counter({'enough': 2}),\n",
1592 " ('(', 'here', '0.001'): Counter({'):': 1}),\n",
1593 " ('(', 'if', '('): Counter({'good': 1}),\n",
1594 " ('(', 'improve', 'guess'): Counter({'x': 2}),\n",
1595 " ('(', 'sqrt', '-'): Counter({'iter': 2}),\n",
1596 " ('(', 'square', 'guess'): Counter({')': 1}),\n",
1597 " ('(', 'the', 'number'): Counter({'whose': 1}),\n",
1598 " ('(+', 'x', 'y'): Counter({')': 1}),\n",
1599 " ('(-', '(', 'square'): Counter({'guess': 1}),\n",
1600 " ('(/', '(+', 'x'): Counter({'y': 1}),\n",
1601 " ('(/', 'x', 'guess'): Counter({')))': 1}),\n",
1602 " ('(<', '(', 'abs'): Counter({'(-': 1}),\n",
1603 " (')', '(', 'average'): Counter({'guess': 1}),\n",
1604 " (')', '(', 'if'): Counter({'(': 1}),\n",
1605 " (')', '(/', '(+'): Counter({'x': 1}),\n",
1606 " (')', '(<', '('): Counter({'abs': 1}),\n",
1607 " (')', '2', '))'): Counter({'We': 1}),\n",
1608 " (')', 'and', 'a'): Counter({'value': 1}),\n",
1609 " (')', 'guess', '('): Counter({'sqrt': 1}),\n",
1610 " (')', 'x', '))'): Counter({'0.001': 1}),\n",
1611 " (')', 'x', ')))'): Counter({'A': 1}),\n",
1612 " ('))', '0.001', '))'): Counter({'Finally': 1}),\n",
1613 " ('))', 'Finally', ','): Counter({'we': 1}),\n",
1614 " ('))', 'We', 'also'): Counter({'have': 1}),\n",
1615 " (')))', 'A', 'guess'): Counter({'is': 1}),\n",
1616 " (')))', 'where', '('): Counter({'define': 1}),\n",
1617 " ('):', '22', '('): Counter({'define': 1}),\n",
1618 " (',', 'but', 'it'): Counter({'is': 1}),\n",
1619 " (',', 'we', 'are'): Counter({'done': 1}),\n",
1620 " (',', 'we', 'must'): Counter({'repeat': 1}),\n",
1621 " (',', 'we', 'need'): Counter({'a': 1}),\n",
1622 " (',', 'we', 'obtain'): Counter({'better': 1}),\n",
1623 " ('-', 'enough', '?'): Counter({'guess': 2}),\n",
1624 " ('-', 'iter', '('): Counter({'improve': 1}),\n",
1625 " ('-', 'iter', 'guess'): Counter({'x': 1}),\n",
1626 " (\".''\", 'The', 'following'): Counter({'will': 1}),\n",
1627 " ('.)', 'The', 'idea'): Counter({'is': 1}),\n",
1628 " ('0.001', '))', 'Finally'): Counter({',': 1}),\n",
1629 " ('0.001', '):', '22'): Counter({'(': 1}),\n",
1630 " ('1.7', '.)', 'The'): Counter({'idea': 1}),\n",
1631 " ('2', '))', 'We'): Counter({'also': 1}),\n",
1632 " ('22', '(', 'define'): Counter({'(': 1}),\n",
1633 " (':', '(', 'define'): Counter({'(': 2}),\n",
1634 " (';', 'if', 'not'): Counter({',': 1}),\n",
1635 " ('?', 'guess', 'x'): Counter({')': 2}),\n",
1636 " ('A', 'guess', 'is'): Counter({'improved': 1}),\n",
1637 " ('Continuing', 'this', 'process'): Counter({',': 1}),\n",
1638 " ('Finally', ',', 'we'): Counter({'need': 1}),\n",
1639 " ('If', 'the', 'guess'): Counter({'is': 1}),\n",
1640 " ('Now', \"let's\", 'formalize'): Counter({'the': 1}),\n",
1641 " ('See', 'exercise', '1.7'): Counter({'.)': 1}),\n",
1642 " ('The', 'following', 'will'): Counter({'do': 1}),\n",
1643 " ('The', 'idea', 'is'): Counter({'to': 1}),\n",
1644 " ('We', 'also', 'have'): Counter({'to': 1}),\n",
1645 " ('We', 'start', 'with'): Counter({'a': 1}),\n",
1646 " ('We', 'write', 'this'): Counter({'basic': 1}),\n",
1647 " ('a', 'predetermined', 'tolerance'): Counter({'(': 1}),\n",
1648 " ('a', 'procedure', ':'): Counter({'(': 1}),\n",
1649 " ('a', 'value', 'for'): Counter({'the': 2}),\n",
1650 " ('a', 'very', 'good'): Counter({'test': 1}),\n",
1651 " ('a', 'way', 'to'): Counter({'get': 1}),\n",
1652 " ('abs', '(-', '('): Counter({'square': 1}),\n",
1653 " ('also', 'have', 'to'): Counter({'say': 1}),\n",
1654 " ('an', 'improved', 'guess'): Counter({'.': 1}),\n",
1655 " ('and', 'a', 'value'): Counter({'for': 1}),\n",
1656 " ('and', 'better', 'approximations'): Counter({'to': 1}),\n",
1657 " ('and', 'the', 'old'): Counter({'guess': 1}),\n",
1658 " ('answer', 'until', 'it'): Counter({'is': 1}),\n",
1659 " ('approximations', 'to', 'the'): Counter({'square': 1}),\n",
1660 " ('are', 'done', ';'): Counter({'if': 1}),\n",
1661 " ('are', 'trying', 'to'): Counter({'compute': 1}),\n",
1662 " ('as', 'a', 'procedure'): Counter({':': 1}),\n",
1663 " ('average', 'guess', '(/'): Counter({'x': 1}),\n",
1664 " ('average', 'x', 'y'): Counter({')': 1}),\n",
1665 " ('averaging', 'it', 'with'): Counter({'the': 1}),\n",
1666 " ('basic', 'strategy', 'as'): Counter({'a': 1}),\n",
1667 " ('better', 'and', 'better'): Counter({'approximations': 1}),\n",
1668 " ('better', 'approximations', 'to'): Counter({'the': 1}),\n",
1669 " ('but', 'it', 'is'): Counter({'not': 1}),\n",
1670 " ('by', \"''\", 'good'): Counter({'enough': 1}),\n",
1671 " ('by', 'averaging', 'it'): Counter({'with': 1}),\n",
1672 " ('by', 'less', 'than'): Counter({'a': 1}),\n",
1673 " ('close', 'enough', 'so'): Counter({'that': 1}),\n",
1674 " ('compute', ')', 'and'): Counter({'a': 1}),\n",
1675 " ('define', '(', 'average'): Counter({'x': 1}),\n",
1676 " ('define', '(', 'good'): Counter({'-': 1}),\n",
1677 " ('define', '(', 'improve'): Counter({'guess': 1}),\n",
1678 " ('define', '(', 'sqrt'): Counter({'-': 1}),\n",
1679 " ('differs', 'from', 'the'): Counter({'radicand': 1}),\n",
1680 " ('do', 'for', 'illustration'): Counter({',': 1}),\n",
1681 " ('done', ';', 'if'): Counter({'not': 1}),\n",
1682 " ('enough', \".''\", 'The'): Counter({'following': 1}),\n",
1683 " ('enough', '?', 'guess'): Counter({'x': 2}),\n",
1684 " ('enough', 'for', 'our'): Counter({'purposes': 1}),\n",
1685 " ('enough', 'so', 'that'): Counter({'its': 1}),\n",
1686 " ('exercise', '1.7', '.)'): Counter({'The': 1}),\n",
1687 " ('following', 'will', 'do'): Counter({'for': 1}),\n",
1688 " ('for', 'illustration', ','): Counter({'but': 1}),\n",
1689 " ('for', 'our', 'purposes'): Counter({',': 1}),\n",
1690 " ('for', 'the', 'guess'): Counter({'.': 1}),\n",
1691 " ('for', 'the', 'radicand'): Counter({'(': 1}),\n",
1692 " ('formalize', 'the', 'process'): Counter({'in': 1}),\n",
1693 " ('from', 'the', 'radicand'): Counter({'by': 1}),\n",
1694 " ('get', 'started', '.'): Counter(),\n",
1695 " ('good', '-', 'enough'): Counter({'?': 2}),\n",
1696 " ('good', 'enough', \".''\"): Counter({'The': 1}),\n",
1697 " ('good', 'enough', 'for'): Counter({'our': 1}),\n",
1698 " ('good', 'test', '.'): Counter(),\n",
1699 " ('guess', '(', 'sqrt'): Counter({'-': 1}),\n",
1700 " ('guess', '(/', 'x'): Counter({'guess': 1}),\n",
1701 " ('guess', ')', 'x'): Counter({'))': 1}),\n",
1702 " ('guess', ')))', 'where'): Counter({'(': 1}),\n",
1703 " ('guess', ':', '('): Counter({'define': 1}),\n",
1704 " ('guess', 'is', 'good'): Counter({'enough': 1}),\n",
1705 " ('guess', 'is', 'improved'): Counter({'by': 1}),\n",
1708 " ')'): Counter({'(': 2, '(<': 1, 'guess': 1, 'x': 1}),\n",
1709 " ('have', 'to', 'say'): Counter({'what': 1}),\n",
1710 " ('here', '0.001', '):'): Counter({'22': 1}),\n",
1711 " ('idea', 'is', 'to'): Counter({'improve': 1}),\n",
1712 " ('if', '(', 'good'): Counter({'-': 1}),\n",
1713 " ('if', 'not', ','): Counter({'we': 1}),\n",
1714 " ('illustration', ',', 'but'): Counter({'it': 1}),\n",
1715 " ('improve', 'guess', 'x'): Counter({')': 2}),\n",
1716 " ('improve', 'the', 'answer'): Counter({'until': 1}),\n",
1717 " ('improved', 'by', 'averaging'): Counter({'it': 1}),\n",
1718 " ('improved', 'guess', '.'): Counter(),\n",
1719 " ('in', 'terms', 'of'): Counter({'procedures': 1}),\n",
1720 " ('is', 'close', 'enough'): Counter({'so': 1}),\n",
1721 " ('is', 'good', 'enough'): Counter({'for': 1}),\n",
1722 " ('is', 'improved', 'by'): Counter({'averaging': 1}),\n",
1723 " ('is', 'not', 'really'): Counter({'a': 1}),\n",
1724 " ('is', 'to', 'improve'): Counter({'the': 1}),\n",
1725 " ('it', 'is', 'close'): Counter({'enough': 1}),\n",
1726 " ('it', 'is', 'not'): Counter({'really': 1}),\n",
1727 " ('it', 'with', 'the'): Counter({'quotient': 1}),\n",
1728 " ('iter', '(', 'improve'): Counter({'guess': 1}),\n",
1729 " ('iter', 'guess', 'x'): Counter({')': 1}),\n",
1730 " ('its', 'square', 'differs'): Counter({'from': 1}),\n",
1731 " ('less', 'than', 'a'): Counter({'predetermined': 1}),\n",
1732 " (\"let's\", 'formalize', 'the'): Counter({'process': 1}),\n",
1733 " ('mean', 'by', \"''\"): Counter({'good': 1}),\n",
1734 " ('must', 'repeat', 'the'): Counter({'process': 1}),\n",
1735 " ('need', 'a', 'way'): Counter({'to': 1}),\n",
1736 " ('not', ',', 'we'): Counter({'must': 1}),\n",
1737 " ('not', 'really', 'a'): Counter({'very': 1}),\n",
1738 " ('number', 'whose', 'square'): Counter({'root': 1}),\n",
1739 " ('obtain', 'better', 'and'): Counter({'better': 1}),\n",
1740 " ('of', 'procedures', '.'): Counter(),\n",
1741 " ('of', 'the', 'radicand'): Counter({'and': 1}),\n",
1742 " ('old', 'guess', ':'): Counter({'(': 1}),\n",
1743 " ('our', 'purposes', ','): Counter({'we': 1}),\n",
1744 " ('predetermined', 'tolerance', '('): Counter({'here': 1}),\n",
1745 " ('procedure', ':', '('): Counter({'define': 1}),\n",
1746 " ('process', ',', 'we'): Counter({'obtain': 1}),\n",
1747 " ('process', 'in', 'terms'): Counter({'of': 1}),\n",
1748 " ('process', 'with', 'an'): Counter({'improved': 1}),\n",
1749 " ('purposes', ',', 'we'): Counter({'are': 1}),\n",
1750 " ('quotient', 'of', 'the'): Counter({'radicand': 1}),\n",
1751 " ('radicand', '(', 'the'): Counter({'number': 1}),\n",
1752 " ('radicand', 'and', 'the'): Counter({'old': 1}),\n",
1753 " ('radicand', 'by', 'less'): Counter({'than': 1}),\n",
1754 " ('really', 'a', 'very'): Counter({'good': 1}),\n",
1755 " ('repeat', 'the', 'process'): Counter({'with': 1}),\n",
1756 " ('root', 'we', 'are'): Counter({'trying': 1}),\n",
1757 " ('say', 'what', 'we'): Counter({'mean': 1}),\n",
1758 " ('so', 'that', 'its'): Counter({'square': 1}),\n",
1759 " ('sqrt', '-', 'iter'): Counter({'(': 1, 'guess': 1}),\n",
1760 " ('square', 'differs', 'from'): Counter({'the': 1}),\n",
1761 " ('square', 'guess', ')'): Counter({'x': 1}),\n",
1762 " ('square', 'root', '.'): Counter(),\n",
1763 " ('square', 'root', 'we'): Counter({'are': 1}),\n",
1764 " ('start', 'with', 'a'): Counter({'value': 1}),\n",
1765 " ('strategy', 'as', 'a'): Counter({'procedure': 1}),\n",
1766 " ('terms', 'of', 'procedures'): Counter({'.': 1}),\n",
1767 " ('than', 'a', 'predetermined'): Counter({'tolerance': 1}),\n",
1768 " ('that', 'its', 'square'): Counter({'differs': 1}),\n",
1769 " ('the', 'answer', 'until'): Counter({'it': 1}),\n",
1770 " ('the', 'guess', '.'): Counter(),\n",
1771 " ('the', 'guess', 'is'): Counter({'good': 1}),\n",
1772 " ('the', 'number', 'whose'): Counter({'square': 1}),\n",
1773 " ('the', 'old', 'guess'): Counter({':': 1}),\n",
1774 " ('the', 'process', 'in'): Counter({'terms': 1}),\n",
1775 " ('the', 'process', 'with'): Counter({'an': 1}),\n",
1776 " ('the', 'quotient', 'of'): Counter({'the': 1}),\n",
1777 " ('the', 'radicand', '('): Counter({'the': 1}),\n",
1778 " ('the', 'radicand', 'and'): Counter({'the': 1}),\n",
1779 " ('the', 'radicand', 'by'): Counter({'less': 1}),\n",
1780 " ('the', 'square', 'root'): Counter({'.': 1}),\n",
1781 " ('this', 'basic', 'strategy'): Counter({'as': 1}),\n",
1782 " ('this', 'process', ','): Counter({'we': 1}),\n",
1783 " ('to', 'compute', ')'): Counter({'and': 1}),\n",
1784 " ('to', 'get', 'started'): Counter({'.': 1}),\n",
1785 " ('to', 'improve', 'the'): Counter({'answer': 1}),\n",
1786 " ('to', 'say', 'what'): Counter({'we': 1}),\n",
1787 " ('to', 'the', 'square'): Counter({'root': 1}),\n",
1788 " ('tolerance', '(', 'here'): Counter({'0.001': 1}),\n",
1789 " ('trying', 'to', 'compute'): Counter({')': 1}),\n",
1790 " ('until', 'it', 'is'): Counter({'close': 1}),\n",
1791 " ('value', 'for', 'the'): Counter({'guess': 1, 'radicand': 1}),\n",
1792 " ('very', 'good', 'test'): Counter({'.': 1}),\n",
1793 " ('way', 'to', 'get'): Counter({'started': 1}),\n",
1794 " ('we', 'are', 'done'): Counter({';': 1}),\n",
1795 " ('we', 'are', 'trying'): Counter({'to': 1}),\n",
1796 " ('we', 'mean', 'by'): Counter({\"''\": 1}),\n",
1797 " ('we', 'must', 'repeat'): Counter({'the': 1}),\n",
1798 " ('we', 'need', 'a'): Counter({'way': 1}),\n",
1799 " ('we', 'obtain', 'better'): Counter({'and': 1}),\n",
1800 " ('what', 'we', 'mean'): Counter({'by': 1}),\n",
1801 " ('where', '(', 'define'): Counter({'(': 1}),\n",
1802 " ('whose', 'square', 'root'): Counter({'we': 1}),\n",
1803 " ('will', 'do', 'for'): Counter({'illustration': 1}),\n",
1804 " ('with', 'a', 'value'): Counter({'for': 1}),\n",
1805 " ('with', 'an', 'improved'): Counter({'guess': 1}),\n",
1806 " ('with', 'the', 'quotient'): Counter({'of': 1}),\n",
1807 " ('write', 'this', 'basic'): Counter({'strategy': 1}),\n",
1808 " ('x', ')', '('): Counter({'average': 1, 'if': 1}),\n",
1809 " ('x', ')', '(<'): Counter({'(': 1}),\n",
1810 " ('x', ')', 'guess'): Counter({'(': 1}),\n",
1811 " ('x', ')', 'x'): Counter({')))': 1}),\n",
1812 " ('x', '))', '0.001'): Counter({'))': 1}),\n",
1813 " ('x', ')))', 'A'): Counter({'guess': 1}),\n",
1814 " ('x', 'guess', ')))'): Counter({'where': 1}),\n",
1815 " ('x', 'y', ')'): Counter({'(/': 1, '2': 1}),\n",
1816 " ('y', ')', '(/'): Counter({'(+': 1}),\n",
1817 " ('y', ')', '2'): Counter({'))': 1})}))"
1820 "execution_count": 20,
1822 "output_type": "execute_result"
1826 "find_counts(sentences(tokenise(sample_text)), tuple_size=3)"
1830 "cell_type": "code",
1831 "execution_count": 21,
1839 "('Continuing', 'this', 'process')"
1842 "execution_count": 21,
1844 "output_type": "execute_result"
1848 "s = sentences(tokenise(sample_text))[0]\n",
1853 "cell_type": "code",
1854 "execution_count": 22,
1860 "unaccent_specials = ''.maketrans({\"’\": \"'\", \"’\": \"'\"})\n",
1861 "def unaccent(text):\n",
1862 " \"\"\"Remove all accents from letters.\n",
1863 " It does this by converting the unicode string to decomposed compatability\n",
1864 " form, dropping all the combining accents, then re-encoding the bytes.\n",
1866 " >>> unaccent('hello')\n",
1868 " >>> unaccent('HELLO')\n",
1870 " >>> unaccent('héllo')\n",
1872 " >>> unaccent('héllö')\n",
1874 " >>> unaccent('HÉLLÖ')\n",
1877 " translated_text = text.translate(unaccent_specials)\n",
1878 " return unicodedata.normalize('NFKD', translated_text).\\\n",
1879 " encode('ascii', 'ignore').\\\n",
1884 "cell_type": "code",
1885 "execution_count": 23,
1891 "sicp = unaccent(open('sicp.txt').read())\n",
1892 "sicp_starts, sicp_counts = find_counts(sentences(tokenise(sicp)), tuple_size=3)"
1896 "cell_type": "code",
1897 "execution_count": 24,
1905 "[(('subset', 'of', 'mathematical'), Counter({'logic': 1})),\n",
1906 " (('at', 'MIT', 'who'), Counter({'major': 1})),\n",
1907 " (('enforces', 'the', 'restriction'), Counter({'that': 1})),\n",
1908 " (('makes', 'it', 'very'), Counter({'difficult': 1})),\n",
1909 " (('understand', 'the', \"compiler's\"), Counter({'preserving': 1})),\n",
1910 " (('with', 'instructions', 'to'), Counter({'initialize': 1, 'test': 1})),\n",
1911 " (('to', 'problems', 'in'), Counter({'adding': 1})),\n",
1912 " (('problem', 'is', 'and'), Counter({'how': 1})),\n",
1913 " (('stream', '(', 'conjoin'), Counter({'(': 1})),\n",
1914 " (('organization', ',', 'then'), Counter({'to': 1}))]"
1917 "execution_count": 24,
1919 "output_type": "execute_result"
1923 "list(sicp_counts.items())[:10]"
1927 "cell_type": "code",
1928 "execution_count": 25,
1936 "[(('With', 'permanent', '-'), 1),\n",
1937 " (('The', 'recursive', 'compilation'), 1),\n",
1938 " (('Define', 'abstractions', 'that'), 1),\n",
1939 " (('Hall', 'the', 'Rosalind'), 1),\n",
1940 " (('The', 'effect', 'executingnew'), 1),\n",
1941 " (('1', '-', '4.1'), 1),\n",
1942 " (('So', 'the', 'procedure'), 1),\n",
1943 " (('However', ',', 'with'), 1),\n",
1944 " (('Figure', '3.2', 'shows'), 1),\n",
1945 " (('In', 'software', '-'), 1)]"
1948 "execution_count": 25,
1950 "output_type": "execute_result"
1954 "list(sicp_starts.items())[:10]"
1958 "cell_type": "code",
1959 "execution_count": 26,
1970 "execution_count": 26,
1972 "output_type": "execute_result"
1976 "list(sicp_counts[('Gas', 'Meters', '.')].elements())"
1980 "cell_type": "code",
1981 "execution_count": 27,
1989 "('The', 'left', \"''\")"
1992 "execution_count": 27,
1994 "output_type": "execute_result"
1998 "random.choice(list(sicp_starts.elements()))"
2002 "cell_type": "code",
2003 "execution_count": 28,
2014 "execution_count": 28,
2016 "output_type": "execute_result"
2020 "t = ('as', '+')\n",
2025 "cell_type": "code",
2026 "execution_count": 29,
2032 "def markov_sentence(counts, starts, items=None):\n",
2034 " current = random.choice(list(starts.elements()))\n",
2035 " chain = list(current)\n",
2036 " nexts = list(counts[current].elements())\n",
2037 " while nexts and items and i < items:\n",
2038 " next_item = random.choice(nexts)\n",
2039 " chain += [next_item]\n",
2040 " current = current[1:] + (next_item, )\n",
2042 " nexts = list(counts[current].elements())\n",
2043 " # print(chain, ':', current, ':', nexts)\n",
2048 "cell_type": "code",
2049 "execution_count": 30,
2057 "'Rewrite the sqrt procedure of section 2.2 .'"
2060 "execution_count": 30,
2062 "output_type": "execute_result"
2066 "' '.join(markov_sentence(sicp_counts, sicp_starts, 500))"
2070 "cell_type": "code",
2071 "execution_count": 31,
2082 "execution_count": 31,
2084 "output_type": "execute_result"
2088 "sicp_counts['the', 'dispatch', 'procedure']"
2092 "cell_type": "code",
2093 "execution_count": 32,
2101 "'Continuing this process , we obtain better and better approximations to the square root .'"
2104 "execution_count": 32,
2106 "output_type": "execute_result"
2110 "' '.join(markov_sentence(one_s_counts, one_s_starts, 500))"
2114 "cell_type": "code",
2115 "execution_count": 33,
2123 "(defaultdict(collections.Counter,\n",
2124 " {(',', 'we'): Counter({'obtain': 1}),\n",
2125 " ('Continuing', 'this'): Counter({'process': 1}),\n",
2126 " ('and', 'better'): Counter({'approximations': 1}),\n",
2127 " ('approximations', 'to'): Counter({'the': 1}),\n",
2128 " ('better', 'and'): Counter({'better': 1}),\n",
2129 " ('better', 'approximations'): Counter({'to': 1}),\n",
2130 " ('obtain', 'better'): Counter({'and': 1}),\n",
2131 " ('process', ','): Counter({'we': 1}),\n",
2132 " ('root', '.'): Counter(),\n",
2133 " ('square', 'root'): Counter({'.': 1}),\n",
2134 " ('the', 'square'): Counter({'root': 1}),\n",
2135 " ('this', 'process'): Counter({',': 1}),\n",
2136 " ('to', 'the'): Counter({'square': 1}),\n",
2137 " ('we', 'obtain'): Counter({'better': 1})}),\n",
2138 " Counter({('Continuing', 'this'): 1}))"
2141 "execution_count": 33,
2143 "output_type": "execute_result"
2147 "one_s_counts, one_s_starts"
2151 "cell_type": "code",
2152 "execution_count": 35,
2158 "def sentence_join(tokens):\n",
2160 " for t in tokens:\n",
2161 " if t[-1] not in \".,:;')-\":\n",
2162 " sentence += ' '\n",
2164 " return sentence.strip()"
2168 "cell_type": "code",
2169 "execution_count": 36,
2177 "'Griss, Martin L.'"
2180 "execution_count": 36,
2182 "output_type": "execute_result"
2186 "sentence_join(markov_sentence(sicp_counts, sicp_starts, 500))"
2190 "cell_type": "code",
2191 "execution_count": 38,
2199 "'2 Compiling Expressions In this section we will examine several Lisp procedures and design a specific register machine to execute programs written in Scheme, we used a succession of programs, most of the pairs generated in a typical computation are used only to speed up the evaluator by separating analysis from runtime execution. Unfortunately, as we have implemented adjoin- term to work for polynomials with coefficients that are themselves sequences are subtrees. In the original definition of scale- list, the recursive structure of the procedure object W1. A. Turner, David, and Daniel Weinreb. 4 Compound Procedures 1.1. Although their method was complex, it produced reasonably efficient programs because it did little redundant search. Exercise 3.13 constructed such lists. Modify the handling of cond so that it expects the integrand as a delayed argument and hence can be used in this way: ( define ( scheme- number -> scheme- number scheme- number -> scheme- number- package instantiate instantiate a pattern instruction counting instruction execution procedure instruction sequence, a list of n elements ? Exercise 2.65. Exercise 3.22.'"
2202 "execution_count": 38,
2204 "output_type": "execute_result"
2208 "' '.join(sentence_join(markov_sentence(sicp_counts, sicp_starts, 500)) for _ in range(10))"
2212 "cell_type": "code",
2213 "execution_count": 42,
2219 "kjb = unaccent(open('king-james-bible.txt').read())\n",
2220 "kjb_starts, kjb_counts = find_counts(sentences(tokenise(kjb)), tuple_size=3)"
2224 "cell_type": "code",
2225 "execution_count": 43,
2233 "'4: 5 And Simon answering said unto him, Thou wicked and slothful servant, thou knewest that I reap where I sowed not, and he that is of a perverse heart shall be there: and make no mention of the name of it called Babel; because the former troubles are forgotten, and because of the Ethiopian woman whom he had chosen. 20: 6 But Abram said unto Lot, Hast thou found honey ? eat so much as heard whether there be prophecies, they shall fall one upon another, that shall not be cut off from among his people: neither shalt thou suffer the salt of the covenant stood: and they rest not day and night come to an end, 21: 26 They mount up to heaven, and on camels, and asses. 15: 4 Yea, though he be not redeemed within the space of a full year may he redeem it. 89: 43 Thou hast also committed fornication with her, and disallowed her not: then all her vows, or of the strangers for a prey, and to the soldiers, when they saw that the Syrians were fled, they likewise fled before Abishai his brother, is in darkness even until now. 8: 8 Also he sent forth a raven, which went out from the land of Canaan, the lot of our inheritance on this side Jordan westward. 2: 6 His body also was like the fiery flame, and the Jebusites, which were remaining of the families of the Gershonites according to their families was thus: even the border of Simeon, Shemuel the son of Kareah spake to Gedaliah in Mizpah secretly saying, Let neither man nor woman alive, to bring up the tithe of the corn, and to the king, and of oil, ye shall keep this service. 8: 8 So Rabshakeh returned, and corrupted all their doings. 18: 17 And the flood was forty days upon the land, and their wives, and all they that were vexed with unclean spirits: and they possessed it, and set his heart on Daniel to deliver him: and he said unto them thus, Who commanded you to perform, even ten thousand captives, and brought him to the face, both he that soweth and he that formed the eye, I am Christ; and shall set the woman before the LORD, the fire causeth the waters to boil, to make an atonement for your sin. 2: 22 Thou shalt eat it within thy gates: 20: 4 And whither I go. 8: 29 And Jesus answered and said, I am in a great strait: let us go by night, being one of them.'"
2236 "execution_count": 43,
2238 "output_type": "execute_result"
2242 "' '.join(sentence_join(markov_sentence(kjb_counts, kjb_starts, 500)) for _ in range(10))"
2246 "cell_type": "code",
2247 "execution_count": 44,
2253 "all_starts = sicp_starts + kjb_starts"
2257 "cell_type": "code",
2258 "execution_count": 45,
2266 "[(('The', 'programmer', 'must'), 1),\n",
2267 " (('And', 'Jehoram', 'reigned'), 1),\n",
2268 " (('The', 'recursive', 'compilation'), 1),\n",
2269 " (('17', ':', '22'), 10),\n",
2270 " (('Hall', 'the', 'Rosalind'), 1),\n",
2271 " (('107', ':', '10'), 1),\n",
2272 " (('The', 'stored', 'value'), 1),\n",
2273 " (('148', ':', '1'), 1),\n",
2274 " (('So', 'the', 'procedure'), 1),\n",
2275 " (('Woe', 'to', 'the'), 1),\n",
2276 " (('Design', 'and', 'implement'), 1),\n",
2277 " (('Figure', '3.2', 'shows'), 1),\n",
2278 " (('23', ':', '30'), 7),\n",
2279 " (('51', ':', '6'), 3),\n",
2280 " (('The', 'key', 'modularity'), 1),\n",
2281 " (('6', ':', '17'), 25),\n",
2282 " (('47', ':', '1'), 5),\n",
2283 " (('mutable', 'Indeed', ','), 1),\n",
2284 " (('And', 'he', 'saith'), 4),\n",
2285 " (('31', 'Exercise', '1.9'), 1)]"
2288 "execution_count": 45,
2290 "output_type": "execute_result"
2294 "list(all_starts.items())[:20]"
2298 "cell_type": "code",
2299 "execution_count": 46,
2305 "all_counts = collections.defaultdict(collections.Counter)\n",
2306 "for k in sicp_counts:\n",
2307 " all_counts[k] = sicp_counts[k].copy()\n",
2308 "for k in kjb_counts:\n",
2309 " all_counts[k] += kjb_counts[k].copy()"
2313 "cell_type": "code",
2314 "execution_count": 47,
2322 "\"The New Hacker's Dictionary. 14 Any memory cell that is not one- directional computations, which perform operations on prespecified arguments to produce desired outputs. 6 Internal Definitions Our environment model of procedure application, which is defined to be the special case where the set elements need not be a one- element list, which is the root of the tree to find the next free location. Fill in the missing expressions in the following definition of factorial: ( define ( user- print modified for compiled code apply- generic requests an operation to initialize the stack and return it, and students pick it up in a few seconds with the Fermat method), and test each of the 12 primes found in exercise 1.22. High- level languages, erected on a machine- language program machine model modified for compiled code monitoring performance ( stack use) of compiled code, and each time we move down the right branch and which will be executed). We have not shown the part of the implementation. ( Hint: Use substitution to evaluate ( square x) ( if (= n 1) ( make- new- machine make- operation- exp- reg dest)))) ( lambda() < exp>), without using the optimization provided by memo- proc do something like ( set ! * unparsed * ( cdr * unparsed*)) sent)) We can generate such a parse with a simple program that has separate procedures for each of the items in the set is ( 1) = y 1. Then we can find the remainder of the division is called the mutual exclusion problem. 4, where we found that formulating stream models of systems with loops may require uses of delay beyond the hidden'' delay supplied by cons- stream initial- value ( thunk- value obj)) ( else ( make- rat is called. Assume that the coefficients of the terms and add them. If none of the < test>, and the result of the operation is valid.\""
2325 "execution_count": 47,
2327 "output_type": "execute_result"
2331 "' '.join(sentence_join(markov_sentence(sicp_counts, sicp_starts, 500)) for _ in range(10))"
2335 "cell_type": "code",
2336 "execution_count": 48,
2344 "\"19: 25 But thou, O God: for they commit lewdness. 16: 15 And forgetteth that the foot may crush them, or that is in thee by the walls and in the feast of unleavened bread, until the selfsame day. 28: 23 But I will take away out of all his troubles. 4: 5 And they shall answer and say unto him, Is not this the fast that I have been with you at all seasons: the hard causes they brought unto him all the elders of the land of Egypt saying, 12: 11 Now when Job's three friends heard of all that therein is, in my realm, which are come to the place which the man of God, the God of Israel, which they could not so much as to eat. 5: 28 The LORD shall preserve thy going out; and it was shut. 43: 4 And the king of the nations: for I will stretch out my hand, and be rejected of the elders: from whom also I speak freely: for I have loved strangers, and after his going forth is prepared as the morning, that they come up out of Egypt, even they also turned to be their governor in the land of thy acts and of thy wisdom was not told me: thy hair is as a troubled fountain, and she conceived, and bare Jacob the fifth son. 22: 38 And Elisha came again to him, and upon the great toe of their right feet: and Deborah went up with ten thousand men of Judah; We have a little sister, and her days shall not be forgiven. 13: 2 And it shall come to pass, when the people removed from their tents, and said unto him that is near of kin unto us, he would raise up Christ to sit on the throne; yea, they have trodden my portion under foot, whose land the rivers have spoiled, to the right hand of the king. 40: 34 Then said they unto him an accusation against him. 14: 1 The priests the Levites, unto Ezra the priest brought the law before the congregation for judgment, but there was no bread there but the shewbread, which was the son of Meshullam, the son of Hinnom, and burnt it with fire, and destroyed down to the pit.\""
2347 "execution_count": 48,
2349 "output_type": "execute_result"
2353 "' '.join(sentence_join(markov_sentence(kjb_counts, kjb_starts, 500)) for _ in range(10))"
2357 "cell_type": "code",
2358 "execution_count": 50,
2366 "'6: 30 And the children of Israel, and the garlick: 11: 11 And Balak said unto Balaam, Go with the men, whom I have not spoken of me the thing that I hate, saith the LORD. 14: 27 And Joshua made them that day, saith the LORD; If ye will not fall upon me yourselves. 7: 2 Thou hast given a banner to them that believe: 2: 37 And at the end of the mountain that lieth before the valley of vision, breaking down the walls of the houses withal: 29: 37 Their meat offering and their drink offerings, and offer an offering made by fire unto the LORD. Then the master of his mercy; 1: 36 And Bethnimrah, and Succoth, and encamped at Hazeroth. If the queue was initially empty, we set the front and rear pointers of the queue in the first month in the second chariot that he had built, 10: 32 Benjamin, Malluch, and Adaiah, 10: 6 In burnt offerings and sacrifices, and with him an hundred and thirty. An extreme case of inefficiency occurs when the system falls into infinite loops in making deductions. 18: 12 And when the days of Cainan were nine hundred sixty and two years, and begat Methuselah: 5: 11 And Manoah arose, and rebuked them, because of the words which the horn spake: I sought him, but feared the people, He is my shepherd, and the Levites shall keep the watch of the LORD, and we will give ourselves continually to prayer, a certain blind man sat by the way. 34: 20 In a moment, and be still. One thing that makes the query language provides means of combination is crucial to the ability to represent compound data. 4: 15 That which is far off shall die of the pestilence.'"
2369 "execution_count": 50,
2371 "output_type": "execute_result"
2375 "' '.join(sentence_join(markov_sentence(all_counts, all_starts, 500)) for _ in range(10))"
2379 "cell_type": "code",
2380 "execution_count": 63,
2386 "all2 = unaccent(open('sicp-trimmed.txt').read() + open('king-james-bible.txt').read())\n",
2387 "all2_starts, all2_counts = find_counts(sentences(tokenise(all2)), tuple_size=2)"
2391 "cell_type": "code",
2392 "execution_count": 65,
2400 "['32 The stranger that is, that hath taken a new clause to the unit square ( imag- part, and our Saviour.',\n",
2401 " '112: 2 And, behold, immediately he arose, and cast them to pass at that level, which loveth thee and thy word is gone a little sister, to bring them unto the sea, they reach even to him, with the whole land shall be the Son of man are before the LORD pondereth the hearts of the first and the latter days.',\n",
2402 " '10: 38 Joel the chief man of God, as much as any of the wood offering, with his fathers: also they were ashamed: let not the light of the Greeks seek after my name, and said unto him that doeth righteousness at all redeem ought of the LORD appointed other seventy also, as at other times, and Mearah that is spent in our streets: and in Benjamin fenced cities, and to all that he will preserve him, and couple the curtains of goats that were numbered of them that sleep sleep in the house of Jeroboam the son of Mattaniah: for ye shall be shortened.',\n",
2403 " '( This argument is the spirit of his nostrils, and turn again by the heel in the place where concurrency control, and he that reapeth may rejoice.',\n",
2404 " '6: 7 That ye may be of the truth.',\n",
2405 " '6: 10 And thou shalt see it.',\n",
2406 " \"9: 25 And it shall come and sing praise to thee with ? x set) false))))) Without- interrupts disables time- shared operating systems, especially they who are ye in me is true,'' for example, if thou warn the righteous smite me; 26: 10 Declaring the end.\",\n",
2407 " '7: 22 But he rebelled against thee, yet make thee to anger, and Jeremoth, and the men of Babylon.',\n",
2408 " '( define ( cube x)))) ( parallel- execute is a great multitude from Galilee, into the ark of the dust of the desire of our attitudes about programming and, behold, they brought out the mote out of thy land shall fall therein: and the compiler.',\n",
2409 " 'And Peter remembered the days when God overthrew Sodom and her towns and country round about upon the horns, and openeth their ears are open, and to the user, provide a rigorous mathematical definition of the boards of fir.',\n",
2411 " 'For example, we set the battle increased that trouble me ! for my comfort in these cases are recognized by the space is ( define ( append- instruction- sequence, we will use a distinct bignum data type enables the system should be bound in chains among all the days that have not walked in the faith, I will surely shew myself unto prayer.',\n",
2412 " '1: 15 And thou shalt require of the testimony in Jacob his people made no lamentation.',\n",
2413 " '12: 37 Then he questioned with him.',\n",
2414 " 'The procedure that takes as input a pattern such as had not obtained that which is at hand, that David had a servant to wife.',\n",
2415 " '2: 11 Now this I say unto thee; and they that were diseased.',\n",
2416 " 'There are many ways in the matter, they withered away from him, sing praises unto God from the tower, and birds of the terms of more and more abundantly unto you, he hath given unto thee: and they shall offer the gift, with the beasts of the same car.',\n",
2417 " 'You must implement the generic procedure so that they name, and go up, and take up his pillars.',\n",
2418 " \"We will have to change ( or ( recursively) during analysis is a faithful man who was yet shut up him that shaketh it ? 30: 15 The way of the LORD's passover.\",\n",
2419 " 'Amen, and combine the two horns were high; that thou hast heard, Satan: thou hast redeemed.',\n",
2420 " \"The community's broader work goes beyond issues of objects that can skill to hew in the gate of Issachar according to all that they may shave their heads, neither have seen strange things to write coercion procedures that manipulate the shared account.\",\n",
2421 " \"25: 1: 36 My desire is, and Lot his brother's name was Tamar: she is thy love to have done evil in his disease he sought how he loved the people and the Amalekites had carried it into the sea side: and they shall be as frontlets between thine eyes behold, the joy wherewith we joy for your goodness is as the shadow of death stain it; because he had said unto her mistress, and they of Tyre and Sidon, which uses the last; I will restore it to a given application problem; the family of the whole congregation of the armies of Israel, and shod them, having faithful children not accused of riot, speaking of the lad where he entereth in by the young men now arise, if we call make- new- machine procedure, we hurt them, and his dwelling place of rest, but shall surely pay ox for a fool: much more diligent, upon these tables the words which I also was accounted to him, and much people, and upon the persons were four leprous men at his birth.\",\n",
2422 " '32: 3 She crieth in the gate from the power of the sea shall be unclean.',\n",
2423 " '2: 13 To keep the commandments of the wicked he turneth upside down shall be set in my sanctuary ? but thou shalt make two rings in the wine, which is called the Italian band, when ye go to Dothan.',\n",
2424 " '21: 8 Therefore thus saith the LORD our God in heaven.',\n",
2425 " 'The empty set is being paid more than lovers of God; every one over against him.',\n",
2426 " 'And the sons of Bilhah.',\n",
2427 " '34: 22 Saying, Give us this great fire any more at all times: unless she had seen.',\n",
2428 " '1: 7 Ain, Remmon, and Lot the son of Pashur, a flame: there shall be strong.',\n",
2429 " '32: 10 Yea, all the leaves of a combination, and Meshullam.']"
2432 "execution_count": 65,
2434 "output_type": "execute_result"
2438 "[sentence_join(markov_sentence(all2_counts, all2_starts, 500)) for _ in range(30)]"
2442 "cell_type": "code",
2443 "execution_count": 66,
2449 "sicp_lovecraft = unaccent(open('sicp-trimmed.txt').read() + open('lovecraft.txt').read())\n",
2450 "sl2_starts, sl2_counts = find_counts(sentences(tokenise(sicp_lovecraft)), tuple_size=2)"
2454 "cell_type": "code",
2455 "execution_count": 70,
2463 "\"To make a new procedure object W1. Now, if you fail to imagine an alien evolution had led him. We also have to steer better with four interface procedures to enforce the condition is called forcing. In Proceedings of the window I did not, they wished; so that the great sweep, half- bent on its own opposite. There he worked like beavers over Lake's two best planes, fitting them again it was very blurred, and very handsome save for his family. By incorporating a limited number of arrests, the brightness and affability which promised respite from our emotions, and aerial, aeroplane parts, an' crinkly albino hair, pale blue eyes, impotently trying to tell is more ancient than the ordered union- set pairs))) Make- withdraw. Out of the same hallucination. I had wander'd in rapture beneath them; and there was only a lone coyote on the side turned away from both men sat still and attempt to divide both the Esquimaux wizards and the weirdness of the sort used in Mesopotamia, being wakeful, and could not sleep well that sucks your life and sensation- the hellish whine of the vault I kept deathly quiet, and when I told them the back of the Eighteenth Century, with full daemoniac fury upon the dark stairs. ( You should find that much of the same constraint that the whole way to the westward precipice beside him was a baronet before his arrival. 1 Representations for Complex Numbers We will augment the factorial machine shown in figure 5.14) of section 5.2 we use apply- dispatch, and seemed to notice this ripple until reminded by later events; but I can scarcely describe the strangeness was not sorry for him did not believe he was so rapidly overtaking it in an infinite continued fraction expansion for e x is unbound.\""
2466 "execution_count": 70,
2468 "output_type": "execute_result"
2472 "\" \".join(sentence_join(markov_sentence(sl2_counts, sl2_starts, 500)) for _ in range(10))"
2476 "cell_type": "code",
2477 "execution_count": 75,
2485 "<p>Mrs. Now she heard voices in other universes and other myths, they raised and the senior Ward, however, were soon unbuttoning our heavy flying furs. 4 Exponentiation Consider the following August his labours. The face was a dream- world discovery in press. Each time we called a program for simulating diffusion ( say N / k calls to protected are done; though once in a begin.) The evaluator can check to see a pale lemon- yellow while his singular results. I had carried off. Reflecting upon these pictures can revive. There was a hideous uncertainty came over and over must you land amongst them with hot brooding gaze and evil. Dee was never regarded by the known habits of childish rebelliousness being exchanged for other needs of the steel- rimmed pince- nez and pointed stiffly to a cloud of probable East- Indian or Indochinese provenance, though I could tell; yet it is too tremendous for any to picture or encompass. Aroused at last to see the old Asian castles clinging to him on his study, a rational number can automatically be applied to frames in parallel and merging with the unbeautiful things of earth's convulsions, this is embedded.</h1>"
2488 "<IPython.core.display.HTML object>"
2492 "output_type": "display_data"
2496 "from IPython.core.display import display, HTML\n",
2497 "display(HTML('<p>' + \n",
2498 " \" \".join(sentence_join(markov_sentence(sl2_counts, sl2_starts, 500)) for _ in range(10)) + \n",
2503 "cell_type": "code",
2504 "execution_count": null,
2514 "display_name": "Python 3",
2515 "language": "python",
2519 "codemirror_mode": {
2523 "file_extension": ".py",
2524 "mimetype": "text/x-python",
2526 "nbconvert_exporter": "python",
2527 "pygments_lexer": "ipython3",
projects / name-generation.git / blob