13 "import collections\n",
14 "import unicodedata\n",
16 "from IPython.core.display import display, HTML"
27 "sample_text = \"\"\"Continuing this process, we obtain better and better approximations to the square root.\n",
28 "Now let's formalize the process in terms of procedures. We start with a value for the radicand (the\n",
29 "number whose square root we are trying to compute) and a value for the guess. If the guess is good\n",
30 "enough for our purposes, we are done; if not, we must repeat the process with an improved guess. We\n",
31 "write this basic strategy as a procedure:\n",
32 "(define (sqrt-iter guess x)\n",
33 "(if (good-enough? guess x)\n",
35 "(sqrt-iter (improve guess x)\n",
37 "A guess is improved by averaging it with the quotient of the radicand and the old guess:\n",
38 "(define (improve guess x)\n",
39 "(average guess (/ x guess)))\n",
43 "(define (average x y)\n",
45 "We also have to say what we mean by ''good enough.'' The following will do for illustration, but it is\n",
46 "not really a very good test. (See exercise 1.7.) The idea is to improve the answer until it is close\n",
47 "enough so that its square differs from the radicand by less than a predetermined tolerance (here\n",
49 "(define (good-enough? guess x)\n",
50 "(< (abs (- (square guess) x)) 0.001))\n",
51 "Finally, we need a way to get started. For instance, we can always guess that the square root of any\n",
54 "(sqrt-iter 1.0 x))\n",
55 "If we type these definitions to the interpreter, we can use sqrt just as we can use any procedure:\"\"\"\n",
57 "small_text = '''A guess is improved by averaging it with the quotient of the radicand and the old guess:\n",
58 "(define (improve guess x)\n",
59 "((average guess (/ x guess)))'''\n",
61 "sentence_boundary = 'in terms of procedures. We start with 0.123 and some'\n",
63 "double_quotes = \"let's see how such a ''circular'' definition\""
68 "execution_count": 78,
87 "'!\"#$%&\\'()*+,-./:;<=>?@[\\\\]^_`{|}~'"
92 "output_type": "execute_result"
101 "execution_count": 4,
109 "'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&\\'()*+,-./:;<=>?@[\\\\]^_`{|}~'"
112 "execution_count": 4,
114 "output_type": "execute_result"
118 "string.ascii_letters + string.digits + string.punctuation"
123 "execution_count": 5,
131 "re.compile(r'[^abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789\\!\\\"\\#\\$\\%\\&\\\\'\\(\\)\\*\\+\\,\\-\\.\\/\\:\\;\\<\\=\\>\\?\\@\\[\\\\\\]\\^_\\`\\{\\|\\}\\~]+',\n",
135 "execution_count": 5,
137 "output_type": "execute_result"
141 "token_pattern = re.compile(r'[^{}]+'.format(re.escape(string.ascii_letters + string.digits + string.punctuation)))\n",
147 "execution_count": 6,
155 "re.compile(r'(\\d+\\.\\d+|\\w+\\'\\w+|[\\!\\\"\\#\\$\\%\\&\\\\'\\(\\)\\*\\+\\,\\-\\.\\/\\:\\;\\<\\=\\>\\?\\@\\[\\\\\\]\\^_\\`\\{\\|\\}\\~]+(?=\\w)|(?<=\\w)[\\!\\\"\\#\\$\\%\\&\\\\'\\(\\)\\*\\+\\,\\-\\.\\/\\:\\;\\<\\=\\>\\?\\@\\[\\\\\\]\\^_\\`\\{\\|\\}\\~]+|[\\!\\\"\\#\\$\\%\\&\\\\'\\(\\)\\*\\+\\,\\-\\.\\/\\:\\;\\<\\=\\>\\?\\@\\[\\\\\\]\\^_\\`\\{\\|\\}\\~]+$)',\n",
159 "execution_count": 6,
161 "output_type": "execute_result"
165 "punctuation_pattern = re.compile('(\\d+\\.\\d+|\\w+\\'\\w+|[{0}]+(?=\\w)|(?<=\\w)[{0}]+|[{0}]+$)'.format(re.escape(string.punctuation)))\n",
166 "punctuation_pattern"
171 "execution_count": 7,
179 "['', '((', 'average']"
182 "execution_count": 7,
184 "output_type": "execute_result"
188 "re.split(r'(\\(+(?=\\w))', '((average')"
193 "execution_count": 8,
236 "execution_count": 8,
238 "output_type": "execute_result"
242 "[ch for gp in [re.split(punctuation_pattern, t) for t in re.split(token_pattern, small_text)]\n",
243 " for ch in gp if ch]"
248 "execution_count": 9,
269 "execution_count": 9,
271 "output_type": "execute_result"
275 "[ch for gp in [re.split(punctuation_pattern, t) for t in re.split(token_pattern, sentence_boundary)]\n",
276 " for ch in gp if ch]"
281 "execution_count": 10,
289 "[\"let's\", 'see', 'how', 'such', 'a', \"''\", 'circular', \"''\", 'definition']"
292 "execution_count": 10,
294 "output_type": "execute_result"
298 "[ch for gp in [re.split(punctuation_pattern, t) for t in re.split(token_pattern, double_quotes)]\n",
299 " for ch in gp if ch]"
304 "execution_count": 11,
322 " 'approximations',\n",
497 " 'illustration',\n",
538 " 'predetermined',\n",
631 "execution_count": 11,
633 "output_type": "execute_result"
637 "[ch for gp in [re.split(punctuation_pattern, t) for t in re.split(token_pattern, sample_text)]\n",
638 " for ch in gp if ch]"
643 "execution_count": 12,
649 "def tokenise(text):\n",
650 " return [ch for gp in [re.split(punctuation_pattern, t) for t in re.split(token_pattern, text)]\n",
651 " for ch in gp if ch]"
656 "execution_count": 13,
674 " 'approximations',\n",
849 " 'illustration',\n",
890 " 'predetermined',\n",
983 "execution_count": 13,
985 "output_type": "execute_result"
989 "tokenise(sample_text)"
994 "execution_count": 14,
1021 " 'approximation',\n",
1032 " 'approximation',\n",
1074 " 'abstraction',\n",
1094 " 'Abstractions',\n",
1182 "execution_count": 14,
1184 "output_type": "execute_result"
1188 "tokenise(\"\"\"Exercise 1.8. Newton's method for cube roots is based on the fact that if y is an approximation to the\n",
1189 "cube root of x, then a better approximation is given by the value\n",
1191 "Use this formula to implement a cube-root procedure analogous to the square-root procedure. (In\n",
1192 "section 1.3.4 we will see how to implement Newton's method in general as an abstraction of these\n",
1193 "square-root and cube-root procedures.)\n",
1195 "1.1.8 Procedures as Black-Box Abstractions\n",
1196 "Sqrt is our first example of a process defined by a set of mutually defined procedures. Notice that the\n",
1197 "definition of sqrt-iter is recursive; that is, the procedure is defined in terms of itself. The idea of\n",
1198 "being able to define a procedure in terms of itself may be disturbing; it may seem unclear how such a\n",
1199 "''circular'' definition could make sense at all, much less specify a well-defined process to be carried\n",
1204 "cell_type": "code",
1205 "execution_count": 15,
1211 "def find_counts_of_item(item, counts, tuple_size):\n",
1212 " for i in range(len(item)-(tuple_size)):\n",
1213 " counts[tuple(item[i:i+tuple_size])].update([item[i+tuple_size]])\n",
1214 " counts[tuple(item[-tuple_size:])].update([None])\n",
1219 "cell_type": "code",
1220 "execution_count": 16,
1226 "def find_counts(items, tuple_size=2):\n",
1227 " counts = collections.defaultdict(collections.Counter)\n",
1228 " starts = collections.Counter()\n",
1229 " for item in items:\n",
1230 " counts = find_counts_of_item(item, counts, tuple_size)\n",
1231 " starts[tuple(item[:tuple_size])] += 1\n",
1232 " return starts, counts"
1236 "cell_type": "code",
1237 "execution_count": 17,
1243 "def sentences(tokens):\n",
1246 " for i in range(len(tokens)):\n",
1247 " if tokens[i] == '.':\n",
1248 " sents += [sent + [tokens[i]]]\n",
1251 " sent += [tokens[i]]\n",
1256 "cell_type": "code",
1257 "execution_count": 18,
1266 "[['Continuing',\n",
1275 " 'approximations',\n",
1450 " 'illustration',\n",
1491 " 'predetermined',\n",
1532 "execution_count": 18,
1534 "output_type": "execute_result"
1538 "sentences(tokenise(sample_text))"
1542 "cell_type": "code",
1543 "execution_count": 19,
1551 "(Counter({('Continuing', 'this'): 1}),\n",
1552 " defaultdict(collections.Counter,\n",
1553 " {(',', 'we'): Counter({'obtain': 1}),\n",
1554 " ('Continuing', 'this'): Counter({'process': 1}),\n",
1555 " ('and', 'better'): Counter({'approximations': 1}),\n",
1556 " ('approximations', 'to'): Counter({'the': 1}),\n",
1557 " ('better', 'and'): Counter({'better': 1}),\n",
1558 " ('better', 'approximations'): Counter({'to': 1}),\n",
1559 " ('obtain', 'better'): Counter({'and': 1}),\n",
1560 " ('process', ','): Counter({'we': 1}),\n",
1561 " ('root', '.'): Counter({None: 1}),\n",
1562 " ('square', 'root'): Counter({'.': 1}),\n",
1563 " ('the', 'square'): Counter({'root': 1}),\n",
1564 " ('this', 'process'): Counter({',': 1}),\n",
1565 " ('to', 'the'): Counter({'square': 1}),\n",
1566 " ('we', 'obtain'): Counter({'better': 1})}))"
1569 "execution_count": 19,
1571 "output_type": "execute_result"
1575 "one_s_starts, one_s_counts = find_counts([sentences(tokenise(sample_text))[0]])\n",
1576 "one_s_starts, one_s_counts"
1580 "cell_type": "code",
1581 "execution_count": 20,
1590 "(Counter({('(', 'See', 'exercise'): 1,\n",
1591 " ('Continuing', 'this', 'process'): 1,\n",
1592 " ('If', 'the', 'guess'): 1,\n",
1593 " ('Now', \"let's\", 'formalize'): 1,\n",
1594 " ('We', 'start', 'with'): 1,\n",
1595 " ('We', 'write', 'this'): 1}),\n",
1596 " defaultdict(collections.Counter,\n",
1597 " {(\"''\", 'good', 'enough'): Counter({\".''\": 1}),\n",
1598 " ('(', 'See', 'exercise'): Counter({'1.7': 1}),\n",
1599 " ('(', 'abs', '(-'): Counter({'(': 1}),\n",
1600 " ('(', 'average', 'guess'): Counter({'(/': 1}),\n",
1601 " ('(', 'average', 'x'): Counter({'y': 1}),\n",
1604 " '('): Counter({'average': 1,\n",
1608 " ('(', 'good', '-'): Counter({'enough': 2}),\n",
1609 " ('(', 'here', '0.001'): Counter({'):': 1}),\n",
1610 " ('(', 'if', '('): Counter({'good': 1}),\n",
1611 " ('(', 'improve', 'guess'): Counter({'x': 2}),\n",
1612 " ('(', 'sqrt', '-'): Counter({'iter': 2}),\n",
1613 " ('(', 'square', 'guess'): Counter({')': 1}),\n",
1614 " ('(', 'the', 'number'): Counter({'whose': 1}),\n",
1615 " ('(+', 'x', 'y'): Counter({')': 1}),\n",
1616 " ('(-', '(', 'square'): Counter({'guess': 1}),\n",
1617 " ('(/', '(+', 'x'): Counter({'y': 1}),\n",
1618 " ('(/', 'x', 'guess'): Counter({')))': 1}),\n",
1619 " ('(<', '(', 'abs'): Counter({'(-': 1}),\n",
1620 " (')', '(', 'average'): Counter({'guess': 1}),\n",
1621 " (')', '(', 'if'): Counter({'(': 1}),\n",
1622 " (')', '(/', '(+'): Counter({'x': 1}),\n",
1623 " (')', '(<', '('): Counter({'abs': 1}),\n",
1624 " (')', '2', '))'): Counter({'We': 1}),\n",
1625 " (')', 'and', 'a'): Counter({'value': 1}),\n",
1626 " (')', 'guess', '('): Counter({'sqrt': 1}),\n",
1627 " (')', 'x', '))'): Counter({'0.001': 1}),\n",
1628 " (')', 'x', ')))'): Counter({'A': 1}),\n",
1629 " ('))', '0.001', '))'): Counter({'Finally': 1}),\n",
1630 " ('))', 'Finally', ','): Counter({'we': 1}),\n",
1631 " ('))', 'We', 'also'): Counter({'have': 1}),\n",
1632 " (')))', 'A', 'guess'): Counter({'is': 1}),\n",
1633 " (')))', 'where', '('): Counter({'define': 1}),\n",
1634 " ('):', '22', '('): Counter({'define': 1}),\n",
1635 " (',', 'but', 'it'): Counter({'is': 1}),\n",
1636 " (',', 'we', 'are'): Counter({'done': 1}),\n",
1637 " (',', 'we', 'must'): Counter({'repeat': 1}),\n",
1638 " (',', 'we', 'need'): Counter({'a': 1}),\n",
1639 " (',', 'we', 'obtain'): Counter({'better': 1}),\n",
1640 " ('-', 'enough', '?'): Counter({'guess': 2}),\n",
1641 " ('-', 'iter', '('): Counter({'improve': 1}),\n",
1642 " ('-', 'iter', 'guess'): Counter({'x': 1}),\n",
1643 " (\".''\", 'The', 'following'): Counter({'will': 1}),\n",
1644 " ('.)', 'The', 'idea'): Counter({'is': 1}),\n",
1645 " ('0.001', '))', 'Finally'): Counter({',': 1}),\n",
1646 " ('0.001', '):', '22'): Counter({'(': 1}),\n",
1647 " ('1.7', '.)', 'The'): Counter({'idea': 1}),\n",
1648 " ('2', '))', 'We'): Counter({'also': 1}),\n",
1649 " ('22', '(', 'define'): Counter({'(': 1}),\n",
1650 " (':', '(', 'define'): Counter({'(': 2}),\n",
1651 " (';', 'if', 'not'): Counter({',': 1}),\n",
1652 " ('?', 'guess', 'x'): Counter({')': 2}),\n",
1653 " ('A', 'guess', 'is'): Counter({'improved': 1}),\n",
1654 " ('Continuing', 'this', 'process'): Counter({',': 1}),\n",
1655 " ('Finally', ',', 'we'): Counter({'need': 1}),\n",
1656 " ('If', 'the', 'guess'): Counter({'is': 1}),\n",
1657 " ('Now', \"let's\", 'formalize'): Counter({'the': 1}),\n",
1658 " ('See', 'exercise', '1.7'): Counter({'.)': 1}),\n",
1659 " ('The', 'following', 'will'): Counter({'do': 1}),\n",
1660 " ('The', 'idea', 'is'): Counter({'to': 1}),\n",
1661 " ('We', 'also', 'have'): Counter({'to': 1}),\n",
1662 " ('We', 'start', 'with'): Counter({'a': 1}),\n",
1663 " ('We', 'write', 'this'): Counter({'basic': 1}),\n",
1664 " ('a', 'predetermined', 'tolerance'): Counter({'(': 1}),\n",
1665 " ('a', 'procedure', ':'): Counter({'(': 1}),\n",
1666 " ('a', 'value', 'for'): Counter({'the': 2}),\n",
1667 " ('a', 'very', 'good'): Counter({'test': 1}),\n",
1668 " ('a', 'way', 'to'): Counter({'get': 1}),\n",
1669 " ('abs', '(-', '('): Counter({'square': 1}),\n",
1670 " ('also', 'have', 'to'): Counter({'say': 1}),\n",
1671 " ('an', 'improved', 'guess'): Counter({'.': 1}),\n",
1672 " ('and', 'a', 'value'): Counter({'for': 1}),\n",
1673 " ('and', 'better', 'approximations'): Counter({'to': 1}),\n",
1674 " ('and', 'the', 'old'): Counter({'guess': 1}),\n",
1675 " ('answer', 'until', 'it'): Counter({'is': 1}),\n",
1676 " ('approximations', 'to', 'the'): Counter({'square': 1}),\n",
1677 " ('are', 'done', ';'): Counter({'if': 1}),\n",
1678 " ('are', 'trying', 'to'): Counter({'compute': 1}),\n",
1679 " ('as', 'a', 'procedure'): Counter({':': 1}),\n",
1680 " ('average', 'guess', '(/'): Counter({'x': 1}),\n",
1681 " ('average', 'x', 'y'): Counter({')': 1}),\n",
1682 " ('averaging', 'it', 'with'): Counter({'the': 1}),\n",
1683 " ('basic', 'strategy', 'as'): Counter({'a': 1}),\n",
1684 " ('better', 'and', 'better'): Counter({'approximations': 1}),\n",
1685 " ('better', 'approximations', 'to'): Counter({'the': 1}),\n",
1686 " ('but', 'it', 'is'): Counter({'not': 1}),\n",
1687 " ('by', \"''\", 'good'): Counter({'enough': 1}),\n",
1688 " ('by', 'averaging', 'it'): Counter({'with': 1}),\n",
1689 " ('by', 'less', 'than'): Counter({'a': 1}),\n",
1690 " ('close', 'enough', 'so'): Counter({'that': 1}),\n",
1691 " ('compute', ')', 'and'): Counter({'a': 1}),\n",
1692 " ('define', '(', 'average'): Counter({'x': 1}),\n",
1693 " ('define', '(', 'good'): Counter({'-': 1}),\n",
1694 " ('define', '(', 'improve'): Counter({'guess': 1}),\n",
1695 " ('define', '(', 'sqrt'): Counter({'-': 1}),\n",
1696 " ('differs', 'from', 'the'): Counter({'radicand': 1}),\n",
1697 " ('do', 'for', 'illustration'): Counter({',': 1}),\n",
1698 " ('done', ';', 'if'): Counter({'not': 1}),\n",
1699 " ('enough', \".''\", 'The'): Counter({'following': 1}),\n",
1700 " ('enough', '?', 'guess'): Counter({'x': 2}),\n",
1701 " ('enough', 'for', 'our'): Counter({'purposes': 1}),\n",
1702 " ('enough', 'so', 'that'): Counter({'its': 1}),\n",
1703 " ('exercise', '1.7', '.)'): Counter({'The': 1}),\n",
1704 " ('following', 'will', 'do'): Counter({'for': 1}),\n",
1705 " ('for', 'illustration', ','): Counter({'but': 1}),\n",
1706 " ('for', 'our', 'purposes'): Counter({',': 1}),\n",
1707 " ('for', 'the', 'guess'): Counter({'.': 1}),\n",
1708 " ('for', 'the', 'radicand'): Counter({'(': 1}),\n",
1709 " ('formalize', 'the', 'process'): Counter({'in': 1}),\n",
1710 " ('from', 'the', 'radicand'): Counter({'by': 1}),\n",
1711 " ('get', 'started', '.'): Counter({None: 1}),\n",
1712 " ('good', '-', 'enough'): Counter({'?': 2}),\n",
1713 " ('good', 'enough', \".''\"): Counter({'The': 1}),\n",
1714 " ('good', 'enough', 'for'): Counter({'our': 1}),\n",
1715 " ('good', 'test', '.'): Counter({None: 1}),\n",
1716 " ('guess', '(', 'sqrt'): Counter({'-': 1}),\n",
1717 " ('guess', '(/', 'x'): Counter({'guess': 1}),\n",
1718 " ('guess', ')', 'x'): Counter({'))': 1}),\n",
1719 " ('guess', ')))', 'where'): Counter({'(': 1}),\n",
1720 " ('guess', ':', '('): Counter({'define': 1}),\n",
1721 " ('guess', 'is', 'good'): Counter({'enough': 1}),\n",
1722 " ('guess', 'is', 'improved'): Counter({'by': 1}),\n",
1725 " ')'): Counter({'(': 2, '(<': 1, 'guess': 1, 'x': 1}),\n",
1726 " ('have', 'to', 'say'): Counter({'what': 1}),\n",
1727 " ('here', '0.001', '):'): Counter({'22': 1}),\n",
1728 " ('idea', 'is', 'to'): Counter({'improve': 1}),\n",
1729 " ('if', '(', 'good'): Counter({'-': 1}),\n",
1730 " ('if', 'not', ','): Counter({'we': 1}),\n",
1731 " ('illustration', ',', 'but'): Counter({'it': 1}),\n",
1732 " ('improve', 'guess', 'x'): Counter({')': 2}),\n",
1733 " ('improve', 'the', 'answer'): Counter({'until': 1}),\n",
1734 " ('improved', 'by', 'averaging'): Counter({'it': 1}),\n",
1735 " ('improved', 'guess', '.'): Counter({None: 1}),\n",
1736 " ('in', 'terms', 'of'): Counter({'procedures': 1}),\n",
1737 " ('is', 'close', 'enough'): Counter({'so': 1}),\n",
1738 " ('is', 'good', 'enough'): Counter({'for': 1}),\n",
1739 " ('is', 'improved', 'by'): Counter({'averaging': 1}),\n",
1740 " ('is', 'not', 'really'): Counter({'a': 1}),\n",
1741 " ('is', 'to', 'improve'): Counter({'the': 1}),\n",
1742 " ('it', 'is', 'close'): Counter({'enough': 1}),\n",
1743 " ('it', 'is', 'not'): Counter({'really': 1}),\n",
1744 " ('it', 'with', 'the'): Counter({'quotient': 1}),\n",
1745 " ('iter', '(', 'improve'): Counter({'guess': 1}),\n",
1746 " ('iter', 'guess', 'x'): Counter({')': 1}),\n",
1747 " ('its', 'square', 'differs'): Counter({'from': 1}),\n",
1748 " ('less', 'than', 'a'): Counter({'predetermined': 1}),\n",
1749 " (\"let's\", 'formalize', 'the'): Counter({'process': 1}),\n",
1750 " ('mean', 'by', \"''\"): Counter({'good': 1}),\n",
1751 " ('must', 'repeat', 'the'): Counter({'process': 1}),\n",
1752 " ('need', 'a', 'way'): Counter({'to': 1}),\n",
1753 " ('not', ',', 'we'): Counter({'must': 1}),\n",
1754 " ('not', 'really', 'a'): Counter({'very': 1}),\n",
1755 " ('number', 'whose', 'square'): Counter({'root': 1}),\n",
1756 " ('obtain', 'better', 'and'): Counter({'better': 1}),\n",
1757 " ('of', 'procedures', '.'): Counter({None: 1}),\n",
1758 " ('of', 'the', 'radicand'): Counter({'and': 1}),\n",
1759 " ('old', 'guess', ':'): Counter({'(': 1}),\n",
1760 " ('our', 'purposes', ','): Counter({'we': 1}),\n",
1761 " ('predetermined', 'tolerance', '('): Counter({'here': 1}),\n",
1762 " ('procedure', ':', '('): Counter({'define': 1}),\n",
1763 " ('process', ',', 'we'): Counter({'obtain': 1}),\n",
1764 " ('process', 'in', 'terms'): Counter({'of': 1}),\n",
1765 " ('process', 'with', 'an'): Counter({'improved': 1}),\n",
1766 " ('purposes', ',', 'we'): Counter({'are': 1}),\n",
1767 " ('quotient', 'of', 'the'): Counter({'radicand': 1}),\n",
1768 " ('radicand', '(', 'the'): Counter({'number': 1}),\n",
1769 " ('radicand', 'and', 'the'): Counter({'old': 1}),\n",
1770 " ('radicand', 'by', 'less'): Counter({'than': 1}),\n",
1771 " ('really', 'a', 'very'): Counter({'good': 1}),\n",
1772 " ('repeat', 'the', 'process'): Counter({'with': 1}),\n",
1773 " ('root', 'we', 'are'): Counter({'trying': 1}),\n",
1774 " ('say', 'what', 'we'): Counter({'mean': 1}),\n",
1775 " ('so', 'that', 'its'): Counter({'square': 1}),\n",
1776 " ('sqrt', '-', 'iter'): Counter({'(': 1, 'guess': 1}),\n",
1777 " ('square', 'differs', 'from'): Counter({'the': 1}),\n",
1778 " ('square', 'guess', ')'): Counter({'x': 1}),\n",
1779 " ('square', 'root', '.'): Counter({None: 1}),\n",
1780 " ('square', 'root', 'we'): Counter({'are': 1}),\n",
1781 " ('start', 'with', 'a'): Counter({'value': 1}),\n",
1782 " ('strategy', 'as', 'a'): Counter({'procedure': 1}),\n",
1783 " ('terms', 'of', 'procedures'): Counter({'.': 1}),\n",
1784 " ('than', 'a', 'predetermined'): Counter({'tolerance': 1}),\n",
1785 " ('that', 'its', 'square'): Counter({'differs': 1}),\n",
1786 " ('the', 'answer', 'until'): Counter({'it': 1}),\n",
1787 " ('the', 'guess', '.'): Counter({None: 1}),\n",
1788 " ('the', 'guess', 'is'): Counter({'good': 1}),\n",
1789 " ('the', 'number', 'whose'): Counter({'square': 1}),\n",
1790 " ('the', 'old', 'guess'): Counter({':': 1}),\n",
1791 " ('the', 'process', 'in'): Counter({'terms': 1}),\n",
1792 " ('the', 'process', 'with'): Counter({'an': 1}),\n",
1793 " ('the', 'quotient', 'of'): Counter({'the': 1}),\n",
1794 " ('the', 'radicand', '('): Counter({'the': 1}),\n",
1795 " ('the', 'radicand', 'and'): Counter({'the': 1}),\n",
1796 " ('the', 'radicand', 'by'): Counter({'less': 1}),\n",
1797 " ('the', 'square', 'root'): Counter({'.': 1}),\n",
1798 " ('this', 'basic', 'strategy'): Counter({'as': 1}),\n",
1799 " ('this', 'process', ','): Counter({'we': 1}),\n",
1800 " ('to', 'compute', ')'): Counter({'and': 1}),\n",
1801 " ('to', 'get', 'started'): Counter({'.': 1}),\n",
1802 " ('to', 'improve', 'the'): Counter({'answer': 1}),\n",
1803 " ('to', 'say', 'what'): Counter({'we': 1}),\n",
1804 " ('to', 'the', 'square'): Counter({'root': 1}),\n",
1805 " ('tolerance', '(', 'here'): Counter({'0.001': 1}),\n",
1806 " ('trying', 'to', 'compute'): Counter({')': 1}),\n",
1807 " ('until', 'it', 'is'): Counter({'close': 1}),\n",
1808 " ('value', 'for', 'the'): Counter({'guess': 1, 'radicand': 1}),\n",
1809 " ('very', 'good', 'test'): Counter({'.': 1}),\n",
1810 " ('way', 'to', 'get'): Counter({'started': 1}),\n",
1811 " ('we', 'are', 'done'): Counter({';': 1}),\n",
1812 " ('we', 'are', 'trying'): Counter({'to': 1}),\n",
1813 " ('we', 'mean', 'by'): Counter({\"''\": 1}),\n",
1814 " ('we', 'must', 'repeat'): Counter({'the': 1}),\n",
1815 " ('we', 'need', 'a'): Counter({'way': 1}),\n",
1816 " ('we', 'obtain', 'better'): Counter({'and': 1}),\n",
1817 " ('what', 'we', 'mean'): Counter({'by': 1}),\n",
1818 " ('where', '(', 'define'): Counter({'(': 1}),\n",
1819 " ('whose', 'square', 'root'): Counter({'we': 1}),\n",
1820 " ('will', 'do', 'for'): Counter({'illustration': 1}),\n",
1821 " ('with', 'a', 'value'): Counter({'for': 1}),\n",
1822 " ('with', 'an', 'improved'): Counter({'guess': 1}),\n",
1823 " ('with', 'the', 'quotient'): Counter({'of': 1}),\n",
1824 " ('write', 'this', 'basic'): Counter({'strategy': 1}),\n",
1825 " ('x', ')', '('): Counter({'average': 1, 'if': 1}),\n",
1826 " ('x', ')', '(<'): Counter({'(': 1}),\n",
1827 " ('x', ')', 'guess'): Counter({'(': 1}),\n",
1828 " ('x', ')', 'x'): Counter({')))': 1}),\n",
1829 " ('x', '))', '0.001'): Counter({'))': 1}),\n",
1830 " ('x', ')))', 'A'): Counter({'guess': 1}),\n",
1831 " ('x', 'guess', ')))'): Counter({'where': 1}),\n",
1832 " ('x', 'y', ')'): Counter({'(/': 1, '2': 1}),\n",
1833 " ('y', ')', '(/'): Counter({'(+': 1}),\n",
1834 " ('y', ')', '2'): Counter({'))': 1})}))"
1837 "execution_count": 20,
1839 "output_type": "execute_result"
1843 "find_counts(sentences(tokenise(sample_text)), tuple_size=3)"
1847 "cell_type": "code",
1848 "execution_count": 21,
1856 "('Continuing', 'this', 'process')"
1859 "execution_count": 21,
1861 "output_type": "execute_result"
1865 "s = sentences(tokenise(sample_text))[0]\n",
1870 "cell_type": "code",
1871 "execution_count": 22,
1877 "unaccent_specials = ''.maketrans({\"’\": \"'\", \"’\": \"'\"})\n",
1878 "def unaccent(text):\n",
1879 " \"\"\"Remove all accents from letters.\n",
1880 " It does this by converting the unicode string to decomposed compatability\n",
1881 " form, dropping all the combining accents, then re-encoding the bytes.\n",
1883 " >>> unaccent('hello')\n",
1885 " >>> unaccent('HELLO')\n",
1887 " >>> unaccent('héllo')\n",
1889 " >>> unaccent('héllö')\n",
1891 " >>> unaccent('HÉLLÖ')\n",
1894 " translated_text = text.translate(unaccent_specials)\n",
1895 " return unicodedata.normalize('NFKD', translated_text).\\\n",
1896 " encode('ascii', 'ignore').\\\n",
1901 "cell_type": "code",
1902 "execution_count": 23,
1908 "sicp = unaccent(open('sicp.txt').read())\n",
1909 "sicp_starts, sicp_counts = find_counts(sentences(tokenise(sicp)), tuple_size=3)"
1913 "cell_type": "code",
1914 "execution_count": 24,
1922 "[(('the', 'controller', 'completely'), Counter({'describeof': 1})),\n",
1923 " (('equations', 'imply', 'that'), Counter({'(': 1})),\n",
1924 " (('important', 'point', 'to'), Counter({'note': 1, 'observe': 1})),\n",
1925 " (('separately', 'by', 'each'), Counter({'query': 1})),\n",
1926 " (('to', 'explore', 'variations'), Counter({'of': 1})),\n",
1927 " (('rock', 'songs', '.'), Counter({None: 1})),\n",
1928 " (('software', 'engineers', 'have'), Counter({'the': 1})),\n",
1929 " (('great', 'confusion', ','), Counter({'as': 1})),\n",
1930 " (('increasingly', 'elaborate', 'models'), Counter({'of': 1})),\n",
1931 " (('-', 'lambda1', '))'), Counter({'entry2': 2}))]"
1934 "execution_count": 24,
1936 "output_type": "execute_result"
1940 "list(sicp_counts.items())[:10]"
1944 "cell_type": "code",
1945 "execution_count": 25,
1953 "[(('29', 'There', 'is'), 1),\n",
1954 " (('In', 'such', 'an'), 1),\n",
1955 " (('To', 'answer', 'a'), 1),\n",
1956 " (('Y', '.'), 2),\n",
1957 " (('If', 'f', '('), 1),\n",
1958 " (('This', 'can', 'greatly'), 1),\n",
1959 " (('Design', 'a', 'machine'), 1),\n",
1960 " (('Exercise', '2.8', '.'), 1),\n",
1961 " (('Control', '(', 'how'), 1),\n",
1965 "execution_count": 25,
1967 "output_type": "execute_result"
1971 "list(sicp_starts.items())[:10]"
1975 "cell_type": "code",
1976 "execution_count": 26,
1987 "execution_count": 26,
1989 "output_type": "execute_result"
1993 "list(sicp_counts[('Gas', 'Meters', '.')].elements())"
1997 "cell_type": "code",
1998 "execution_count": 27,
2006 "('The', 'constructor', 'for')"
2009 "execution_count": 27,
2011 "output_type": "execute_result"
2015 "random.choice(list(sicp_starts.elements()))"
2019 "cell_type": "code",
2020 "execution_count": 28,
2031 "execution_count": 28,
2033 "output_type": "execute_result"
2037 "t = ('as', '+')\n",
2042 "cell_type": "code",
2043 "execution_count": 29,
2049 "def markov_item(starts, counts, max_len=None):\n",
2050 " valid_found = False\n",
2051 " while not valid_found:\n",
2053 " current = random.choice(list(starts.elements()))\n",
2054 " chain = list(current)\n",
2055 " next_item = random.choice(list(counts[current].elements()))\n",
2056 " while next_item and ((max_len and i < max_len) or not max_len):\n",
2057 " chain += [next_item]\n",
2058 " current = current[1:] + (next_item, )\n",
2060 " next_item = random.choice(list(counts[current].elements()))\n",
2061 " # print(chain, ':', current, ':', list(counts[current].elements()), ':', next_item)\n",
2062 " if max_len and i < max_len:\n",
2063 " valid_found = True\n",
2064 " if not max_len:\n",
2065 " valid_found = True\n",
2070 "cell_type": "code",
2071 "execution_count": 30,
2079 "'46 Alternatively , multiprocessing computers provide instructions that support atomic operations directly in hardware .'"
2082 "execution_count": 30,
2084 "output_type": "execute_result"
2088 "' '.join(markov_item(sicp_starts, sicp_counts, 500))"
2092 "cell_type": "code",
2093 "execution_count": 31,
2104 "execution_count": 31,
2106 "output_type": "execute_result"
2110 "sicp_counts['the', 'dispatch', 'procedure']"
2114 "cell_type": "code",
2115 "execution_count": 32,
2123 "'Continuing this process , we obtain better and better approximations to the square root .'"
2126 "execution_count": 32,
2128 "output_type": "execute_result"
2132 "' '.join(markov_item(one_s_starts, one_s_counts, 500))"
2136 "cell_type": "code",
2137 "execution_count": 33,
2145 "(defaultdict(collections.Counter,\n",
2146 " {(',', 'we'): Counter({'obtain': 1}),\n",
2147 " ('Continuing', 'this'): Counter({'process': 1}),\n",
2148 " ('and', 'better'): Counter({'approximations': 1}),\n",
2149 " ('approximations', 'to'): Counter({'the': 1}),\n",
2150 " ('better', 'and'): Counter({'better': 1}),\n",
2151 " ('better', 'approximations'): Counter({'to': 1}),\n",
2152 " ('obtain', 'better'): Counter({'and': 1}),\n",
2153 " ('process', ','): Counter({'we': 1}),\n",
2154 " ('root', '.'): Counter({None: 1}),\n",
2155 " ('square', 'root'): Counter({'.': 1}),\n",
2156 " ('the', 'square'): Counter({'root': 1}),\n",
2157 " ('this', 'process'): Counter({',': 1}),\n",
2158 " ('to', 'the'): Counter({'square': 1}),\n",
2159 " ('we', 'obtain'): Counter({'better': 1})}),\n",
2160 " Counter({('Continuing', 'this'): 1}))"
2163 "execution_count": 33,
2165 "output_type": "execute_result"
2169 "one_s_counts, one_s_starts"
2173 "cell_type": "code",
2174 "execution_count": 34,
2180 "def sentence_join(tokens):\n",
2182 " for t in tokens:\n",
2183 " if t[-1] not in \".,:;')-\":\n",
2184 " sentence += ' '\n",
2186 " return sentence.strip()"
2190 "cell_type": "code",
2191 "execution_count": 35,
2199 "'4, we can usually do better by taking advantage of additional structure that may be represented in two almost equivalent ways: and He has written the following two rules, we can find integers not divisible by 7 simply by accessing elements of this stream: ( define input- 1 input- 2 to 1 and allow the values to which they are listed.'"
2202 "execution_count": 35,
2204 "output_type": "execute_result"
2208 "sentence_join(markov_item(sicp_starts, sicp_counts, 500))"
2212 "cell_type": "code",
2213 "execution_count": 36,
2221 "\"3. We model state with local state variables describing the actual object's state. Since ? x is bound in the frame. 61 Interest in logic programming peaked during the early 80s when the Japanese government began an ambitious project aimed at building superfast computers optimized to run logic programming languages. 4.1. We will compile the definition of f and start the machine, and so on, his modified eval will usually check fewer clauses than the original eval before identifying the type of the expression. This makes no difference in the values returned by the call to make- operation- exp- label dest)))) ( lambda ( pair) ( prime ? (+ ( car pair) ( cadr s))) ( set- signal ! input- 1 ( right- branch set)) ( element- of list2))) ( require ( null ? rest) result ( iter ( stream- cdr, and so will work with a system that performs arithmetic operations on complex numbers and ordinary numbers should be the sequence ( enumerate- interval stream- filter examines the stream- car s) ( if ( not ( job ? x ( computer ? type) could be constructed by evaluating the expression ( f ? y) a), and the remaining pairs: 67 Observe that the expression is a definition, so it calls compile- definition to compile code to compute the gcd when the rational numbers are constructed. 1. In order to keep the procedure general, we can print rational numbers by printing the sequence of items in a list and generate the list of words for the required part, thus preserving the illusion that all the possible values of an inexact quantity). The result of adding, subtracting, multiplying, or dividing two intervals is a function only of the widths of the intervals, it is irrelevant what a, b, x, and use this to define gcd- terms a b)))) Using the substitution model cannot do this. In general, however, we can install in our simulation program a meter'' that measures the size of the exponent we can compute n ! using the recursive factorial procedure: 27 (( lambda ( a b c) '( d e f));;; M- Eval input: ( list- union ( list first- reg) ( registers- needed relations, computing in terms of non- strict.\""
2224 "execution_count": 36,
2226 "output_type": "execute_result"
2230 "' '.join(sentence_join(markov_item(sicp_starts, sicp_counts, 500)) for _ in range(10))"
2234 "cell_type": "code",
2235 "execution_count": 37,
2241 "kjb = unaccent(open('king-james-bible.txt').read())\n",
2242 "kjb_starts, kjb_counts = find_counts(sentences(tokenise(kjb)), tuple_size=3)"
2246 "cell_type": "code",
2247 "execution_count": 38,
2255 "'12: 1 Help, LORD; for thy God helpeth thee. 66: 8 O bless our God, and that ye might fear the LORD from this time forth and for evermore. 9: 30 If there be laid on him a scarlet robe. 16: 38 The son of Amzi, the son of Micah, as he hath said, and be dandled upon her knees. 4: 12 And David commanded to gather together the strangers that came out of the land, saying, Because I drew him out of the temple which was in Bethlehem. 3: 24 Then he is gracious, and will give ten tribes to thee: We have such an high priest became us, who knew no sin; that we should die in the pit, and his oath unto Isaac; 105: 15 Saying, Touch not mine anointed, and be astonied one with another what they might do to Jesus. 10: 8 Neither let us commit fornication, as some of them committed, and of the south shall come into the land which I sware unto Abraham, As for Sarai thy wife, and upon the great toe of his right foot, upon the four corners of one base: and the truth shall make you free. 8: 15 We who are Jews by nature, and wert graffed contrary to nature into a good olive tree: how much more do his friends go far from him ? he that formed the earth and the heaven, they go to be with Sarah after the manner of men were they whom ye slew at Tabor ? And they said, Seven. 13: 26 Therefore their inhabitants were of small power, they were thy merchants in all sorts of wine: 10: 2 Thus saith the Lord GOD, I will get me honour upon Pharaoh, and let it be granted to the Jews: for the letter killeth, but the Holy Ghost. 13: 6 Then David put garrisons in Syria of Damascus: and when he came to David to Hebron, so he would also finish in you the same things to you in truth, in judgment, and equity cannot enter.'"
2258 "execution_count": 38,
2260 "output_type": "execute_result"
2264 "' '.join(sentence_join(markov_item(kjb_starts, kjb_counts, 500)) for _ in range(10))"
2268 "cell_type": "code",
2269 "execution_count": 39,
2275 "all_starts = sicp_starts + kjb_starts"
2279 "cell_type": "code",
2280 "execution_count": 40,
2289 "[(('119', ':', '112'), 1),\n",
2290 " (('29', 'There', 'is'), 1),\n",
2291 " (('To', 'answer', 'a'), 1),\n",
2292 " (('Y', '.'), 2),\n",
2293 " (('36', ':', '36'), 3),\n",
2294 " (('Ye', 'shall', 'seek'), 1),\n",
2295 " (('And', 'in', 'like'), 1),\n",
2296 " (('If', 'f', '('), 1),\n",
2297 " (('3', ':', '47'), 1),\n",
2298 " (('27', ':', '24'), 7),\n",
2299 " (('26', ':', '28'), 5),\n",
2300 " (('Control', '(', 'how'), 1),\n",
2301 " (('16', ':', '43'), 3),\n",
2302 " (('They', 'should', 'be'), 1),\n",
2303 " (('139', ':', '9'), 1),\n",
2304 " (('So', 'he', 'drew'), 1),\n",
2305 " (('If', 'the', 'symbol'), 1),\n",
2306 " (('RC', 'should', 'take'), 1),\n",
2307 " (('?', 'type', ')'), 3),\n",
2308 " (('How', 'does', 'the'), 1)]"
2311 "execution_count": 40,
2313 "output_type": "execute_result"
2317 "list(all_starts.items())[:20]"
2321 "cell_type": "code",
2322 "execution_count": 41,
2328 "all_counts = collections.defaultdict(collections.Counter)\n",
2329 "for k in sicp_counts:\n",
2330 " all_counts[k] = sicp_counts[k].copy()\n",
2331 "for k in kjb_counts:\n",
2332 " all_counts[k] += kjb_counts[k].copy()"
2336 "cell_type": "code",
2337 "execution_count": 42,
2345 "\"In becoming an expert programmer, just as our embedded Lisp evaluator uses primitives and control structure from the underlying Scheme system to perform arithmetic with rational numbers. What are these constants ? Similarly, find the ratios of the stack required to compute n ! by specifying that we first multiply 1 by 2, 3, 6, 10, 15,.... Exercise 3.56. Describe what kind of information ( patterns and frames) is included in this history, and how abstraction preserves for us the flexibility to consider alternate implementations. When evaluation is complete, x will be 1, y will be 2, 3 } could be represented as a pair of numbers: the x coordinate and the y coordinate. 43- 112. The timing diagram in figure 3.29, where Peter changes the account balance between the times when Paul accesses the account only very rarely. The painter that draws a line on the screen between two specified points. ( save continue) ( save n); save factorial procedure Figure 5.17: Compilation of the definition of the primitive procedure objects, so long as apply can identify and apply them by using the order of events where balance starts at 100, Peter withdraws 10, Paul withdraws 25, and yet the final value of balance. The entries at ev- application or ev- begin ev- definition- 1)) after- gcd- 2 Figure 5.10: Assigning labels to the continue register, since each level'' of the polynomials can be integers, rational numbers, complex numbers are implemented in terms of n for the total number of leaves of a tree branch- dest breakpoint broken heart bug capturing a free variable car ( primitive procedure) apply- dispatch ( test ( op definition?) ( reg ( reg proc)) ( goto ( label read- eval- print- loop)) ( else ( actual- value rather than eval: ( define ( add- streams ( scale- list integrand dt) int))) The interpreter's ability to deal with both of these can be used as a preparation for work in artificial intelligence. When we consider processes that operate on this representation.\""
2348 "execution_count": 42,
2350 "output_type": "execute_result"
2354 "' '.join(sentence_join(markov_item(sicp_starts, sicp_counts, 500)) for _ in range(10))"
2358 "cell_type": "code",
2359 "execution_count": 43,
2367 "'8: 16 ( For six months did Joab remain there with all Israel, and he shall serve: I have not shewed them. 25: 34 But when the blade was sprung up, it withered away, because they were accursed: neither will I tempt the LORD. 16: 44 Behold, he breaketh down, and the land of thy kindred that is called a brother be a fornicator, or covetous, or an Hebrew woman, be sold unto your enemies for bondmen and bondwomen unto you: ye shall pass before your brethren the children of Israel took Amaziah king of Judah went up to eat and drink before him; and he gave him to wife Asenath the daughter of Saul, that Saul put the people in whose heart are the ways of my people: and he took her, and yet couldest not be satisfied; and thy raiment was of fine gold, amounting to six hundred talents. 32: 6 And Israel said unto him, I know thee by name, hath lifted up his eyes, and when he saw that, behold, I have put off my sackcloth, and girded himself. 28: 9 But the wise took oil in their vessels with their lamps, and took counsel how they might destroy him. And Tobiah sent letters to put me into the dust of your city, which were come again out of the camp, all Israel have transgressed thy law, nor hearkened unto me, even he lifted up his eyes, and look not back: bring my sons from far, their silver and their gold shall be able to redeem it, then it shall be given unto you. 37: 3 Trust in the LORD, that obeyeth the voice of singing men and singing women. 19: 10 Delight is not seemly for a fool: much less do lying lips a prince. 36: 18 Because of the multitude of thy strangers shall be like small dust, and made him look up: and it came to pass the selfsame day the hand of the LORD, that hate thee. 13: 58 And they called for Samson out of the midst of us, and shall rain it upon him while he is near: 55: 11 So that the face of his brother whom he slew at one time.'"
2370 "execution_count": 43,
2372 "output_type": "execute_result"
2376 "' '.join(sentence_join(markov_item(kjb_starts, kjb_counts, 500)) for _ in range(10))"
2380 "cell_type": "code",
2381 "execution_count": 44,
2389 "\"7: 3 And when I rose in the morning as he returned into the host, and went forth before them all, saying, Behold, I have brought him forth abroad, and said, Thy servant Uriah the Hittite: thirty and seven thousand. 135: 8 Who also declared unto us your love in the truth; It is expedient for you, that ye should be guilty. 68: 10 Thy cheeks are comely with rows of jewels, thy neck with chains of gold. 2: 25 And he set up the horn. 19: 14 My kinsfolk have failed, and my people love to have it return 0. 5: 14 And when Eli heard the noise of the taking of Babylon the earth is earthly, and speaketh uprightly; he that toucheth the land, concerning the vessels that remain in this city, and had beaten the graven images into powder, and strawed it upon the altar: these are the kings of Israel ? 16: 10 And I took the little book. 17: 8 Upright men shall be made smooth; 3: 2 And the Lord make you to increase and abound in love one toward another; men with men working that which is sold shall remain in the day when I drink it new with you in weakness, and in all thy coast seven days; and also after that, when they spake unto them, Hearken unto the voice of mirth, and the seats of them that boil, where the body of Christ; that we may put them to shame that hated us. 2: 2 Then said the LORD, and of brass, and carried the people away into Babylon unto Christ are fourteen generations; and thou shalt live. 27: 13 Why dost thou strive against him ? or if thy transgressions be multiplied, and all the curses that are written in the king's dale: for he hath been worth a double hired servant to thee, and thy silver and thy gold is mine; and she shall turn to you again. 18: 43 And the LORD spake unto Moses, saying, Have thou nothing to do with thee, saith the Lord GOD.\""
2392 "execution_count": 44,
2394 "output_type": "execute_result"
2398 "' '.join(sentence_join(markov_item(all_starts, all_counts, 500)) for _ in range(10))"
2402 "cell_type": "code",
2403 "execution_count": 45,
2409 "all2 = unaccent(open('sicp-trimmed.txt').read() + open('king-james-bible.txt').read())\n",
2410 "all2_starts, all2_counts = find_counts(sentences(tokenise(all2)), tuple_size=2)"
2414 "cell_type": "code",
2415 "execution_count": 46,
2424 "['Typical memory systems provide a driver loop.',\n",
2425 " '2: 10 Which doeth great wonders, ye were sealed twelve thousand.',\n",
2426 " \"59: 13 ( 3 4)) ( fib n) ( newline)) We must evaluate (* x y) (/ (+ x 4))) x) ( let (( avpt (/ (+ ( sum term a) ( registers- needed seq1)) ( branch ( label ev- sequence '( proc argl continue)); linkage code machine- model > < value>. Thus, she came trembling, he that ruled throughout the seven seals thereof: it shall be forty and five hundred and ten thousand in breadth.\",\n",
2427 " '9: 22 And the chief captain that he shall do my prophets no harm: 35 And the firstborn, Jehush the second time the LORD: that I visit them, If thou cast down, even since the assembler to store the current value of the sword, and to which denominators.',\n",
2428 " 'And he blessed Joseph, saying, They hated me, Son of man: preserve my life, or a product of the mountain which is escaped ? And the children of Israel went thither a whoring after their tongues, in the dispatch as in a 1954 paper that essentially founded the earth are burned without inhabitant, and it was not, to find the value of a combination operation cross- type information.',\n",
2429 " '35: 14 And that first covenant had also seen the Father hath loved us, and mourn; 61: 8 But there is neither bond nor free: for that the brook Kidron.',\n",
2430 " '22: 18 But he that confirmeth not all of them in the procedure object followed by code to check whether the car pointer of the winepress shall not do any thing as of the congregation of the king had heard that it is symmetrical-- variables are transformed in this case, we will shew who are under the shadow of thy body, yet shall know that the LORD.',\n",
2431 " '1: 16 Wash you, an he lamb without blemish: 29 Then fled Moses at this: primitive expressions such as C.',\n",
2432 " '22: 4: 6 Then shall he appear the sign of a man to his sons that shall vex thee, O Judah, in which my people, that Pharaoh should have sorrow from them that did cleave unto the LORD shall renew their strength, O Media; all that pertained to Saul ? choose you, having never learned ? 7: 1 And the remnant of the fire shall ever be removed, and exhort.',\n",
2433 " '12: 42 For I was an angel come down from the lions ? The most common way to do unto the king said unto the king of Shimron, and slew them at all times, to identify all the army of the house, and cause the horn of oil, saith the LORD said unto him, Nay; but the LORD followed them.',\n",
2434 " '6: 2 And he said unto them; and it was told is true, then that we have students use the second seal, I have decked my bed I sought him, Is Saul also went his way, and the transgression of an hundred talents of gold, and in the way he sees it.',\n",
2436 " '11: 11 If ye have gathered the wind ceased: and David his father: and it was hid three months in Jerusalem.',\n",
2437 " 'Next, the same with a great forsaking in the world with time.',\n",
2438 " '13: 10 Yet was she slain.',\n",
2439 " '18: 30 And Mephibosheth had a long blast with the trumpets, and cast them down into Egypt.',\n",
2440 " 'Thus make- queue, a third type.',\n",
2441 " '( Compare the two patterns (? x c ? x should be apparent that the primitive elements of its arguments, the selectors they call their lands; every one for his mouth, and the candlestick, and filled them with the voice of Israel, to him, and how he had delight in lies: they shall light the hidden wisdom, nor did him honour at his words: and the nail, and on the eighth day; and there be laid in the six hundred men; leave us not love in the face of the Lord, behold, men of Israel; and he shall eat the fruit of the fat of rams, of the air; the family of the prophets, that we have not profited them that they might not lift up thine eyes be open, and teachest him out of thy counsels of the blood upon him.',\n",
2442 " '3: 33 They give drink to every good work.',\n",
2443 " '14: 8 For he that is an everlasting covenant, whom God hath remembered her iniquities.',\n",
2444 " '46: 2 When I brake the bands of their sacrifices, which brought thee out of the nations be blessed.',\n",
2445 " '4: 10 Arise ye, when thou thyself art a God of Abraham, I was an hundred forty and five.',\n",
2446 " '2: 17 And David said, How many hired servants of Saul the son of Israel eat not any that were virgins apparelled.',\n",
2447 " '8: 15 Every raven after his servant with the edge of the altar round about Gibeah.',\n",
2448 " '32: 31 Behold, thou hast made void the counsel of peace, without changing the thunk once the longsuffering of our God.',\n",
2449 " '2: 21 Have pity upon the earth; and he had commanded him, saying, So is he which baptizeth with the notion of a variable, we will change make- instruction- sequences is thus the empty frame, [ 2 ] message- passing techniques developed in conjunction with higher- order evaluation applicative order as a branch, and begat sons and their inheritance be given to thy fathers hath given me knowledge of him.',\n",
2450 " '8: 10 And Judah saw his sons.',\n",
2451 " 'Proof of correctness of the priests praised the LORD.',\n",
2452 " '71: 19 I know thy works.',\n",
2453 " '12: 44 And Shema begat Raham, the son of Josedech, the dart, nor make any manner of sickness and all the people that they should believe on him, Let her alone: if so be that they were come from the face of the nations of the going up to the Huffman tree of figure 5.12 and examine the state of that value leads to the LORD for evermore, and in the midst of Israel numbered, and ointments, and twelve oxen, that they should be the Son, go forth as a tree non- strict nondeterminism, we can tell whether the bindings in the evaluator machine, and followed the LORD sent an angel standing in the house of feasting and joy; he hath taken increase: but I obtained mercy; that they without us: for thou art good in the midst of the expression ( and ( not (= ( remainder ( square x) Figure 3.12: Lists x: (( a b) ( first- class elements in language design who were fifty and six.']"
2456 "execution_count": 46,
2458 "output_type": "execute_result"
2462 "[sentence_join(markov_item(all2_starts, all2_counts, 500)) for _ in range(30)]"
2466 "cell_type": "code",
2467 "execution_count": 47,
2473 "sicp_lovecraft = unaccent(open('sicp-trimmed.txt').read() + open('lovecraft.txt').read())\n",
2474 "sl2_starts, sl2_counts = find_counts(sentences(tokenise(sicp_lovecraft)), tuple_size=2)"
2478 "cell_type": "code",
2479 "execution_count": 48,
2487 "'But on the moon shone down cold through the unseen tumbler meant a danger not to be increasing in vividness and darkened with dread of opening it or descend the wide appearance of this treatment of not and lisp- value rather than practical examples in this decrepit edifice. There were gods and the receiver, and shuddered. Bothersome forms, and the hellish image; but it is worth correcting. Three coffin- shaped man with Oriental eyes has said that Aspinwall had died of it. With the extra lens I could not have written the following procedures. The telepathic messages had not yet sufficiently trained to do with queer oils as Marceline had always done. The inlaid doors and the pc: ( define ( analyze- quoted exp) ( let (( x 3- 10 I have ever shared. Example: Arithmetic Operations The task seemed known to me in this farther void of fear and triumph seemed to evoke. Only after such a loathsome cost, and the awful concept of a branch instruction at the ends of the equator had been there and engulfed all the efforts of sturdy Colonial tenants and dewy rose- wreathed world of somnolent cerebration. Sir Wade would speak of our physical creation.'"
2490 "execution_count": 48,
2492 "output_type": "execute_result"
2496 "\" \".join(sentence_join(markov_item(sl2_starts, sl2_counts, 500)) for _ in range(10))"
2500 "cell_type": "code",
2501 "execution_count": 49,
2509 "<p>\" I buried myself in a fearful daze out into the grounds, and especially down cellar, and from what I went with them gold- green stone idol found. We had all been rather jovial, and a general alarm. We will also modify the environment as context for evaluation of the creatures to invade a lethal stupor which wards off madness by dulling the memory of those books wish a word or a 1) (* x (+ x 2))) produces the average citizen. The names of Akeley and play, and produces a painter; therefore, is called. There are, which one might spy through the remaining stretch of road, and as she had said in a scientific purpose, so that its cdr is the empty stream or a labyrinth of inexplicably fashioned metal under a certain transcribed witch- woman- her name in life imagined, the sleeping plain. To form even a sign of man's world and perhaps sinister history, philosophy, and was placed on exhibition early in the water change- detector sense- data and primitive mammals, and the like. His walks were late ( as that of the forbidden ? The rifling of Ezra Weeden, who had come to recognize the will and buried to the open sea some were incised and wholly at the hospital. Trying the match is basically the same way as for the tomb of man and his hints occasionally became concrete. Curwen's sailors would then pose as a free hand and radiating out in the neighbourhood noted. He had known Al always, were freely spoken of as two separate problems: what'' to a tremendous effect on me, and even the myriad towering stories had fallen through, revealing a wide range.</h1>"
2512 "<IPython.core.display.HTML object>"
2516 "output_type": "display_data"
2520 "display(HTML('<p>' + \n",
2521 " \" \".join(sentence_join(markov_item(sl2_starts, sl2_counts, 500)) for _ in range(10)) + \n",
2526 "cell_type": "code",
2527 "execution_count": 57,
2539 "execution_count": 57,
2541 "output_type": "execute_result"
2545 "sum(sicp_starts.values()), sum(sum(c.values()) for c in sicp_counts.values())"
2549 "cell_type": "code",
2550 "execution_count": 58,
2562 "execution_count": 58,
2564 "output_type": "execute_result"
2568 "sum(kjb_starts.values()), sum(sum(c.values()) for c in kjb_counts.values())"
2572 "cell_type": "code",
2573 "execution_count": 91,
2585 "execution_count": 91,
2587 "output_type": "execute_result"
2591 "lovecraft = unaccent(open('lovecraft-trimmed.txt').read())\n",
2592 "lovecraft_starts, lovecraft_counts = find_counts(sentences(tokenise(lovecraft)), tuple_size=2)\n",
2593 "sum(lovecraft_starts.values()), sum(sum(c.values()) for c in lovecraft_counts.values())"
2597 "cell_type": "code",
2598 "execution_count": 92,
2609 "execution_count": 92,
2611 "output_type": "execute_result"
2615 "sum(kjb_starts.values()) / sum(sicp_starts.values())"
2619 "cell_type": "code",
2620 "execution_count": 93,
2628 "3.8448464032356435"
2631 "execution_count": 93,
2633 "output_type": "execute_result"
2637 "sum(sum(c.values()) for c in kjb_counts.values()) / sum(sum(c.values()) for c in sicp_counts.values())"
2641 "cell_type": "code",
2642 "execution_count": 94,
2650 "(3.0035465329582975, 2.7443625012037365)"
2653 "execution_count": 94,
2655 "output_type": "execute_result"
2659 "sum(lovecraft_starts.values()) / sum(sicp_starts.values()), \\\n",
2660 "sum(sum(c.values()) for c in lovecraft_counts.values()) / sum(sum(c.values()) for c in sicp_counts.values())"
2664 "cell_type": "code",
2665 "execution_count": 95,
2671 "def scale_merge(left_starts, left_start_scale, left_counts, left_count_scale, \n",
2672 " right_starts, right_start_scale, right_counts, right_count_scale):\n",
2673 " starts = collections.Counter()\n",
2674 " counts = collections.defaultdict(collections.Counter)\n",
2676 " for k, n in left_starts.items():\n",
2677 " starts[k] = n * left_start_scale\n",
2678 " for k, n in right_starts.items():\n",
2679 " starts[k] += n * right_start_scale\n",
2681 " for k in left_counts:\n",
2682 " for j in left_counts[k]:\n",
2683 " counts[k][j] = left_counts[k][j] * left_count_scale\n",
2685 " for k in right_counts:\n",
2686 " for j in right_counts[k]:\n",
2687 " counts[k][j] = right_counts[k][j] * right_count_scale\n",
2689 " return starts, counts"
2693 "cell_type": "code",
2694 "execution_count": 96,
2700 "sk_starts, sk_counts = scale_merge(sicp_starts, 3, sicp_counts, 4, kjb_starts, 1, kjb_counts, 1)"
2704 "cell_type": "code",
2705 "execution_count": 97,
2713 "<p>The voltage response v of the circuit ( summarized by v C, the Lisp evaluator would be to process the query ( and ( supervisor ? x ? middle- manager in the wheel rule of section 4.4.</p><p>3: 11 Therefore thy gates shall be burned therein.</p><p>36: 3 And say to the forest of the south shall be strong, and eat bread.</p><p>The servants said unto him, My LORD, if thou go with us; and he gave him, and saith unto them, ready to depart on the morrow, which was set over the affairs of this life, and out of the hand that wrote.</p><p>5: 6 And the sword shall abide on his cities, and with an extreme burning, and the vintage shall reach unto Azal: yea, though many false witnesses came, yet found they none.</p><p>He adds all the weekly meetings of the firm to the Microshaft data base by expressions of the query system repeatedly reads input expressions.</p><p>Specifically: The evaluator enables us to increase the modularity of our systems by encapsulating, or hiding,'' parts of the earth, that the LORD cast out before the LORD, as the LORD commanded to give unto her the cup of the Lord Jesus Christ, was in number three hundred thousand choice men, able to deliver you from his iniquities.</p><p>Cy agrees that Ben is right about the behavior of a quantity x as a function of n, to be applied in the same way as in the night visions, and your goodliest young men, and they slew all the males from a month old and upward, from the east side unto the west side, a portion for Asher.</p><p>13: 1 And the LORD said, Bring the portion which I gave thee, of the children of Israel before their idols, and all that is in use, existing programs that define procedures with these names bound as local variables.</p><p>For example, the complex number z = x + iy ( where i 2 =- 1) can be expressed as sequence operations.</p>"
2716 "<IPython.core.display.HTML object>"
2720 "output_type": "display_data"
2724 "display(HTML(cat('<p>' + sentence_join(markov_item(sk_starts, sk_counts, 500)) + '</p>' for _ in range(10))))"
2728 "cell_type": "code",
2729 "execution_count": 98,
2735 "sl_starts, sl_counts = scale_merge(sicp_starts, 3, sicp_counts, 2, lovecraft_starts, 1, lovecraft_counts, 1)"
2739 "cell_type": "code",
2740 "execution_count": 99,
2748 "<p>Akeley had been a nightmare of buzzing voices, and a partial relief from the second signal ordering a general plan was to see him.</p><p>From the handwriting ? Do you wonder how many farmhouses burnt to ashes.</p><p>1 that the interpreter runs, it follows a process that must be made to a system in which complex numbers are naturally represented as ordered pairs.</p><p>Then the GCD is the other argument for * ( assign proc ( op ( opcompiled- procedure- entry) ( let (( segments ( segments agenda) ( cdr z)) ( append (( save, first- reg) ( modifies- register ? modularity, [ 2 ] unify- match query- pattern frame) ( let (( t1 -> t2 ( apply- generic op ( t1 -> t2 ( get- register- contents < machine- model > < register- name > ( op vector- set!) ( reg new- cdrs) ( reg env));; begin actual procedure body ( save continue) ( goto ( reg val)) Now we can try our rational- number operations in terms of abstract selectors and constructors for this notation such that our derivative program still works ? 2.3.</p><p>And yet it was, or that those horrible cylinders and machines- and the desolate salt marshes, desolate and unpeopled, chaos was complete long before I die I should be as it shines on certain others- even a perfect solution, because of a long and familiar doom.</p><p>He defines the following two rules: For any list y, the empty list, then the smaller number in the sequence.</p><p>Of all its curious influence call up the sixty- three at the cryptic parchment; but upon examining the bank as if to accentuate by their fellow- men.</p><p>When he read this, but kept it in the hideous culmination of events that depopulated the whole scene of such data as my torch could not doubt the power of its unfamiliar temporary form, was of little quaint fishing towns that climbed from the Rowley road drew so close to the fourth floor, and likewise any metal case- resulted in a vast Italian quarter, and a feeling that some of our camel drivers older than Memphis and mankind.</p><p>\" Ye see all too close to the sight.</p><p>In the roseal dawn the burghers of Milwaukee rose to panic.</p>"
2751 "<IPython.core.display.HTML object>"
2755 "output_type": "display_data"
2759 "display(HTML(cat('<p>' + sentence_join(markov_item(sl_starts, sl_counts, 500)) + '</p>' for _ in range(10))))"
2763 "cell_type": "code",
2764 "execution_count": 100,
2770 "lk_starts, lk_counts = scale_merge(lovecraft_starts, 1, lovecraft_counts, 1, kjb_starts, 1, kjb_counts, 1)"
2774 "cell_type": "code",
2775 "execution_count": 101,
2783 "<p>I say harass, because they have when they tore open the massive pre- Revolutionary homes with their nails, so I think almost hope that no man has yet dared not seem to have the ether- resisting wings characteristic of him, and many things.</p><p>2: 31 And he said unto him, Caesar's.</p><p>33: 9 Nevertheless the priests of the high places of Baal, which are called might receive the fruits of your ground; neither shall thy tears run down like a river, and every tree therein: for then should ye go after vain things, which thou hast redeemed.</p><p>He could scarcely decipher what they portrayed, and almost ghastly results, since it could be done.</p><p>27: 12 These shall stand upon the mount of Olives, then sent Jesus two disciples, 21: 6 And Ezra blessed the LORD God, even the porch of the house of the LORD was with Jehoshaphat, because he had heard therefore that he was Rebekah's son: and I will remove far off from my presence: 23: 11 And they found written in the law.</p><p>Was he just come up.</p><p>Lanterns that shudder and death are penned.</p><p>But this was a cross of new developments in those fields where the west window, and with haste To get this impetus, though to my flagging quest; for thousands and tens of thousands of light which would warn the waiting horse gave a thrill that a small man probably having a kind of a chaotic pronunciation.</p><p>Beneath him dozens of queer things I had not traversed before; and though progress was very close indeed.</p><p>52: 23 And they were exceeding many: neither was the word of the LORD came again unto Jerusalem and Judah, Hanani, Eliathah, Giddalti, and Romamtiezer, Joshbekashah, Mallothi, Hothir, and Mahazioth: 25: 27 Over against the border were at the north bay of the salt sea: this shall not be ashamed of Chemosh, as the manner of all the tribes of the children of Ammon said to Hanun, Thinkest thou that David doth honour thy father, that he may die: because she hath not sinned.</p>"
2786 "<IPython.core.display.HTML object>"
2790 "output_type": "display_data"
2794 "display(HTML(cat('<p>' + sentence_join(markov_item(lk_starts, lk_counts, 500)) + '</p>' for _ in range(10))))"
2798 "cell_type": "code",
2799 "execution_count": null,
2809 "display_name": "Python 3",
2810 "language": "python",
2814 "codemirror_mode": {
2818 "file_extension": ".py",
2819 "mimetype": "text/x-python",
2821 "nbconvert_exporter": "python",
2822 "pygments_lexer": "ipython3",
projects / name-generation.git / blob