From 3b09529ff714aef2750f81f13eb50dc4d05c9246 Mon Sep 17 00:00:00 2001 From: Arno Klein Date: Thu, 24 Sep 2020 14:20:55 -0400 Subject: [PATCH] Update notebook --- engram_layout.ipynb | 1138 ++++++++++++++++++++++++++----------------- 1 file changed, 697 insertions(+), 441 deletions(-) diff --git a/engram_layout.ipynb b/engram_layout.ipynb index ccc90e1..4ddc571 100644 --- a/engram_layout.ipynb +++ b/engram_layout.ipynb @@ -11,10 +11,10 @@ "\n", "The [Engram layout](https://github.com/binarybottle/engram-layout) is a keyboard layout optimized for comfortable touch typing in English created by [Arno Klein](https://binarybottle.com), with open source code to create other optimized key layouts.\n", "\n", - " K P U Y G R D W Q\n", - " I O E A H T S N J\n", - " V Z X C L B F M\n", - "\n", + " K U O Y W L G B Q\n", + " H I E A T R S N J \n", + " V Z X C D M F P \n", + " \n", "The Shift key accesses characters (top) that look similar to the numbers:\n", "\n", " ! = ? + $ @ ^ & % *\n", @@ -27,15 +27,14 @@ "\n", "Swapping the Backspace and Caps lock keys completes the layout:\n", "\n", - "\n", " ~ ! = ? + $ @ ^ & % * < >\n", " # 1 2 3 4 5 6 7 8 9 0 [ ] Caps\n", "\n", - " Tab K P U Y ' \" G R D W Q - /\n", - " Back I O E A , . H T S N J Enter\n", - " Shift V Z X C ( ) L B F M Shift\n", + " Tab K U O Y ' \" W L G B Q - /\n", + " Back H I E A , . T R S N J Enter\n", + " Shift V Z X C ( ) D M F P Shift\n", "\n", - " Ctrl Fn Cmd Alt Space Alt Ctrl Arrows\n" + " Ctrl Fn Cmd Alt Space Alt Ctrl Arrows" ] }, { @@ -57,10 +56,11 @@ " - [Strength matrix](#strength)\n", " - [Flow matrix](#flow)\n", "7. Steps:\n", - " - [Step 1: Arrange the most frequent vowels and consonants](#step1)\n", - " - [Step 2: Arrange the remaining letters (except for command characters Z,X,C,V)](#step2)\n", - " - [Step 3: Add command shortcut characters ](#step3)\n", - " - [Step 4: Arrange punctuation marks in easy-to-remember places](#step4)" + " - [Step 1: Distribute the 8 most frequent letters (4 vowels, 4 consonants) to the left and right](#step1)\n", + " - [Step 2: Add command shortcut characters on the left or right](#step2)\n", + " - [Step 3: Distribute 8 of the remaining letters to the left and right](#step3)\n", + " - [Step 4: Optimize arrangement of all letters on the left and right](#step4)\n", + " - [Step 5: Arrange punctuation marks and characters in easy-to-remember places](#step5)" ] }, { @@ -170,30 +170,32 @@ "source": [ "## Summary of steps and results \n", "\n", - "- Step 1: Arrange the most frequent vowels and consonants\n", - "- Step 2: Arrange the remaining letters (except for command characters Z,X,C,V)\n", - "- Step 3: Add command shortcut characters\n", - "- Step 4: Arrange punctuation marks in easy-to-remember places\n", + "- Step 1: Distribute the 8 most frequent letters (4 vowels, 4 consonants) to the left and right\n", + "- Step 2: Add command shortcut characters on the left or right\n", + "- Step 3: Distribute 8 of the remaining letters to the left and right\n", + "- Step 4: Optimize arrangement of all letters on the left and right \n", + "- Step 5: Arrange punctuation marks and characters in easy-to-remember places\n", + " \n", + "### 1. Distribute the 8 most frequent letters (4 vowels, 4 consonants) to the left and right\n", "\n", - "### Step 1: Arrange the most frequent vowels and consonants\n", + "**E, T, A, O, I, N, S, R**, H, L, D, C, U, M, F, P, G, W, Y, B, V, K, X, J, Q, Z\n", "\n", - "My goal was to arrange 24 of the 26 letters in 8 columns of keys requiring no lateral movements, with 2 middle columns reserved for punctuation.\n", + "My goal was to arrange 24 of the 26 letters in finger-column keys (requiring no lateral movements) with 2 columns reserved for punctuation between the left and right sides. Our optimization algorithm splits the 8 most frequent letters across left and right sides:\n", "\n", - "First, I select 5 keys on the left and right sides having the strongest finger positions, and assign to these keys the top-scoring arrangement of the 5 vowels and of the 5 most frequent consonants. In prior experiments, vowels on the left got consistently higher scores, so I continue with vowels on the left:\n", + " - - O - - S - - \n", + " - I E A T N R -\n", + " - - - - - - - -\n", "\n", - "**E**, T, **A, O, I**, N, S, R, H, L, D, C, **U**, M, F, P, G, W, Y, B, V, K, X, J, Q, Z\n", + "This algorithm also generates a mirror image of the above arrangement:\n", "\n", - "E, **T**, A, O, I, **N, S, R, H**, L, D, C, U, M, F, P, G, W, Y, B, V, K, X, J, Q, Z\n", - " \n", - " Left: Right:\n", - "\n", - " - - U - - R - - \n", - " I O E A H T S N\n", + " - - S - - O - -\n", + " - R N T A E I - \n", " - - - - - - - -\n", - " \n", - "This arrangement is very reasonable, as it places vowels of decreasing frequency in positions of decreasing strength, and the most common bigrams are easy to type.\n", - " \n", - "#### Details\n", + "\n", + "In all of the following steps, we build a layout from both arrangements but only show the top arrangement for clarity.\n", + "These initial arrangements are very reasonable, as they place letters of decreasing frequency in positions of decreasing finger strength, and roll in for most common bigrams: IO, EA, IE, NT, ST, RT (not TR or NS).\n", + " \n", + "#### **Details**
\n", "The optimization algorithm finds every permutation of a given set of letters (40,320 for this intial set of 8), maps these letter permutations to a set of keys, and ranks these letter-key mappings according to a score reflecting ease of typing key pairs and frequency of letter pairs (bigrams). The score is the average of the scores for all possible bigrams in this arrangement. The score for each bigram is a product of the frequency of occurrence of that bigram and the factors Flow, Strength, and Speed: \n", "\n", "**Flow**: measure of ease of a finger transition from the first in a pair of letters to the second\n", @@ -220,31 +222,56 @@ "\n", "\"Estimation of digraph costs for keyboard layout optimization\", \n", "A Iseri, Ma Eksioglu, International Journal of Industrial Ergonomics, 48, 127-138, 2015. \n", + " \n", + "### 2. Add command shortcut characters on the left or right\n", + "\n", + "I experimented with common command characters (Z,X,C,V) on the left, a familiar location (with Q on the right):\n", + "\n", + " - - O - - S - - Q\n", + " - I E A T N R - -\n", + " Z X C V - - - -\n", + " \n", + "and with command characters on the right (with Q on the left):\n", "\n", + " Q - O - - S - Y Z\n", + " - I E A T N R C X \n", + " - - - - - - - V\n", + "\n", + "Rationale for placement on the right:\n", + " \n", + "- Z is the least frequent letter and is placed in the hardest-to-reach position.\n", + "- Z & Y (Undo & Redo), and X & C (Cut & Copy) pair well together. \n", + "- Moving command shortcuts to the right puts C & V (Copy & Paste) in closer proximity to a Ctrl key, or it enforces two-handed Ctrl operations when using the harder-to-reach left Ctrl key.\n", + "- Q is the least frequent remaining letter, and is placed in the hardest-to-reach remaining key location.\n", + "- Q is in the upper left key in the QWERTY layout, so will be easy to remember.\n", " \n", - "### Step 2: Arrange the remaining letters (except for command characters Z,X,C,V)\n", + "### 3. Distribute 8 of the remaining letters to the left and right\n", "\n", - "I reserve the familiar location of the bottom left row for common command shortcut letters Z, X, C, and V, and place Q and J, the least common letters (after Z) in the hardest-to-reach locations:\n", + "*E, T, A, O, I, N, S, R*, **H, L, D**, [C], **U, M, F, P, G**, W, [Y], B, [V], K, [X], J, *Q*, [Z] \n", + " \n", + "### 4. Optimize arrangement of all letters on the left and right \n", " \n", - "E, T, A, O, I, N, S, R, H, **L, D**, [C], U, **M, F, P, G, W, Y, B**, [V], **K**, [X], [J], [Q], [Z]\n", + "I applied the same algorithm as in Steps 1 and 3, but to each side separately (to make it computationally tractable), then to the remaining letters, and finally to the command characters on the left side. \n", "\n", - " - - U - - R - - [Q]\n", - " I O E A H T S N [J]\n", - " * * * * - - - -\n", + "The top-scoring full layouts had vowels on the left side and command characters on either side:\n", " \n", - "### Step 3: Add command shortcut characters \n", + " J U O Y W S M Q Z score: 0.04264\n", + " H I E A T N R C X \n", + " P K G D L F B V\n", "\n", - "I arrange the common command characters (Z,X,C,V) in the bottom left row, and choose the sequence V,Z,X,C so that the more frequent letters V and C are accessible by folding the smaller fingers, repeated shortcuts V and Z (paste and undo) are closer to the Ctrl/Cmd key, and the sequence is close to the familiar Z,X,C,V (with V on the left side).\n", + " Q U O Y W S M J Z score: 0.04264\n", + " H I E A T N R C X \n", + " P K G D L F B V\n", "\n", - " K P U Y G R D W [Q]\n", - " I O E A H T S N [J]\n", - " V Z X C L B F M \n", + " K U O Y W L G B Q score: 0.04263\n", + " H I E A T R S N J \n", + " V Z X C D M F P\n", " \n", - "### Step 4. Arrange punctuation marks in easy-to-remember places\n", + "### 5. Arrange punctuation marks and characters in easy-to-remember places\n", "\n", "**Frequency of punctuation** \n", "\n", - "These sources helped guide arrangement of punctuation keys:\n", + "These sources helped guided our arrangement:\n", " \n", " - \"Punctuation Input on Touchscreen Keyboards: Analyzing Frequency of Use and Costs\"
\n", " S Malik, L Findlater - College Park: The Human-Computer Interaction Lab. 2013
\n", @@ -259,9 +286,9 @@ "\n", "Resulting in:\n", "\n", - " K P U Y ' \" G R D W Q\n", - " I O E A , . H T S N J\n", - " V Z X C ( ) L B F M \n", + " J U O Y ' \" W S M Q Z\n", + " H I E A , . T N R C X \n", + " P K G D ( ) L F B V\n", "\n", "Shift accesses similar-looking characters above the numbers:\n", "\n", @@ -312,7 +339,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 6, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -332,9 +359,11 @@ "import matplotlib.pyplot as plt \n", "import seaborn as sns\n", "\n", - "# Use speed data?\n", - "use_speed_data = False\n", + "# Influence of strength data\n", + "strength_factor = 0.01 # Published finger strength data is given very low weight, and is used primarily for ordering initial sequence of letters in Step 1.\n", "\n", + "# Influence of speed data\n", + "speed_factor = 0.0 # Published speed data was only used for early experimentation.\n", "\n", "# Select keys to quantify pairwise relationships:\n", "def select_keys(data_matrix, keys, verbose=False):\n", @@ -559,7 +588,7 @@ " \n", " print(\"Topmost of {0} permutations: {1}\".format(len(sorted_permutations_left) * len(sorted_permutations_right), top_score))\n", " print(\"{0}\".format(top_permutation))\n", - " \n", + " \n", " return top_permutation, top_score, scores\n", "\n", " \n", @@ -631,7 +660,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 7, "metadata": { "colab": {}, "colab_type": "code", @@ -975,7 +1004,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 8, "metadata": { "colab": {}, "colab_type": "code", @@ -983,7 +1012,7 @@ }, "outputs": [], "source": [ - "if use_speed_data:\n", + "if speed_factor > 0.0:\n", "\n", " load_original_interkey_timings_table = False\n", " if load_original_interkey_timings_table:\n", @@ -1026,7 +1055,7 @@ " TimeSymmetric24x24[j,i] = avgvalue\n", "\n", " # Normalize matrix with min-max scaling to a range with maximum = 1:\n", - " newMin = np.min(TimeSymmetric24x24) / np.max(TimeSymmetric24x24)\n", + " newMin = 1.0 - strength_factor # np.min(TimeSymmetric24x24) / np.max(TimeSymmetric24x24)\n", " newMax = 1.0\n", " TimeSymmetric24x24 = newMin + (TimeSymmetric24x24 - np.min(TimeSymmetric24x24)) * (newMax - newMin) / (np.max(TimeSymmetric24x24) - np.min(TimeSymmetric24x24))\n", "\n", @@ -1170,7 +1199,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 9, "metadata": { "colab": {}, "colab_type": "code", @@ -1179,7 +1208,7 @@ "outputs": [], "source": [ "# Histogram\n", - "if use_speed_data:\n", + "if speed_factor > 0.0:\n", " sns_plot = sns.distplot(Speed24x24)\n", " sns_plot.figure.savefig(\"{0}_histogram.png\".format(\"Speed24x24\"))" ] @@ -1243,7 +1272,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 10, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -1325,7 +1354,7 @@ "Strength24x24 = (Strength24x24 + Strength24x24.transpose())\n", "\n", "# Normalize matrix with min-max scaling to a range with maximum = 1:\n", - "newMin = 0.99 # np.min(Strength24x24) / np.max(Strength24x24)\n", + "newMin = 1.0 - strength_factor # np.min(Strength24x24) / np.max(Strength24x24)\n", "newMax = 1.0\n", "Strength24x24 = newMin + (Strength24x24 - np.min(Strength24x24)) * (newMax - newMin) / (np.max(Strength24x24) - np.min(Strength24x24))\n", "\n", @@ -1341,7 +1370,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 11, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -1466,12 +1495,34 @@ "id": "dpKA0PZwDzR-" }, "source": [ - "### Factors to penalize difficult key transitions" + "### Factors to penalize difficult key transitions\n", + "\n", + "Examples:\n", + "\n", + " Left: Right:\n", + " 1 2 3 4 13 14 15 16 \n", + " 5 6 7 8 17 18 19 20\n", + " 9 10 11 12 21 22 23 24\n", + "\n", + "key 10 to key 1: same_hand * roll_out * not_home_row * skip_home_row * side_top * side_up_1away_down * center_bottom = 0.9^6 = 0.531441\n", + "key 9 to key 1: same_hand * same_finger * not_home_row * skip_home_row * side_top = 0.8 * 0.9^3 = 0.5832\n", + "\n", + "key 2 to key 7: same_hand * not_home_row * ring_up_middle_down = 0.9^2 = 0.81\n", + "key 2 to key 6: same_hand * same_finger * not_home_row = 0.8 * 0.9 = 0.72\n", + "\n", + "key 11 to key 2: same_hand * roll_out * not_home_row * skip_home_row * center_bottom * ring_up_middle_down = 0.9^5 = 0.59049\n", + "key 10 to key 2: same_hand * same_finger * not_home_row * skip_home_row * center_bottom = 0.8 * 0.9^3 = 0.5832\n", + "\n", + "key 12 to key 2: same_hand * roll_out * not_home_row * skip_home_row = 0.9^4 = 0.6561\n", + "key 10 to key 2: same_hand * same_finger * not_home_row * skip_home_row * center_bottom = 0.8 * 0.9^3 = 0.5832\n", + "\n", + "key 12 to key 1: same_hand * roll_out * not_home_row * skip_home_row * side_top = 0.9^5 = 0.59049\n", + "key 9 to key 1: same_hand * same_finger * not_home_row * skip_home_row * side_top = 0.8 * 0.9^3 = 0.5832" ] }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 45, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -1488,16 +1539,16 @@ "text": [ "Flow24x24 min = 0.5314410000000002, max = 1.0\n", "Flow24x24 key number pairs with minimum values:\n", - " 4 -> 11 (0.5314410000000002)\n", + " 23 -> 16 (0.5314410000000002)\n", " 10 -> 1 (0.5314410000000002)\n", + " 4 -> 11 (0.5314410000000002)\n", " 13 -> 22 (0.5314410000000002)\n", - " 23 -> 16 (0.5314410000000002)\n", - " 13 -> 23 (0.5609655000000001)\n", - " 11 -> 1 (0.5609655000000001)\n", - " 22 -> 16 (0.5609655000000001)\n", " 4 -> 10 (0.5609655000000001)\n", - " 22 -> 13 (0.5904900000000002)\n", - " 22 -> 15 (0.5904900000000002)\n", + " 22 -> 16 (0.5609655000000001)\n", + " 11 -> 1 (0.5609655000000001)\n", + " 13 -> 23 (0.5609655000000001)\n", + " 3 -> 11 (0.5832000000000002)\n", + " 24 -> 16 (0.5832000000000002)\n", "Flow24x24 key number pairs with maximum values:\n", " 5 -> 18 (1.0)\n", " 20 -> 18 (1.0)\n", @@ -1513,7 +1564,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAATkAAAEZCAYAAADsTVLHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO2dedgcVZn2f3cCsgwQNiWQsEQHBBQITlhGEZCABlFgRIfFkc0h38yYwCDIIowgH0LioIgsM0SWAf0grAI6JIAgMChLGAwBEkAkLCEExADKuAzkfb4/6jRpm7e76317re77d13n6qpTT51zqrrr6XPq3PWUIgJjjOlVRnS6AcYY00rs5IwxPY2dnDGmp7GTM8b0NHZyxpiexk7OGNPT2Mn1AZI2kRSSVuh0W4xpN3ZyPYakZyT9QdIbpQRs0IJ6viLpUUm/k7RQ0leq2O2SHOzpOcvdS9I9kl6TtETS9yStPojd2pJ+LemeRo/F9DZ2cr3JpyNitVICFregDgEHA2sBk4Apkg74MwNpReAc4P4hlDsKOJ3MMW8BjAX+dRC76cCCoTfb9Bt2cn2IpA0k3SRpqaSnJB2R8ldOvcB10/rJkt6StEZaP13SdwAi4psR8VBEvBURTwA3Ah+pqOoY4Fbg8Yr6b5b0rbL1qyRdksq9IiJmR8TvI+JV4HuV5Ur6a+CDwKVNOymmZ7GT60+uBBaR9ZY+C5whaWJE/BGYA+yS7HYGnmW5k9kZuKuyMEkCPgo8Vpa3MXA4cNog9R8OfEHSbpI+D2wHHFWlrTtXlDsSOB+YAviZRFMXO7ne5IZ0T+s1STeUb5C0IbATcHxE/DEi5gIXAV9IJncBu6RJiq2B76b1lcmc0X8NUt+pZL+l8p7Vd4F/iYg3Ko0jYgnwD8BlZMPZgyPid5V2kvYADgG+VpZ9JHB/RPx3nXNgDGAn16vsGxFrprRvxbYNgKUVTuVZYExavgvYFfgQ8AhwG1nPbkfgqYh4pbwwSVPI7s3tFRF/SnmfBlaPiKtqtPHHwEjgiYh4x+SBpB2BK4DPRsSTKW8DMid3Up3jN+ZtLCnoPxYDa0tavczRbQS8kJZ/Drwf+BvgroiYL2kjYC8qhqqSDgdOAHaOiEVlmyYCEyQtSeujgGWStoqIfVLeN8gmDsZJOjAiriwrd1vgJuDwiLi9rNztgfWB+dkImVWAVVI9YyJi2TDPiellIsKphxLwDLB7Rd4mZPevVkjr/wWcB6xMNiR9CdijzP7nwG+Bj6b1a9L658psPg8sAbYYpA2rA6PL0lXA2cDaafvOwCtkvcedSstp2wdTe/YfpNyVKso9imzmdnSnz7tT9yYPV/uTA8kc32Lgh8ApEXFb2fa7gBWBB8rWVwfuLrM5HVgHmFOmyft3gIj4XUQsKSXgD8D/RMTSNFN7OTAlIl6IbKh6MXBpmsA4Bng3cHFZuY+lcv9UUe7rwJtp2ZhBUYQnqIwxvYt7csaYnsZOzhjTFUi6RNLLkh6tsl2SvpsE7PMkfShPuXZyxphu4T/IHhGsxp7ApilNBv4tT6F2csaYriAi7gaW1jDZB7g8Mu4D1pS0fr1y7eSMMUVhDPB82foilovYq9LNYmBP+xrTetTIzgNLNst9nY5c/5f/h2yYWWJGRMwYQnWDtbVu/d3s5Njia2dX3bbgtKMBeN/MM6ra/OqAr+a2yVPXTp85q3pjgXuuP7ZmOeVljTv3W1VtFk49BsjX7j23OLGqzawFZwIwaeuTq9rMnpeFedtt4rSqNnfcfgKQ7xx123fWrLraaZP3N9Ss42+EAQZy2yaHNhSnVskiYMOy9bHkCCPWMicnaXOyMfQYMm+7GLgpIhwDzJgeYVnkd3JNcDY3kcUtnAnsALweES+2od53Iul4MlX9TJar5scCV0qaGRHVuw3GmMIw0MS7SpKuJAsOsa6kRcApZE/eEBH/DtwMfBJ4Cvg9cFieclvVk/si8IGIeLM8U9K3yWKDDerkJE0mjdkvvPDCFjXNGNMs3hxCTIRV6myPiAPrbA/gS7krTLRqdnWAwd8rsH7aNigRMSMiJkTEhMmTJ1czM8Z0CQNE7tQpWtWT+2fgdkm/ZPmU70bAX5JFdDXG9ADLCiCCaImTi4jZkjYji/81hmzqdxEwJxzzy5ieoZM9tLx0cxSSrm2YMT1EQzq5JS9skPs6HT1mcUN1DZeu1skZY7qbNwvQF+lqJ5dH7Hjsw/tXtTlrm6ty2zQq5CzZbfnV2kLO+WfkF2nmaXeec5RHMPzh/auLk39+VX5xcrOOq1nfWbPqaqdNnt9ZPbuhHH8jLOt+H9fdTs4Y093klwJ3Djs5Y8ywWdbYLb22YCdnjBk2Ax6uGmN6GffkjDE9zZvR/SEp7eSMMcOmCD05i4GN6W8a8lJzntsk93W63UbPWAxsjCkWA9H9PbmudnLNinzaTjFwXiFnLdFwSTDcLDFwHqFvHsGwxcDtsSmUGLgAw9VWRwYeA9wfEW+U5U+KiNmtqtcY0z7ejK7uJwEtiicn6UjgRmAq8Kikfco21/6bMsYUhmUod+oUrXLDRwB/FRFvSNoEuFbSJhFxDjVudDoysDHFYlkfS0hGloaoEfGMpF3JHN3G1HByFW/zibPrvLXIGNNZBgpwT65VbniJpPGlleTwPgWsC2zVojqNMW1mGSNyp07Rqp7cwcBb5RkR8RZwsCSPQ43pEYowXLUY2Jj+pqHx5vW/2jb3dfqZ9/3CYmBjTLHo5DA0L13t5PKIWPOIYdthU7IbP6W2zdzz8gt0d/rMWVVt7rn+2Nzl7Ll+9VdVznrxfAD2GPG5qja3DVyTlZNDMNwsAXcem3bW1U6bPL+zenZDOf5GGCjAcLWrnZwxprtxT84Y09Ms87OrxpheZsA9OWNML/NmjOx0E+piJ2eMGTZF0MnZyRljhk0RJh4sBjamv2lo5uC8x3fLfZ1O2fwOi4GNMcWiCD25rnZyecSw7YwyO7Bks+qNBUaMfjKXTb2yhmKTJ8JwHtHouHOri4oXTs1Exd0WrbfR76zZ30Uem16LDFyEiYe2uWFJl7erLmNMexiIEblTp2hJT07STZVZwMckrQkQEXu3ol5jTHvp53c8jAXmAxeRTSAImABUHxPhyMDGFI1+fnZ1AnAUcBLwlYiYK+kPEXFXrZ0qIwNfPrv6PTljTOfpW51cRAwAZ0u6Jn2+1Kq6jDGdo5/DnwMQEYsi4nPALOAHrazLGNN+3hwYmTvlQdIkSU9IekrSCYNs31jS7ZLmSbpT0ti6ZVoMbExf01BX7IR5n819nU7b+tqadUkaCTwJ7AEsAuYAB0bE/DKba4AfR8RlknYDDouIL9Qqt/sH1MaYrmUglDvlYHvgqYh4OiL+F5gJ7FNhsyVwe1r+6SDb30FX3yfLE/U2jxg2jyCyUTFsqax2i4HzCELziKrzCIYtBm7cptfEwEMJtVSunkjMSJONJcYAz5etLwJ2qCjmYWA/4Bzgb4DVJa0TEb+pVm9XOzljTHczlKCZFeqJwRissMrh8LHAeZIOBe4GXqDizYCV2MkZY4ZNzmFoXhYBG5atjwUWlxtExGLgMwCSVgP2i4jXaxVqJ2eMGTZNfnZ1DrCppHFkPbQDgIPKDSStCyxNMrUTgUvqFeqJB2PMsGnmxEN6Af0U4BZgAXB1RDwm6TRJpUdBdwWekPQksB7wjXrluidnjBk2zX6sKyJuBm6uyPta2fK1wLVDKdNOzhgzbIrwxIPFwMb0Nw15qcPmHJb7Or10u0sdGdgYUyzeyvm4Vifpaic3fkp1gerc8/JHvW1W9Nw8YuA8NtBeMXCeY2tWFGaLgWvb9J4YuPuHqy2ZXZW0g6Q10vIqkr4u6UeSpksa1Yo6jTHtp8mPdbWEVklILgF+n5bPAUYB01PepS2q0xjTZvo2/DkwImleACZExIfS8j2S5raoTmNMm+lkDy0vrXKvj0o6LC0/LGkCgKTNgDer7SRpsqQHJT04Y0atR9yMMd3AAMqdOkWrenJ/D5wj6WTgFeBeSc+TRRj4+2o7VYY/v6DGxIMxpvO8NdD9D021Kvz568ChklYH3pvqWRQRL7WiPmNMZyjCcNViYGP6m4a81F53H5n7Ov3Pnb9rMbAxplgUQSfX1U4uj4g1jyCyWdFzmykGziPSbJYYOI+oullRmC0Grm3Tc2LgAgxXu9rJGWO6Gzs5Y0xP07ezq8aY/iDckzPG9DKeeDDG9DS+J2eM6WmKMFy1GNiY/qYhL7XjLSfmvk7v+8SZFgMbY4qFh6sNsucWJ1bdNmvBmUDzxMCNRhiGTBDbTDFwO0WzzRKWdpsYuJ3nuR3HBd0lBu7egeByWuLkJL2L7MWwiyPiJ5IOAj5M9i7FGRFRNdySMaY49PPs6qWp7FUlHQKsBlwPTAS2Bw5pUb3GmDZShImHVjm5rSJia0krAC8AG0TEMkk/AB5uUZ3GmDbTz/fkRqQh618Aq5K942EpsBKwYrWdJE0GJgNceOGFLWqaMaZZDAz0r5O7GHgcGAmcBFwj6WlgR2BmtZ0qIwP/8OzqEw/GmM7Tt8PViDhb0lVpebGky4Hdge9FxAOtqNMY036KMFy1GNiY/qYhL7XlDafmvk7n73uqxcDGmGLRt8PVZrHHiM9V3XbbwDVAPsFwHqHvbhOnVbW54/YTgNrRcyGLoFsrwjAsjzKcR8g57tzq9S2cmkXrzXNszbJplqi6nQLuZtXVTptaxwXN/84aoQjD1a52csaY7sY9OWNMb1OAO+d2csaYYeOenDGmp+leccZy7OSMMcPGPTljTE8TBXisy2JgY/qbhrzUe684I/d1+vRBX61bl6RJwDlkj4ReFBHTKrZvBFwGrJlsToiIm2uV2f0vTTTGdC0Ryp3qIWkkcD6wJ7AlcKCkLSvMTgaujohtyWJWXlCv3K4eru65/peqbpv14vkATNr65Ko2s+ednpWTQzCcp5zxU2qLNOeed3QuwTBQUzRcEgw3S8Rbq02l9lgM3D02RRIDN3m8tT3wVEQ8DSBpJrAPML+ixjXS8ihgcb1Cu9rJGWO6m6FMPJSHUkvMSJGHSowBni9bXwTsUFHMqcCtkqaShXLbvV69dnLGmOEzhJ5cRSi1wRjMY1bWcCDwHxHxLUl/DXxf0gcjYqBaoXZyxpjh01wJySJgw7L1sbxzOPpFYBJARNwraWVgXeDlaoW2ZOJB0ihJ0yQ9Luk3KS1IeWvW2G+ypAclPThjRi2Hb4zpCmIIqT5zgE0ljSt7GdZNFTbPkb0rBklbACsDv65VaKtmV68GXgV2jYh1ImId4GMp75pqO0XEjIiYEBETJk+eXM3MGNMthPKnekVFvAVMAW4he7Pf1RHxmKTTJO2dzI4BjpD0MHAlcGjU0cFVHa5K2gr4HtnNwFnA8RHxatr2QERsX6PcTSJiesUBLAGmSzq8VoOMMcWh2TLbpHm7uSLva2XL84GPDKXMqmJgSfcApwP3AX8PHAbsHRG/kvSLpFOptu+twE+AyyLipZS3HnAosEdE1J0RwWJgY9pBQzfVNr74m7mv02e/eFxHHo+oNVxdLSJmR8RrEXEWWTdytqQdqe+A9gfWAe6StFTSUuBOYG2geiRMY0yh0IByp05Ra3ZVkkZFxOsAEfFTSfsB15E5q6qkYe3xKVUWehjZy6fr0iwRax6bPILhWsJKyMSVeWzqlVWy2fKr1ds9/4zmCnTz2Bz78P5Vbc7a5qrc7clTTrfV1U6bZv6G8tTXEAUYb9XqyU0HtijPiIh5ZDMb1zdQ59cb2NcY0000ceKhVVTtyUXEFVXynwOOqFWopHnVNgHr5W6dMaa7KUBPrlVi4PWAT5BJRsoR8PMW1WmMaTd97OR+TDZxMbdyg6Q7W1SnMabd9IKTk7R2RCwdSqER8cUa2w4aSlnGmO6lk7OmecnzxMP9kq6R9ElJ3X9Expj20dzHulpC3cjAybHtDhxOFu/pKrIoAE+2uG0F6AgbU3ga6riMO/dbua/ThVOP6ToxMACRcVtEHEj25MMhwAOS7kqhTowxfYoif+oUee7JrQP8HfAF4CVgKllkgPFkD9uPa1XjihRltlRWM4Wc7Ty2dkYGbmfE4zwRmPOUUysq9Nzzmis632NE7YeCbhvIYlzkiZyd59gaokfe1nUv8H1g34hYVJb/oKR/b02zjDGFoAA3lfI4ufdHREj6i8oNlZFGjDH9harG4+0e8syu7ihpPll8JyRtI6nuG3KMMX1AAWZX8zi575A9vfAbgIh4GNi51g6S1pB0pqTvSzqoYltVB+nIwMYUjB5xckTE8xVZy+rscinZ1PR1wAGSrpO0Utq2Y416HBnYmALRE7OrwPOSPgxEirt+JGnoWoP3RcR+afkGSScBd5SFMDbG9AIFmF3NIwZeFziHTBAs4FbgyFqPeklaAHyg/DVhkg4BjiN7pnXjHG0rwLyNMYWnIS+16bSzc1+nvzzh6O4SA0saCxARr0TE5yNivYh4T0T8HfVjrP8I2K08IyIuI3sJxf822GZjTLdQgHtytYart0v6REQ8U56ZIvueTObIBiUijquSP1tSbbVsGUWKMlsqK49N3ja189iada7bWU6zohk3KwJzs2xqCYZhuWi4WZGzG6GT99ryUmvi4WjgNkmbljIknQh8GdilgTodGdiYXqHIPbmIuFnSn4BZkvYle251O2Dn0qsJq+HIwMb0CQXoydWcXY2I2yUdSvamrZ8DEyPijznKdWRgY/qAIgxXa71c+ndkflrASmQvsHk5hV6KiFijRrmODGxMP1BkJxcRqw+3UEcGNqY/KHRPzhhj6lIAJ1dXDNxBurZhxvQQDQl0Nz8lvxj48a93RgzsnpwxZth4uNogFgP3rxg4j02zxMB52txOwXAtkS8sF/rmiTLcajFwEcZbXe3kjDHdTRGCZtrJGWOGTwF6crniyTUDSe9pV13GmPbQK/HkhoyktSuzyF5juC3ZjO6gYZokTQYmA1x44YVQS25sjOk8BejJtWq4+grwbEXeGOAhstPy3sF2iogZQCnueUyv83o/Y0yH6WMndxxZkM2vRMQjAJIWRkTL3tFqjGk/fTvxEBFnSZoJnC3peeAUCuHzjTFDoQg6uZY/8SDp08BJwCYRMXoIuxbg9BlTeBp6CmGrY/I/8fDIt+o/8SBpEtnrFkYCF0XEtIrtZwMfS6urAu+JiDVrldlyCUlE/EjST4D3QRZZOCIubXW9xpg20MSuiKSRwPnAHsAiYI6kmyJi/tvVRRxdZj8V2LZeuW3RyUXEH4BH0+rXyV5ZWJc8au1mqcwbratUVh6bvG1q57E161wX6TsrlTPu3OpPGCycmj+M+E6fOauqzT3XH5u7nN0mTqtqA3DH7ScAMGnrk6vazJ53OpDvqYhGaPLDqNsDT0XE0wDpltc+wPwq9geS3QqrSaskJI4MbEw/0NybSmOA8nc8LwJ2GMxQ0sbAOOCOeoW2qifnyMDG9AFDmV0t18EmZiTZ2Nsmg+xWzY0eAFwbEfVedN8yJ+fIwMb0A0PoyVXoYAdjEbBh2fpYYHEV2wOAL+Wpt1USEkcGNqYPaLKEZA6wqaRxwAtkjuwd/kLS+4G1gHvzFNq2Z1eNMT1IE19JGBFvAVOAW4AFwNUR8Zik0yTtXWZ6IDAzcurfHIXEGDNsmi0GjoibgZsr8r5WsX7qUMp0+HNj+puGVCDb/lN+MfAvLnD4c2NMwejbZ1ebRbeFPx9Ysln1xgIjRj+Zy6ZeWUOx6bbw53kEse0UAzfrHDbLJk8Y9bzhz8dPqV7W3PPyi6EbogDjra52csaY7qYID+i3MzLwOu2qyxjTJpo4u9oqWuLkJE2TtG5aniDpaeB+Sc9K2qXGfpMlPSjpwRkzamkGjTHdgCJyp07Rqp7cXhHxSlr+V2D/iPhLsugCVW84RMSMiJgQERMmT55czcwY0yVoIH/qFK1ycitKKt3vWyUi5gBExJPASi2q0xjTbgowXG3VxMP5wM2SpgGzJX0HuB6YCLzjeVZjTDEpwsRDy8TAknYF/hHYjMyZPg/cAFySHt+oRwFOnzGFpyGB7vaHfDv3dfrAZV/uLTFwRNwJ3FmZL+kwcgbNNMZ0N0XoyXVCJ5c7MrDFwMUTA+cR6OYRxOYpJ48Ytp3nuVk2tQTVMLQowxYDOzKwMaYBNND9Xs6RgY0xw6afh6uODGxMP9CvTs6RgY3pDxyFxBjT2/RrT84Y0x8UYeLBkYGN6W8aEujutN9Zua/Te647trfEwMaYPqAAXZGudnIWAxdPDDzu3OpRbRdOPSZ3OY1G0C1Fz23WeW6nYLiWyBeWC32bFYW5EfpZQmKM6Qe693bX29jJGWOGTRF6cq2KDDxB0k8l/UDShpJuk/S6pDmStq2xnyMDG1Mg+jlo5gXAN4H/JHuM68KIGAWckLYNiiMDG1MwBiJ/6hAtiwwcEbMi4kogIuJasoXbgZVbVKcxpt30cWTgP0r6ODAKCEn7RsQN6SU2y1pUpzGmzRThnlxLxMCStiEbrg4AR5NFCD4EeAE4IiLyRCIpwOkzpvA0JNDdddL03NfpnbOP74gYuCXD1Yh4OCI+ERF7RsTjEXFURKwZER8A3t+KOo0x7UeRP3UKRwa2GDi3TbPqakcE3ZIYtp1i4GZ9X7UE1bBcVN2sKMyNUIRnVx0Z2BgzfPo41JIjAxvTB6iPn3hwZGBj+oHu93GODGyMaYA+7skZY/qAvp14MMb0B0V4x4MjAxvT3zQk0N3jI6fnvk5v+9nJjgxsjCkYBeiKdLWT6zYxcK1ySmXlscnbpnYeW7PO9Z5bnFjVZtaCM4F8ItY8NnkiA+cRwzbr/DTrHOaNDJznHLU+MnBzvZykScA5wEjgooiYNojN3wKnkrnYh+tNZna1kzPGdDlNdHKSRgLnA3sAi4A5km6KiPllNpsCJwIfiYhXJb2nXrl2csaYYaNlTe3JbQ88FRFPA0iaCewDzC+zOQI4PyJeBYiIl+sV2qrIwKMkTZP0uKTfpLQg5a1ZYz9HBjamSETkTuXXd0qVkXHHAM+XrS9KeeVsBmwm6WeS7kvD25q0qid3NXAHsGtELAGQNJos3NI1ZN3RdxARM4CSd4vpNe4nGGO6gCEMVyuu78EYbPa1soIVgE2BXYGxwH9J+mBEvFat0FZFBt4kIqaXHBxARCyJiOnARi2q0xjTbgaGkOqzCNiwbH0ssHgQmxsj4s2IWAg8Qeb0qtIqJ/espOMkvR1xRNJ6ko7nz7ujxpgCo4jcKQdzgE0ljZP0LuAA4KYKmxuAjwFIWpds+Pp0nTa2JDLwWmQvrdmHLCJJAC+RNXh6RCzNUUwBFDjGFJ6GBLqTtvmX3Nfp7If/b926JH0S+A6ZhOSSiPiGpNOAByPiJkkCvgVMInuVwjciYmbNMlv1xIOkzcm6m/dFxBtl+ZMiYnaOIuzkjGk9jTm5rU7K7+Qe+UbvPPEg6UjgS8AC4CJJR0XEjWnzGUAeJ9c0sWMem0brKpWVxyZvm9p5bM0615O2Prmqzex5pwP5BMO5yln/S9XLefF8IN9x5YkwnEd4PH5K9brmnpf/HOYVA+dpU57jb4gCPLvaqtnVI4C/iog3JG0CXCtpk4g4hwb/OYwx3UM/B80cWRqiRsQzknYlc3QbYydnTO9QACfXqtnVJZLGl1aSw/sUsC6wVYvqNMa0m4HInzpEq3pyBwNvlWdExFvAwZIubFGdxph2M9D9N+VaFf58UY1tP2tFncaYDlCA4aof0DfGDJ8ChD93ZGBj+puGJgL3HPfl3NfprIXf7h2dnDGmT+jeTtLbdLWTsxi4eGLg3Sa+I5Dr29xx+wm568ojGN5jxOeq2tw2cA0A486tLphdODUTzOY5rmYJhpspBm7W99oQBRiudrWTM8Z0Of06u2qM6RMKMFxtVWTgNSSdKen7kg6q2HZBjf0cGdiYIjEwkD91iFY98XAp2azNdcABkq6TtFLatmO1nSJiRkRMiIgJkydXRkY2xnQdQwh/3ilaNVx9X0Tsl5ZvkHQScIekvVtUnzGmExRguNoqJ7eSpBERMQCQAt8tAu4GVmtRncaYdlOA2dVWRQb+JnBrRPykIn8ScG5E1IzJnuj+s2dM8WksaObaR+QPmrn0ex0RA7fknlxEHAcskjRR0mpl+bOBI1tRpzGmA/TrPTlJU4EpZJGBL66IDPwNYFaecvIIJ499eP+qNmdtc1Vum0brKpWVxyZvm9p5bM061+0UcOcRDLfzPG/51erHPv+Mo3OX00xBeZ76GqKPdXKTcWRgY3qfPp54cGRgY/qAKEBPzpGBjTHDZ9lA/tQhHBnYGDN8ovt7co4MbIwZNlEAnZwf0DfGDJ8C9OQcGdiY/qahicA9Ru6f+zq9bdlVnZl0jIjCJGCybXrLphvb1M82vZg63oAhNRYetE1v2XRjm/rZphdTqyQkxhjTFdjJGWN6mqI5uTzhgm1TLJt212ebPqObZ1eNMaZhitaTM8aYIWEnZ4zpaezkjDE9Tdc+1iVpc2AfYAzZ0w+LgZsiYsEwyxoD3B8pBFTKnxRZtGIkbQ9ERMyRtCUwCXg8Im6uUublEXFwnXp3ArYHHo2IW1PeDsCCiPitpFWAE4APAfOBMyLidUlHAj+MiOdrlP0u4ABgcUT8JL368cNkgUpnRMSbye59wN8AG5IFTfglcGVEvF7zpBnTI3TlxIOk44EDgZlA6WH/sWQX9cyImJajjMMi4tLkML5EdvGPB96OUizpoYj4kKRTgD3JnP5twA7AncDuwC1p/c+KBz4G3AEQEXun8h6IiO3T8hGp3h8CHwd+FBHTJD0GbBMRb0maAfweuBaYmPI/I+l14H+AXwFXAtdExK8rju//pfauCrxG9oKg61M5iohD0rF/GrgL+CQwF3iVzOn9U0TcWe88dguS3hMRLzehnHUi4jfNaNMw6h4FnAjsC7w7Zb8M3AhMi4jX6uw/KyL2lLRGKmcsMCsiriizuSAi/knSaOAUYAD4GjAV2I/sOjgqIl5s7tF1MZ1WIw+WgCeBFQfJfxfwy5xlPJc+HwFWS8ubAA+SfckAvyizGUnmMH4LrJHyVwHmAQ8BPwB2BXZJny+m5V3K6vxF2fIc4N1p+S+AR9LygjKbh+GFjDMAAAZ3SURBVCraPLdUDtmthI8DFwO/BmYDhwCrJ5t56XMF4CWyQKWQOeB55ceVllcF7kzLG5Ud+yhgGvA48JuUFqS8NXOe61npcw3gTOD7wEEVNhekz9HAvwHnA+sAp6Z2Xg2sn2zWrkjrAM8AawFrJ5tJZWWPSudpHnAFsF7Knwasm5YnAE8DTwHPlr639N2eTPYazWrHNwH4afoNbEj2R/h6+o63TTarAacBj6VtvwbuAw4tK+cW4HhgdFne6JR3W1r/UJX0V8CLyea6dGz7Ajel9ZXKf1Pp9zKVbKQwL9WxUcq7sdPXeDtTxxtQ5Uf1OLDxIPkbA0+Urc+rkh4B/pRs5leUsVr6AXybMqdStv0XFfZzyRzO0enHPT7lPz1I+x5OF+I6VDxCw3Kncg1wWFq+FJiQljcD5pT/UMv2XRHYm6xX9+uU9yiZ018L+B3LL/6VSY40nYfSj38t4L/Lynw0fda98FJe2y4+st7Hwor0Zvp8uvIcARcBp6ffx9HADaXjL7P5KbBd2bl+MC0vBM4CngMeSPtvUHH+HyDr6R8IPA98NuVPBO5NyzcCh5L1rr4M/AuwKXAZ2W0IKPvtDvLbeSJ9LiMbIfx0kPSH0m+yYt+TgJ+R/e5K57n8N/1c5W+609d4O1PHG1DlC59E9o87i0zAOCNdHE/x5//gL5ENQTeuSJuQ3asi/WDGV5S/AnA5sCyt3w+smpZHlNmNqriYxpI5qfMqfzhp+zNkvYWF6XN0yl+N5Q51FPAfZEPR+9PF+zTZkHKbyh/oIHWskj6PTvs9S/YGtNuB75E5tlOSzVFkjmQG2R9Hybm+G7g7Lde98NJy2y4+4Nj0fW9Vtm1hhe1DlfsNUs7jwApp+b4Km0cGKeejwAXAknRck3O0ufTn9XBFfukPawTZvV2AW4HjSD3NlLcemaP/SVp/FNi0yvfxfPpcQNnvNOUdQtaLfLayPcDpgx17v6SON6Bqw7Ifx45k9xE+m5ZHVthcDOxUZf8r0udYynopFTYfSZ8rVdm+bvmFVpa/F+nfOeexrAqMq8hbHdiGrCe0XsW2zXKWuwGp1wGsmc7T9hU2H0j5m1cpo+6Fl/LaevGx/A/l2+lcPV1hu4isx3QMmbNX2bbScH1qOr7dyIbF3wF2Br4OfD/ZPDTI8Ywk+6O9NK3fS3br4HNkfyr7pvxdWN4j/Hnpt0h2H/SWsvJKvbS1gOlkzvdVYGk6Z9NZ3hP/LPD+Kue5VO83gd0H2T6JdDuHbOi82iA2fwlcO9zrsoip4w1w6vAP4M8vvKUVF95aZXYdufiSw7gPWFKRf0pFKt3/HA1cXma3K3AV2X3OR4Cbyd4mV+rhzcxxjrYhG9bPAjYHziGb7HkM+HCy2ZpsWPsacA/pj4qs13xkWVmbk01orVZ5jipsJg7TZs+hlNMPqeMNcOreRBreNsOuERuyCaAPtqOuVtqQ3VZ4AriB7NbGPmU2Dw3BZmozbPoldbwBTt2bGOS+43DtbJMNx8k3098Wm35JXSsGNu1B0rxqm8juzeW2s01tG/K9j7idNn2BnZxZD/gE2Y3wckR2M30odrapbbNE0viImAvZ+4glfQq4hOXvI26nTV9gJ2d+TDasmVu5QdKdQ7SzTW2bPO8jbqdNX9CVj3UZY0yzcBQSY0xPYydnjOlp7OTMoEgqD0n1SUm/lLRRg2VuLuleSX+SdGzjrTSmPp54MDWRNBE4F/h4RDzXYHFLycSu+zbcMGNy4p6cqYqkj5I99L9XRPwq5b1b0nWS5qT0EUkjUk/v3clmhKSnJK1bXl5EvBwRc8iCEhjTFuzkTDVWIgsftG9EPF6Wfw5wdkRsRxY84aKIGCCLtfb5ZLM72YP4r7SzwcYMhp2cqcabZCLWL1bk7w6cJ2kuWcy4NSStTiYyLYWDP5wsVp4xHcdOzlRjAPhbYDtJXy3LHwH8dUSMT2lMRPwusvdRvCRpN7Jw8bM60GZj3oGdnKlKRPwe+BTweUmlHt2twJSSjaTxZbtcRDZsvToilrWtocbUwE88mEGR9EZErJaWNwTuBv6ZLNLv+cAWZLPzd0fEPyS7FcneEbF9xX28UpmjyaJhrEHWU3wD2DIiftv6IzL9ip2caRqSJpBNSny0020xpoR1cqYpSDoB+EeWz7Aa0xW4J2eM6Wk88WCM6Wns5IwxPY2dnDGmp7GTM8b0NHZyxpiexk7OGNPT/H+8s/89k9LMUgAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -1527,22 +1578,18 @@ "source": [ "# Penalizing factors (set to less than 1.0):\n", "same_hand = 1.0 # Taken care of by splitting up the most frequent letters across left/right sides above\n", + "same_finger = 0.8 # use same finger twice for a non-repeating letter (worse than 2 fingers)\n", "roll_out = 0.9 # roll out from index to little finger\n", + "not_home_row = 0.9 # at least one key not on home row\n", + "skip_home_row = 0.9 # one key on top row, the other on bottom row\n", "side_top = 0.9 # either index or little finger on top row\n", - "center_bottom = 0.9 # either middle or ring finger on bottom row\n", "side_up_1away_down = 0.9 # index above middle, or little above ring \n", "side_up_2away_down = 0.95 # index above ring, or little above middle\n", "side_up_3away_down = 1.0 # index above little, or little above index -- assumed to be negligible\n", + "center_bottom = 0.9 # either middle or ring finger on bottom row\n", "ring_up_middle_down = 0.9 # ring above middle\n", - "same_finger = 0.9 # use same finger twice for a non-repeating letter\n", - "not_home_row = 0.9 # at least one key not on home row\n", - "skip_home_row = 0.9 # one key on top row, the other on bottom row\n", "\n", "all_24_keys = [1,2,3,4, 5,6,7,8, 9,10,11,12, 13,14,15,16, 17,18,19,20, 21,22,23,24]\n", - "# Left: Right:\n", - "# 1 2 3 4 13 14 15 16 \n", - "# 5 6 7 8 17 18 19 20\n", - "# 9 10 11 12 21 22 23 24\n", "\n", "# Create a matrix and multiply by flow factors that promote easy interkey transitions:\n", "T = np.ones((24, 24))\n", @@ -1674,7 +1721,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 46, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -1687,7 +1734,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1718,32 +1765,32 @@ " 5 6 7 8 17 18 19 20\n", " 9 10 11 12 21 22 23 24\n", "\n", - "Flow24x24 min = 0.5314410000000002, max = 1.0\n", - "Flow24x24 key number pairs with minimum values:\n", - "\n", - " 4 -> 11 (0.5314410000000002)\n", - " 10 -> 1 (0.5314410000000002)\n", - " 13 -> 22 (0.5314410000000002)\n", - " 23 -> 16 (0.5314410000000002)\n", - " 13 -> 23 (0.5609655000000001)\n", - " 11 -> 1 (0.5609655000000001)\n", - " 22 -> 16 (0.5609655000000001)\n", - " 4 -> 10 (0.5609655000000001)\n", - " 22 -> 13 (0.5904900000000002)\n", - " 22 -> 15 (0.5904900000000002)\n", - "\n", - "Flow24x24 key number pairs with maximum values:\n", - "\n", - " 5 -> 18 (1.0)\n", - " 20 -> 18 (1.0)\n", - " 5 -> 17 (1.0)\n", - " 5 -> 19 (1.0)\n", - " 5 -> 20 (1.0)\n", - " 19 -> 17 (1.0)\n", - " 19 -> 18 (1.0)\n", - " 19 -> 19 (1.0)\n", - " 6 -> 6 (1.0)\n", - " 6 -> 7 (1.0)" + " Flow24x24 min = 0.5314410000000002, max = 1.0\n", + " Flow24x24 key number pairs with minimum values:\n", + "\n", + " 23 -> 16 (0.5314410000000002)\n", + " 10 -> 1 (0.5314410000000002)\n", + " 4 -> 11 (0.5314410000000002)\n", + " 13 -> 22 (0.5314410000000002)\n", + " 4 -> 10 (0.5609655000000001)\n", + " 22 -> 16 (0.5609655000000001)\n", + " 11 -> 1 (0.5609655000000001)\n", + " 13 -> 23 (0.5609655000000001)\n", + " 3 -> 11 (0.5832000000000002)\n", + " 24 -> 16 (0.5832000000000002)\n", + "\n", + " Flow24x24 key number pairs with maximum values:\n", + "\n", + " 5 -> 18 (1.0)\n", + " 20 -> 18 (1.0)\n", + " 5 -> 17 (1.0)\n", + " 5 -> 19 (1.0)\n", + " 5 -> 20 (1.0)\n", + " 19 -> 17 (1.0)\n", + " 19 -> 18 (1.0)\n", + " 19 -> 19 (1.0)\n", + " 6 -> 6 (1.0)\n", + " 6 -> 7 (1.0)" ] }, { @@ -1758,7 +1805,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 49, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -1781,10 +1828,10 @@ " 13 -> 22 (0.5309299990384617)\n", " 11 -> 1 (0.5581606725000001)\n", " 22 -> 16 (0.5581606725000001)\n", - " 13 -> 23 (0.558592184423077)\n", " 4 -> 10 (0.558592184423077)\n", - " 1 -> 10 (0.5856071019230771)\n", - " 16 -> 23 (0.5856071019230771)\n", + " 13 -> 23 (0.558592184423077)\n", + " 16 -> 24 (0.5773680000000001)\n", + " 24 -> 16 (0.5773680000000001)\n", "SpeedStrengthFlow24x24 key number pairs with maximum values:\n", " 7 -> 18 (1.0)\n", " 18 -> 7 (1.0)\n", @@ -1800,7 +1847,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1812,11 +1859,11 @@ } ], "source": [ - "if use_speed_data:\n", + "if speed_factor > 0.0:\n", " SpeedStrengthFlow24x24 = Speed24x24 * Strength24x24 * Flow24x24\n", "else:\n", " SpeedStrengthFlow24x24 = Strength24x24 * Flow24x24\n", - " \n", + "\n", "# Print:\n", "print_matrix_info(matrix_data=SpeedStrengthFlow24x24, matrix_label=\"SpeedStrengthFlow24x24\", nlines=10)\n", "heatmap(data=SpeedStrengthFlow24x24, title=\"SpeedStrengthFlow24x24\", xlabel=\"Key 1\", ylabel=\"Key 2\")\n", @@ -1829,7 +1876,7 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 50, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -1842,7 +1889,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWoAAAD4CAYAAADFAawfAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO3deXxddZ3/8dcn+9osTdK0WZruC6VrulHKjjKAoIBIQUAQCqiAM/qbh4oOM46OzvhjEEHxVwHZpAwwZRFZZBWBLqRN95buSZu2abokzdJs935/fyRgLWlz09zlJPf9fDzy4Cb33HPeyeP2zbnnfM/3mHMOERHxrphIBxARkRNTUYuIeJyKWkTE41TUIiIep6IWEfG4uFCsNCcnx5WUlIRi1SIi/dLy5cv3O+dyu3ouJEVdUlJCWVlZKFYtItIvmVnF8Z7ToQ8REY8LqKjN7B/NbJ2ZrTWzhWaWFOpgIiLSoduiNrMC4A6g1Dk3AYgFrgp1MBER6RDooY84INnM4oAUYHfoIomIyNG6LWrnXBXwf4FKYA9Q55z7c6iDiYhIh0AOfWQBlwLDgCFAqpl9tYvl5ptZmZmV1dTUBD+piEiUCuTQx3nAdudcjXOuDVgEnHbsQs65Bc65UudcaW5ul0MBRUTkJARS1JXALDNLMTMDzgU2hDaWiIh8IpBj1EuB54AVwJrO1ywIcS4REekU0JWJzrm7gbtDnEWkz3hqaWVQ1nP1zOKgrEf6N12ZKCLicSpqERGPU1GLiHicilpExONU1CIiHqeiFhHxOBW1iIjHqahFRDxORS0i4nEqahERj1NRi4h4nIpaRMTjVNQiIh6nohYR8TgVtYiIx6moRUQ8TkUtIuJxKmoREY/rtqjNbIyZrTzq67CZfTsc4UREJIB7JjrnPgYmA5hZLFAFPB/iXCIi0qmnhz7OBbY65ypCEUZERD6rp0V9FbCwqyfMbL6ZlZlZWU1NTe+TiYgI0IOiNrME4BLg2a6ed84tcM6VOudKc3Nzg5VPRCTq9WSP+h+AFc656lCFERGRz+pJUc/jOIc9REQkdAIqajNLAc4HFoU2joiIHKvb4XkAzrkmYGCIs4iISBd0ZaKIiMepqEVEPE5FLSLicSpqERGPU1GLiHicilpExONU1CIiHqeiFhHxOBW1iIjHqahFRDxORS0i4nEqahERj1NRi4h4nIpaRMTjAprmVES87amllUFZz9Uzi4OyHgku7VGLiHicilpExOMCvRVXppk9Z2YbzWyDmc0OdTAREekQ6DHq+4DXnHNXmFkCkBLCTCIicpRui9rMBgBnAF8DcM61Aq2hjSUiIp8I5NDHcKAG+L2ZlZvZQ2aWeuxCZjbfzMrMrKympiboQUVEolUgRR0HTAUedM5NARqB7x27kHNugXOu1DlXmpubG+SYIiLRK5Ci3gXscs4t7fz+OTqKW0REwqDbonbO7QV2mtmYzh+dC6wPaSoREflUoKM+bgf+0DniYxtwQ+giiYjI0QIqaufcSqA0xFlERKQLujJRRMTjVNQiIh6nohYR8TgVtYiIx6moRUQ8TkUtIuJxKmoREY9TUYuIeJyKWkTE41TUIiIep6IWEfE4FbWIiMepqEVEPE5FLSLicSpqERGPU1GLiHicilpExONU1CIiHhfQrbjMbAdQD/iAduecbsslIhImgd7cFuBs59z+kCUREZEu6dCHiIjHBVrUDvizmS03s/ldLWBm882szMzKampqgpdQRCTKBVrUc5xzU4F/AL5pZmccu4BzboFzrtQ5V5qbmxvUkCIi0SygonbO7e787z7geWBGKEOJiMjfdFvUZpZqZumfPAY+B6wNdTAREekQyKiPQcDzZvbJ8k85514LaSoREflUt0XtnNsGTApDFhER6YKG54mIeJyKWkTE41TUIiIep6IWEfE4FbWIiMepqEVEPE5FLSLicSpqERGPU1GLiHicilpExONU1CIiHqeiFhHxOBW1SA+1+fy0tPkiHUOiSE9ubisS9ZZuO8C3/2cle+qaSY6PZXBGEldMKyQzJSHS0aQf0x61SACcc9z/1mbm/W4JiXExfG78IE4tzKCq9ggPvb+d2qbWSEeUfkxFLRKAJ5dUcM8bm7h44hBevmMuZ43J44uTC7hxzjAaW9p56P3t1B1pi3RM6adU1CLd2HmwiZ+9upG5o3K476rJpCX+7YhhUXYKN84ZRkNLOy+urIpgSunPAi5qM4s1s3IzezmUgUS8xO93/J/nVhFjxs8vn0jnLen+TlF2CueMyWPj3nq27GuIQErp73qyR30nsCFUQUS86KlllSzZdpAfXjSOgszk4y43e8RAMlPieXXtHvzOhTGhRIOAitrMCoGLgIdCG0fEO5rbfPzqrc3MKMnmK9OLTrhsfGwMF5ySz566ZlZUHApTQokWge5R/xL4Z8B/vAXMbL6ZlZlZWU1NTVDCiUTSc8t3sa++hTvPG9XlIY9jnVqQQVFWMm9uqMbn1161BE+3RW1mFwP7nHPLT7Scc26Bc67UOVeam5sbtIAikdDm8/Pgu1uZUpzJaSMGBvQaM+OsMXkcbm5n/Z7DIU4o0SSQPeo5wCVmtgN4GjjHzJ4MaSqRCHuhvIqq2iPcfs7IgPamPzEmP52slHiWbDsQwnQSbbotaufc951zhc65EuAq4G3n3FdDnkwkQvx+x4PvbmX84AGcPSavR6+NMWPmsIFs39/I3rrmECWUaKNx1CLHeG9zDdv2N3LLmcN7tDf9iWlDs4iLMZZs1161BEePito5965z7uJQhRHxgieXVDIwNYELJuSf1OtTE+OYWJjJyspamjV5kwSB9qhFjlJVe4S3N1Zz5fQiEuNiT3o9s4Zn0+rzs2pXbRDTSbRSUYsc5elllTjg6hnFvVpPQWYyeemJlFeqqKX3VNQindp8fp7+aCdnjc6lKDulV+syM6YWZ1F5sIn99S1BSijRSkUt0umN9dXU1Lfw1VlDg7K+yUWZGFC+U1cqSu+oqEU6PbmkgoLMZM7q4ZC84xmQHM/IvDTKK2s1/4f0iopaBNha08CHWw9w9cxiYmN6PiTveKYUZ1F7pI0d+xuDtk6JPipqEeAPSyqJjzWuLD3x5Es9NX7wABLjYlihk4rSCypqiXpHWn08t3wnnz8ln9z0xKCuOyEuhgkFGazdXUdr+3HnNBM5IRW1RL0/rt7N4eb2oJ1EPNaU4kxa2/2s31MXkvVL/6eilqjmnOPJJRWMzEtj5rDskGyjZGAqWSnxOvwhJ01FLVFtRWUtq3fVcf3soSc1r0cgYsyYXJTF1n0NugGunBQVtUS1Rz/cQXpSHJdNLQzpdqYWZ+KAlTu1Vy09p6KWqLW3rplX1+zhK6VFpB51Z/FQGJiWSHF2CuWVh3AaUy09pKKWqPWHpRX4nOO62SVh2d7U4iz21bdQVXskLNuT/iO0uxEiQfLU0sqgrOfqmR2TLTW3+XhqaSXnjh1E8cDezesRqFMLMnh59W7KK2spzArPNqV/0B61RKVnynZyoLGVG+eUhG2byQmxjBs8gFW7amn3h25Mdbvfz9qqOjbsOczew820+zR+u6/THrVEneY2H79+ZwszSrKZHeCNa4NlSnEma6rq2LS3gfFDBgR13T6/o7zyEG9/vI/apr+NLslMiefaWUMZnJEc1O1J+ARyF/IkM1tmZqvMbJ2Z/Vs4gomEysJllVQfbuHb548K2ZC84xmVl05qYhwrKoM7o167389TyypZVF5FWmIc180ayjfOGsGXpxXi9zv+33vb2Kg7o/dZgexRtwDnOOcazCweeN/MXnXOLQlxNpGgO9Lq4zfvbmXW8GxOG5ET9u3HxhiTCzNYsu0gTS3tQVlna7ufhUsr2bC3nosnDmb28IGf/g+oMCuFEblpPLGkgieWVHDDnGGMzEsLynYlfAK5C7lzzjV0fhvf+aXxRdInPb54BzX1LfzjeaMjlmHq0Cx8zrEyCLfp8vsdty9cwYa99VwyaQinjcj5zKeEAcnx3Dx3OAPTEni+fJfmHOmDAjqZaGaxZrYS2Ae84ZxbGtpYIsF3oKGFe9/cxDlj85g5PLzHpo82OCOZ4uwU3t+yn7Zenuj7zbtbeH1dNReeOphZJ/idEuJi+NKUQg41tfHn9Xt7tU0Jv4CK2jnnc85NBgqBGWY24dhlzGy+mZWZWVlNTU2wc4r0it85FpVXER8Tw0+/9Jm3b9idOTqX2qY2Xl69+6TX8dfNNdzzxiYunTyEOQGcFB2Wk8qs4dks3nqAigOaH7sv6dHwPOdcLfAucEEXzy1wzpU650pzc3ODFE8kOJZuP8j2/Y388OJxnhj9MCY/nbz0RB58dyt+f8+PJO6uPcKdT69kVF4aP7vs1IBPin5+fD4DkuN5de1eXSHZhwQy6iPXzDI7HycD5wEbQx1MJFi21TTw2to9jMpLC/qNAU5WjBlnjs5lU3UDb2/c16PXtrb7+cYfVtDa7ufBr04jJSHwUbaJ8bGcMTqXyoNN7DjQ1NPYEiGB7FEPBt4xs9XAR3Qco345tLFEgmPb/gYeW7yDrJQEvlxaFPbheCcysTCTgsxk7n97M74e7FX/9E/rWbmzll9cMZERuT0fwTGtOIuUhFje26RDlH1FIKM+VjvnpjjnJjrnJjjnfhyOYCK94XeOsh0HefzDCjJTEvj66cNIC/HESz0VG2N89/OjWbWrjt9/sD2g1zxfvovHFldw89xh/MOpg09quwlxMZw2IoePq+vZU6d5R/oCXUIufUpru5+6I23sO9xMTX0LtU2tNLW009rup93nZ0/dEcp2HOT+tzezqLyK/Iwkbjp9GOlJ8ZGO3qUvTi7gvHGD+K/XP2bLvoYTLvvephr++bnVzByWzT9fMLZX2501PJuE2Bj+unl/r9Yj4eGtXQyRLlQcaOStjdVs3FMf8MxzA1MTuHpGMacMGeCpwx3HMjP+47IJfO7e9/jOs6t47tbZxMd+dv9pReUhbnliOSPz0llwXWmXy/RESkIc00uyWLztABec0nGCUbxLRS2e1dLu4zfvbOXBd7fS5vNTlJ3COWPzSE+KIyk+Fhy0+fy0+vy0+Rztfj85qYkMzkwiJy2RGA8X9NHy0pP4yRcn8K2nyrn6d0v41bwpn45M8fsdz5Tt5Kd/2sCgAYk8fuMMMoJUqjOHDeSDrQcorzzEmWPygrJOCQ0VtXhS5YEmbnh0GVtrGrl08hDG5g8IWkF50cUTh+DzO36waA0X3vdXvlxaRFyMsWz7QcoqDjFzWDb3XDkpqHdJz0lPpGRgCmUVhzhjdK6nP3lEOxW1eM6O/Y3M+90SjrT5ePSG6Zw1Ji9o81F72aWTCzi1IIN/emYVj324A79zZKYk8IsrJnLFtMKQFOm0odn874pd7DjQxLCc1KCvX4JDRS2esn1/I1ctWEybz/HUTbOCPhWo1w3PTeOFb84J2/ZOLcjgj6t3s7zikIrawzTqQzyjsaWdmx77iDafY+HN0VfSkZAQF8PEggzWVNXS3OaLdBw5DhW1eIJzju8tWsP2/Y08cPUUxuSnRzpS1CgtyabN51hbVRfpKHIcKmrxhCeWVPDHVbv5zufGRGSe6GhWlJXMwNSEoEy7KqGhopaIqzzQxE/+tIGzx+Ry25kjIh0n6pgZk4oy2V7TSPXh5kjHkS6oqCXifvzyeuJijJ9dNpGYGA0Ri4RJhZk44I+rTn7aVQkdFbVE1Dsb9/HmhmruOHcU+RlJkY4TtXLTExmSmaSi9igVtURMS7uPf/vjOobnpHLjnGGRjhP1JhVmsmpXHdv366YCXqNx1BIxD/11OzsONPH4jTNIiNM+Q6RNLMzktXV7eWnlbu48b1Sv1hWsC5SunlkclPX0dfrXIRGxu/YID7y9hc+fMogzRuuOQF6QkRzPjJJsXlxVpbu/eIyKWiLiP17ZgN85fnjR+EhHkaNcMnkI22oaWbf7cKSjyFFU1BJ2H27dz8ur93DbWSMoyk6JdBw5yoUTBhMXY7ykk4qeoqKWsGrz+fnXl9ZRmJXMrRoz7TlZqQmcOTqXP67afVI33ZXQCOTmtkVm9o6ZbTCzdWZ2ZziCSf/0+OIKNlU38C8Xj++YU1o855LJQ9hT18xHOw5GOop0CmSPuh34jnNuHDAL+KaZ6cCi9FhNfQu/fGMTZ47O5fzxgyIdR47jvHGDSI6P5UUd/vCMQG5uu8c5t6LzcT2wASgIdTDpf/7ztY00t/u4+wvjNUm9h6UmxnHe+EG8smYPre3+SMcReniM2sxKgCnA0i6em29mZWZWVlOj29DL31tecYjnlu/iprnDGZ6bFuk40o1LJw2htqmN97fo37IXBFzUZpYG/C/wbefcZ8buOOcWOOdKnXOlubkaFyt/4/M77n5pLfkDkvjW2SMjHUcCcMboXDKS43lxpQ5/eEFARW1m8XSU9B+cc4tCG0n6m6c/qmRt1WF+cNE4UhN1MWxfkBAXw4Wn5vPG+mqaWtsjHSfqBTLqw4CHgQ3Ouf8OfSTpTw41tvKL1z9m5rBsvjBxcKTjSA9cMqmAplYfb27YF+koUS+Q3Zs5wLXAGjNb2fmzHzjnXgldLOkv5j9RxuEjbcwcNpCFy3ZGOo70wIxh2eQPSOKllVVcMmlIpONEtW6L2jn3PqBT9NJjS7Yd4KMdh5g7MkdTmPZBsTHGxRMH89jiHdQ2tZKZkhDpSFFLVyZKSDS3+fjBojVkpcRz7jiNme6rLp1cQJvP8cqavZGOEtVU1BISD7y9hW37G/nilAJNYdqHTSgYwPDcVJ5brsNWkaR/QRJ0yysO8eBftnLZ1AJG5elu4n2ZmTFvejErKmvZuFcz6kWKilqCqu5IG3csLGdwRhL/eskpkY4jQXD5tEIS4mKCdjMA6TkVtQSNc467nl/D3sPN/GreFAYkxUc6kgRBdmoCF07I5/kVVRpTHSEqagmaxz7cwcur9/BP549manFWpONIEF09cyj1Le26+W2EqKglKN7aUM2PX17P+eMHaZ7pfmh6SRaj8tL4gw5/RISKWnptbVUdty8s55QhGdx31WRiYzTsvr8xM66dPZTVu+pYsu1ApONEHRW19Mq63XVc98gyMpPjeej6UlISNJdHf3VlaRE5aYnc//bmSEeJOipqOWnllYeYt2AJSXEx/OHmWQwaoKsP+7Ok+FjmnzGMD7YcYHnFoUjHiSoqajkpr6/by1cfWkpmSgL/c8tshuWkRjqShME1M4eSlRKvveowU1FLj/j8jl+8vpFbnljOyLw0nrlltu4kHkVSE+O4ae5w3v24hlU7ayMdJ2rogKJ0qauLG/bXt/C/5buoONBE6dAsvjBpCG9v1BSY0ea62UP5/Qfb+dGLa1l022nExWp/L9T0F5Zutfv8vLephl+9vZnqw81cMa2Qy6YWEq9/oFEpPSmeu79wCqt31fHIB9sjHScqaI9ajss5x5qqOl5ft5dDTW2MGzyASycNYUCyrjiMdhdPHMyLK3fz329s4vOn5DN0oM5RhJJ2iaRLFQca+e1ftvL0RztJjIvlhtNKuHbWUJW0AB3jqn/yxQnEx8Twj/+zkiOtvl6tz+8c++tb2FrTwM6DTVQfbsbnd0FK2/dpj1r+zsa9h7n3jU28vq6a9KQ4LptSwNShWcSYLmKRv5efkcTPL5/I7QtXcPPjZTx0fSlJ8bEBv76hpZ21VXWsqapj16Em2nx/X8wpCbGU7zzEFVMLOW1kTrDj9yndFrWZPQJcDOxzzk0IfSSJhC37Gvjlm5v405o9pCXEce64POaOzNVc0nJCF00czJG2SXz32VXc9uRyfvmVKWSkHP9Tl985NlfXs2z7QT6ursfvIC89kekl2QzOSCIzJYF2n5/GVh9b9jXw1oZ9LFpRxblj87jronEMz00L42/nHYHsUT8KPAA8HtooEgkVBxq5763NvFBeRVJ8LLedOYL5ZwzXHT0kYFdMK6S13c9dL6zhjF+8w+3njMQwkhM69q5b2/3sqTvy6d7z4eZ2UhPjOH1kLpOLM8k/zoVSU4uzuHxaAb//YAcPvL2Fz//yPf790glcNaM4nL+eJwRyz8T3zKwk9FEknKpqj3D/W5t5dvku4mKMr58+jFvPHMHAtMRIR5M+6OqZxUwuyuTnr23kJ3/aAEByfCyJcTHUHmkDOu7BOHpQOhcVZTJucDpxMd1/WkuMi+XWM0dw+dRCvvPsKr63aA0b99Zz10XjomrUUdCOUZvZfGA+QHFx9P0fr6+oPtzMr9/ZwtOddwS/dtZQvnHWCPJ0+bf00vghA3j8xhl8tOMgj7y/nQONrbS0+ShNTyQvPYkRuWmf7mX3VG56Io9cX8p/vraR3/11O7sOHeE310yNmkNzQStq59wCYAFAaWmpTtf2ULDunnH1zK7/J7mtpoGH39/Oc8t34fM7rpxexLfOHsmQzOSgbFfkE9NLstlc3RD09cbFxnDXReMpyk7hX15cx7eeWsGvr5kaFXvWGvXRz5XtOMiC97bxxoZq4mNjuHxqAd84a6Qu+5Y+67rZJTgHd7+0jjufLuf+eVP7/dS6Kup+qKGlnVdW7+GpZZWs3FlLZko8t589kmtnl5CbrmPQ0vddf1oJbT4/P/nTBgoyN3DXReMjHSmkAhmetxA4C8gxs13A3c65h0MdTHqmzednc3UD3366nD+vr6ap1ceI3FR+fOkpXDGtUPNES79z09zh7DzYxO/+up3huWnM68ejQQIZ9TEvHEGkZ5xzVNe3sGVfA1v21bN9fyNtPkdmSjyXTh7CFdOKmFqcielCFenHfnTxeCoONvGjF9ZSnJ3CnH56YYx2s/qQ+uY2ttY0sLm6gS01DdQ3d9wROictkdKh2YzJT4+6YUsS3eJiY7h/3hSueHAxtz65nOe/MYeRef3vohgVtYf5naPyQBMb9h5my74G9tQ1Ax2X1o7ITWNUXhoj89LITEn49DUqaYk26UnxPPy1Ur746w+48dGPeOGbc8hOTej+hX2Iitpj/M6x40Aja6sOs253HfXN7cSaMXRgCp8bP4hReekMzkzS3BsnKVjDIMVbCrNSWHBdKVctWMItT5Tx5E0zSYw7uTHbXqSi9oiDja0s236Q8spD1Le0ExdjjMlPZ8KQDMbmp5PYg8luRKLR1OIs7vnyJG5fWM73F63hni9P6jfnaFTUEbZ+92HufXMTb6yvJsZgzKB0JhVlMiY/vV/tEYiEwxcmDWFbTSP3vrmJEblpfPPskZGOFBQq6gjZXF3PvW9u4pU1exmQFMc5Y/OYXpJNhuZ7FumVO84dybb9Dfzi9Y8ZlpPKhacOjnSkXlNRh9m2mgbue2szL63aTWpCHHecM5Kvzx3On1bviXQ0kX7BzPjPyyey82AT//TMSgoyk5lUlBnpWL2iog6TnQebuO+tzTxfXkVCbAy3njmC+XOHkxXks9M6WSYCSfGxLLiuYyTITY+X8eI35/TpeW1U1CG2u/YI97+9hWfLdhIbY9xwWgm3njWCHE0nKhJSOWmJPHz9dC5/8EOufXgpz9wyu89O46uiDpF9ndOJLuycTvSamcV84+yRDNJ0oiJhMyY/nYeuL+X6R5Zx7cPLWDh/Vp88D6SiDrL9DS389t2tPLGkAp/f8eXSQr51zigK+vDHLpG+bNbwgfz22mnMf7yMr/1+GY9+bcYJbxfmRSrqXjj6eHBDSzsfbNnP4q0HaPP5mVKcxTlj88hOTeAvH9dEMKWInD0mj/vnTeX2hSv4yoLFPH7jjD51swwVdS8damzlr1tqKNtxCJ/fcWphBueNHUSOphMV8ZQLJuTzyNemc8sTy7nit4t59IbpfeZmuSrqk7Rx72GeLdvJql21GMaU4kzOGJWrghbxsLmjcnnyppl8/dGPuOSBD7jnykl8/pT8SMfqloq6Bxpb2nl59W6e/mgn5ZW1xMcas4cP5PRRuX3yBIVINJpanMXLd8zltieXc8sTy7np9GF853NjTvp+juGgou5Gu8/P8opDvLCyipdW7qax1cfIvDR+eNE4cJCSqD+hSF9TkJnMs7fO5icvb+Ch97fz5/XV/PRLE5g7KjfS0bqklulCY0s7722q4Y0N1byzcR+HmtpIio/h4olDmDejiKnFWZiZLi4R6cMS42L59y9O4KKJg/n+ojVc+/Ay5o7K4dvnjWLa0OxIx/s7Kmo6Zq5bXnGo8+sgq3bW0erzk5Eczzlj8zh//CDOGJ1LmvaeRfqdWcMH8uqdc3licQW//ctWLn9wMVOKM/lKaREXTRxMelLkD2sG1DxmdgFwHxALPOSc+3lIU4VIfXMb2/c3dt6+quNrU3U9Ow40ARAfa5wyJIPrTxvKOWMHUVqSpYn4RaJAUnwsN58xnGtmFbNw2U4WLqvke4vW8C8vrmP6sCzOGp3H1KFZjB88ICLHsgO5uW0s8GvgfGAX8JGZveScWx/sMLtrjwAQY4YZWMf2Mev4WbvfT2t755fvqMftfo60+Tjc3MbhI+0cPtLG4eY29je0sreumer6Zqrrmmls9f3tF4/pmIx/bP4AvjK9mNKSLE4tyCBJ8z6LRK2UhDi+fvowbpxTQvnOWl5ds4d3P67hp69sACA2xijOTmFIZhJDMpIZkpnMkMwkslMTGZAUR2ZKAmPy04OeK5A96hnAFufcNgAzexq4FAh6UZ97z1840ubrfsEAJMfHkp2awKABiYzNT+fM0bnkD0hi6MAURualMXRgqvaWRaRLZsbU4iymFmdx10Wwt66Z1btqWVNVx/b9jeyuPcJ7m2vYV9+Cc397XU5aAmU/PD/oeQIp6gJg51Hf7wJmHruQmc0H5nd+22Jma3sfL+xygP2RDnESlDu8gpb7mmCsJHDd5g5znm5d08feIxWA/Qg4udxDj/dEIEXd1b1s3Gd+4NwCYAGAmZU550oDjucRyh1eyh1efTF3X8wMwc8dyGf/XUDRUd8XAruDFUBERE4skKL+CBhlZsPMLAG4CngptLFEROQT3R76cM61m9m3gNfpGJ73iHNuXTcvWxCMcBGg3OGl3OHVF3P3xcwQ5Nzm3GcON4uIiIdofJqIiMepqEVEPK5XRW1mF5jZx2a2xcy+d4LlrjAzZ2aeGGbTXW4z+5qZ1ZjZys6vmyKR81iB/L3N7EozW1bfvfIAAAPISURBVG9m68zsqXBn7EoAf+97j/pbbzKz2kjkPCZTd5mLzewdMys3s9VmdmEkch4rgNxDzeytzszvmllhJHIey8weMbN9x7v+wjr8qvP3Wm1mU8OdsYtM3WUea2aLzazFzL7bq405507qi44Ti1uB4UACsAoY38Vy6cB7wBKg9GS3F6yvQHIDXwMeiHTWk8g9CigHsjq/z+sLuY9Z/nY6Tlh7OjMdJ4tu63w8HtjRF/7WwLPA9Z2PzwGeiHTuzixnAFOBtcd5/kLgVTqu65gFLO0DmfOA6cBPge/2Zlu92aP+9NJy51wr8Mml5cf6d+C/gOZebCuYAs3tNYHkvhn4tXPuEIBzbl+YM3alp3/vecDCsCQ7vkAyO2BA5+MMvHFtQSC5xwNvdT5+p4vnI8I59x5w8ASLXAo87josATLNbHB40nWtu8zOuX3OuY+Att5uqzdF3dWl5QVHL2BmU4Ai59zLvdhOsHWbu9PlnR+xnjOzoi6eD7dAco8GRpvZB2a2pHPWw0gL9O+NmQ0FhgFvhyHXiQSS+V+Br5rZLuAVOj4JRFoguVcBl3c+/hKQbmYDw5CttwJ+H/VHvSnqE15abmYxwL3Ad3qxjVAI5JL4PwIlzrmJwJvAYyFP1b1AcsfRcfjjLDr2TB8ys8wQ5+pOQFMQdLoKeM45F5yZuU5eIJnnAY865wrp+Fj+ROd7PpICyf1d4EwzKwfOBKqA9lAHC4KevI/6nd68sbq7tDwdmAC8a2Y76Diu9JIHTih2e0m8c+6Ac66l89vfAdPClO1EArmUfxfwonOuzTm3HfiYjuKOpJ5MQXAVkT/sAYFl/jrwDIBzbjGQRMdEPJEUyHt7t3PuMufcFOCuzp/VhS/iSYvqqSx6U9QnvLTcOVfnnMtxzpU450roOJl4iXOurFeJe6/bS+KPOfZ1CbAhjPmOJ5BL+V8AzgYwsxw6DoVsC2vKzwpoCgIzGwNkAYvDnK8rgWSuBM4FMLNxdBR1TVhTflYg7+2co/b8vw88EuaMJ+sl4LrO0R+zgDrn3J5IhwqbXp71vBDYRMeZ5rs6f/ZjOgr52GXfxQOjPgLJDfwMWEfH8bx3gLGRzhxgbgP+m465wtcAV0U6c6DvEzqO+f480ll78LceD3zQ+R5ZCXwu0pkDzH0FsLlzmYeAxEhn7sy1ENhDx4m3XXR8YrkVuLXzeaPjBiZbO9/bEe+SADLnd/78MFDb+XjAyWxLl5CLiHhcpE9+iIhIN1TUIiIep6IWEfE4FbWIiMepqEVEPE5FLSLicSpqERGP+//4+h9ZbspSbAAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -1873,32 +1920,31 @@ " 5 6 7 8 17 18 19 20\n", " 9 10 11 12 21 22 23 24\n", "\n", - "SpeedStrengthFlow24x24 min = 0.4874949173076925, max = 1.0\n", - "SpeedStrengthFlow24x24 key number pairs with minimum values:\n", - "\n", - " 23 -> 16 (0.4874949173076925)\n", - " 10 -> 1 (0.4874949173076925)\n", - " 13 -> 22 (0.5263309903846156)\n", - " 4 -> 11 (0.5263309903846156)\n", - " 11 -> 1 (0.5329172250000002)\n", - " 22 -> 16 (0.5329172250000002)\n", - " 13 -> 23 (0.5372323442307694)\n", - " 4 -> 10 (0.5372323442307694)\n", - " 1 -> 10 (0.5416610192307695)\n", - " 16 -> 23 (0.5416610192307695)\n", - "\n", - "SpeedStrengthFlow24x24 key number pairs with maximum values:\n", + " SpeedStrengthFlow24x24 min = 0.5270463917307694, max = 1.0\n", + " SpeedStrengthFlow24x24 key number pairs with minimum values:\n", + " 23 -> 16 (0.5270463917307694)\n", + " 10 -> 1 (0.5270463917307694)\n", + " 4 -> 11 (0.5309299990384617)\n", + " 13 -> 22 (0.5309299990384617)\n", + " 11 -> 1 (0.5581606725000001)\n", + " 22 -> 16 (0.5581606725000001)\n", + " 4 -> 10 (0.558592184423077)\n", + " 13 -> 23 (0.558592184423077)\n", + " 16 -> 24 (0.5773680000000001)\n", + " 24 -> 16 (0.5773680000000001)\n", + "\n", + " SpeedStrengthFlow24x24 key number pairs with maximum values:\n", "\n", " 7 -> 18 (1.0)\n", - " 18 -> 18 (1.0)\n", - " 7 -> 7 (1.0)\n", " 18 -> 7 (1.0)\n", - " 7 -> 8 (0.9903846153846154)\n", - " 18 -> 8 (0.9903846153846154)\n", - " 7 -> 17 (0.9903846153846154)\n", - " 18 -> 17 (0.9903846153846154)\n", - " 8 -> 18 (0.9903846153846154)\n", - " 17 -> 7 (0.9903846153846154)" + " 7 -> 7 (1.0)\n", + " 18 -> 18 (1.0)\n", + " 17 -> 7 (0.9990384615384615)\n", + " 18 -> 8 (0.9990384615384615)\n", + " 8 -> 18 (0.9990384615384615)\n", + " 18 -> 17 (0.9990384615384615)\n", + " 7 -> 8 (0.9990384615384615)\n", + " 7 -> 17 (0.9990384615384615)" ] }, { @@ -1908,7 +1954,7 @@ "id": "REInHU9tdYLP" }, "source": [ - "## Step 1: Arrange the most frequent vowels and consonants \n", + "## Step 1: Distribute the most frequent letters (4 vowels, 4 consonants) to the left and right \n", "\n", "Select the first set of keys to which we will assign letters from 24 finger-column keys (requiring no lateral movements):\n", "\n", @@ -1917,25 +1963,22 @@ " 5 6 7 8 17 18 19 20 \n", " 9 10 11 12 21 22 23 24\n", "\n", - "Select 5 keys on each side for some of the strongest finger positions:\n", + "Select 4 keys on each side for some of the strongest finger positions:\n", "\n", " - - 3 - - 14 - -\n", - " 5 6 7 8 17 18 19 20\n", + " - 6 7 8 17 18 19 -\n", " - - - - - - - -\n", "\n", - "Find all permutations of the 5 vowels and of the 5 most frequent consonants\n", + "Find all permutations of the 8 most frequent letters, assign to the 8 keys:\n", "\n", - "#### **E**, T, **A, O, I**, N, S, R, H, L, D, C, **U**, M, F, P, G, W, Y, B, V, K, X, J, Q, Z\n", - "#### E, **T**, A, O, I, **N, S, R, H**, L, D, C, U, M, F, P, G, W, Y, B, V, K, X, J, Q, Z\n", + "**E, T, A, O, I, N, S, R**, H, L, D, C, U, M, F, P, G, W, Y, B, V, K, X, J, Q, Z\n", "\n", - "In prior experiments where I arranged vowels on the left or right with command shortcut letters on the left or right, vowels on the left got consistently higher scores, so we will continue with vowels on the left.\n", - " \n", - "Score each arrangement based on bigram frequencies: For each permutation of letters, construct a frequency matrix of each ordered pair of letters (bigram). Multiply this frequency matrix by our speed-strength-flow matrix to compute a score." + "We score each arrangement based on bigram frequencies: For each permutation of letters, construct a frequency matrix of each ordered pair of letters (bigram). Multiply this frequency matrix by our speed-strength-flow matrix to compute a score." ] }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 51, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -1950,265 +1993,565 @@ "name": "stdout", "output_type": "stream", "text": [ - "Topmost of 120 permutations: 0.21824565954307476\n", - "['U' 'I' 'O' 'E' 'A']\n", - "['U', 'I', 'O', 'E', 'A'] 0.21824565954307476\n", - "['A', 'I', 'E', 'O', 'U'] 0.21741501790263346\n", - "['A', 'E', 'I', 'O', 'U'] 0.2164913031644108\n", - "['E', 'I', 'O', 'U', 'A'] 0.21595564492945266\n", - "['U', 'I', 'O', 'A', 'E'] 0.2151564451139404\n", - "['U', 'I', 'E', 'O', 'A'] 0.21493519445803785\n", - "['U', 'O', 'I', 'E', 'A'] 0.21482970748545938\n", - "['A', 'I', 'O', 'U', 'E'] 0.21468337154294054\n", - "['O', 'I', 'E', 'A', 'U'] 0.21467633052219948\n", - "['A', 'I', 'O', 'E', 'U'] 0.2146243477946652\n" + "Topmost of 40320 permutations: 0.2459074672620355\n", + "['O' 'I' 'E' 'A' 'S' 'T' 'R' 'N']\n", + "['O', 'I', 'E', 'A', 'S', 'T', 'R', 'N'] 0.2459074672620355\n", + "['S', 'N', 'R', 'T', 'O', 'A', 'E', 'I'] 0.2459074672620355\n", + "['S', 'R', 'N', 'T', 'O', 'A', 'E', 'I'] 0.24589462128208767\n", + "['O', 'I', 'E', 'A', 'S', 'T', 'N', 'R'] 0.24589462128208767\n", + "['O', 'I', 'E', 'A', 'R', 'T', 'S', 'N'] 0.24564434990058556\n", + "['R', 'N', 'S', 'T', 'O', 'A', 'E', 'I'] 0.24564434990058556\n", + "['R', 'S', 'N', 'T', 'O', 'A', 'E', 'I'] 0.2455083521942179\n", + "['O', 'I', 'E', 'A', 'R', 'T', 'N', 'S'] 0.2455083521942179\n", + "['O', 'I', 'A', 'E', 'S', 'T', 'R', 'N'] 0.24547037286390488\n", + "['S', 'N', 'R', 'T', 'O', 'E', 'A', 'I'] 0.24547037286390483\n" ] } ], "source": [ - "keys_vowels = [3, 5,6,7,8]\n", - "all_letters_vowels = ['E','A','O','I','U']\n", - "move_positions_vowels = [0,1,2,3,4] # indices to selected keys that don't have assigned letters\n", - "fixed_positions_vowels = [] # indices to keys with assigned letters\n", - "top_permutation_vowels, letter_permutations_vowels, scores_vowels = permute_and_optimize(keys_vowels, SpeedStrengthFlow24x24, bigrams, all_letters_vowels, move_positions_vowels, fixed_positions_vowels, ntop=10, verbose=False)" + "keys1 = [3, 6,7,8, 14, 17,18,19]\n", + "all_letters1 = ['E','T','A','O','I','N','S','R']\n", + "move_positions1 = [0,1,2,3, 4,5,6,7] # indices to selected keys that don't have assigned letters\n", + "fixed_positions1 = [] # indices to keys with assigned letters\n", + "top_permutation1, letter_permutations1, scores1 = permute_and_optimize(keys1, SpeedStrengthFlow24x24, bigrams, all_letters1, move_positions1, fixed_positions1, ntop=10, verbose=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "raw", + "id": "c4xacvCLDzS1" + }, + "source": [ + " Topmost of 40320 permutations:\n", + " ['O', 'I', 'E', 'A', 'S', 'T', 'R', 'N'] 0.2459074672620355\n", + "\n", + " Left: Right:\n", + "\n", + " - - O - - S - \n", + " - I E A T R N -\n", + " - - - - - - - -\n", + " \n", + "These initial arrangements are very reasonable, as they place letters of decreasing frequency in positions of decreasing finger strength, and roll in for most of the common bigrams (IO, EA, IE, ST, NT, RT)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "UONFg0NBV7vb" + }, + "source": [ + "## Step 2: Distribute 8 more letters to the left and right \n", + "\n", + "*E, T, A, O, I, N, S, R*, **H, L, D**, [C], **U, M, F, P, G**, W, Y, B, [V], K, [X], J, Q, [Z]\n", + " \n", + "Select 8 keys that do not include the hard-to-reach top corners on the left and right sides, and reserve the bottom left row for common command shortcut characters:\n", + "\n", + " - + O - - S + - \n", + " + I E A T R N + \n", + " [ ] + + + +" ] }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 56, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Topmost of 120 permutations: 0.09986505083969377\n", - "['R' 'H' 'T' 'S' 'N']\n", - "['R', 'H', 'T', 'S', 'N'] 0.09986505083969377\n", - "['R', 'S', 'H', 'T', 'N'] 0.09940632253257314\n", - "['R', 'H', 'S', 'T', 'N'] 0.09934912551586801\n", - "['R', 'H', 'T', 'N', 'S'] 0.09927925487520622\n", - "['N', 'H', 'T', 'S', 'R'] 0.09887958335263419\n", - "['R', 'N', 'H', 'T', 'S'] 0.09854079307089186\n", - "['N', 'H', 'T', 'R', 'S'] 0.0984110972727467\n", - "['R', 'H', 'N', 'T', 'S'] 0.09835137332497557\n", - "['N', 'R', 'H', 'T', 'S'] 0.0982366425522243\n", - "['R', 'S', 'N', 'H', 'T'] 0.09816367338052523\n" + "Topmost of 40320 permutations: 0.08278122255657477\n", + "['U' 'O' 'H' 'I' 'E' 'A' 'S' 'P' 'T' 'R' 'N' 'L' 'D' 'G' 'F' 'M']\n", + "['U', 'H', 'P', 'L', 'D', 'G', 'F', 'M'] 0.08278122255657477\n", + "['U', 'H', 'F', 'L', 'D', 'G', 'P', 'M'] 0.08277789528703293\n", + "['U', 'H', 'M', 'L', 'D', 'G', 'F', 'P'] 0.0827582210987688\n", + "['U', 'H', 'M', 'L', 'D', 'G', 'P', 'F'] 0.08272617033219082\n", + "['U', 'H', 'M', 'L', 'D', 'F', 'P', 'G'] 0.08271547189489878\n", + "['U', 'H', 'P', 'L', 'D', 'F', 'G', 'M'] 0.0827118901038631\n", + "['U', 'H', 'M', 'L', 'D', 'F', 'G', 'P'] 0.08268894902351764\n", + "['U', 'H', 'F', 'L', 'D', 'G', 'M', 'P'] 0.08268264759713942\n", + "['U', 'H', 'M', 'L', 'D', 'P', 'F', 'G'] 0.08266544877230847\n", + "['U', 'H', 'F', 'L', 'D', 'M', 'P', 'G'] 0.08266536899363089\n" ] } ], "source": [ - "keys_top_consonants = [14, 17,18,19,20]\n", - "all_letters_top_consonants = ['T','N','S','R','H']\n", - "move_positions_top_consonants = [0,1,2,3,4] # indices to selected keys that don't have assigned letters\n", - "fixed_positions_top_consonants = [] # indices to keys with assigned letters\n", - "top_permutation_top_consonants, letter_permutations_top_consonants, scores_top_consonants = permute_and_optimize(keys_top_consonants, SpeedStrengthFlow24x24, bigrams, all_letters_top_consonants, move_positions_top_consonants, fixed_positions_top_consonants, ntop=10, verbose=False)" + "keys2 = [2,3, 5,6,7,8, 14,15, 17,18,19,20, 21,22,23,24]\n", + "all_letters2 = ['H','O', 'L','I','E','A', 'S','D', 'T','R','N','U', 'M','F','P','G'] # all letters under consideration (move or fix in place)\n", + "move_positions2 = [0, 2, 7, 11, 12,13,14,15] # 0-indices to selected keys to assign letters to\n", + "fixed_positions2 = [1, 3,4,5, 6, 8,9,10] # 0-indices to keys with fixed letter assignments\n", + "top_permutation2, letter_permutations2, scores2 = permute_and_optimize(keys2, SpeedStrengthFlow24x24, bigrams, all_letters2, move_positions2, fixed_positions2, ntop=10, verbose=False)" ] }, { "cell_type": "markdown", - "metadata": { - "colab_type": "raw", - "id": "c4xacvCLDzS1" - }, + "metadata": {}, "source": [ - "#### Top-scoring of 120 permutations for each side\n", - " \n", - " - - U - - R - - \n", - " I O E A H T S N\n", - " - - - - - - - -\n", - " \n", - "This arrangement is very reasonable, as vowels of decreasing frequency are placed in positions of decreasing strength, and are easy to type (roll in) for the most common bigrams (OU, IO, EA, and IE).\n", - "\n", - "2-vowel bigram frequencies (>1 billion):\n", - " \n", - " OU 24531132241 - in\n", - " IO 23542263265 - in \n", - " EA 19403941063 - in\n", - " IE 10845731320 - in\n", - " AI 8922759715 - out \n", - " IA 8072199471 - in \n", - " EI 5169898489 - out \n", - " AU 3356322923 x out \n", - " UI 2852182384 x out\n", - " OI 2474275212 - out\n", - " EO 2044268477 x out \n", - " OA 1620913259 - in \n", - " OE 1089254517 - in \n", - " \n", - "2-consonant bigram frequencies (>10 billion) (T, N, S, R, H):\n", + "Top-scoring layout:\n", "\n", - " TH 100272945963 - in\n", - " ND 38129777631 \n", - " ST 29704461829 - in\n", - " NT 29359771944 - in\n", - " NG 26871805511\n", - " CH 16854985236\n", - " NS 14350320288 - in\n", - " PR 13378480175\n", - " CT 12997849406\n", - " TR 12006693396 x same finger\n", - " LY 11983948242\n", - " NC 11722631112\n", - " RS 11180732354 x out\n", - " WH 10680697684\n", - " RT 10198055461 - same finger" + " - U O - - S P -\n", + " H I E A T R N L \n", + " [ ] D G F M" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 3: Optimize arrangement of letters " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Find all permutations and their scores for just the left side:" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Topmost of 720 permutations: 0.0886514445702601\n", + "['U' 'O' 'H' 'I' 'E' 'A']\n", + "['U', 'O', 'H', 'I', 'E', 'A'] 0.0886514445702601\n", + "['O', 'U', 'H', 'E', 'A', 'I'] 0.08833296014158909\n", + "['U', 'O', 'I', 'H', 'E', 'A'] 0.0879980634037669\n", + "['U', 'O', 'H', 'I', 'A', 'E'] 0.0879861003423566\n", + "['O', 'U', 'H', 'A', 'E', 'I'] 0.08793211831911096\n", + "['O', 'U', 'H', 'I', 'E', 'A'] 0.08791541800050758\n", + "['O', 'U', 'I', 'H', 'E', 'A'] 0.0878912316593447\n", + "['O', 'U', 'H', 'E', 'I', 'A'] 0.08781789614757092\n", + "['U', 'O', 'H', 'E', 'A', 'I'] 0.08772471452567442\n", + "['O', 'U', 'H', 'A', 'I', 'E'] 0.08758275473960088\n" + ] + } + ], + "source": [ + "keys3L = [2,3, 5,6,7,8]\n", + "all_letters3L = ['U','O', 'H','I','E','A'] # all letters under consideration (move or fix in place)\n", + "move_positions3L = [0,1, 2,3,4,5] # 0-indices to selected keys to assign letters to\n", + "fixed_positions3L = [] # 0-indices to keys with fixed letter assignments\n", + "top_permutation3L, letter_permutations3L, scores3L = permute_and_optimize(keys3L, SpeedStrengthFlow24x24, bigrams, all_letters3L, move_positions3L, fixed_positions3L, ntop=10, verbose=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Find all permutations and their scores for just the right side:" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Topmost of 362880 permutations: 0.08347530761148962\n", + "['D' 'L' 'T' 'S' 'R' 'N' 'G' 'F' 'M' 'P']\n", + "['D', 'L', 'S', 'R', 'N', 'G', 'F', 'M', 'P'] 0.08347530761148962\n", + "['D', 'L', 'S', 'R', 'N', 'G', 'M', 'F', 'P'] 0.08339547071634427\n", + "['G', 'L', 'S', 'R', 'N', 'D', 'F', 'M', 'P'] 0.08338573966074468\n", + "['G', 'L', 'S', 'R', 'N', 'D', 'M', 'F', 'P'] 0.08330897015136488\n", + "['L', 'G', 'R', 'S', 'N', 'D', 'M', 'F', 'P'] 0.0832860828809356\n", + "['L', 'G', 'S', 'D', 'N', 'P', 'F', 'M', 'R'] 0.0832799207065086\n", + "['G', 'D', 'S', 'R', 'N', 'L', 'F', 'M', 'P'] 0.0832692883597318\n", + "['D', 'G', 'S', 'R', 'N', 'L', 'F', 'M', 'P'] 0.08326179716332474\n", + "['L', 'G', 'S', 'D', 'N', 'P', 'M', 'F', 'R'] 0.08325102907912418\n", + "['L', 'G', 'S', 'R', 'N', 'D', 'M', 'F', 'P'] 0.08324895072103226\n" + ] + } + ], + "source": [ + "keys3R = [14,15, 17,18,19,20, 21,22,23,24]\n", + "all_letters3R = ['S','P', 'T','R','N','L', 'D','G','F','M'] # all letters under consideration (move or fix in place)\n", + "move_positions3R = [0,1, 3,4,5, 6,7,8,9] # 0-indices to selected keys to assign letters to\n", + "fixed_positions3R = [2] # 0-indices to keys with fixed letter assignments\n", + "top_permutation3R, letter_permutations3R, scores3R = permute_and_optimize(keys3R, SpeedStrengthFlow24x24, bigrams, all_letters3R, move_positions3R, fixed_positions3R, ntop=10, verbose=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " Left: Topmost of 720 permutations: 0.0886514445702601\n", + " ['U' 'O' 'H' 'I' 'E' 'A']\n", + " Right: Topmost of 362880 permutations: 0.08347530761148962\n", + " ['D' 'L' 'T' 'S' 'R' 'N' 'G' 'F' 'M' 'P']" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Step 2: Arrange the remaining letters (except for command characters Z,X,C,V) \n", + "#### Combine left and right sides\n", "\n", - "We will reserve the familiar location of the bottom left row for common command shortcut letters Z, X, C, and V, and will place Q and J, the least common letters (after Z) in the hardest-to-reach locations:\n", - " \n", - "#### E, T, A, O, I, N, S, R, H, **L, D**, [C], U, **M, F, P, G, W, Y, B**, [V], **K**, [X], [J], [Q], [Z]\n", + "Place Z,X,C,V and K,Y,W,B in any open spots just to optimize layout of the other letters:\n", + " \n", + " [K] U O [Y] [W] D L [B]\n", + " H I E A T S R N \n", + " [V Z X C] G F M P" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Topmost of 10000 permutations: 0.044060535344865315\n", + "['K', 'U', 'O', 'Y', 'H', 'I', 'E', 'A', 'V', 'Z', 'X', 'C', 'W', 'D', 'L', 'B', 'T', 'S', 'R', 'N', 'M', 'G', 'F', 'P']\n" + ] + } + ], + "source": [ + "ntop=100\n", + "verbose=False\n", + "letter_permutations_left = letter_permutations3L\n", + "scores_permutations_left = scores3L\n", + "letter_permutations_right = letter_permutations3R\n", + "scores_permutations_right = scores3R\n", + "move_positions_left = [1,2, 4,5,6,7]\n", + "fixed_positions_left = [0,3, 8,9,10,11]\n", + "fixed_letters_left = ['K','Y', 'V','Z','X','C']\n", + "move_positions_right = [1,2, 5,6,7, 8,9,10,11]\n", + "fixed_positions_right = [0,3, 4]\n", + "fixed_letters_right = ['W','B', 'T']\n", + "top_permutation3, top_score3, scores3 = optimize_full_layout_with_left_right_top_scores(SpeedStrengthFlow24x24, bigrams, letter_permutations_left, scores_permutations_left, move_positions_left, fixed_letters_left, fixed_positions_left, letter_permutations_right, scores_permutations_right, move_positions_right, fixed_letters_right, fixed_positions_right, ntop, verbose)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " Topmost of 10000 permutations: 0.044060535344865315\n", + " ['K', 'U', 'O', 'Y', 'H', 'I', 'E', 'A', 'V', 'Z', 'X', 'C', 'W', 'D', 'L', 'B', 'T', 'S', 'R', 'N', 'M', 'G', 'F', 'P']\n", "\n", - " - - U - - R - - [Q]\n", - " I O E A H T S N [J]\n", - " * * * * - - - -" + "#### Optimize arrangement of the least frequent remaining letters (K,Y,W,B)\n", + "\n", + "E, T, A, O, I, N, S, R, H, L, D, [C], U, M, F, P, G, **W, Y, B**, [V], **K**, [X], **J, Q**, [Z]" ] }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 69, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "3628800: ['K' 'P' 'U' 'Y' 'I' 'O' 'E' 'A' 'G' 'R' 'D' 'W' 'H' 'T' 'S' 'N' 'L' 'B'\n", - " 'F' 'M'] 0.05757\n", - "Topmost of 3628800 permutations: 0.057574391656673045\n", - "['K' 'P' 'U' 'Y' 'I' 'O' 'E' 'A' 'G' 'R' 'D' 'W' 'H' 'T' 'S' 'N' 'L' 'B'\n", - " 'F' 'M']\n", - "['K', 'P', 'Y', 'G', 'D', 'W', 'L', 'B', 'F', 'M'] 0.057574391656673045\n", - "['K', 'P', 'Y', 'G', 'D', 'W', 'L', 'F', 'B', 'M'] 0.057571721168694356\n", - "['K', 'P', 'Y', 'G', 'D', 'W', 'M', 'B', 'F', 'L'] 0.05757100970558833\n", - "['K', 'P', 'Y', 'G', 'D', 'W', 'M', 'F', 'B', 'L'] 0.057568394930514334\n", - "['Y', 'P', 'K', 'G', 'D', 'W', 'L', 'B', 'F', 'M'] 0.05756690005784394\n", - "['Y', 'P', 'K', 'G', 'D', 'W', 'L', 'F', 'B', 'M'] 0.05756422956986526\n", - "['K', 'P', 'Y', 'G', 'D', 'F', 'L', 'B', 'W', 'M'] 0.05756420247999035\n", - "['Y', 'P', 'K', 'G', 'D', 'W', 'M', 'B', 'F', 'L'] 0.05756351810675922\n", - "['K', 'P', 'Y', 'G', 'M', 'W', 'D', 'B', 'F', 'L'] 0.057562808350394776\n", - "['Y', 'P', 'K', 'G', 'D', 'W', 'M', 'F', 'B', 'L'] 0.05756090333168523\n" + "Topmost of 24 permutations: 0.044060535344865315\n", + "['K' 'U' 'O' 'Y' 'H' 'I' 'E' 'A' 'V' 'Z' 'X' 'C' 'W' 'D' 'L' 'B' 'T' 'S'\n", + " 'R' 'N' 'M' 'G' 'F' 'P']\n", + "['K', 'Y', 'W', 'B'] 0.044060535344865315\n", + "['Y', 'K', 'W', 'B'] 0.04405538756006012\n", + "['B', 'Y', 'K', 'W'] 0.04405119298397605\n", + "['K', 'Y', 'B', 'W'] 0.044045796541307816\n", + "['B', 'Y', 'W', 'K'] 0.04404269353907869\n", + "['Y', 'K', 'B', 'W'] 0.044040648756502626\n", + "['W', 'Y', 'K', 'B'] 0.044018542937578085\n", + "['B', 'K', 'Y', 'W'] 0.04401112815908396\n", + "['Y', 'B', 'K', 'W'] 0.044004732990800335\n", + "['Y', 'B', 'W', 'K'] 0.04399623354590297\n" ] } ], "source": [ - "keys24 = [1,2,3,4, 5,6,7,8, 13,14,15,16, 17,18,19,20, 21,22,23,24]\n", - "all_letters2 = ['L','D','U','M', 'I','O','E','A', 'F','R','P','G', 'H','T','S','N', 'W','Y','B','K']\n", - "move_positions2 = [0,1,3, 8,10,11, 16,17,18,19]\n", - "fixed_positions2 = [2, 4,5,6,7, 9, 12,13,14,15]\n", - "top_permutation2, letter_permutations2, scores2 = permute_and_optimize(keys24, SpeedStrengthFlow24x24, bigrams, all_letters2, move_positions2, fixed_positions2, ntop=10, verbose=True)" + "keys24 = [1,2,3,4, 5,6,7,8, 9,10,11,12, 13,14,15,16, 17,18,19,20, 21,22,23,24]\n", + "all_letters4 = ['K','U','O','Y', 'H','I','E','A', 'V','Z','X','C', 'W','D','L','B', 'T','S','R','N', 'M','G','F','P']\n", + "move_positions4 = [0,3, 12,15]\n", + "fixed_positions4 = [1,2, 4,5,6,7, 8,9,10,11, 13,14, 16,17,18,19, 20,21,22,23] # 0-indices to keys with fixed letter assignments\n", + "top_permutation4, letter_permutations4, scores4 = permute_and_optimize(keys24, SpeedStrengthFlow24x24, bigrams, all_letters4, move_positions4, fixed_positions4, ntop=10, verbose=False)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - " Topmost of 3628800 permutations: 0.057574391656673045\n", - " ['K' 'P' 'U' 'Y' 'I' 'O' 'E' 'A' 'G' 'R' 'D' 'W' 'H' 'T' 'S' 'N' 'L' 'B' 'F' 'M']\n", - " ['K', 'P', 'Y', 'G', 'D', 'W', 'L', 'B', 'F', 'M'] 0.057574391656673045\n", - " ['K', 'P', 'Y', 'G', 'D', 'W', 'L', 'F', 'B', 'M'] 0.057571721168694356\n", - " ['K', 'P', 'Y', 'G', 'D', 'W', 'M', 'B', 'F', 'L'] 0.05757100970558833\n", - " ['K', 'P', 'Y', 'G', 'D', 'W', 'M', 'F', 'B', 'L'] 0.057568394930514334\n", - " ['Y', 'P', 'K', 'G', 'D', 'W', 'L', 'B', 'F', 'M'] 0.05756690005784394\n", - " ['Y', 'P', 'K', 'G', 'D', 'W', 'L', 'F', 'B', 'M'] 0.05756422956986526\n", - " ['K', 'P', 'Y', 'G', 'D', 'F', 'L', 'B', 'W', 'M'] 0.05756420247999035\n", - " ['Y', 'P', 'K', 'G', 'D', 'W', 'M', 'B', 'F', 'L'] 0.05756351810675922\n", - " ['K', 'P', 'Y', 'G', 'M', 'W', 'D', 'B', 'F', 'L'] 0.057562808350394776\n", - " ['Y', 'P', 'K', 'G', 'D', 'W', 'M', 'F', 'B', 'L'] 0.05756090333168523" + " Topmost of 24 permutations: \n", + " ['K' 'U' 'O' 'Y' 'H' 'I' 'E' 'A' 'V' 'Z' 'X' 'C' 'W' 'D' 'L' 'B' 'T' 'S' 'R' 'N' 'M' 'G' 'F' 'P']\n", + " ['K', 'Y', 'W', 'B'] 0.044060535344865315" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Step 3: Add command shortcut characters \n", + "## Step 4: Add command shortcut characters \n", "\n", - "Arrange the common command characters (Z,X,C,V) in the bottom left row:\n", + "Arrange the common command characters (Z,X,C,V) on the left and the remaining least frequent letters Q and J on the far right:\n", "\n", - " K P U Y G R D W [Q]\n", - " I O E A H T S N [J]\n", - " - - - - L B F M" + " K U O Y W D L B Q\n", + " H I E A T S R N J \n", + " - - - - G M F P" ] }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 70, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Topmost of 24 permutations: 0.04407240680046151\n", - "['K' 'P' 'U' 'Y' 'I' 'O' 'E' 'A' 'C' 'X' 'Z' 'V' 'G' 'R' 'D' 'W' 'H' 'T'\n", - " 'S' 'N' 'L' 'B' 'F' 'M']\n", - "['C', 'X', 'Z', 'V'] 0.04407240680046151\n", - "['C', 'Z', 'X', 'V'] 0.044071275336314955\n", - "['V', 'X', 'Z', 'C'] 0.044066347764175645\n", - "['V', 'Z', 'X', 'C'] 0.04406521956989739\n", - "['C', 'V', 'Z', 'X'] 0.04399736044912012\n", - "['X', 'V', 'Z', 'C'] 0.043974683713264774\n", - "['C', 'V', 'X', 'Z'] 0.043972925016483436\n", - "['C', 'Z', 'V', 'X'] 0.04397033283646972\n", - "['Z', 'V', 'X', 'C'] 0.04395714995196931\n", - "['X', 'Z', 'V', 'C'] 0.043947656438979854\n" + "Topmost of 24 permutations: 0.044071371113229375\n", + "['K' 'U' 'O' 'Y' 'H' 'I' 'E' 'A' 'C' 'X' 'Z' 'V' 'W' 'D' 'L' 'B' 'T' 'S'\n", + " 'R' 'N' 'M' 'G' 'F' 'P']\n", + "['C', 'X', 'Z', 'V'] 0.044071371113229375\n", + "['V', 'X', 'Z', 'C'] 0.04406805221272717\n", + "['C', 'Z', 'X', 'V'] 0.044063850975499204\n", + "['V', 'Z', 'X', 'C'] 0.044060535344865315\n", + "['C', 'V', 'Z', 'X'] 0.04400289646109712\n", + "['C', 'V', 'X', 'Z'] 0.04397312197965523\n", + "['X', 'V', 'Z', 'C'] 0.0439566465915067\n", + "['Z', 'V', 'X', 'C'] 0.04393480477192898\n", + "['C', 'Z', 'V', 'X'] 0.04392765396414349\n", + "['C', 'X', 'V', 'Z'] 0.04390546335974223\n" ] } ], "source": [ "keys24 = [1,2,3,4, 5,6,7,8, 9,10,11,12, 13,14,15,16, 17,18,19,20, 21,22,23,24]\n", - "all_letters_ZXCV = ['K','P','U','Y', 'I','O','E','A', 'Z','X','C','V', 'G','R','D','W', 'H','T','S','N', 'L','B','F','M']\n", - "move_positions_ZXCV = [8,9,10,11]\n", - "fixed_positions_ZXCV = [0,1,2,3, 4,5,6,7, 12,13,14,15, 16,17,18,19, 20,21,22,23]\n", - "top_permutation_ZXCV, letter_permutations_ZXCV, scores_ZXCV = permute_and_optimize(keys24, SpeedStrengthFlow24x24, bigrams, all_letters_ZXCV, move_positions_ZXCV, fixed_positions_ZXCV, ntop=10, verbose=False)" + "all_letters4_ZXCV = ['K','U','O','Y', 'H','I','E','A', 'V','Z','X','C', 'W','D','L','B', 'T','S','R','N', 'M','G','F','P']\n", + "move_positions4_ZXCV = [8,9,10,11]\n", + "fixed_positions4_ZXCV = [0,1,2,3, 4,5,6,7, 12,13,14,15, 16,17,18,19, 20,21,22,23] # 0-indices to keys with fixed letter assignments\n", + "top_permutation4_ZXCV, letter_permutations4_ZXCV, scores4_ZXCV = permute_and_optimize(keys24, SpeedStrengthFlow24x24, bigrams, all_letters4_ZXCV, move_positions4_ZXCV, fixed_positions4_ZXCV, ntop=10, verbose=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " Topmost of 24 permutations: 0.044071371113229375\n", + " ['K' 'U' 'O' 'Y' 'H' 'I' 'E' 'A' 'C' 'X' 'Z' 'V' 'W' 'D' 'L' 'B' 'T' 'S' 'R' 'N' 'M' 'G' 'F' 'P']\n", + " ['C', 'X', 'Z', 'V'] 0.044071371113229375\n", + " ['V', 'X', 'Z', 'C'] 0.04406805221272717\n", + " ['C', 'Z', 'X', 'V'] 0.044063850975499204\n", + " ['V', 'Z', 'X', 'C'] 0.044060535344865315\n", + "\n", + " K U O Y W D L B Q\n", + " H I E A T S R N J \n", + " V Z X C M G F P\n", + " \n", + "We will use the 4th top-scoring sequence of command shortcut characters (V,Z,X,C) because V and Z (paste and undo) are often repeated, and should lie closer to the Ctrl/Cmd key for ease of access with one hand. This sequence is also the same as the familiar Z,X,C,V with V moved to the left side." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - " ['C', 'X', 'Z', 'V'] 0.04407240680046151\n", - " ['C', 'Z', 'X', 'V'] 0.044071275336314955\n", - " ['V', 'X', 'Z', 'C'] 0.044066347764175645\n", - " ['V', 'Z', 'X', 'C'] 0.04406521956989739\n", + "#### Workspace to score and explore alterations to the above layouts:" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "KUOY-SR 0.04401807153800817\n", + "KUOY-RS 0.043997091340504314\n", + "KYOU-SR 0.0438722799049078\n", + "KYOU-RS 0.043851327891499675\n" + ] + } + ], + "source": [ + "data_matrix = SpeedStrengthFlow24x24\n", + "#data_matrix = Flow24x24\n", "\n", - "We will choose V,Z,X,C so that the more frequent letters V and C are accessible by folding the smaller fingers, repeated shortcuts V and Z (paste and undo) are closer to the Ctrl/Cmd key, and the sequence is close to Z,X,C,V (with V on the left side)." + "letters = ['K','U','O','Y', 'H','I','E','A', 'V','Z','X','C', 'W','D','L','B', 'T','S','R','N', 'G','M','F','P']\n", + "t = score_layout(data_matrix, letters, bigrams, verbose=False)\n", + "print('KUOY-SR', t)\n", + "letters = ['K','U','O','Y', 'H','I','E','A', 'V','Z','X','C', 'W','D','L','B', 'T','R','S','N', 'G','M','F','P']\n", + "t = score_layout(data_matrix, letters, bigrams, verbose=False)\n", + "print('KUOY-RS', t)\n", + "letters = ['K','Y','O','U', 'H','I','E','A', 'V','Z','X','C', 'W','D','L','B', 'T','S','R','N', 'G','M','F','P']\n", + "t = score_layout(data_matrix, letters, bigrams, verbose=False)\n", + "print('KYOU-SR', t)\n", + "letters = ['K','Y','O','U', 'H','I','E','A', 'V','Z','X','C', 'W','D','L','B', 'T','R','S','N', 'G','M','F','P']\n", + "t = score_layout(data_matrix, letters, bigrams, verbose=False)\n", + "print('KYOU-RS', t)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Optimized layout\n", + " data_matrix = SpeedStrengthFlow24x24\n", + " KUOY-SR 0.04401807153800817\n", + " KUOY-RS 0.043997091340504314\n", + " KYOU-SR 0.0438722799049078\n", + " KYOU-RS 0.043851327891499675" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Optimized full layouts\n", "\n", - " K P U Y G R D W Q score: 0.04406521956989739\n", - " I O E A H T S N J\n", - " V Z X C L B F M\n", + "The top-scoring layouts had all vowels arranged the same way on the left, with command characters on either right or left, and additional small differences: \n", "\n", - " K U O Y W L G B [Q]\n", - " H I E A T R S N [J] \n", - " V Z X C D M F P\n", + " K U O Y W D L B Q\n", + " H I E A T S R N J \n", + " V Z X C G M F P\n", + " \n", + "Switching UOY to YOU improves the ease of typing of some of the most frequent bigrams listed below (AY,YO,CY). The only advantage to UOY is that Y is an infrequent letter set in a hard-to-reach key.\n", "\n", - " K Y O U W L G B [Q]\n", - " H I E A T R S N [J] \n", - " V Z X C D M F P\n", + " K Y O U W D L B Q\n", + " H I E A T S R N J \n", + " V Z X C G M F P\n", + "\n", + "Switching SR to RS:\n", + "\n", + " K Y O U W D L B Q\n", + " H I E A T R S N J \n", + " V Z X C G M F P\n", "\n", - "Difficult-to-type bigrams with frequencies >1 billion for 2 vowels, 2 consonants, or with K,P,Y,V,Z,X,C (unless equally difficult):\n", + " Y P O U G D L B Q\n", + " H I E A T R S N J \n", + " V Z X C M K W F\n", "\n", - " KPUY KUOY KYOU\n", + " RT Y P O U G D L B Q\n", + " H I E A R T S N J \n", + " V Z X C M K W F\n", + "\n", + "E, T, A, O, I, N, S, R, H, L, D, [C], U, M, F, P, G, W, Y, B, [V], K, [X], J, Q, [Z]" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Topmost of 40320 permutations: 0.043941330819070576\n", + "['Y' 'P' 'O' 'U' 'H' 'I' 'E' 'A' 'V' 'Z' 'X' 'C' 'G' 'D' 'L' 'B' 'R' 'T'\n", + " 'S' 'N' 'M' 'K' 'W' 'F']\n", + "['Y', 'P', 'G', 'B', 'M', 'K', 'W', 'F'] 0.043941330819070576\n", + "['Y', 'P', 'G', 'B', 'M', 'W', 'K', 'F'] 0.0439388651259269\n", + "['Y', 'P', 'K', 'B', 'M', 'G', 'W', 'F'] 0.043927353522464775\n", + "['Y', 'P', 'W', 'B', 'M', 'G', 'K', 'F'] 0.043926939625720855\n", + "['Y', 'G', 'W', 'B', 'M', 'K', 'F', 'P'] 0.043923746223730444\n", + "['Y', 'P', 'G', 'B', 'F', 'K', 'W', 'M'] 0.04392297971926771\n", + "['Y', 'G', 'K', 'B', 'M', 'W', 'F', 'P'] 0.04392186498623449\n", + "['Y', 'P', 'G', 'B', 'F', 'W', 'K', 'M'] 0.04392051416201005\n", + "['Y', 'P', 'W', 'B', 'G', 'K', 'F', 'M'] 0.04391985634897772\n", + "['Y', 'G', 'K', 'B', 'M', 'F', 'W', 'P'] 0.043918030239304816\n" + ] + } + ], + "source": [ + "keys24 = [1,2,3,4, 5,6,7,8, 9,10,11,12, 13,14,15,16, 17,18,19,20, 21,22,23,24]\n", + "all_letters5 = ['K','Y','O','U', 'H','I','E','A', 'V','Z','X','C', 'W','D','L','B', 'R','T','S','N', 'G','M','F','P']\n", + "move_positions5 = [0,1,12,15,20,21,22,23]\n", + "fixed_positions5 = [2,3, 4,5,6,7, 8,9,10,11, 13,14, 16,17,18,19] \n", + "top_permutation5, letter_permutations5, scores5 = permute_and_optimize(keys24, SpeedStrengthFlow24x24, bigrams, all_letters5, move_positions5, fixed_positions5, ntop=10, verbose=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Topmost of 40320 permutations: 0.043817776964952926\n", + "['Y' 'P' 'O' 'U' 'H' 'I' 'E' 'A' 'V' 'Z' 'X' 'C' 'F' 'D' 'L' 'B' 'T' 'N'\n", + " 'S' 'R' 'G' 'K' 'W' 'M']\n", + "['Y', 'P', 'F', 'B', 'G', 'K', 'W', 'M'] 0.043817776964952926\n", + "['Y', 'P', 'F', 'B', 'G', 'W', 'K', 'M'] 0.043815316453357955\n", + "['Y', 'P', 'B', 'W', 'G', 'F', 'K', 'M'] 0.04381491612990255\n", + "['Y', 'P', 'K', 'B', 'G', 'F', 'W', 'M'] 0.04381373356858536\n", + "['Y', 'P', 'B', 'F', 'G', 'K', 'W', 'M'] 0.043811814863853674\n", + "['Y', 'P', 'F', 'W', 'G', 'B', 'K', 'M'] 0.04381113363355744\n", + "['Y', 'P', 'B', 'K', 'G', 'F', 'W', 'M'] 0.043811036161600564\n", + "['Y', 'P', 'B', 'F', 'G', 'W', 'K', 'M'] 0.04380934740270156\n", + "['Y', 'P', 'W', 'B', 'G', 'F', 'K', 'M'] 0.043807871920387056\n", + "['Y', 'P', 'F', 'K', 'G', 'B', 'W', 'M'] 0.04380727633405708\n" + ] + } + ], + "source": [ + "keys24 = [1,2,3,4, 5,6,7,8, 9,10,11,12, 13,14,15,16, 17,18,19,20, 21,22,23,24]\n", + "all_letters5 = ['K','Y','O','U', 'H','I','E','A', 'V','Z','X','C', 'W','D','L','B', 'T','N','S','R', 'G','M','F','P']\n", + "move_positions5 = [0,1,12,15,20,21,22,23]\n", + "fixed_positions5 = [2,3, 4,5,6,7, 8,9,10,11, 13,14, 16,17,18,19] \n", + "top_permutation5, letter_permutations5, scores5 = permute_and_optimize(keys24, SpeedStrengthFlow24x24, bigrams, all_letters5, move_positions5, fixed_positions5, ntop=10, verbose=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Topmost of 40320 permutations: 0.04394065704343464\n", + "['Y' 'P' 'O' 'U' 'H' 'I' 'E' 'A' 'V' 'Z' 'X' 'C' 'G' 'D' 'L' 'B' 'T' 'R'\n", + " 'S' 'N' 'M' 'K' 'W' 'F']\n", + "['Y', 'P', 'G', 'B', 'M', 'K', 'W', 'F'] 0.04394065704343464\n", + "['Y', 'P', 'G', 'B', 'M', 'W', 'K', 'F'] 0.04394046346632777\n", + "['Y', 'G', 'K', 'B', 'M', 'W', 'F', 'P'] 0.043924042178772965\n", + "['Y', 'P', 'K', 'B', 'G', 'W', 'F', 'M'] 0.04392333546006803\n", + "['Y', 'P', 'G', 'W', 'M', 'K', 'B', 'F'] 0.04392265234414575\n", + "['Y', 'G', 'W', 'B', 'M', 'K', 'F', 'P'] 0.04391968076906147\n", + "['Y', 'P', 'G', 'K', 'M', 'W', 'B', 'F'] 0.04391959882447153\n", + "['K', 'Y', 'G', 'B', 'M', 'W', 'F', 'P'] 0.04391943606401468\n", + "['Y', 'P', 'W', 'B', 'G', 'K', 'F', 'M'] 0.04391919635487101\n", + "['Y', 'P', 'K', 'B', 'M', 'G', 'W', 'F'] 0.04391881764106538\n" + ] + } + ], + "source": [ + "keys24 = [1,2,3,4, 5,6,7,8, 9,10,11,12, 13,14,15,16, 17,18,19,20, 21,22,23,24]\n", + "all_letters5 = ['K','Y','O','U', 'H','I','E','A', 'V','Z','X','C', 'W','D','L','B', 'T','R','S','N', 'G','M','F','P']\n", + "move_positions5 = [0,1,12,15,20,21,22,23]\n", + "fixed_positions5 = [2,3, 4,5,6,7, 8,9,10,11, 13,14, 16,17,18,19] \n", + "top_permutation5, letter_permutations5, scores5 = permute_and_optimize(keys24, SpeedStrengthFlow24x24, bigrams, all_letters5, move_positions5, fixed_positions5, ntop=10, verbose=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Difficult-to-type bigrams with frequencies >1 billion for 2 vowels, 2 consonants, or with K,P,Y,V,Z,X,C (unless equally difficult), with marks for differences between SR and RS layouts (xx = single finger, x = roll-out):\n", + "\n", + " SR RS UOY YOU\n", "\n", " TH 100272945963\n", " ND 38129777631\n", " ST 29704461829\n", " NT 29359771944\n", " NG 26871805511\n", - " OU 24531132241 x \n", + " OU 24531132241 \n", " IO 23542263265\n", " VE 23270129573\n", " CO 22384167777 \n", @@ -2216,54 +2559,42 @@ " IC 19701195496\n", " EA 19403941063\n", " CE 18367773425\n", - " CH 16854985236 x x \n", + " CH 16854985236 \n", " CA 15174413181\n", " NS 14350320288\n", " HO 13672603513\n", - " PE 13477683504 x\n", + " PE 13477683504 \n", " EC 13457763533\n", " PR 13378480175 \n", " CT 12997849406 \n", - " TR 12006693396 xx x x\n", + " TR 12006693396 \n", " LY 11983948242\n", " NC 11722631112\n", - " RS 11180732354 x \n", + " RS 11180732354 o x \n", " IE 10845731320\n", " WH 10680697684 \n", - " RT 10198055461 xx \n", - " PO 10189505383 xx\n", + " RT 10198055461 \n", + " PO 10189505383 \n", " TS 9516029773\n", " PA 9123652775\n", " AI 8922759715\n", " SH 8888705287\n", - " IV 8116349309 xx x x\n", + " IV 8116349309 \n", " IA 8072199471\n", " CI 7936922442\n", - " VI 7600241898 xx\n", - " PL 7415349106 xx xx\n", + " VI 7600241898 \n", + " PL 7415349106 \n", " EV 7184041787\n", " LD 7122648226\n", " RY 6985436186\n", - " MP 6743935008 x x\n", + " MP 6743935008 \n", " BL 6581097936\n", - " GH 6414827751 xx\n", - " K P U Y G R D W Q score: 0.04406521956989739\n", - " I O E A H T S N J\n", - " V Z X C L B F M\n", - "\n", - " K U O Y W L G B [Q]\n", - " H I E A T R S N [J] \n", - " V Z X C D M F P\n", - "\n", - " K Y O U W L G B [Q]\n", - " H I E A T R S N [J] \n", - " V Z X C D M F P\n", - "\n", + " GH 6414827751 \n", " TY 6408447994\n", - " AY 6128842727 xx x x\n", + " AY 6128842727 xx x\n", " EX 6035335807\n", " KE 6027536039\n", - " FR 6011200185 xx\n", + " FR 6011200185 xx o\n", " AV 5778409728\n", " GR 5548472398\n", " SP 5392724233\n", @@ -2271,25 +2602,25 @@ " EI 5169898489\n", " OV 5021440160\n", " BY 4975814759\n", - " RM 4938158020\n", + " RM 4938158020 x xx\n", " OC 4692062395\n", " RN 4521640992\n", " SC 4363410770\n", - " YO 4226720021\n", + " YO 4226720021 x o\n", " CR 4214150542\n", " CL 4201617719\n", " UE 4158448570\n", " EY 4053144855\n", - " LS 3990203351\n", + " LS 3990203351 x xx\n", " UP 3835093459\n", " HT 3670802795\n", - " DS 3560125353\n", + " DS 3560125353 xx o\n", " LT 3486149365\n", " PI 3470838749\n", " RC 3422694015\n", " AU 3356322923\n", " CK 3316660134\n", - " BR 3145611704\n", + " BR 3145611704 x o\n", " PT 2982699529\n", " PU 2947681332\n", " UI 2852182384\n", @@ -2300,11 +2631,11 @@ " RK 2736041446\n", " YS 2730343336\n", " PH 2661480326\n", - " MS 2617582287\n", + " MS 2617582287 xx x\n", " MB 2544901434\n", " OI 2474275212\n", - " RL 2432373251\n", - " DR 2409399231\n", + " RL 2432373251 xx x\n", + " DR 2409399231 o xx\n", " HR 2379584978\n", " TW 2322619238\n", " FT 2302659749\n", @@ -2315,7 +2646,7 @@ " NF 1894270041\n", " XP 1885334638\n", " GN 1850801359\n", - " SM 1838392669\n", + " SM 1838392669 xx x\n", " FL 1830098844\n", " IZ 1814164135\n", " OK 1813376076\n", @@ -2324,95 +2655,26 @@ " GL 1709752272\n", " OA 1620913259\n", " SY 1602829285\n", - " SL 1575646777\n", + " SL 1575646777 x xx\n", " PS 1538723474\n", " LF 1507867867\n", " NV 1466426243\n", " NK 1455100124\n", " KN 1450401608\n", - " GS 1443474876\n", + " GS 1443474876 x xx\n", " DY 1421751251\n", " HY 1412343465\n", " ZE 1402290616\n", " KS 1339590722\n", " XT 1315669490\n", - " BS 1292319275\n", + " BS 1292319275 o x\n", " IK 1209994695\n", - " CY 1176324279\n", + " CY 1176324279 xx x\n", " RP 1173542093\n", " SK 1112771273\n", " XI 1111463633\n", " OE 1089254517\n", - " OY 1020190223" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Workspace to score and explore alterations to the above layouts:" - ] - }, - { - "cell_type": "code", - "execution_count": 61, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "KPUY-B 0.04401907615377155\n", - "KPUY-G 0.04406521956989739\n", - "KUOY 0.04411932034016915\n", - "KYOU 0.044117479486280115\n" - ] - } - ], - "source": [ - "data_matrix = SpeedStrengthFlow24x24\n", - "# E, T, A, O, I, U N, S, R, H, V X Z C\n", - "# L, D, [C], U, M, F, P, G, \n", - "# W, Y, B, [V], K, [X], [J], [Q], [Z]\n", - "\n", - "\"\"\"\n", - " K P U Y B R D W [Q]\n", - " I O E A H T S N [J]\n", - " V Z X C L G F M \n", - "\"\"\"\n", - "letters = ['K','P','U','Y', 'I','O','E','A', 'V','Z','X','C', 'B','R','D','W', 'H','T','S','N', 'L','G','F','M']\n", - "t = score_layout(data_matrix, letters, bigrams, verbose=False)\n", - "print('KPUY-B', t)\n", - "\"\"\"\n", - " K P U Y G R D W [Q]\n", - " I O E A H T S N [J]\n", - " V Z X C L B F M\n", - "\"\"\"\n", - "letters = ['K','P','U','Y', 'I','O','E','A', 'V','Z','X','C', 'G','R','D','W', 'H','T','S','N', 'L','B','F','M']\n", - "t = score_layout(data_matrix, letters, bigrams, verbose=False)\n", - "print('KPUY-G', t)\n", - " \n", - "\"\"\"\n", - " K U O Y W L G B [Q]\n", - " H I E A T R S N [J] \n", - " V Z X C D M F P\n", - "\"\"\"\n", - "letters = ['K','U','O','Y', 'H','I','E','A', 'V','Z','X','C', 'W','L','G','B', 'T','R','S','N', 'D','M','F','P']\n", - "t = score_layout(data_matrix, letters, bigrams, verbose=False)\n", - "print('KUOY', t)\n", - "\n", - "\"\"\"\n", - " K U O Y W L G B [Q]\n", - " H I E A R T S N [J] \n", - " V Z X C D M F P\n", - "\n", - " K U O Y G D L B [Q]\n", - " H I E A R T S N [J] \n", - " V Z X C W M F P\n", - "\"\"\"\n", - "letters = ['K','U','O','Y', 'H','I','E','A', 'V','Z','X','C', 'W','L','G','B', 'R','T','S','N', 'D','M','F','P']\n", - "t = score_layout(data_matrix, letters, bigrams, verbose=False)\n", - "print('KYOU', t)\n" + " OY 1020190223 o x" ] }, { @@ -2432,7 +2694,7 @@ "id": "TPW3wZw2DzT7" }, "source": [ - "## Step 4: Arrange punctuation marks and characters in easy-to-remember places " + "## Step 5: Arrange punctuation marks and characters in easy-to-remember places " ] }, { @@ -2506,47 +2768,41 @@ { "cell_type": "markdown", "metadata": { - "colab_type": "raw", - "id": "7lqP4bDvDzT8" + "colab_type": "text", + "id": "sdl3lLOfDzT8" }, "source": [ "### Add punctuation keys and number keys\n", "\n", - " K P U Y ' \" G R D W Q\n", - " I O E A , . H T S N J\n", - " V Z X C ( ) L B F M\n", - "\n", - "The Shift key accesses characters (top) that look similar to the numbers:\n", + " # 1 2 3 4 5 6 7 8 9 0 < >\n", "\n", - " ! = ? + $ @ ^ & % *\n", - " 1 2 3 4 5 6 7 8 9 0\n", + " K U O Y ' \" W L G B Q\n", + " H I E A , . T S R N J \n", + " V Z X C ( ) D M F P \n", + " \n", + "Shift to access similar-looking characters above the numbers, and swap the Backspace and Caps lock keys:\n", "\n", - "and accesses related but less common punctuation (top):\n", "\n", - " ` \\ ; : { } | _\n", - " ' \" , . ( ) / -\n", + " ~ ! = ? + $ @ ^ & % * < >\n", + " # 1 2 3 4 5 6 7 8 9 0 [ ] Caps\n", "\n", - "Swapping the Backspace and Caps lock keys completes the layout:\n", + " Tab K U O Y ' \" W L G B Q - /\n", + " Back H I E A , . T S R N J Enter\n", + " Shift V Z X C ( ) D M F P Shift\n", "\n", + " Ctrl Fn Cmd Alt Space Alt Ctrl Arrows\n", "\n", - " ~ ! = ? + $ @ ^ & % * < >\n", - " # 1 2 3 4 5 6 7 8 9 0 [ ] Caps\n", "\n", - " Tab K P U Y ' \" G R D W Q - /\n", - " Back I O E A , . H T S N J Enter\n", - " Shift V Z X C ( ) L B F M Shift\n", + "Shift to access less common, but similar-meaning punctuation (top):\n", "\n", - " Ctrl Fn Cmd Alt Space Alt Ctrl Arrows\n" + " ~ ` \\ ; : { } | _\n", + " # ' \" , . ( ) / -" ] }, { "cell_type": "code", "execution_count": null, - "metadata": { - "colab": {}, - "colab_type": "code", - "id": "OTb_PhuQa8RY" - }, + "metadata": {}, "outputs": [], "source": [] }