sforman
/
Thun
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Thun/docs/notebooks/BigInts.ipynb

3114 lines
61 KiB
Plaintext
Raw Blame History

{
"cells": [
{
"cell_type": "code",
"execution_count": 1,
"id": "73967878",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": []
}
],
"source": [
"[all true swap [&] step] inscribe\n",
"[any false swap [|] step] inscribe"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "b34d58ef",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": []
}
],
"source": [
"[base 2147483648] inscribe"
]
},
{
"cell_type": "markdown",
"id": "9749000b",
"metadata": {},
"source": [
"Model bigints as a pair of Boolean for the sign and a list of integers for the digits, to keep things simple let the bool be the first item on a list followed by zero or more int digits. The digits shall be confined to the range zero to `pow(2, 31) - 1`\n",
"\n",
"Another way to say that is that our numbers are in base `2147483648` and our \"nine\" is `2147483647` (`0b1111111111111111111111111111111`, 31 ones.)\n",
"\n",
"This lets us use (Oberon RISC) 32-bit signed ints to store our digits."
]
},
{
"cell_type": "markdown",
"id": "956c8ee2",
"metadata": {},
"source": [
"## Take Two\n",
"\n",
"This really got away from me the first time. I think the big mistake ai made was including the middle branch in the recursive branch.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "afe33f94",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "03a44beb",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "9947b864",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "e91b6e37",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "8e7d4379",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "211669e7",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "d7ee0e4a",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "c9f34050",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "9d5972c4",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "cd6dc2e4",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "0beeac21",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "ccc32d74",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "7d2c5b56",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "83cbf474",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "be9be8d9",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "4c7df3f0",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "88f27acd",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "960edfef",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "2b3cad6c",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "7c613941",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "991f0d25",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "c3221039",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "ff5ab28c",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "58a46766",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "f488664c",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "5eefa527",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "d1f695de",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "22e5236c",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "5e069159",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "8e2fc444",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "025672cb",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "3359c82f",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "011563c0",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "f0e5eb9a",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "cb5a858d",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "936ef79c",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "e8a8bbe9",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "80672bab",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "aa635304",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "eba35315",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "14e8ca33",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": 3,
"id": "35476eac",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": []
}
],
"source": [
"[valid_digit [0 >] [base <] &&] inscribe"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "02a48806",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"32 true 1232147483648 false"
]
}
],
"source": [
"clear\n",
"32 valid_digit 1232147483648 valid_digit"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "1d276daf",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"true"
]
}
],
"source": [
"clear\n",
"[true 3 2 1]\n",
"rest [valid_digit] map all"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "2454e662",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[true 3 2 1]"
]
}
],
"source": [
"clear\n",
"[true 3 2 1]"
]
},
{
"cell_type": "markdown",
"id": "bfed1f25",
"metadata": {},
"source": [
"Because we are working with Python Joy right now we can convert ints to bigints.\n",
"\n",
"To get the sign bool we can just use `!-` (\"not negative\")"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "8a60b54b",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"true false"
]
}
],
"source": [
"clear\n",
"23 !- -23 !-"
]
},
{
"cell_type": "markdown",
"id": "73bfa634",
"metadata": {},
"source": [
"To get the list of digits...\n",
"\n",
"```\n",
" @staticmethod\n",
" def digitize(n):\n",
" if n < 0:\n",
" raise ValueError(f'Non-negative only: {n}')\n",
" while n:\n",
" n, digit = divmod(n, 2**31)\n",
" yield OberonInt(digit)\n",
"\n",
"```\n",
"\n",
" [0 >=] [base divmod swap] while"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "3fc98ccd",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1797196498 5748904729"
]
}
],
"source": [
"clear\n",
"\n",
"12345678901234567890 base divmod swap"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "b838c4cb",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1797196498 1453937433 2"
]
}
],
"source": [
"base divmod swap"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "4d9d926a",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": 10,
"id": "faaac9d6",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1312754386 1501085485 57659106 105448366 58"
]
}
],
"source": [
"clear\n",
"\n",
"1234567890123456789012345678901234567890\n",
" [0 >] [base divmod swap] while pop"
]
},
{
"cell_type": "code",
"execution_count": 11,
"id": "2a613f36",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[58 105448366 57659106 1501085485 1312754386]"
]
}
],
"source": [
"clear\n",
"\n",
"[1234567890123456789012345678901234567890]\n",
" [ [0 >] [base divmod swap] while pop ]\n",
" infra"
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "e97b149d",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1234567890123456789012345678901234567890 [0 <=] [pop []] [base divmod swap] [i cons]"
]
}
],
"source": [
"clear\n",
"\n",
"1234567890123456789012345678901234567890\n",
" [0 <=] [pop []] [base divmod swap] [i cons]"
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "de4fe588",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1312754386 1501085485 57659106 105448366 58]"
]
}
],
"source": [
"genrec"
]
},
{
"cell_type": "code",
"execution_count": 14,
"id": "67bb934b",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[]"
]
}
],
"source": [
"clear\n",
"\n",
"0 [0 <=] [pop []] [base divmod swap] [i cons] genrec"
]
},
{
"cell_type": "code",
"execution_count": 15,
"id": "e4c66f15",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": []
}
],
"source": [
"clear\n",
"\n",
"[digitalize [0 <=] [pop []] [base divmod swap] [i cons] genrec] inscribe"
]
},
{
"cell_type": "code",
"execution_count": 16,
"id": "b6f77ac6",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1312754386 1501085485 57659106 105448366 58]"
]
}
],
"source": [
"clear\n",
"\n",
"1234567890123456789012345678901234567890 digitalize"
]
},
{
"cell_type": "markdown",
"id": "1bf8ba9e",
"metadata": {},
"source": [
"So `!-` for the sign and `abs digitalize` for the digits, followed by `cons`:"
]
},
{
"cell_type": "code",
"execution_count": 17,
"id": "246c2a58",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[true 1312754386 1501085485 57659106 105448366 58]"
]
}
],
"source": [
"clear\n",
"\n",
"1234567890123456789012345678901234567890 [!-] [abs digitalize] cleave cons"
]
},
{
"cell_type": "code",
"execution_count": 18,
"id": "5a72ce30",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[true 1312754386 1501085485 57659106 105448366 58]"
]
}
],
"source": [
"[to_bigint [!-] [abs digitalize] cleave cons] inscribe"
]
},
{
"cell_type": "code",
"execution_count": 19,
"id": "59514dcd",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[true 1312754386 1501085485 57659106 105448366 58]"
]
}
],
"source": [
"clear\n",
"\n",
"1234567890123456789012345678901234567890 to_bigint"
]
},
{
"cell_type": "code",
"execution_count": 20,
"id": "f3c19364",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[false 1312754386 1501085485 57659106 105448366 58]"
]
}
],
"source": [
"clear\n",
"\n",
"-1234567890123456789012345678901234567890 to_bigint"
]
},
{
"cell_type": "markdown",
"id": "4dbd0f30",
"metadata": {},
"source": [
"## Addition of Like Signs\n",
"\n",
"I think we're going to want a recursive function (duh!?) but it's not quite a standard *hylomorphism* for (at least) two reasons:\n",
"\n",
"- We're tearing down two lists simultaneously.\n",
"- They might not be the same length.\n",
"\n",
"The base case would be two empty lists. In that case the result is determined by the `carry` bit, (Should zero be represented by the empty list `[]`, by `[0]`, or by both?) zero or one.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 21,
"id": "dd25bb96",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"false"
]
}
],
"source": [
"clear\n",
"\n",
"[] bool"
]
},
{
"cell_type": "code",
"execution_count": 22,
"id": "c9bdd641",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"true"
]
}
],
"source": [
"clear\n",
"\n",
"[] [] [bool not] ii &"
]
},
{
"cell_type": "markdown",
"id": "50665e75",
"metadata": {},
"source": [
"### Predicate\n",
"so the predicate for the whole thing would be"
]
},
{
"cell_type": "code",
"execution_count": 121,
"id": "187aa6ec",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": []
}
],
"source": [
"clear\n",
"\n",
"[_add_p [bool not] ii &] inscribe"
]
},
{
"cell_type": "code",
"execution_count": 123,
"id": "ee3d2316",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"true"
]
}
],
"source": [
"clear\n",
"\n",
"[][]_add_p"
]
},
{
"cell_type": "code",
"execution_count": 124,
"id": "7e8c4942",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"false"
]
}
],
"source": [
"clear\n",
"\n",
"[1][]_add_p"
]
},
{
"cell_type": "code",
"execution_count": 125,
"id": "8b41766c",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"false"
]
}
],
"source": [
"clear\n",
"\n",
"[][1]_add_p"
]
},
{
"cell_type": "code",
"execution_count": 126,
"id": "1bacc617",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"false"
]
}
],
"source": [
"clear\n",
"\n",
"[1][1]_add_p"
]
},
{
"cell_type": "markdown",
"id": "abe20e0b",
"metadata": {},
"source": [
"### Base Case\n",
"In the base case we discard one list and check the carry to determine our result as decribed above:"
]
},
{
"cell_type": "code",
"execution_count": 127,
"id": "5e5ddf74",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1]"
]
}
],
"source": [
"clear\n",
"\n",
"true [] [] pop swap [] [1 swons] branch"
]
},
{
"cell_type": "code",
"execution_count": 128,
"id": "c57d1fb2",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[]"
]
}
],
"source": [
"clear\n",
"\n",
"false [] [] pop swap [] [1 swons] branch"
]
},
{
"cell_type": "code",
"execution_count": 129,
"id": "59b1338c",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": []
}
],
"source": [
"clear"
]
},
{
"cell_type": "code",
"execution_count": 31,
"id": "ed38fdb1",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": []
}
],
"source": [
"[_add_then pop swap [] [1 swons] branch] inscribe"
]
},
{
"cell_type": "markdown",
"id": "978b5cac",
"metadata": {},
"source": [
"### Recursive Branch\n",
"So (ignoring the source of the initial carry bit for now) we have:\n",
"\n",
" _add_p == [bool not] ii &\n",
" _add_then == pop swap [] [1 swons] branch\n",
"\n",
" add_digits == [_add_p] [_add_then] [R0] [R1] genrec\n",
"\n",
"What should the recursive branch do?\n",
"\n",
"It will be some `ifte` expression:\n",
"\n",
" R0 [add_digits] R1 == [P] [THEN] [ELSE] ifte\n",
"\n",
"Ideally, we can arrange to neatly bracket the `[add_digits]` quote, but otherwise we can build up the `ifte` quotes in the usual way with `cons` and `concat`."
]
},
{
"cell_type": "markdown",
"id": "7246fe3d",
"metadata": {},
"source": [
"#### Is One List Empty?\n",
"The context will be a Boolean carry bit and two lists, one of which (but not both!) may be empty.\n",
"\n",
" carry [a ...] [b ...] R0 [add_digits] R1\n",
"\n",
" carry [] [b ...] R0 [add_digits] R1\n",
"\n",
" carry [a ...] [] R0 [add_digits] R1\n",
"\n",
"So I think the first thing to do is detect and handle the (possibly) empty lists?"
]
},
{
"cell_type": "markdown",
"id": "d54e0860",
"metadata": {},
"source": [
"#### predicate"
]
},
{
"cell_type": "code",
"execution_count": 92,
"id": "728f7b72",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"true"
]
}
],
"source": [
"clear\n",
"\n",
"[1] [1] [bool] ii &"
]
},
{
"cell_type": "code",
"execution_count": 93,
"id": "3561502a",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"false"
]
}
],
"source": [
"clear\n",
"\n",
"[1] [] [bool] ii &"
]
},
{
"cell_type": "code",
"execution_count": 94,
"id": "2c395fcc",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"false"
]
}
],
"source": [
"clear\n",
"\n",
"[] [1] [bool] ii &"
]
},
{
"cell_type": "markdown",
"id": "13993d1f",
"metadata": {},
"source": [
"So our `ifte` predicate is `[bool] ii &`, what's the rest look like?\n",
"\n",
" [[bool] ii &] ... [add_digits] ... ifte\n",
"\n",
"We will need `add_digits` on the `true` branch to deal with the rest of the lists, but not (I think) on the false branch?\n",
"\n",
" [[bool] ii &] [... [add_digits] ...] [ELSE] ifte"
]
},
{
"cell_type": "code",
"execution_count": 130,
"id": "9caf15b4",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": []
}
],
"source": [
"[_add_rec_pred [bool] ii &] inscribe"
]
},
{
"cell_type": "markdown",
"id": "2adf3f59",
"metadata": {},
"source": [
"#### `true` branch\n",
"Let's square away the `true` branch first.\n",
"\n",
" carry [a ...] [b ...] ... [add_digits] ...\n",
"\n",
"First we will want to `uncons` the digits"
]
},
{
"cell_type": "code",
"execution_count": 95,
"id": "1e53236f",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"false 1 4 [2 3] [5 6]"
]
}
],
"source": [
"clear\n",
"\n",
"false [1 2 3] [4 5 6] [uncons] ii swapd"
]
},
{
"cell_type": "markdown",
"id": "8d66b26b",
"metadata": {},
"source": [
"#### add-with-carry\n",
"So now we want some function `F` to `dipd` below the list tails that accepts a bool and two ints and leaves behind a new int and a new Boolean carry flag:\n",
"\n",
" carry0 a b F\n",
" --------------------------\n",
" (a+b+carry0) carry\n",
"\n",
"(I find it interesting that this function accepts the carry from below the int args but returns it above the result. Hmm...)"
]
},
{
"cell_type": "code",
"execution_count": 96,
"id": "2f70ca25",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0 1"
]
}
],
"source": [
"clear\n",
"\n",
"[bool_to_int [0] [1] branch] inscribe\n",
"\n",
"false bool_to_int\n",
"true bool_to_int"
]
},
{
"cell_type": "code",
"execution_count": 97,
"id": "c19916c5",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"3"
]
}
],
"source": [
"clear\n",
"\n",
"false 1 2 [bool_to_int] dipd + +"
]
},
{
"cell_type": "code",
"execution_count": 98,
"id": "ead4cc5e",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"4"
]
}
],
"source": [
"clear\n",
"\n",
"true 1 2 [bool_to_int] dipd + +"
]
},
{
"cell_type": "markdown",
"id": "ddb201ca",
"metadata": {},
"source": [
"So the first part of `F` is `[bool_to_int] dipd + +` to get the total, then we need to"
]
},
{
"cell_type": "code",
"execution_count": 99,
"id": "129997e0",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"4"
]
}
],
"source": [
"base mod"
]
},
{
"cell_type": "code",
"execution_count": 100,
"id": "22209a15",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"false"
]
}
],
"source": [
"base >="
]
},
{
"cell_type": "code",
"execution_count": 101,
"id": "57649cf3",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"4 false"
]
}
],
"source": [
"clear\n",
"\n",
"4 base [mod] [>=] clop"
]
},
{
"cell_type": "code",
"execution_count": 102,
"id": "3c2e42be",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"100 true"
]
}
],
"source": [
"clear\n",
"\n",
"base 100 +\n",
"\n",
"base [mod] [>=] clop"
]
},
{
"cell_type": "markdown",
"id": "893a39c4",
"metadata": {},
"source": [
"\n",
" F == [bool_to_int] dipd + + base [mod] [>=] clop\n"
]
},
{
"cell_type": "code",
"execution_count": 103,
"id": "257d757c",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": []
}
],
"source": [
"clear\n",
"[_add-with-carry0 [bool_to_int] dipd + +] inscribe\n",
"[_add-with-carry1 base [mod] [>=] clop] inscribe\n",
"[add-with-carry _add-with-carry0 _add-with-carry1] inscribe"
]
},
{
"cell_type": "code",
"execution_count": 104,
"id": "1d50a1c6",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"100 true"
]
}
],
"source": [
"clear\n",
"\n",
"false base 100 add-with-carry"
]
},
{
"cell_type": "code",
"execution_count": 105,
"id": "b93ae376",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"101 true"
]
}
],
"source": [
"clear\n",
"\n",
"true base 100 add-with-carry"
]
},
{
"cell_type": "code",
"execution_count": 106,
"id": "4f86c2c7",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"102 false"
]
}
],
"source": [
"clear\n",
"\n",
"false 2 100 add-with-carry"
]
},
{
"cell_type": "code",
"execution_count": 107,
"id": "68a8a9c2",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"103 false"
]
}
],
"source": [
"clear\n",
"\n",
"true 2 100 add-with-carry"
]
},
{
"cell_type": "markdown",
"id": "e9a512f0",
"metadata": {},
"source": [
"Going back to our `true` branch we have:"
]
},
{
"cell_type": "code",
"execution_count": 108,
"id": "74873f5b",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"false 1 4 [2 3] [5 6]"
]
}
],
"source": [
"clear\n",
"\n",
"false [1 2 3] [4 5 6] [uncons] ii swapd"
]
},
{
"cell_type": "markdown",
"id": "5520db54",
"metadata": {},
"source": [
"#### `uncons-two`\n",
"We could call this `uncons-two`:"
]
},
{
"cell_type": "code",
"execution_count": 116,
"id": "e7176ea9",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1 4 [2 3] [5 6]"
]
}
],
"source": [
"clear\n",
"\n",
"[uncons-two [uncons] ii swapd] inscribe\n",
"\n",
"[1 2 3] [4 5 6] uncons-two"
]
},
{
"cell_type": "code",
"execution_count": 117,
"id": "64b575f7",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": []
}
],
"source": [
"clear"
]
},
{
"cell_type": "markdown",
"id": "9445eb3c",
"metadata": {},
"source": [
"Plugging in `add-with-carry` we get:"
]
},
{
"cell_type": "code",
"execution_count": 118,
"id": "7e745018",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"5 false [2 3] [5 6]"
]
}
],
"source": [
"clear\n",
"\n",
"false [1 2 3] [4 5 6] uncons-two [add-with-carry] dipd"
]
},
{
"cell_type": "markdown",
"id": "121ff3c0",
"metadata": {},
"source": [
"### Recur\n",
"\n",
"It is at this point that we would recur:\n",
"\n",
" 5 false [2 3] [5 6] [add_digits] i ...\n",
" ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ \n",
"\n",
"This part runs and becomes some list (possibly empty) of result digits (the base case consumes the carry flag and one list):\n",
"\n",
" 5 [7 9]\n",
"\n",
"So our conclusion must be `cons`:\n",
"\n",
" 5 [7 9] cons\n",
" [5 7 9]\n",
"\n",
"And our whole branch function is:\n",
"\n",
" THEN == uncons-two [add-with-carry] dipd [add_digits] i cons\n",
"\n",
" [_add_rec_pred] [THEN] [ELSE] ifte\n",
"\n",
"It's a little tricky having that recursive call being nested like that:\n",
"\n",
" THEN0.1 == [add-with-carry] dipd\n",
" THEN0 == uncons-two THEN0.1\n",
" THEN1 == i cons\n",
"\n",
" [_add_rec_pred] [THEN0 [add_digits] THEN1] [ELSE] ifte\n",
"\n",
"But we can make it work."
]
},
{
"cell_type": "markdown",
"id": "cd576704",
"metadata": {},
"source": [
"#### Interlude: Nested or Unnested?\n",
"\n",
" F == [P] [THEN] [R0] [R1] genrec\n",
" F == [P] [THEN] [R0 [F] R1] ifte\n",
"\n",
"Our recursive branch will take the form of an `ifte` expression that incorporates the function `[F]` into one of its branches:\n",
"\n",
" F == [P] [THEN] [[P0] [THEN0 [F] THEN1] [ELSE] ifte] ifte\n",
"\n",
" F == [P] [THEN] [[P0] [THEN0]] [F] [[THEN1] cons concat [ELSE] ifte] ifte\n",
"\n",
"\n",
"\n",
" [P0] [THEN0] [F] [THEN1] cons concat [ELSE] ifte\n",
" ------------------------------------------------------\n",
" [P0] [THEN0] [[F] THEN1] concat [ELSE] ifte\n",
" ------------------------------------------------------\n",
" [P0] [THEN0 [F] THEN1] [ELSE] ifte\n",
" ------------------------------------------------------\n",
" [P0] [THEN0 [F] THEN1] [ELSE] ifte\n",
"\n",
"It's awkward but it works."
]
},
{
"cell_type": "code",
"execution_count": 112,
"id": "4fcf1d97",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": []
}
],
"source": [
"clear"
]
},
{
"cell_type": "markdown",
"id": "85a49679",
"metadata": {},
"source": [
"#### `false` branch\n",
"And now we deal with the cases where one of the two lists (but not both) is empty:\n",
"\n",
" carry [a ...] [] ELSE\n",
" carry [] [b ...] ELSE\n",
"\n",
"We get rid of the empty list:\n",
"\n",
"[bool] [popd] [pop] ifte"
]
},
{
"cell_type": "code",
"execution_count": 113,
"id": "affd02fb",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": []
}
],
"source": [
"[ditch-empty-list [bool] [popd] [pop] ifte] inscribe"
]
},
{
"cell_type": "code",
"execution_count": 114,
"id": "5cc19cea",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1]"
]
}
],
"source": [
"[1][] ditch-empty-list"
]
},
{
"cell_type": "code",
"execution_count": 115,
"id": "12d72692",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1]"
]
}
],
"source": [
"clear\n",
"[][1] ditch-empty-list"
]
},
{
"cell_type": "markdown",
"id": "aa76c2fc",
"metadata": {},
"source": [
"#### add-carry-to-digits\n",
"So now we have `carry` and one list of digits. (We also know that we have at least one digit in the list at this point but we likely won't need that information.)\n",
"\n",
" carry [a ...] add-carry-to-digits\n",
"\n",
"I think once we define `add-carry-to-digits` we are pretty much done? Let's find out."
]
},
{
"cell_type": "markdown",
"id": "828699dc",
"metadata": {},
"source": [
"##### If `carry` is `false` we just return the digits list, eh?\n",
"\n",
" false [a ...] swap [] [THEN] branch\n",
" -----------------------------------------\n",
" [a ...]"
]
},
{
"cell_type": "markdown",
"id": "2a386fe2",
"metadata": {},
"source": [
"##### If `true` we want to maybe reuse `add-with-carry`?\n",
"\n",
"\n",
" true [a ...] swap [THEN] [] branch\n",
" ----------------------------------------\n",
" [a ...] THEN\n",
" --------------------------------------\n",
" false 1 a add-with-carry [...] G\n",
" --------------------------------------\n",
" (1+a) carry [...] G\n",
" ------------------------------------------------\n",
" (1+a) carry [...] add-carry-to-digits cons\n",
" ------------------------------------------------\n",
" (1+a) [...] cons\n",
" ------------------------------------------------\n",
" [(1+a) ...]\n",
"\n",
"So `add-carry-to-digits` is a recursive function (not a `branch` after all.)"
]
},
{
"cell_type": "markdown",
"id": "08a149fa",
"metadata": {},
"source": [
"Omitting `ditch-empty-list` for the moment:\n",
"\n",
" THEN == [false 1] dip uncons [add-with-carry] dip [add-carry-to-digits] i cons\n",
"\n",
" [a ...] THEN\n",
" [a ...] [false 1] dip uncons [add-with-carry] dip [add-carry-to-digits] i cons\n",
" false 1 [a ...] uncons [add-with-carry] dip [add-carry-to-digits] i cons\n",
" false 1 a [...] [add-with-carry] dip [add-carry-to-digits] i cons\n",
" false 1 a add-with-carry [...] [add-carry-to-digits] i cons\n",
" (1+a) false [...] [add-carry-to-digits] i cons\n",
" (1+a) false [...] add-carry-to-digits cons\n",
" (1+a) [...] cons\n",
" [(1+a) ...]\n",
"\n",
"QED"
]
},
{
"cell_type": "code",
"execution_count": 64,
"id": "9f4ebfd9",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": []
}
],
"source": [
"clear"
]
},
{
"cell_type": "markdown",
"id": "afd8074b",
"metadata": {},
"source": [
"#### add-carry-to-digits, recursively\n",
"\n",
" carry [...] add-carry-to-digits\n",
"\n",
" carry [...] [P] [THEN] [R0] [R1] genrec\n",
"\n",
"So:\n",
"\n",
" P == swap not\n",
" \n",
"-or-\n",
"\n",
" P == pop not\n",
" \n",
"and\n",
"\n",
" THEN == popd\n",
"\n",
"That leaves:\n",
"\n",
" true [...] R0 [add-carry-to-digits] R1\n",
"\n",
"I am tempted to leave the transformation from the above form to\n",
"\n",
" true [...] popd [false 1] dip uncons [add-with-carry] dip [add-carry-to-digits] i cons\n",
"\n",
"as the proverbial \"exercise for the reader\" but it's kinda trivial:\n",
"\n",
" R0 == popd [false 1] dip uncons [add-with-carry] dip\n",
" R1 == i cons\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 65,
"id": "0c095d53",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"2 false [2 3]"
]
}
],
"source": [
"true [1 2 3] popd [false 1] dip uncons [add-with-carry] dip"
]
},
{
"cell_type": "code",
"execution_count": 66,
"id": "e793bd13",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"2 [2 3]"
]
}
],
"source": [
"popd"
]
},
{
"cell_type": "code",
"execution_count": 67,
"id": "e5d3966a",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[2 2 3]"
]
}
],
"source": [
"cons"
]
},
{
"cell_type": "code",
"execution_count": 73,
"id": "c8aec12d",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": []
}
],
"source": [
"clear\n",
"\n",
"[add-carry-to-digits [pop not] [popd] [popd [false 1] dip uncons [add-with-carry] dip] [i cons] genrec] inscribe"
]
},
{
"cell_type": "code",
"execution_count": 74,
"id": "d290d896",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[2 2 3]"
]
}
],
"source": [
"true [1 2 3] add-carry-to-digits"
]
},
{
"cell_type": "code",
"execution_count": 75,
"id": "10cb7a1f",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1 2 3]"
]
}
],
"source": [
"clear\n",
"\n",
"false [1 2 3] add-carry-to-digits"
]
},
{
"cell_type": "code",
"execution_count": 84,
"id": "89298766",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"true [2147483647 2147483647 2 3]"
]
}
],
"source": [
"clear\n",
"\n",
"true base -- dup [2 3] ccons"
]
},
{
"cell_type": "code",
"execution_count": 85,
"id": "af73db1b",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[0 0 3 3]"
]
}
],
"source": [
"add-carry-to-digits"
]
},
{
"cell_type": "markdown",
"id": "69f59f45",
"metadata": {},
"source": [
"E.g. 3299 + 1 = 3300"
]
},
{
"cell_type": "code",
"execution_count": 90,
"id": "00fa293e",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"false [2147483647 2147483647 2 3]"
]
}
],
"source": [
"clear\n",
"\n",
"false base -- dup [2 3] ccons"
]
},
{
"cell_type": "code",
"execution_count": 91,
"id": "227a28f1",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[2147483647 2147483647 2 3]"
]
}
],
"source": [
"add-carry-to-digits"
]
},
{
"cell_type": "markdown",
"id": "50d06f33",
"metadata": {},
"source": [
"So that seems like it works."
]
},
{
"cell_type": "code",
"execution_count": 119,
"id": "7e735e04",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": []
}
],
"source": [
"clear"
]
},
{
"cell_type": "markdown",
"id": "b55599cb",
"metadata": {},
"source": [
"## Our Story So Far...\n",
" _add_p == [bool not] ii &\n",
" _add_then == pop swap [] [1 swons] branch\n",
" _add_rec_pred == [bool] ii &\n",
"\n",
" add_digits == [_add_p] [_add_then] [R0] [R1] genrec"
]
},
{
"cell_type": "markdown",
"id": "f515f498",
"metadata": {},
"source": [
"Where:\n",
"\n",
" R0 [add_digits] R1\n",
" -----------------------------------------------------\n",
" [_add_rec_pred] [ THEN ] [ELSE] ifte\n",
" -----------------------------------------------------\n",
" [_add_rec_pred] [THEN0 [add_digits] THEN1] [ELSE] ifte\n",
"\n",
" THEN0 == uncons-two [add-with-carry] dipd\n",
"\n",
" THEN1 == i cons\n",
"\n",
" ELSE == ditch-empty-list add-carry-to-digits"
]
},
{
"cell_type": "code",
"execution_count": 131,
"id": "348e377d",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": []
}
],
"source": [
"[THEN0 uncons-two [add-with-carry] dipd] inscribe\n",
"[THEN1 i cons] inscribe\n",
"[ELSE ditch-empty-list add-carry-to-digits] inscribe"
]
},
{
"cell_type": "markdown",
"id": "c3b2768f",
"metadata": {},
"source": [
"Recalling:\n",
"\n",
" [P0] [THEN0] [F] [THEN1] cons concat [ELSE] ifte\n",
" ------------------------------------------------------\n",
" [P0] [THEN0] [[F] THEN1] concat [ELSE] ifte\n",
" ------------------------------------------------------\n",
" [P0] [THEN0 [F] THEN1] [ELSE] ifte\n",
" ------------------------------------------------------\n",
" [P0] [THEN0 [F] THEN1] [ELSE] ifte"
]
},
{
"cell_type": "markdown",
"id": "2d58b809",
"metadata": {},
"source": [
"Ergo:\n",
"\n",
" R0 == [_add_rec_pred] [THEN0]\n",
" R1 == [THEN1] cons concat [ELSE] ifte\n",
"\n",
" add_digits == [_add_p] [_add_then] [R0] [R1] genrec\n"
]
},
{
"cell_type": "code",
"execution_count": 132,
"id": "2219756c",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": []
}
],
"source": [
"[_add_R0 [_add_rec_pred] [THEN0]] inscribe\n",
"[_add_R1 [THEN1] cons concat [ELSE] ifte] inscribe"
]
},
{
"cell_type": "code",
"execution_count": 133,
"id": "80866347",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": []
}
],
"source": [
"[add_digits [_add_p] [_add_then] [_add_R0] [_add_R1] genrec] inscribe"
]
},
{
"cell_type": "code",
"execution_count": 134,
"id": "51314100",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"false [3 2 1] [8]"
]
}
],
"source": [
"false [3 2 1] [8] "
]
},
{
"cell_type": "code",
"execution_count": 135,
"id": "63a589cb",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[11 2 1]"
]
}
],
"source": [
"add_digits"
]
},
{
"cell_type": "code",
"execution_count": 136,
"id": "b5c5b50b",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[2147483647 11 2 1]"
]
}
],
"source": [
"base -- swons"
]
},
{
"cell_type": "code",
"execution_count": 137,
"id": "1c81b4bc",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"false [2147483647 11 2 1] [23]"
]
}
],
"source": [
"false swap [23]"
]
},
{
"cell_type": "code",
"execution_count": 138,
"id": "cdd845ef",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[22 12 2 1]"
]
}
],
"source": [
"add_digits"
]
},
{
"cell_type": "code",
"execution_count": 142,
"id": "583a2390",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[2147483647] [1]"
]
}
],
"source": [
"clear base -- unit [1]"
]
},
{
"cell_type": "markdown",
"id": "defedd4b",
"metadata": {},
"source": [
"When i tried it it failed and inspection revealed that I had forgotten to set the initial carry value."
]
},
{
"cell_type": "code",
"execution_count": 144,
"id": "532967be",
"metadata": {
"scrolled": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"false [2147483647] [1]"
]
}
],
"source": [
"clear false base -- unit [1]"
]
},
{
"cell_type": "code",
"execution_count": 145,
"id": "e15c8b33",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[0 1]"
]
}
],
"source": [
"add_digits"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "84c6c958",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": 148,
"id": "ca5c95af",
"metadata": {
"scrolled": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"false [2147483647 2147483647 2147483647 2147483647] [1]"
]
}
],
"source": [
"clear false base -- unit dup concat dup concat [1]"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "3a6960ea",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "8c32715b",
"metadata": {},
"source": [
"#### I made a mistake in add-carry-to-digits\n",
"\n",
"The recursive branch:\n",
"\n",
" true [...] R0 [add-carry-to-digits] R1\n",
"\n",
"Must also deal with the case where the list is empty!\n",
"\n",
" true [] R0 [add-carry-to-digits] R1\n",
"\n",
"The `popd` is okay, but then we need a branch:\n",
"\n",
" R0 == popd ? [1 swons] [R0.t] branch\n",
" R0.t == [false 1] dip uncons [add-with-carry] dip\n",
"\n",
" R1 == i cons\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "1b4b1302",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "cab5271f",
"metadata": {},
"source": [
"#### add-carry-to-digits, recursively, TAKE TWO\n",
"\n",
" carry [...] add-carry-to-digits\n",
"\n",
" carry [...] [P] [THEN] [R0] [R1] genrec\n",
"\n",
" P == pop not\n",
" THEN == popd\n",
"\n",
"That leaves one of:\n",
"\n",
" true [...] R0 [add-carry-to-digits] R1\n",
"\n",
"-or-\n",
"\n",
" true [] R0 [add-carry-to-digits] R1\n",
"\n",
"It would be fun to just set `R1` to `ifte`\n",
"\n",
" true [] R0 [add-carry-to-digits] ifte\n",
"\n",
"Which means that `R0` must be a predicate and the \"then\" branch.\n",
"\n",
" true [] [bool not] [THEN] [add-carry-to-digits] ifte\n",
"\n",
"And I think `THEN` would just be:\n",
"\n",
" THEN == popd 1 swons\n",
"\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 162,
"id": "955aed77",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": []
}
],
"source": [
"clear\n",
"[R0.t [false 1] dip uncons [add-with-carry] dip] inscribe\n",
"[add-carry-to-digits\n",
" [pop not]\n",
" [popd]\n",
" [[bool not] [popd 1 swons]]\n",
" [ifte]\n",
" genrec\n",
"] inscribe"
]
},
{
"cell_type": "markdown",
"id": "1ee5b941",
"metadata": {},
"source": [
"This is still broken because the "
]
},
{
"cell_type": "code",
"execution_count": 160,
"id": "8ca1f509",
"metadata": {
"scrolled": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"true [2147483647 2147483647 2147483647 2147483647]"
]
}
],
"source": [
"clear true base -- unit dup concat dup concat"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "77e2e26f",
"metadata": {},
"outputs": [],
"source": [
"add-carry-to-digits"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "07a528bd",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "97ed01aa",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "dee054a6",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "f92eebb0",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "36e683fd",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "91ffeec1",
"metadata": {},
"source": [
"#### add-carry-to-digits\n",
"\n",
"So `add-carry-to-digits` is a recursive function:\n",
"\n",
" carry [a ...] add-carry-to-digits\n",
"\n",
" carry [a ...] [P] [THEN] [R0] [R1] genrec\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "dc5f3cba",
"metadata": {},
"outputs": [],
"source": [
"[pop not] [popd] [[bool not] [1 cons swap]] [ifte] genrec"
]
},
{
"cell_type": "markdown",
"id": "6201b301",
"metadata": {},
"source": [
"##### If `carry` is `false` we just return the digits list, eh?\n",
"\n",
" false [a ...] [pop not] [popd] [R0] [R1] genrec\n",
" -----------------------------------------------------\n",
" [a ...]"
]
},
{
"cell_type": "markdown",
"id": "2ffbb77c",
"metadata": {},
"source": [
"##### If `true` we want to maybe reuse `add-with-carry`?\n",
"\n",
" true [a ...] R0 [add-carry-to-digits] R1\n",
"\n",
"-or-\n",
"\n",
" true [] R0 [add-carry-to-digits] R1\n",
"\n",
"Um...\n",
"\n",
" true [] [bool not] [1 cons popd] [add-carry-to-digits] ifte\n",
"\n",
"\n",
" true [] [bool not] [1 cons popd] [add-carry-to-digits] ifte\n",
" true [] 1 cons popd\n",
" true [1] popd\n",
" [1]\n",
"\n",
"-or-\n",
"\n",
" true [a ...] [bool not] [1 cons swap] [F add-carry-to-digits] itfe\n",
" true [a ...] F add-carry-to-digits\n",
"\n",
"\n",
" true [a ...] F add-carry-to-digits\n",
" ---------------------------------------------------------\n",
" true 0 a add-with-carry [...] add-carry-to-digits\n",
"\n",
" \n",
" F == 0 swap uncons [add-with-carry] dip\n",
"\n",
"\n",
" true [a ...] [bool not] [1 cons swap] [add-carry-to-digits] [F] swoncat itfe\n",
"\n",
"\n",
"\n",
" true [a ...] [bool not] [1 cons swap] [add-carry-to-digits] [0 swap uncons [add-with-carry] dip] swoncat itfe\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 162,
"id": "0ee18517",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": []
}
],
"source": [
"clear\n",
"[R0.t [false 1] dip uncons [add-with-carry] dip] inscribe\n",
"[add-carry-to-digits\n",
" [pop not]\n",
" [popd]\n",
" [[bool not] [popd 1 swons]]\n",
" [ifte]\n",
" genrec\n",
"] inscribe"
]
},
{
"cell_type": "markdown",
"id": "965cf4df",
"metadata": {},
"source": [
"Omitting `ditch-empty-list` for the moment:\n",
"\n",
" THEN == [false 1] dip uncons [add-with-carry] dip [add-carry-to-digits] i cons\n",
"\n",
" [a ...] THEN\n",
" [a ...] [false 1] dip uncons [add-with-carry] dip [add-carry-to-digits] i cons\n",
" false 1 [a ...] uncons [add-with-carry] dip [add-carry-to-digits] i cons\n",
" false 1 a [...] [add-with-carry] dip [add-carry-to-digits] i cons\n",
" false 1 a add-with-carry [...] [add-carry-to-digits] i cons\n",
" (1+a) false [...] [add-carry-to-digits] i cons\n",
" (1+a) false [...] add-carry-to-digits cons\n",
" (1+a) [...] cons\n",
" [(1+a) ...]\n",
"\n",
"QED"
]
},
{
"cell_type": "code",
"execution_count": 64,
"id": "1787863d",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": []
}
],
"source": [
"clear"
]
},
{
"cell_type": "markdown",
"id": "77eeace6",
"metadata": {},
"source": [
"#### add-carry-to-digits, recursively\n",
"\n",
" carry [...] add-carry-to-digits\n",
"\n",
" carry [...] [P] [THEN] [R0] [R1] genrec\n",
"\n",
"So:\n",
"\n",
" P == swap not\n",
" \n",
"-or-\n",
"\n",
" P == pop not\n",
" \n",
"and\n",
"\n",
" THEN == popd\n",
"\n",
"That leaves:\n",
"\n",
" true [...] R0 [add-carry-to-digits] R1\n",
"\n",
"I am tempted to leave the transformation from the above form to\n",
"\n",
" true [...] popd [false 1] dip uncons [add-with-carry] dip [add-carry-to-digits] i cons\n",
"\n",
"as the proverbial \"exercise for the reader\" but it's kinda trivial:\n",
"\n",
" R0 == popd [false 1] dip uncons [add-with-carry] dip\n",
" R1 == i cons\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "2a37982c",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "0c1ad90d",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "a184d47c",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "0343594a",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "e13c8b2e",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "e921d72a",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "2727bab9",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "3373be97",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "342e9982",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "7f655e89",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "611f40ff",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "bada9caa",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "fb66962d",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "6764903e",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "b4b10bfe",
"metadata": {},
"outputs": [],
"source": [
"[base 2147483648] inscribe\n",
"[valid_digit [0 >] [base <] &&] inscribe\n",
"[_add_p [bool not] ii &] inscribe\n",
"[_add_then pop swap [] [1 swons] branch] inscribe\n",
"[_add_rec_pred [bool] ii &] inscribe\n",
"[bool_to_int [0] [1] branch] inscribe\n",
"[_add-with-carry0 [bool_to_int] dipd + +] inscribe\n",
"[_add-with-carry1 base [mod] [>=] clop] inscribe\n",
"[add-with-carry _add-with-carry0 _add-with-carry1] inscribe\n",
"[uncons-two [uncons] ii swapd] inscribe\n",
"[ditch-empty-list [bool] [popd] [pop] ifte] inscribe\n",
"[add-carry-to-digits [pop not] [popd] [popd [false 1] dip uncons [add-with-carry] dip] [i cons] genrec] inscribe\n",
"[THEN0 uncons-two [add-with-carry] dipd] inscribe\n",
"[THEN1 i cons] inscribe\n",
"[ELSE ditch-empty-list add-carry-to-digits] inscribe\n",
"[_add_R0 [_add_rec_pred] [THEN0]] inscribe\n",
"[_add_R1 [THEN1] cons concat [ELSE] ifte] inscribe\n",
"[add_digits [_add_p] [_add_then] [_add_R0] [_add_R1] genrec] inscribe\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "11c66f4e",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "60cda31e",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "0852a374",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "c2c3f8f5",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "eb4d2dac",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "6c7f705e",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "8e69a883",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "551b52de",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": 55,
"id": "3fb6905c",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1] 2 false [2 3]"
]
}
],
"source": [
"[isnt_bigint\n",
"[first isnt_bool]\n",
"[rest [isnt_int] map]\n",
"cleave cons\n",
"] inscribe"
]
},
{
"cell_type": "code",
"execution_count": 56,
"id": "39b3d4bc",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1] 2 false [2 3] [[!] [!-] [!=] [%] [&] [&&] [*] [+] [++] [-] [--] [/] [<] [<<] [<<{}] [<=] [<>] [<{}] [=] [>] [>=] [>>] [?] [abs] [add] [add-with-carry] [all] [anamorphism] [and] [any] [app1] [app2] [app3] [appN] [at] [b] [base] [binary] [bool] [bool_to_int] [branch] [ccccons] [ccons] [choice] [clear] [cleave] [clop] [cmp] [codi] [codireco] [concat] [cond] [cons] [digitalize] [dinfrirst] [dip] [dipd] [dipdd] [disenstacken] [ditch-empty-list] [div] [divmod] [down_to_zero] [drop] [dup] [dupd] [dupdd] [dupdip] [dupdipd] [enstacken] [eq] [first] [first_two] [flatten] [floordiv] [fork] [fourth] [gcd] [gcd2] [ge] [genrec] [getitem] [grabN] [grba] [gt] [help] [i] [ifte] [ii] [infra] [infrst] [inscribe] [isnt_bigint] [isnt_bool] [isnt_int] [isnt_stack] [le] [loop] [lshift] [lt] [make_generator] [manual] [map] [max] [min] [mod] [mul] [ne] [neg] [not] [nulco] [nullary] [of] [or] [over] [pam] [pm] [pop] [popd] [popdd] [popop] [popopd] [popopdd] [popopop] [pow] [pred] [primrec] [product] [quit] [quoted] [range] [range_to_zero] [reco] [remove] [rest] [reverse] [roll<] [roll>] [rolldown] [rollup] [rrest] [rshift] [run] [second] [select] [sharing] [shift] [shunt] [size] [sort] [spiral_next] [split_at] [split_list] [sqr] [stack] [stackd] [step] [step_zero] [stuncons] [stununcons] [sub] [succ] [sum] [swaack] [swap] [swapd] [swoncat] [swons] [tailrec] [take] [ternary] [third] [times] [to_bigint] [trace] [tuck] [unary] [uncons] [unique] [unit] [unquoted] [unswons] [valid_digit] [warranty] [while] [words] [x] [xor] [zip] [|] [||] [•]]"
]
}
],
"source": [
"words"
]
},
{
"cell_type": "code",
"execution_count": 57,
"id": "4c5edbfa",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": []
}
],
"source": [
"clear"
]
},
{
"cell_type": "code",
"execution_count": 58,
"id": "1e201000",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"2147483648"
]
}
],
"source": [
"1 31 <<"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b310e739",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": 59,
"id": "fc53f72d",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"12 3"
]
}
],
"source": [
"clear\n",
"\n",
"123 10 divmod"
]
},
{
"cell_type": "code",
"execution_count": 60,
"id": "2cb7c88f",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"12 0 3"
]
}
],
"source": [
"base divmod"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "e7c36361",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": 61,
"id": "005ac08e",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"==== Help on divmod ====\n",
"\n",
"Similarly to pm (\"Plus or minus\") this function computes\n",
"both the\n",
"::\n",
"\n",
" a b divmod\n",
" ---------------------\n",
" a b div a b mod\n",
" ---------------------\n",
" q r\n",
"\n",
"Where: q * b + r == a\n",
"\n",
"---- end ( divmod )\n",
"\n",
"\n",
"12 0 3"
]
}
],
"source": [
"[divmod] help"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "6ebcf6d8",
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Joypy",
"language": "",
"name": "thun"
},
"language_info": {
"file_extension": ".joy",
"mimetype": "text/plain",
"name": "Joy"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
Reference in New Issue View Git Blame Copy Permalink