CheatSheet.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# This is Q Practice\n",
    "\n",
    "## Philosophy\n",
    "### 1. Interpreted. \n",
    "Q is interpreted, not compiled. The interpreter's eval and parse routines are exposed so that you can dynamically generate code in a controlled manner.\n",
    "\n",
    "### 2.Types.  \n",
    "Q is a dynamically typed language, in which type checking is mostly unobtrusive. \n",
    "\n",
    "### 3. Evaluation Order\n",
    "While q is entered left-to-right, expressions are evaluated right-to-left or, as the q gods prefer, left of right – meaning that a function is applied to the argument on its right.\n",
    "\n",
    "### 4. Null and Infinity Values \n",
    "In q, null values are typed and take the same space as non-nulls. Numeric types also have infinity values. Infinite and null values can participate in arithmetic and other operations with (mostly) predictable results.\n",
    "\n",
    "### 5.Integrated I/O\n",
    " I/O is done through function handles that act as windows to the outside world. Once such a handle is initialized, passing a value to the handle is a write.\n",
    " \n",
    " ### 6. Table Oriented \n",
    "q has tables as first class entities.A table can be viewed as a list of record dictionaries.\n",
    "\n",
    "### 7. Ordered Lists \n",
    "In q, data structures are based on ordered lists, so time series maintain the order in which they are created. Moreover, simple lists occupy contiguous storage, so processing big data is fast. Very fast.\n",
    "\n",
    "### 8. Column Oriented \n",
    "Q tables are column lists in contiguous storage and operations apply on entire columns.\n",
    "\n",
    "### 9. In-Memory Database \n",
    "One can think of kdb+ as an in-memory database with persistent backing. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variable (Assignable)\n",
    "\":\" instead of \"=\"\n",
    "\n",
    "\"%\" instead of \"/\" for division"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "a:9 / intended to be a comment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10\r\n"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b:2+a:8 / calculate from RIGHT to LEFT, in other words, b<=(2+a=<8) \n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8\r\n"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "121312412\r\n"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "long:121312412 / long\n",
    "long"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8798.212\r\n"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float:8798.2121 / Aften known as \"DOUBLE\" in many languages\n",
    "float"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0b\r\n"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool:199=200 / \n",
    "bool /1b for true, 0b for false"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2000.01.03\r\n"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "date:2000.01.01 / this is actually 0, as base point\n",
    "date+2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0D12:00:00.000000000\r\n"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "time:12:00:00.000000000 / this is noon\n",
    "time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "`Similar_to_string_in_other_language\r\n"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "symbol:`Similar_to_string_in_other_language\n",
    "symbol"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1 2 3 4\r\n"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_of_int:(1; 2; 3; 4)\n",
    "list_of_int"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0 1 2 3 4 5 6 7 8\r\n"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_by_til: til 9\n",
    "list_by_til"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "`zero`one`two`three\r\n"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_of_symbols:(`zero; `one; `two; `three)\n",
    "list_of_symbols"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1 3 5 7 9 11 13 15\r\n"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_op: 1+2* til 8\n",
    "list_op"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1 2 3 4 5\r\n"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "1 2\r\n"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "4 5\r\n"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "`long$()\r\n"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_join: 1 2 , 3, 4 5 / join by \",\"\n",
    "list_join\n",
    "2#list_join / get the first 2\n",
    "-2#list_join / get the last 2. Positive argument means take from the front, negative from the back.\n",
    "\n",
    "0#list_join / get an empty list of the same type as the first item"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8 8 8 8 8\r\n"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "1 2 3 1 2 3\r\n"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "1\r\n"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "/ Some tricks\n",
    "\n",
    "5#8 / 8 8 8 8 8\n",
    "6#1 2 3 / 1 2 3 1 2 3\n",
    "list_join[0] / 0 based list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions- first class value\n",
    "correspond to \"lambda expressions\" or \"anonymous functions\" in other languages."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "87\r\n"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "87\r\n"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "func:{[x;y;z] a:x*x; b:y;c:z; a-b+c} / to define a function, x;y are formal parameters\n",
    "func2:{a:x*x; b:y;c:z; a-b+c} / The same but with the implicit parameters x, y, and z in that order.\n",
    "func[10;8;5] / instead of func(10,8)\n",
    "func2[10;8;5] / the same as the above"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions on List, similar to Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1 2 3 4 5 6 7 8 9 10\r\n"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "0100000000b\r\n"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "0011111111b\r\n"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "46\r\n"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "45\r\n"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "55\r\n"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "0\r\n"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "3628800\r\n"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1+ til 10\n",
    "1= til 10\n",
    "1<til 10\n",
    "1+/til 10 / = 1 + sum(0..9)\n",
    "(+/) til 10 / Accumulate\n",
    "(+/) 1+ til 10  / Accumulate\n",
    "(*/) til 10 / Production\n",
    "(*/) 1+ til 10 / Production"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15\r\n"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "55\r\n"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0 {x+y}/ 1 2 3 4 5\n",
    "0 {x+y}/ 1+til 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|, which returns the larger of its operands\n",
    "&, which returns the smaller of its operands."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10\r\n"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "8\r\n"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "9\r\n"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "0\r\n"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "1000\r\n"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "55\r\n"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "3628800\r\n"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "40\r\n"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "10\r\n"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10|8\n",
    "10&8\n",
    "(|/) til 10\n",
    "(&/) til 10\n",
    "(*/) 3#10\n",
    "\n",
    "sum 1+til 10 / this is +/\n",
    "\n",
    "prd 1+til 10 / this is */ -- note missing \"0\"\n",
    "max 20 10 40 30 / this is |/\n",
    "min 20 10 40 30 / this is &/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Fibonacci Numbers (Example)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2\r\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "3\r\n"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "1 2 3\r\n"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "1 1 2 3 5 8 13\r\n"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "F0:1 2\n",
    "show 2#F0\n",
    "sum -2#F0\n",
    "\n",
    "F0,sum -2#F0\n",
    "\n",
    "5 {x,sum -2#x}/ 1 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Trading Example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2 -1 3 -1 2 -1f\r\n"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "2 3 7 10 15 19f\r\n"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "2 6 9 11\r\n"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "2 2 2 2  2  2 \r\n",
       "2 3 6 6  6  6 \r\n",
       "2 3 7 9  9  9 \r\n",
       "2 3 7 10 11 11\r\n"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "buys:2 1 4 3 5 4f\n",
    "sells:2 4 3 2\n",
    "deltas [buys]\n",
    "sums [buys]\n",
    "sums[sells] \n",
    "sums[sells] &\\: sums[buys] / That adverb is called each left and it has the funky notation \\:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2\r\n"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "6 3\r\n"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "count (til 6; 10 20 30) \n",
    "count each (til 6; 10 20 30) / count each"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2 2 2 2 2 2\r\n",
       "0 1 4 4 4 4\r\n",
       "0 0 1 3 3 3\r\n",
       "0 0 0 1 2 2\r\n"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "deltas sums[sells] &\\: sums[buys]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2 0 0 0 0 0\r\n",
       "0 1 3 0 0 0\r\n",
       "0 0 1 2 0 0\r\n",
       "0 0 0 1 1 0\r\n"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "deltas each deltas sums[sells] &\\: sums[buys]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionaries (Key List - Value List) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a| 0\r\n",
       "b| 1\r\n",
       "c| 2\r\n",
       "d| 3\r\n"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "3\r\n"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d:`a`b`c`d!til 4\n",
    "d\n",
    "d[`d]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "c1| 0 10 20 30 40\r\n",
       "c2| 1 2 3\r\n"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "1 2 3\r\n"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "3\r\n"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c1| 10\r\n",
       "c2| 2\r\n"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c1 c2 \r\n",
       "------\r\n",
       "10 1.1\r\n",
       "20 2.2\r\n",
       "30 3.3\r\n"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "10\r\n"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dc:`c1`c2!(10 * til 5; 1+ til 3)\n",
    "dc\n",
    "dc[`c2]\n",
    "dc[`c2;2]\n",
    "dc[;1]\n",
    "trans:flip `c1`c2!(10 20 30; 1.1 2.2 3.3)\n",
    "trans\n",
    "trans[0;`c1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Table-- A flipped column dictionary\n",
    "A table is a flipped column dictionary.\n",
    "It is also a list of record dictionaries.\n",
    "The column names in table definition are not symbols, although they are converted to symbols under the covers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "c1 c2 \r\n",
       "------\r\n",
       "10 1.1\r\n",
       "20 2.2\r\n",
       "30 3.3\r\n"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "table1:([] c1:10 20 30; c2:1.1 2.2 3.3) \n",
    " / [] are necessary to differentiate a table from a list\n",
    "\n",
    " / vs dictionary `c1`c2!(10 20 30; 1.1 2.2 3.3) \n",
    "table1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Q-SQL\n",
    "it is not evaluated right-to-left. Rather, it is syntactic sugar designed to mimic SQL SELECT.\n",
    "Whereas SQL SELECT operates on fields on a row-by-row basis, select performs vector operations on column lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "c1   c2 c3\r\n",
       "----------\r\n",
       "1000 a  10\r\n",
       "1001 b  20\r\n",
       "1002 c  30\r\n",
       "1003 a  40\r\n",
       "1004 b  50\r\n",
       "1005 a  60\r\n"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "table2:([] c1:1000+til 6; c2:`a`b`c`a`b`a; c3:10*1+til 6)\n",
    "table2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "c1   val\r\n",
       "--------\r\n",
       "1000 20 \r\n",
       "1001 40 \r\n",
       "1002 60 \r\n",
       "1003 80 \r\n",
       "1004 100\r\n",
       "1005 120\r\n"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "select c1, val:2*c3 from table2 / : To define a new column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "c2| count_c1 sum_c3\r\n",
       "--| ---------------\r\n",
       "a | 3        110   \r\n",
       "b | 2        70    \r\n",
       "c | 1        30    \r\n"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "select count_c1: count c1, sum_c3: sum c3 by c2 from table2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ovrund| c2\r\n",
       "------| --\r\n",
       "0     | 2 \r\n",
       "1     | 4 \r\n"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "select count c2 by ovrund:c3<=40 from table2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "c1   c2 c3 \r\n",
       "-----------\r\n",
       "1000 a  100\r\n",
       "1001 b  20 \r\n",
       "1002 c  30 \r\n",
       "1003 a  400\r\n",
       "1004 b  50 \r\n",
       "1005 a  600\r\n"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c1   c2 c3\r\n",
       "----------\r\n",
       "1000 a  10\r\n",
       "1001 b  20\r\n",
       "1002 c  30\r\n",
       "1003 a  40\r\n",
       "1004 b  50\r\n",
       "1005 a  60\r\n"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "update c3:10*c3 from table2 where c2=`a / Here \":\" means assignment\n",
    " / update are vector operations on columns, not row-by-row.\n",
    "table2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "c1   c2 c3\r\n",
       "----------\r\n",
       "1000 a  10\r\n",
       "1003 a  40\r\n",
       "1005 a  60\r\n",
       "1001 b  20\r\n",
       "1004 b  50\r\n",
       "1002 c  30\r\n"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "`c2 xasc table2 / To sord ASC by `c2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Random Data Generator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12 8 10 1 9 11 5 6 1 5\r\n"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "`aapl`aapl`ibm`ibm`aapl`ibm`aapl`ibm`aapl`ibm\r\n"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10?20 /  first 20 integers starting at 0 (i.e., not including 20).\n",
    "10?`aapl`ibm /  10 random selections from the items in a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0 0 0 0 0 5 5 5 5 5 10 10 10 10 10\r\n"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 xbar til 15 /The left operand of xbar is an interval width, and the right operand is a list of numeric values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "63.33333\r\n"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 2 3 wavg 50 60 70"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### string , a list of char\n",
    "string is not an atom or even a first class entity in q; it is a list having count 6. And it should not be confused with its symbol cousin `string, which is an atom having count 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"string\"\r\n"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "6\r\n"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "1\r\n"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(\"s\";\"t\"; \"r\"; \"i\"; \"n\"; \"g\")\n",
    "count \"string\"\n",
    "count `string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### File IO\n",
    "A symbolic file handle is a symbol of a particular form that represents the name of a resource on the file system. The leading ':' distinguishes the symbol as a handle."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "`:/q/save/t\r\n"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c1 c2 \r\n",
       "------\r\n",
       "a  1.1\r\n",
       "b  2.2\r\n",
       "c  3.3\r\n"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t:([] c1:`a`b`c; c2:1.1 2.2 3.3)\n",
    "`:/q/save/t set t / write \n",
    "t2: get `:/q/save/t /read\n",
    "t2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "`:/q/life.txt\r\n"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "\"Meaning\"\r\n",
       "\"of\"\r\n",
       "\"life\"\r\n"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "`:/q/life.txt 0: (\"Meaning\";\"of\";\"life\") \n",
    "/ write text to file\n",
    "txt:read0 `:/q/life.txt / read text from file\n",
    "txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "`:/q/examples/t.csv\r\n"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "\"c1,c2\"\r\n",
       "\"a,1.1\"\r\n",
       "\"b,2.2\"\r\n",
       "\"c,3.3\"\r\n"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "`:/q/examples/t.csv 0: csv 0: t\n",
    "t2: read0 `:/q/examples/t.csv\n",
    "t2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "c1 c2 \r\n",
       "------\r\n",
       "a  1.1\r\n",
       "b  2.2\r\n",
       "c  3.3\r\n"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t3: (\"SF\"; enlist \",\") 0: `:/q/examples/t.csv / S: sysmbol, F: float\n",
    "t3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Interprocess Communication\n",
    "q)\\p 5060 / on server\n",
    "q)f:{x*y} / on server\n",
    "echo:{show x} / on server\n",
    "rsvp:{[arg;cb] show arg; (neg .z.w) (cb; 43); show `done;} "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "ename": "\u001b[0;31mhop. OS reports: No connection could be made because the target machine actively refused it.\u001b[0m",
     "evalue": "\u001b[0;31mhop. OS reports: No connection could be made because the target machine actively refused it.\u001b[0m",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31mevaluation error:\n\u001b[0m",
      "\u001b[0;31mhop. OS reports: No connection could be made because the target machine actively refused it.\u001b[0m",
      "\u001b[0;31m\u001b[0m",
      "\u001b[0;31m  [0]  h:hopen `:localhost:5060 / on client\r\n         ^\r\n\u001b[0m"
     ]
    }
   ],
   "source": [
    "h:hopen `:localhost:5060 / on client\n",
    "h \"2*34\"\n",
    "h (`f; 6; 7) / on client"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "echo:{show x} / Client"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "ename": "\u001b[0;31mh\u001b[0m",
     "evalue": "\u001b[0;31mh\u001b[0m",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31mevaluation error:\n\u001b[0m",
      "\u001b[0;31mh\u001b[0m",
      "\u001b[0;31m\u001b[0m",
      "\u001b[0;31m  [0]  (neg h) (`echo; 42) / on client\r\n            ^\r\n\u001b[0m"
     ]
    }
   ],
   "source": [
    "(neg h) (`echo; 42) / on client"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "ename": "\u001b[0;31mh\u001b[0m",
     "evalue": "\u001b[0;31mh\u001b[0m",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31mevaluation error:\n\u001b[0m",
      "\u001b[0;31mh\u001b[0m",
      "\u001b[0;31m\u001b[0m",
      "\u001b[0;31m  [0]  (neg h) (`rsvp; 42; `echo) / on client\r\n            ^\r\n\u001b[0m"
     ]
    }
   ],
   "source": [
    "(neg h) (`rsvp; 42; `echo) / on client"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Types: Atoms\n",
    "\n",
    "### Datatype\n",
    "![alt text](datatype2.jpg \"comparation\")\n",
    "\n",
    "### Datatype Comparision\n",
    "![alt text](datatype1.jpg \"comparation\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.3333333\r\n"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "`This is a symbol`\r\n"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "long: 4 / 8 bytes\n",
    "long: 4j / not necessary, the same as the above\n",
    "int: 4i / 4 bytes\n",
    "short: 4h / 2 bytes\n",
    "float: 3.14 / 8 bytes\n",
    "float: 6e23 /scientific notation\n",
    "real: 1.23e / 4 bytes\n",
    "/P 10 / specify a display width of 10\n",
    "1%3\n",
    "\n",
    "bool: 0b / 0b for false and 1b for true , 1 byte\n",
    "\n",
    "byte: 0x12a / leading with 0x\n",
    "guid: 1?0Ng / GUID 16 bytes.\n",
    " / he positive case uses the same initial seed in each new q session \n",
    " / whereas the negative case uses a random seed. The former is useful\n",
    " / for reproducible results during testing but only the latter should\n",
    " / be used in production; otherwise, your \"GUIDs\" will not be unique \n",
    " / across q sessions.\n",
    "\n",
    "char: \"q\" / 1 byte char\n",
    "char: \"\\\"\" / quote\n",
    "char:\"\\\\\" / back-slash\n",
    "char:\"\\n\" / newline\n",
    "char:\"\\r\" / return\n",
    "char:\"\\t\" / horizontal tab\n",
    "`$\"This is a symbol`\" / A symbol with special characters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "31i\r\n"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "36070101i\r\n"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "45296123456789\r\n"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "469993420123456789\r\n"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "1b\r\n"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "180i\r\n"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "1b\r\n"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "1b\r\n"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "720i\r\n"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "45296000i\r\n"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "2000i\r\n"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "1i\r\n"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "2i\r\n"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "12i\r\n"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "34i\r\n"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "56i\r\n"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "day: 2019.01.03 / Leading zeroes in months and days are required; their omission causes an error.\n",
    "`int$2000.02.01\n",
    "time:10:01:10.101 / hh:mm:ss.uuu , 4 bytes integer actually. leading 0s are required.\n",
    "`int$10:01:10.101 / in miliseconds\n",
    "timespan:12:34:56.123456789 / 0Dhh:mm:ss.nnnnnnnnn, in nanoseconds\n",
    "`long$12:34:56.123456789 / 8 bytes integer actually\n",
    "\n",
    "datetime: 2000.01.01T12:00:00.000 / A datetime (deprecated) is the lexical combination\n",
    " / of a date and a time, separated by T as in the ISO standard format. \n",
    "\n",
    "timestamp: 2014.11.22D17:43:40.123456789\n",
    "`long$2014.11.22D17:43:40.123456789 / long, 8 bytes actually\n",
    "\n",
    "datepart: `date$2014.11.22D17:43:40.123456789\n",
    "timespan_part: `timespan$2014.11.22D17:43:40.123456789\n",
    "month: 2015.11m\n",
    "2001.01m=12  / 4 bytes integer actually, m is required.\n",
    "`int$2015.01m \n",
    "2015.07m=2015.07.01 / true\n",
    "minutes: 12:20 \n",
    "12:00=12*60 \n",
    "`int$12:00\n",
    "second: 23:59:59 / 4 bytes\n",
    "`int$12:34:56.000\n",
    "\n",
    "datetime: 2000.01.02T03:04:05.000 \n",
    "`year$datetime\n",
    "`mm$datetime\n",
    "`dd$datetime\n",
    "time:12:34:56.789\n",
    "time.hh\n",
    "time.mm\n",
    "time.ss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Arithmetic Infinities and Nulls\n",
    "Literal\tValue\n",
    "\n",
    "0w\tPositive float infinity\n",
    "\n",
    "-0w\tNegative float infinity\n",
    "\n",
    "0n\tNull float ; NaN, or not a number\n",
    "\n",
    "0W\tPositive long infinity\n",
    "\n",
    "-0W\tNegative long infinity\n",
    "\n",
    "0N\tNull long\n",
    "****************************************\n",
    "0N\tMIN_INT\t-9223372036854775808\n",
    "\n",
    "-0W\tMIN_INT+1\t-9223372036854775807\n",
    "\n",
    "0W\tMAX_INT\t+9223372036854775807\n",
    "****************************************\n",
    "##### The nulls to be handled\n",
    "type\tnull\n",
    "boolean*\t0b\n",
    "guid*\t0Ng (00000000-0000-0000-0000-000000000000)\n",
    "byte*\t0x00\n",
    "short\t0Nh\n",
    "Int\t0N\n",
    "long\t0Nj\n",
    "real\t0Ne\n",
    "float\t0n\n",
    "char*\t\" \"\n",
    "sym\t`\n",
    "timestamp\t0Np\n",
    "month\t0Nm\n",
    "date\t0Nd\n",
    "datetime\t0Nz\n",
    "timespan\t0Nn\n",
    "minute\t0Nu\n",
    "second\t0Nv\n",
    "time\t0Nt\n",
    "The binary types have no null values. There is no room since every bit pattern is a legitimate value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1b\r\n"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "1b\r\n"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "`boolean$()\r\n"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "null `\n",
    "null \" \"\n",
    "null \"\"  / \"\" is not null, it's an empty list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Lists\n",
    "All data structures in q are ultimately built from lists: a dictionary is a pair of lists; a table is a special dictionary; a keyed table is a pair of tables.\n",
    "It may be instructive to think of q lists as dynamically allocated arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1b\r\n"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "100 200 300~(100; 200 ; 300) / q verifies by testing for identity using ~."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ",88\r\n"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "100\r\n"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "100 42 300 400\r\n"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "\"()\"\r\n"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "100 42 300 400\r\n"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "enlist 88 / we cannot use ,88 or (,88)\n",
    "L:100 200 300 400\n",
    "L[0] / 0 based index\n",
    "L[1]:42 / assign to an element\n",
    "L[] / the entire list\n",
    "-3!L[()] / -3! is an utility\n",
    "L[::] / The syntactic form double-colon :: denotes the nil item\n",
    "/ , which allows explicit notation or programmatic generation of an empty index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1 2 3 4 5\r\n"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       ",1\r\n"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       ",1\r\n"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "100 200 30\r\n"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 2 3,4 5 / join\n",
    "x:1\n",
    "(),x  /join\n",
    "x,() /join\n",
    "\n",
    "L1:10 0N 30\n",
    "L2:100 200 0N\n",
    "L1^L2 / 100 200 30 the right item prevails over the corresponding left item except when the right item is null.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100 300\r\n"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "100 300\r\n"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "100 200\r\n",
       "300 400\r\n"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "100 2000 3000 4000\r\n"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "100 2000 3000 4000\r\n"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "2 0\r\n"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L:100 200 300 400\n",
    "L[0 2] /same to L 0 2\n",
    "I:0 2 \n",
    "L[I] / same to L I\n",
    "L[(0 1; 2 3)]\n",
    "L[1 2 3]:2000 3000 4000 // Assign one by one\n",
    "L ::\n",
    "L\n",
    "1001 1002 1003?1003 1001 / ? is overloaded to find"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1    2    3    4   \r\n",
       "100  200  300  400 \r\n",
       "1000 2000 3000 4000\r\n"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "100 200 300 400\r\n"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "4 400 4000\r\n"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "1b\r\n"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m:(1 2 3 4; 100 200 300 400; 1000 2000 3000 4000)\n",
    "m\n",
    "m[1;] / 100 200 300 400\n",
    "m[;3] / 4 400 4000\n",
    "m[1;]~m[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1 2 3 4 6 5\r\n"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "0 2 4\r\n"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "30 40 50\r\n"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "10 20 45 45 45\r\n"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "i| 0 3 8 11 14 17\r\n",
       " | 1 6\r\n",
       "m| 2 7\r\n",
       "s| 4 5 9 10 12 13\r\n",
       "p| 15 16\r\n"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "1| ,0\r\n",
       "2| 1 3\r\n",
       "3| 2 4 8\r\n",
       "4| 5 7\r\n",
       "6| 6 10\r\n",
       "5| ,9\r\n"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "distinct 1 2 3 2 3 4 6 4 3 5 6 / 1 2 3 4 6 5\n",
    "where 101010b / 0 2 4\n",
    "L:10 20 30 40 50\n",
    "L[where L>20] / similar to python\n",
    "L[where L>20]:45\n",
    "L\n",
    "\n",
    "group \"i miss mississippi\"\n",
    "group 1 2 3 2 3 4 6 4 3 5 6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Operators\n",
    "operator, function, and verb – interchangeably.\n",
    "Operators are built-in functions used with in-fix notation. \n",
    "Expressions are evaluated right-to-left"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11 22 33\r\n"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "101 102 103\r\n"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "14\r\n"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "10\r\n"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "10\r\n"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 2 3+10 20 30 /11 22 33, similar to Python\n",
    "100+1 2 3 / 101 102 103\n",
    "2*3+4 / 14\n",
    "(2*3)+4 /10\n",
    "4+2*3 /10\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0b\r\n"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "1b\r\n"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "0b\r\n"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(())~enlist ()\n",
    "(1; 2 3 4)~(1; (2; 3; 4))\n",
    "(1 2;3 4)~(1;2 3 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1b\r\n"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "0b\r\n"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "0b\r\n"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "1b\r\n"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "0b\r\n"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "0b\r\n"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "001b\r\n"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "110b\r\n"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "010b\r\n"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "000100b\r\n"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "1010b\r\n"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not 0b\n",
    "not 1b\n",
    "not 42\n",
    "not 0\n",
    "not 0xff\n",
    "not 98.6\n",
    "\n",
    "2 1 3=1 2 3\n",
    "10 20 30<=30 20 10\n",
    "2=1 2 3\n",
    "\"zaphod\"=\"Arthur\"\n",
    "`a`b`a`d=`a`d`a`b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Division % instead of /"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0b\r\n"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "-8\r\n"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a=1\n",
    "neg a /-1. -a is invalid\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Maximum | and Minimum &"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "43\r\n"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "98.6\r\n"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "1b\r\n"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "0b\r\n"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "01000101b\r\n"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "2 2 2 3 4\r\n"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "\"zrthur\"\r\n"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "42|43\n",
    "98.6&101.9\n",
    "0b|1b / similar to or\n",
    "0b&1b / similar to and\n",
    "11010101b&01100101b /item-wise\n",
    "2|0 1 2 3 4 /item-wise\n",
    "\"zaphod\"|\"arthur\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42\r\n"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "21\r\n"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a:43\n",
    "a-:1 / simiar to a-=1 in c\n",
    "a\n",
    "\n",
    "a&:21 / simiar to a=a & 21\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1  2  103\r\n",
       "10 20 130\r\n"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "1 2 3 4\r\n"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "1 2 3 4 100 200\r\n"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L1:(1 2 3; 10 20 30)\n",
    "L1[;2]+:100\n",
    "L1\n",
    "\n",
    "L:1 2 3\n",
    "L,:4 / append\n",
    "L\n",
    "\n",
    "L,:100 200 /append\n",
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.732051\r\n"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "20.08554\r\n"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "1.098612\r\n"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "32f\r\n"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "1.414214\r\n"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "5f\r\n"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sqrt 3\n",
    "exp 3\n",
    "log 3\n",
    "\n",
    "2 xexp 5 / power\n",
    "2 xexp .5 /power 0,5, actually sqrt\n",
    "2 xlog 32"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3\r\n"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "2\r\n"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "-4\r\n"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "1\r\n"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "2f\r\n"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "1\r\n"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "/ Many languages use % for modulus, but it is division in q\n",
    "\n",
    "7 div 2 / 3, rounded down\n",
    "7 div 2.5 /2 , rounded down\n",
    "-7 div 2 /-4, rounded down\n",
    "\n",
    "7 mod 2 / 3, rounded down. mod = dividend – (dividend div divisor)\n",
    "7 mod 2.5 /2 , rounded down\n",
    "-7 mod 2 /-4, rounded down"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1i\r\n"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "-1i\r\n"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "0i\r\n"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "-1i\r\n"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "1i\r\n"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "42.00001\r\n"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "0w\r\n"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "-0w\r\n"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "4\r\n"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "-5\r\n"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "5\r\n"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "4\r\n"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "-4\r\n"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "42\r\n"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "signum 42 /1i\n",
    "signum -42.0 /-1i\n",
    "signum 0 /0i\n",
    "\n",
    "signum 1999.12.31\n",
    "signum 12:00:00.000000000\n",
    "\n",
    "reciprocal 0.02380952 / 42.00001\n",
    "reciprocal 0.0 / 0w\n",
    "reciprocal -0.0 / -0w\n",
    "\n",
    "floor 4.2 /4\n",
    "floor -4.2 / -5\n",
    "ceiling 4.2 /5\n",
    "ceiling 4 /4\n",
    "ceiling -4.2 /-4\n",
    "\n",
    "abs -42 /42"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1b\r\n"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "2015.01.01 2015.01.02 2015.01.03 2015.01.04 2015.01.05 2015.01.06 2015.01.07 ..\r\n"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "366i\r\n"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "5i\r\n"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2000.01.01<2000.01.01D12:00:00.000000000\n",
    "2015.01.01+til 31 / all days in January\n",
    "2001.01.01-2000.01.01 /366i\n",
    "2015.06m-2015.01m /5i"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Alias ::\n",
    "An alias is a variable that is an expression – i.e., it is not the result of expression evaluation but the expression itself.\n",
    "Evaluation of an alias is lazy, meaning that it occurs only when necessary. More precisely, evaluation is forced when the variable is referenced, at which point a determination is made whether the expression needs to be (re)evaluated"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "43\r\n"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "42\r\n"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a:42\n",
    "b::a\n",
    "c:a\n",
    "a:43\n",
    "b / 43\n",
    "c /42"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n",
      "9\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "25\r\n"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "25\r\n"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "45\r\n"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "a| b\r\n",
       "x| w\r\n",
       "y| w\r\n"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "w::(0N!x*x)+y*y\n",
    "x:3\n",
    "y:4\n",
    "w  / 9 25\n",
    "w / 25\n",
    "y:6\n",
    "w / 9 45\n",
    ".z.b / system dictionary, which is also obtainable via the command \\b."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Views\n",
    "Aliasing is commonly used to provide a database view by specifying a query as the expression."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "sym px  \r\n",
       "--------\r\n",
       "a   99.5\r\n",
       "a   99.4\r\n"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "`t\r\n"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "sym px\r\n",
       "------\r\n",
       "a   42\r\n",
       "a   42\r\n"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t:([]c1:`a`b`c`a;c2:20 15 10 20;c3:99.5 99.45 99.42 99.4)\n",
    "v::select sym:c1,px:c3 from t where c1=`a\n",
    "v\n",
    "update c3:42.0 from `t where c1=`a\n",
    "v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a| b\r\n",
       "x| w\r\n",
       "y| w\r\n",
       "t| v\r\n"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ".z.b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. Dictionaries\n",
    "A dictionary is a mapping defined by an explicit association between a key list and value list. \n",
    "The two lists must have the same count and the key list should be a unique collection."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "`a`b`c\r\n"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "100 200 300\r\n"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "3\r\n"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "100\r\n"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "100 300\r\n"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "100 300\r\n"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d:`a`b`c!100 200 300\n",
    "key d\n",
    "value d\n",
    "count d\n",
    "d[`a]\n",
    "d[`a`c]\n",
    "ks:`a`c\n",
    "d ks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "`a\r\n"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "0      | 110\r\n",
       "100    | 20\r\n",
       "500000 | 30\r\n",
       "99     | 200\r\n",
       "1000000| 300\r\n"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "a| 10\r\n",
       "b| 42\r\n",
       "c| 30\r\n",
       "a| 10\r\n",
       "x| 100\r\n"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "a| 10\r\n",
       "c| 30\r\n"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c| 30\r\n"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d:`a`b`c`a!10 20 30 10\n",
    "d?10 /`a\n",
    "\n",
    "d1:0 100 500000!10 20 30\n",
    "d2:0 99 1000000!100 200 300\n",
    "d1+d2\n",
    "\n",
    "d[`b]:42 / update\n",
    "d[`x]:100 / insert, upsert semantics.\n",
    "d\n",
    "\n",
    "`a`c#d\n",
    "(enlist `c)#d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "c| 30\r\n"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c| 30\r\n"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "\"(`symbol$())!`long$()\"\r\n"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "a| 10\r\n",
       "b| 20\r\n",
       "c| 30\r\n"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d:`a`b`c!10 20 30\n",
    "`a`b _ d / remove `a and `b. A space before _ is required.\n",
    "`a`b cut d / the same as the above\n",
    "\n",
    "-3!`a`b`c _ d /\"(`symbol$())!`long$()\"\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a| -10\r\n",
       "b| -20\r\n",
       "c| -30\r\n"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "a| 20\r\n",
       "b| 40\r\n",
       "c| 60\r\n"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "a| 100\r\n",
       "b| 400\r\n",
       "c| 900\r\n"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "a| 11\r\n",
       "b| 22\r\n",
       "c| 33\r\n"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "a| 10\r\n",
       "b| 20\r\n",
       "c| 30\r\n"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "a| 10\r\n",
       "b| 20\r\n",
       "c| 30\r\n"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "/ Similar to Python\n",
    "d:`a`b`c!10 20 30\n",
    "neg d\n",
    "2*d\n",
    "f:{x*x}\n",
    "f d\n",
    "\n",
    "d1:`a`b`c!1 2 3\n",
    "d2:`a`b`c!10 20 30\n",
    "d1+d2\n",
    "d1,d2 / right has the preference\n",
    "d1^d2 / Similar to the above, but can deal with null"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "c| 10 20 30\r\n"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dc1:(enlist `c)!enlist 10 20 30 / Not = `c!1 2 3\n",
    "dc1 / c| 10 20 30\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 6. Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42\r\n"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "6\r\n"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a:2*3;6*7 \n",
    "a / trick here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "84\r\n"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "25\r\n"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "10\r\n"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{[x] 2*x} 42 / 84,= {[x] 2*x} [42]\n",
    "f:{[x] x*x} / = f:{x*x} / implicit x\n",
    "f 5 / 25, = f[5]\n",
    "\n",
    ".my.name.space.f:{2*x}\n",
    "`.my.name.space.f[5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{x*x}\r\n"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "/ Similar to lambda\n",
    "powers:({1}; {x}; {x*x}; {x*x*x})\n",
    "selected:2\n",
    "powers[selected] /{x*x}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "`a`b`c\r\n"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "::[`a`b`c]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25\r\n"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "42\r\n"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "`a\r\n"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "43\r\n"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "apply:{x y}\n",
    "sq:{x*x}\n",
    "apply[sq; 5]\n",
    "a:42\n",
    "get `a / 42 / get, which returns the value of the global variable whose name is passed.\n",
    "\n",
    "`a set 43\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "420\r\n"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "`a\r\n"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "43\r\n"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f:{[p1] a:42; helper:{[a; p2] a*p2}[a;]; helper p1}\n",
    "f[10]\n",
    "\n",
    "a:42\n",
    "f:{a:98.6; `a set x}\n",
    "f 43\n",
    "a\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "36\r\n"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f:{x-y}\n",
    "g:f[42;] /{x-y}[42;] / Partial function of Python\n",
    "g[6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0N\r\n"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "`\r\n"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "0n\r\n"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 20 30 40[100] / 0N / out of bound\n",
    "`a`b`c[-1]\n",
    "(1.1; 1; `1)[3] / 0n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1 -2 -3\r\n",
       "-4 -5\r\n"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "\"abcde\"\r\n",
       "\"uvxyz\"\r\n"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "\"abc>\"\r\n",
       "\"de>\"\r\n",
       "\"f>\"\r\n"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "\"</abc\"\r\n",
       "\"</de\"\r\n",
       "\"</f\"\r\n"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "1 10 1 20\r\n",
       "2 10 2 20\r\n",
       "3 10 3 20\r\n"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "1 10\r\n",
       "1 20\r\n",
       "2 10\r\n",
       "2 20\r\n",
       "3 10\r\n",
       "3 20\r\n"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "1 10\r\n",
       "1 20\r\n",
       "2 10\r\n",
       "2 20\r\n",
       "3 10\r\n",
       "3 20\r\n"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "neg (1 2 3; 4 5)\n",
    "(\"abc\"; \"uv\"),'(\"de\"; \"xyz\") / zip\n",
    "(\"abc\"; \"de\"; enlist \"f\") ,\\: \">\" /each left\n",
    "\"</\" ,/: (\"abc\"; \"de\"; enlist \"f\") /each right\n",
    "1 2 3,/:\\:10 20 / cross product\n",
    "raze 1 2 3,/:\\:10 20 / cross product\n",
    "1 2 3 cross 10 20 / cross product"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " ### Over (/) for Accumulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1\n",
      "1 2\n",
      "3 3\n",
      "6 4\n",
      "10 5\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "55\r\n"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "15\r\n"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "3628800\r\n"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "10\r\n"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "1\r\n"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0 +/ 1 2 3 4 5 6 7 8 9 10 /55 / Over (/) for Accumulation¶\n",
    "addi:{0N!(x;y); x+y}\n",
    "0 addi/ 1 2 3 4 5 /15 \n",
    "(*/) 1 2 3 4 5 6 7 8 9 10 / product 3628800\n",
    "(|/) 7 8 4 3 10 2 1 9 5 6 / maximum 10\n",
    "(&/) 7 8 4 3 10 2 1 9 5 6 / minimum 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1 2 3 5 8 13 21 34 55 89 144 233\r\n"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "1 2 3 5 8 13 21 34 55 89 144 233\r\n"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597\r\n"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fib:{x,sum -2#x}\n",
    "10 fib/ 1 2 / run 10 times\n",
    "fib/[10; 1 2] / same as the above\n",
    "fib/[{1000>last x}; 1 1] / loop until "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Scan \\\n",
    "\n",
    "The scan adverb \\ is a higher-order function that behaves just like / except that it returns all the intermediate accumulations instead of just the final one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1 3 6 10 15 21 28 36 45 55\r\n"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "1 2 6 24 120 720 5040 40320 362880 3628800\r\n"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "7 8 8 8 10 10 10 10 10 10\r\n"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "7 7 4 3 3 2 1 1 1 1\r\n"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "1 2  3  4  5  6  7  8  9  10\r\n",
       "2 4  6  8  10 12 14 16 18 20\r\n",
       "4 8  12 16 20 24 28 32 36 40\r\n",
       "8 16 24 32 40 48 56 64 72 80\r\n"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "1   2   3   4   5   6   7   8    9    10  \r\n",
       "2   4   6   8   10  12  14  16   18   20  \r\n",
       "4   8   12  16  20  24  28  32   36   40  \r\n",
       "8   16  24  32  40  48  56  64   72   80  \r\n",
       "16  32  48  64  80  96  112 128  144  160 \r\n",
       "32  64  96  128 160 192 224 256  288  320 \r\n",
       "64  128 192 256 320 384 448 512  576  640 \r\n",
       "128 256 384 512 640 768 896 1024 1152 1280\r\n"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f:{2*x}\n",
    "0+\\1 2 3 4 5 6 7 8 9 10 / 1 3 6 10 15 21 28 36 45 55\n",
    "(*\\)1 2 3 4 5 6 7 8 9 10 / \n",
    "(|\\)7 8 4 3 10 2 1 9 5 6 /\n",
    "(&\\)7 8 4 3 10 2 1 9 5 6 /\n",
    "3 f\\1 2 3 4 5 6 7 8 9 10 /\n",
    "(f\\)[{1000>last x};1 2 3 4 5 6 7 8 9 10] / "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### each-previous (':)\n",
    "The adverb each-previous ': provides a declarative way to perform a dyadic operation on each item of a list with its predecessor.\n",
    "During traversal of the list, the current item is the left operand and the previous item is the right operand."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0 -1 2 1 -1\r\n"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "100 -1 2 1 -1\r\n"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "100 -1 2 1 -1\r\n"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "100 0.99 1.020202 1.009901 0.9901961\r\n"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "100 0.99 1.020202 1.009901 0.9901961\r\n"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "0 -1 2 1 -1\r\n"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "011010001101b\r\n"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "100101110010b\r\n"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "100101110010b\r\n"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "100 -': 100 99 101 102 101\n",
    "(-':)100 99 101 102 101 / 100 -1 2 1 -1\n",
    "deltas 100 99 101 102 101 / 100 -1 2 1 -1\n",
    "(%':)100 99 101 102 101 / 100 0.98999999999999999 1.0202020202020201 1.0099009900990099 0.99019607843137258\n",
    "ratios 100 99 101 102 101 /100 0.99 1.020202 1.009901 0.9901961\n",
    "\n",
    "deltas0:{first[x] -': x}\n",
    "deltas0 100 99 101 102 101 / 0 -1 2 1 -1\n",
    "\n",
    "(~':) 1 1 1 2 2 3 4 5 5 5 6 6 / 011010001101b\n",
    "not (~':) 1 1 1 2 2 3 4 5 5 5 6 6 / 100101110010b\n",
    "differ 1 1 1 2 2 3 4 5 5 5 6 6 / 100101110010b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0 3 5 6 7 10\r\n"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "1 1 1\r\n",
       "2 2\r\n",
       ",3\r\n",
       ",4\r\n",
       "5 5 5\r\n",
       "6 6\r\n"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L:1 1 1 2 2 3 4 5 5 5 6 6\n",
    "where differ L / 0 3 5 6 7 10\n",
    "(where differ L) cut L / 1 1 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9 8 7\r\n",
       "11 10\r\n",
       ",12\r\n",
       ",13\r\n"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       ",9\r\n",
       ",8\r\n",
       "7 11\r\n",
       "10 12 13\r\n"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L:9 8 7 11 10 12 13\n",
    "(where -0W>':L) cut L \n",
    "/ 9 8 7\n",
    "/ 11 10\n",
    "/ ,12\n",
    "/ ,13\n",
    "(where 0W<':L) cut L\n",
    "/,9\n",
    "/,8\n",
    "/7 11\n",
    "/10 12 13"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Verb @\n",
    "\n",
    "The higher-order function @ is the true form of basic application in q. It applies a monadic mapping to an argument. As with all built-in functions, it can be written infix or prefix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20\r\n"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "20\r\n"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "20\r\n"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "4\r\n"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "4\r\n"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "100 400 900 1600\r\n"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "10\r\n"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "20\r\n"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 20 30 40@1 /20\n",
    "L:10 20 30 40 /20\n",
    "L@1 /20\n",
    "@[L; 1] /4\n",
    "count@L /4\n",
    "@[count; L] /4\n",
    "{x*x}@L /100 400 900 1600\n",
    "d:`a`b`c!10 20 30\n",
    "d@`a /10\n",
    "@[d;`b] /20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "c1| 2\r\n",
       "c2| `b\r\n"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "20\r\n"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "v| 3.3\r\n"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t:([]c1:1 2 3; c2:`a`b`c)\n",
    "t:([]c1:1 2 3; c2:`a`b`c)\n",
    "t@1\n",
    "/ c1| 2\n",
    "/ c2| `b\n",
    "d:`a`b`c!10 20 30\n",
    "d@`b /20\n",
    "\n",
    "kt:([k:`a`b`c] v:1.1 2.2 3.3)\n",
    "kt@`c\n",
    "/v| 3.3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Verb Dot .\n",
    "he higher-order function . is the true form of multi-variate application in q. It applies a multi-variate mapping to multiple arguments and can be written infix or prefix.\n",
    "The right argument of . must be a list.\n",
    "Separate verb . from its operands by whitespace if they are names or literal constants, as proximity to dots used in name spacing and in decimal numbers can lead to confusion."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "40\r\n"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "40\r\n"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "40\r\n"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "40\r\n"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "40\r\n"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "40\r\n"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "3\r\n"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "3\r\n"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L:(10 20 30; 40 50)\n",
    "L[1][0] / 40\n",
    "L[1; 0] / 40\n",
    "L . 1 0 / 40\n",
    "d:`a`b`c!(10 20 30; 40 50; enlist 60) \n",
    "d[`b][0] / 40\n",
    "d[`b; 0] / 40\n",
    "d . (`b; 0) / 40\n",
    "g:{x+y}\n",
    "g[1; 2] /3\n",
    "g . 1 2 /3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1 2 3\r\n"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "1 2 3\r\n"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "2 5\r\n"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "/ Similar to Python\n",
    "m:(1 2 3;4 5 6)\n",
    "m[0;] / 1 2 3\n",
    "m . (0; ::) / 1 2 3\n",
    "m . (::; 1) / 2 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.8.4 General Apply (@) with Monadic Functions\n",
    "\n",
    "@[L;I;f] / f: Monadic function\n",
    "@[L; I; g; v] / g: Dynadic function\n",
    "\n",
    "Effectively we reach inside (a copy of) the list, apply neg along the specified sub-domain, and return the modified list.\n",
    "\n",
    "For compound data structures such as nested lists, tables and keyed tables, application of @ occurs along a sub-domain at the top level. We'll see how to reach down into data structure in the next section."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a| -10\r\n",
       "b| 20\r\n",
       "c| -30\r\n"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "-10   -20   -30  \r\n",
       "100   200   300  \r\n",
       "-1000 -2000 -3000\r\n"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d:`a`b`c!10 20 30\n",
    "ks:`a`c\n",
    "@[d; ks; neg]\n",
    "/ a| -10\n",
    "/ b| 20\n",
    "/ c| -30\n",
    "\n",
    "m:(10 20 30; 100 200 300; 1000 2000 3000)\n",
    "@[m; 0 2; neg]\n",
    "/ -10 -20 -30\n",
    "/ 100 200 300\n",
    "/ -1000 -2000 -3000\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-10 20 30 40\r\n"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "10 20 30 40\r\n"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "`L\r\n"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "-10 20 30 40\r\n"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L:10 20 30 40\n",
    "@[L; 0; neg] / -10 20 30 40\n",
    "L /10 20 30 40\n",
    "@[`L; 0 ; neg] /`L\n",
    "L /-10 20 30 40\n",
    "/ Observe that the result of an application of pass-by-name is the passed symbolic name. \n",
    "/ This allows chaining of function applications that modify in place.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "110 220 30 40\r\n"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "110 220\r\n"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "11   21   31  \r\n",
       "100  200  300 \r\n",
       "1002 2002 3002\r\n"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L:10 20 30 40\n",
    "@[L; 0 1; +; 100 200] / 110 220 30 40\n",
    "q)100 200+L@0 1 / 110 220\n",
    "\n",
    "m:(10 20 30; 100 200 300; 1000 2000 3000)\n",
    "@[m; 0 2; +; 1 2]\n",
    "/ 11 21 31\n",
    "/ 100 200 300\n",
    "/ 1002 2002 3002"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.8.6 General Apply (.) for Monadic Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20\r\n"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "20\r\n"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "10  -20 30 \r\n",
       "100 200 300\r\n"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "a| 10 -20 30\r\n",
       "b| 40 50\r\n",
       "c| ,60\r\n"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "`d\r\n"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "a| 10 -20 30\r\n",
       "b| 40 50\r\n",
       "c| ,60\r\n"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m:(10 20 30; 100 200 300)\n",
    ".[m; 0 1] / 20\n",
    "d:`a`b`c!(10 20 30; 40 50; enlist 60)\n",
    ".[d; (`a; 1)] /20\n",
    "\n",
    ".[m; 0 1; neg] \n",
    "/ 10 -20 30\n",
    "/ 100 200 300\n",
    ".[d; (`a; 1); neg]\n",
    "\n",
    "/a| 10 -20 30\n",
    "/b| 40 50\n",
    "/c| ,60\n",
    "\n",
    ".[`d; (`a; 1); neg]\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.8.7  General Apply (.) for Dyadic Functions\n",
    "\n",
    ".[L; I; g; v]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10  21  30 \r\n",
       "100 200 300\r\n"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "10  21  30 \r\n",
       "100 202 300\r\n"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "10  20  30 \r\n",
       "100 200 300\r\n"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "`m\r\n"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "10  21  30 \r\n",
       "100 201 300\r\n"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "`m\r\n"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "`m\r\n"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "10  42 30 \r\n",
       "100 42 300\r\n"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "a| 100 201 300\r\n",
       "b| 400 500\r\n",
       "c| ,600\r\n"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "a| 101 201 301\r\n",
       "b| 400 500\r\n",
       "c| ,600\r\n"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "a| 101 200 300\r\n",
       "b| 401 500\r\n",
       "c| ,601\r\n"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "a| 100 200 300\r\n",
       "b| 400 500\r\n",
       "c| ,600\r\n"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "`d\r\n"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "a| 42 200 300\r\n",
       "b| 42 500\r\n",
       "c| ,42\r\n"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m:(10 20 30; 100 200 300)\n",
    ".[m; 0 1; +; 1]\n",
    " /10 21 30\n",
    "/ 100 200 300\n",
    ".[m; (::; 1); +; 1 2]\n",
    "/ 10 21 30\n",
    "/100 202 300\n",
    "m\n",
    "/ 10  20  30 \n",
    "/ 100 200 300\n",
    "\n",
    ".[`m; (::; 1); +; 1]\n",
    "\n",
    "m\n",
    "\n",
    ".[`m; (::; 1); :; 42]\n",
    "`m\n",
    "m\n",
    "\n",
    "d:`a`b`c!(100 200 300; 400 500; enlist 600)\n",
    ".[d; (`a; 1); +; 1]\n",
    "\n",
    ".[d; (`a; ::); +; 1]\n",
    "\n",
    ".[d; (::; 0); +; 1]\n",
    "\n",
    "d\n",
    "\n",
    ".[`d; (::; 0); :; 42]\n",
    "\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 7. Transforming Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-7h\r\n"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "7h\r\n"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "-9h\r\n"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "9h\r\n"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "-11h\r\n"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "11h\r\n"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "-10h\r\n"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "10h\r\n"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "0h\r\n"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "0h\r\n"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "0h\r\n"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "99h\r\n"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "99h\r\n"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "98h\r\n"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type 42 / -7h\n",
    "type 10 20 30 /7h\n",
    "type 98.6 /-9h\n",
    "type 1.1 2.2 3.3 /9h\n",
    "type `a /-11h\n",
    "type `a`b`c / 11h\n",
    "type \"z\" / -10h\n",
    "type \"abc\" /10h\n",
    "\n",
    "/ The type of any general list is 0.\n",
    "\n",
    "type (42h; 42i; 42j) / 0h\n",
    "type (1 2 3; 10 20 30) /0h\n",
    "type () /0h\n",
    "\n",
    "/The type of any dictionary, including a keyed table, is 99h.\n",
    "\n",
    "type (`a`b`c!10 20 30) / 99h\n",
    "type ([k:`a`b`c] v:10 20 30) /99h\n",
    "type ([] c1:`a`b`c; c2:10 20 30) /98h"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "help           | {[gh;h;x]if[10=type u:gh[h]x;-2 u]}[{[h;x]$[i.isf x;h x;i.is..\r\n",
       "print          | {x y;}[{[f;x]embedPy[f;x]}[foreign]enlist]\r\n",
       "a              | 43\r\n",
       "b              | a\r\n",
       "long           | 4\r\n",
       "float          | 6e+023\r\n",
       "bool           | 0b\r\n",
       "date           | 2000.01.01\r\n",
       "time           | 12:34:56.789\r\n",
       "symbol         | `Similar_to_string_in_other_language\r\n",
       "list_of_int    | 1 2 3 4\r\n",
       "list_by_til    | 0 1 2 3 4 5 6 7 8\r\n",
       "list_of_symbols| `zero`one`two`three\r\n",
       "list_op        | 1 3 5 7 9 11 13 15\r\n",
       "list_join      | 1 2 3 4 5\r\n",
       "func           | {[x;y;z] a:x*x; b:y;c:z; a-b+c}\r\n",
       "func2          | {a:x*x; b:y;c:z; a-b+c}\r\n",
       "F0             | 1 2\r\n",
       "buys           | 2 1 4 3 5 4f\r\n",
       "sells          | 2 4 3 2\r\n",
       "d              | `a`b`c!(42 200 300;42 500;,42)\r\n",
       "dc             | `c1`c2!(0 10 20 30 40;1 2 3)\r\n",
       "..\r\n"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get `. / to list the global variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "help           | {[gh;h;x]if[10=type u:gh[h]x;-2 u]}[{[h;x]$[i.isf x;h x;i.is..\r\n",
       "print          | {x y;}[{[f;x]embedPy[f;x]}[foreign]enlist]\r\n",
       "a              | 43\r\n",
       "b              | a\r\n",
       "long           | 4\r\n",
       "float          | 6e+023\r\n",
       "bool           | 0b\r\n",
       "date           | 2000.01.01\r\n",
       "time           | 12:34:56.789\r\n",
       "symbol         | `Similar_to_string_in_other_language\r\n",
       "list_of_int    | 1 2 3 4\r\n",
       "list_by_til    | 0 1 2 3 4 5 6 7 8\r\n",
       "list_of_symbols| `zero`one`two`three\r\n",
       "list_op        | 1 3 5 7 9 11 13 15\r\n",
       "list_join      | 1 2 3 4 5\r\n",
       "func           | {[x;y;z] a:x*x; b:y;c:z; a-b+c}\r\n",
       "func2          | {a:x*x; b:y;c:z; a-b+c}\r\n",
       "F0             | 1 2\r\n",
       "buys           | 2 1 4 3 5 4f\r\n",
       "sells          | 2 4 3 2\r\n",
       "d              | `a`b`c!(42 200 300;42 500;,42)\r\n",
       "dc             | `c1`c2!(0 10 20 30 40;1 2 3)\r\n",
       "..\r\n"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "value `. / to list the global variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 7.2.1 Casts that Widen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42\r\n"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "42i\r\n"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "42f\r\n"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "42\r\n"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "42i\r\n"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "42f\r\n"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "42i\r\n"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "42\r\n"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "42f\r\n"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "7h$42i / int to long /42\n",
    "6h$42 / long to int /42i\n",
    "9h$42 / long to float /42f\n",
    "\n",
    "// Same to the above 3\n",
    "\"j\"$42i /42\n",
    "\"i\"$42 /42i\n",
    "\"f\"$42 /42f\n",
    "\n",
    "// Same to the first 3\n",
    "`int$42 /\n",
    "`long$42i /\n",
    "`float$42 /\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 7.2.2 Casts across Disparate Types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"*\"\r\n"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "10\r\n"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "2000.01.01\r\n"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "366i\r\n"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "43200000000000\r\n"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "0D00:00:00.000000000\r\n"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "`char$42 / \"*\"\n",
    "`long$\"\\n\" \n",
    "\n",
    "`date$0 / 2000.01.01\n",
    "`int$2001.01.01 / millennium occurred on leap year\n",
    "`long$12:00:00.0000000000 / 43200000000000\n",
    "`timespan$0 /"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 7.2.3 Casts that Narrow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12\r\n"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "32767h\r\n"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "`long$12.345 / 12\n",
    "`short$123456789 /32767h\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.3 Data to and from Text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"42\"\r\n"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       ",\"4\"\r\n"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "\"42\"\r\n"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       ",\"2\"\r\n"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "\"{x*x}\"\r\n"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       ",\"1\"\r\n",
       ",\"2\"\r\n",
       ",\"3\"\r\n"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "\"Life\"\r\n",
       "\"the\"\r\n",
       "\"Universe\"\r\n",
       "\"and\"\r\n",
       "\"Everything\"\r\n"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "string 42 / \"42\"\n",
    "string 4 /,\"4\"\n",
    "string 42i /\"42\"\n",
    "a:2.0\n",
    "string a /,\"2\"\n",
    "f:{x*x}\n",
    "string f /\"{x*x}\"\n",
    "\n",
    "string 1 2 3\n",
    "/,\"1\"\n",
    "/,\"2\"\n",
    "/,\"3\"\n",
    "\n",
    "string `Life`the`Universe`and`Everything"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "`abc\r\n"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "`Hello World\r\n"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "/ 7.3.2 Creating Symbols from Strings\n",
    "\n",
    "`$\"abc\" /`abc\n",
    "\n",
    "`$\"Hello World\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7.4 Creating Typed Empty Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "98.6\r\n"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c1:`float$()\n",
    "/c1,:42 /'type Error\n",
    "c1:98.6 \n",
    "c1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7.5 Enumerations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "`aapl`msft`aapl`msft`ibm`ibm`g`g`msft`g`aapl`g`g`g`msft`msft`msft`aapl`aapl`i..\r\n"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "`aapl`msft`ibm`g\r\n"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "1 2 1 2 3 3 0 0 2 0 1 0 0 0 2 2 2 1 1 3 0 1 2 2 0 0 1 0 3 1 3 3 2 0 2 1 0 2 0..\r\n"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "`aapl`msft`aapl`msft`ibm`ibm`g`g`msft`g`aapl`g`g`g`msft`msft`msft`aapl`aapl`i..\r\n"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u:`g`aapl`msft`ibm\n",
    "v:100?u / random generator\n",
    "v\n",
    "u2: distinct v\n",
    "u2\n",
    "\n",
    "k:u?v / enum to int\n",
    "k \n",
    "\n",
    "u[k] /int to enum\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "`u$`aapl`msft`aapl`msft`ibm`ibm`g`g`msft`g`aapl`g`g`g`msft`msft`msft`aapl`aap..\r\n"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "1 2 1 2 3 3 0 0 2 0 1 0 0 0 2 2 2 1 1 3 0 1 2 2 0 0 1 0 3 1 3 3 2 0 2 1 0 2 0..\r\n"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "`u$v / `u$`msft`aapl`aapl`ibm`ibm`aapl`g`g`g`ibm`g`msft`msft`aapl`msft..\n",
    "ev:`u$v\n",
    "`int$ev / "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 8. Tables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "98 42 126\r\n"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "name| `Prefect\r\n",
       "iq  | 126\r\n"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "126\r\n"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "98 42 126\r\n"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "98 42 126\r\n"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "Dent Beeblebrox Prefect\r\n",
       "98   42         126    \r\n"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "`Dent`Beeblebrox`Prefect\r\n"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "1b\r\n"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t:flip `name`iq!(`Dent`Beeblebrox`Prefect;98 42 126)\n",
    "t[;`iq] / 98 42 126\n",
    "t[2;]\n",
    "/ name| `Prefect\n",
    "/ iq  | 126\n",
    "t[2;`iq] /126\n",
    "\n",
    "t[;`iq] /98 42 126\n",
    "t[`iq] /98 42 126\n",
    "t[`name`iq]\n",
    "/ Dent Beeblebrox Prefect\n",
    "/ 98   42         126\n",
    "\n",
    "t.name / Not works inside function\n",
    "\n",
    "t:([] name:`Dent`Beeblebrox`Prefect; iq:98 42 126) / Table define\n",
    "t~flip `name`iq!(`Dent`Beeblebrox`Prefect;98 42 126) / the same"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "`name`iq\r\n"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c   | t f a\r\n",
       "----| -----\r\n",
       "name| s    \r\n",
       "iq  | j    \r\n"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "`kt`t`t3`table1`table2`trans\r\n"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "3\r\n"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "`Beeblebrox\r\n",
       "42\r\n"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cols t / columns / `name`iq\n",
    "meta t /column define\n",
    "/ The key column c of the result contains the column names.\n",
    "/ The column t contains a symbol denoting the type char of the column.\n",
    "/ The column f contains the domains of any foreign key or link columns.\n",
    "/ The column a contains any attributes associated with the column.\n",
    "tables `. / to list the names of tables in the context.\n",
    "\n",
    "count t / Rows\n",
    "value t[1] / a row"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8.4 Primary Keys and Keyed Tables\n",
    "A keyed table is a dictionary mapping a table of key records to a table of value records. \n",
    "\n",
    "A keyed table is not a table – it is a dictionary and so has type 99h.\n",
    "\n",
    "Keys should be unique but (sadly) this is not enforced. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "eid | name       iq \r\n",
       "----| --------------\r\n",
       "1001| Dent       98 \r\n",
       "1002| Beeblebrox 42 \r\n",
       "1003| Prefect    126\r\n"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kt:([eid:1001 1002 1003]\n",
    "      name:`Dent`Beeblebrox`Prefect; iq:98 42 126)\n",
    "kt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "name| `Beeblebrox\r\n",
       "iq  | 42\r\n"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "42\r\n"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "name       iq\r\n",
       "-------------\r\n",
       "Dent       98\r\n",
       "Beeblebrox 42\r\n"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "name       iq\r\n",
       "-------------\r\n",
       "Dent       98\r\n",
       "Beeblebrox 42\r\n"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "eid | name       iq\r\n",
       "----| -------------\r\n",
       "1001| Dent       98\r\n",
       "1002| Beeblebrox 42\r\n"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kt[1002]\n",
    "/ name| `Beeblebrox\n",
    "/ iq  | 42\n",
    "kt[1002][`iq]\n",
    "/42\n",
    "\n",
    "kt[(enlist 1001;enlist 1002)]\n",
    "/ name       iq\n",
    "/ -------------\n",
    "/ Dent       98\n",
    "/ Beeblebrox 42\n",
    "\n",
    "kt ([] eid:1001 1002) / the same\n",
    "\n",
    "([] eid:1001 1002)#kt\n",
    "/eid | name       iq\n",
    "/----| -------------\n",
    "/1001| Dent       98\n",
    "/1002| Beeblebrox 42"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "eid \r\n",
       "----\r\n",
       "1001\r\n",
       "1002\r\n",
       "1003\r\n"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "name       iq \r\n",
       "--------------\r\n",
       "Dent       98 \r\n",
       "Beeblebrox 42 \r\n",
       "Prefect    126\r\n"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       ",`eid\r\n"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "`eid`name`iq\r\n"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "key kt\n",
    "value kt\n",
    "keys kt\n",
    "cols kt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 8.4.8 Tables vs. Keyed Tables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "eid | name       iq \r\n",
       "----| --------------\r\n",
       "1001| Dent       98 \r\n",
       "1002| Beeblebrox 42 \r\n",
       "1003| Prefect    126\r\n"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "eid | name       iq \r\n",
       "----| --------------\r\n",
       "1001| Dent       98 \r\n",
       "1002| Beeblebrox 42 \r\n",
       "1003| Prefect    126\r\n"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "eid  name       iq \r\n",
       "-------------------\r\n",
       "1001 Dent       98 \r\n",
       "1002 Beeblebrox 42 \r\n",
       "1003 Prefect    126\r\n"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t:([] eid:1001 1002 1003; name:`Dent`Beeblebrox`Prefect; iq:98 42 126)\n",
    "`eid xkey t /1!t , the 1st col\n",
    "/eid | name       iq \n",
    "/----| --------------\n",
    "/1001| Dent       98 \n",
    "/1002| Beeblebrox 42 \n",
    "/1003| Prefect    126\n",
    "\n",
    "kt:([eid:1001 1002 1003] name:`Dent`Beeblebrox`Prefect; iq:98 42 126)\n",
    "kt\n",
    "() xkey kt / or 0!t\n",
    "/eid  name       iq \n",
    "/-------------------\n",
    "/1001 Dent       98 \n",
    "/1002 Beeblebrox 42 \n",
    "/1003 Prefect    126"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "eid | name      \r\n",
       "----| ----------\r\n",
       "1001| Dent      \r\n",
       "1002| Beeblebrox\r\n",
       "1003| Prefect   \r\n",
       "1001| Dup       \r\n"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "name| Dent\r\n"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "eid | name\r\n",
       "----| ----\r\n",
       "1001| Dent\r\n",
       "1001| Dup \r\n"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "/ Key should be unique, but which is not guaranteed.\n",
    "t:([] eid:1001 1002 1003 1001; name:`Dent`Beeblebrox`Prefect`Dup)\n",
    "ktdup:`eid xkey t\n",
    "ktdup\n",
    "/eid | name\n",
    "/----| ----------\n",
    "/1001| Dent\n",
    "/1002| Beeblebrox\n",
    "/1003| Prefect\n",
    "/1001| Dup\n",
    "\n",
    "ktdup 1001\n",
    "/name| Dent\n",
    "\n",
    "select from ktdup where eid=1001\n",
    "/eid | name\n",
    "/----| ----\n",
    "/1001| Dent\n",
    "/1001| Dup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "lname      fname | iq \r\n",
       "-----------------| ---\r\n",
       "Dent       Arthur| 98 \r\n",
       "Beeblebrox Zaphod| 42 \r\n",
       "Prefect    Ford  | 126\r\n"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "iq| 42\r\n"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "iq| 98\r\n"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "/ Compount Key columns\n",
    "\n",
    "ktc:([lname:`Dent`Beeblebrox`Prefect; fname:`Arthur`Zaphod`Ford]; iq:98 42 126)\n",
    "ktc\n",
    "ktc[`lname`fname!`Beeblebrox`Zaphod]\n",
    "ktc[`Dent`Arthur]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8.5 Foreign Keys and Virtual Columns\n",
    "A foreign key is one or more table columns whose values are defined as an enumeration over the key column(s) of a keyed table. As in the case of symbol enumeration `sym$, the enumeration restricts foreign key values to be in the list of primary key values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "eid | name       iq \r\n",
       "----| --------------\r\n",
       "1001| Dent       98 \r\n",
       "1002| Beeblebrox 42 \r\n",
       "1003| Prefect    126\r\n"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "eid  sc \r\n",
       "--------\r\n",
       "1003 126\r\n",
       "1001 36 \r\n",
       "1002 92 \r\n",
       "1001 39 \r\n",
       "1002 98 \r\n",
       "1001 42 \r\n"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c  | t f     a\r\n",
       "---| ---------\r\n",
       "eid| j kt_fk  \r\n",
       "sc | j        \r\n"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "eid| kt_fk\r\n"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kt_fk:([eid:1001 1002 1003] name:`Dent`Beeblebrox`Prefect; iq:98 42 126)\n",
    "kt\n",
    "tdetails:([] eid:`kt_fk$1003 1001 1002 1001 1002 1001; sc:126 36 92 39 98 42)\n",
    "tdetails\n",
    "meta tdetails\n",
    "fkeys tdetails"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "name       sc \r\n",
       "--------------\r\n",
       "Prefect    126\r\n",
       "Dent       36 \r\n",
       "Beeblebrox 92 \r\n",
       "Dent       39 \r\n",
       "Beeblebrox 98 \r\n",
       "Dent       42 \r\n"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "select eid.name, sc from tdetails / similar to LINQ \n",
    "/ There is an implicit left join between tdetails and kt here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "name| `Dent\r\n",
       "iq  | 98\r\n"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "name| `Albert\r\n",
       "iq  | 200\r\n"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "name       iq\r\n",
       "-------------\r\n",
       "Dent       98\r\n",
       "Beeblebrox 42\r\n"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "name    iq \r\n",
       "-----------\r\n",
       "Prefect 126\r\n",
       "W       26 \r\n",
       "Albert  200\r\n"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t:([] name:`Dent`Beeblebrox`Prefect; iq:98 42 126)\n",
    "kt:([eid:1001 1002 1003] name:`Dent`Beeblebrox`Prefect; iq:98 42 126)\n",
    "\n",
    "/ Append\n",
    "t,:`name`iq!(`W; 26) / = t,:(`W; 26)\n",
    "t,:`iq`name!(200; `Albert) / =t,:(`Albert;200;) \n",
    "first t\n",
    "/name| `Dent\n",
    "/iq  | 98\n",
    "last t\n",
    "2#t\n",
    "-3#t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0\r\n"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "0\r\n"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "0 2\r\n"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "eid| 1001\r\n"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "ename": "\u001b[0;31mt1\u001b[0m",
     "evalue": "\u001b[0;31mt1\u001b[0m",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31mevaluation error:\n\u001b[0m",
      "\u001b[0;31mt1\u001b[0m",
      "\u001b[0;31m\u001b[0m",
      "\u001b[0;31m  [0]  t1?enlist each 1001 1002\r\n       ^\r\n\u001b[0m"
     ]
    }
   ],
   "source": [
    "t?`name`iq!(`Dent;98)\n",
    "t?(`Dent;98)\n",
    "t?((`Dent;98);(`Prefect;126))\n",
    "kt?`name`iq!(`Dent;98)\n",
    "t1?enlist each 1001 1002\n",
    "\n",
    "/ Union with ,\n",
    "\n",
    "t,`name`iq!(`Slaartibartfast; `123)\n",
    "\n",
    "/ 8.6.5 Coalesce ^\n",
    "/ The behavior of ^ is the same as , when there are no nulls in a column in the right table.\n",
    "\n",
    "([k:`a`b`c] v:10 0N 30)^([k:`a`b`c] v:100 200 0N)\n",
    "/The performance of ^ is slower than that of , since fields of the right operand must be checked for null.\n",
    "\n",
    "/ Column Join\n",
    "\n",
    "([] c1:`a`b`c),'([] c2:100 200 300)\n",
    "([k:1 2 3] v1:10 20 30),'([k:3 4 5] v2:1000 2000 3000)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8.8 Attributes\n",
    "Attributes (other than `g#) are descriptive rather than prescriptive. By this we mean that by applying an attribute you are asserting that the list has a special form, which q will check. It does not instruct q to (re)make the list into the special form; that is your job. A list operation that respects the form specified by the attribute leaves the attribute intact (other than `p#), while an operation that breaks the form results in the attribute being removed in the result.\n",
    "\n",
    "The syntax for applying an attribute is (yet) another overload of #, whose left operand is a symbol specifying the attribute and whose right operand is the target list.\n",
    "\n",
    "Sorted `s#\n",
    "Unique `u#\n",
    "Parted `p#\n",
    "Grouped `g#\n",
    "Remove Attribute `#"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "`s#1 2 4 8\r\n"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "ename": "\u001b[0;31ms\u001b[0m",
     "evalue": "\u001b[0;31ms\u001b[0m",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31mevaluation error:\n\u001b[0m",
      "\u001b[0;31ms\u001b[0m",
      "\u001b[0;31m\u001b[0m",
      "\u001b[0;31m  [0]  s#2 1 3 4 / 's-fail\r\n       ^\r\n\u001b[0m"
     ]
    }
   ],
   "source": [
    "`s#1 2 4 8 / `s#1 2 4 8\n",
    "s#2 1 3 4 / 's-fail"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "`s#1 2 4 8\r\n"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "0 1 2 3 4\r\n"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "`s#1 2 3 4 5 6\r\n"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "1 2 3 4 5 6 0\r\n"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "asc 2 1 8 4 /`s#1 2 4 8\n",
    "til 5 /0 1 2 3 4\n",
    "\n",
    "/When a list with an attribute is amended with ,: \n",
    "/ the result is checked to see that the attribute is preserved; if not, it is removed.\n",
    "\n",
    "L:`s#1 2 3 4 5\n",
    "L,:6\n",
    "L /`s#1 2 3 4 5 6\n",
    "\n",
    "L,:0\n",
    "L / 1 2 3 4 5 6 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "`u#2 1 4 8\r\n"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "ename": "\u001b[0;31mu-fail\u001b[0m",
     "evalue": "\u001b[0;31mu-fail\u001b[0m",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31mevaluation error:\n\u001b[0m",
      "\u001b[0;31mu-fail\u001b[0m",
      "\u001b[0;31m\u001b[0m",
      "\u001b[0;31m  [0]  `u#2 1 4 8 2 /'u-fail\r\n         ^\r\n\u001b[0m"
     ]
    }
   ],
   "source": [
    "`u#2 1 4 8 / `u#2 1 4 8\n",
    "`u#2 1 4 8 2 /'u-fail"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "`u#2 1 4 8 3\r\n"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "2 1 4 8 3 2\r\n"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L:`u#2 1 4 8\n",
    "L,:3\n",
    "L /`u#2 1 4 8 3\n",
    "L,:2\n",
    "L /2 1 4 8 3 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "`p#1 1 2 3 3\r\n"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "1 1 2 3 3 3\r\n"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L:`p#1 1 2 3 3\n",
    "L / `p#1 1 2 3 3\n",
    "L,:3 / the parted attribute is not preserved under any operation on the list, \n",
    "     / even if the operation preserves the property.\n",
    "L /1 1 2 3 3 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "`g#1 2 3 2 3 4 3 4 5 2 3 4 5 4 3 5 6\r\n"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "`g#37 30 75 61 56 23 46 14 13 9 74 55 92 14 90 17 89 49 80 11 8 8 42 94 19 12..\r\n"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "`g#37 30 75 61 56 23 46 14 13 9 74 55 92 14 90 17 89 49 80 11 8 8 42 94 19 12..\r\n"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "/ The grouped attribute `g# differs from other attributes in that \n",
    "/ it can be applied to any list. It causes q to create and maintain an index\n",
    "/ – essentially a hash table. Grouped can be applied to a list when no other\n",
    "/ assumptions about its structure can be made.\n",
    "\n",
    "`g#1 2 3 2 3 4 3 4 5 2 3 4 5 4 3 5 6\n",
    "L:`g#100?100\n",
    "L\n",
    "L,:1 1 1 1\n",
    "L"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 9. Queries: q-sql\n",
    "\n",
    "Vs traditional SQL, there are some significant differences in the syntax and behavior.\n",
    "\n",
    "q table has ordered rows and columns.\n",
    "\n",
    "q table is stored physically as a collection of column lists. \n",
    "\n",
    "q-sql provides upsert semantics."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9.1 Insert"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ",1\r\n"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "/ Append Using Amend\n",
    "t:([] name:`symbol$(); iq:`int$())\n",
    "t,:`name`iq!(`Beeblebrox; 42)\n",
    "\n",
    "`t insert (`name`iq!(`Slartibartfast; 134); (`name`iq!(`Marvin; 200))) / `t instead of t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ",2\r\n"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       ",3\r\n"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "/ 9.1.5 Insert into Keyed Tables\n",
    "kt:([eid:1001 1002] name:`Dent`Beeblebrox; iq:98 42)\n",
    "`kt insert (1005; `Marvin; 200) / ,2\n",
    "`kt insert (1004;`Slartibartfast;158) /,3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9.2 Upsert\n",
    "The upsert template is like insert, only better. Except for the last sub-section on keyed tables, all the examples in the previous section all work the same for upsert."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "`kt\r\n"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "`kt\r\n"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "`:/q4m/tser\r\n"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "`:/q4m/tser\r\n"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c1 c2 \r\n",
       "------\r\n",
       "a  1.1\r\n",
       "b  2.2\r\n",
       "c  3.3\r\n"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "/9.2.3 Upsert on Keyed Tables\n",
    "\n",
    "`kt upsert (1001; `Beeblebrox; 42)\n",
    "`kt upsert (1001; `Beeblebrox; 43)\n",
    "\n",
    "/9.2.4 Upsert on Persisted Tables\n",
    "\n",
    "`:/q4m/tser set ([] c1:`a`b; c2:1.1 2.2)\n",
    "`:/q4m/tser upsert (`c; 3.3) /`:/q4m/tser\n",
    "/ Upserting to a serialized table reads the entire table into memory, updates it and writes out the result.\n",
    "get `:/q4m/tser"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9.3 The select Template"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "x c1 res\r\n",
       "--------\r\n",
       "0 a  20 \r\n",
       "1 b  40 \r\n",
       "2 c  60 \r\n"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c1 c2 c3 \r\n",
       "---------\r\n",
       "a  10 1.1\r\n",
       "b  20 2.2\r\n",
       "c  30 3.3\r\n"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c1 c2 c3 \r\n",
       "---------\r\n",
       "a  10 1.1\r\n"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c1 c2 c3 \r\n",
       "---------\r\n",
       "a  10 1.1\r\n"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c1 c2 c3 \r\n",
       "---------\r\n",
       "c  30 3.3\r\n"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c1 c2 c3 \r\n",
       "---------\r\n",
       "c  30 3.3\r\n"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t:([] c1:`a`b`c; c2:10 20 30; c3:1.1 2.2 3.3)\n",
    "select i, c1, res:2*c2 from t \n",
    "/ A virtual column i represents the offset of each \n",
    "/ record in the table – i.e., i is the row number. \n",
    "/ It is implicitly available in the select phrase.\n",
    "\n",
    "/9.3.2.3 select distinct\n",
    "select distinct from t\n",
    "\n",
    "/9.3.2.4 select[]\n",
    "\n",
    "select[1] from t\n",
    "/ to get the first 1\n",
    "1#select[1] from t\n",
    "select[-1] from t\n",
    "-1#select[-1] from t\n",
    "/ to get the last 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The difference is that the # construct requires computing the entire result set and then keeping only the desired rows, whereas select[n] only extracts the desired number of rows. The latter will be faster and consume less memory for large tables."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This syntax is extended to select[n m] where m is the starting row number and n is the number of rows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "c1 c2 c3 \r\n",
       "---------\r\n",
       "b  20 2.2\r\n"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c1 c2 c3 \r\n",
       "---------\r\n",
       "c  30 3.3\r\n"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "select[1,1] from t\n",
    "select[1;>c1] from t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "c1 c2 c3 \r\n",
       "---------\r\n",
       "b  20 2.2\r\n"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c1 c2 c3 \r\n",
       "---------\r\n",
       "a  10 1.1\r\n",
       "b  20 2.2\r\n"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t:([] c1:`a`b`c; c2:10 20 30; c3:1.1 2.2 3.3)\n",
    "select from t where (c2>15)&c3<3.0\n",
    "select from t where c2 within 10 20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t:([] f:1.1 2.2 3.3; s:(\"abc\";enlist \"d\";\"ef\"))\n",
    "select from t where s~\\:\"ef\"\n",
    "/ f s\n",
    "/ --------\n",
    "/ 3.3 \"ef\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No having "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "sym  ex time     price\r\n",
       "----------------------\r\n",
       "IBM  N  12:10:00 82.1 \r\n",
       "IBM  O  12:30:00 81.95\r\n",
       "MSFT N  12:45:00 23.45\r\n"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t:([]sym:`IBM`IBM`MSFT`IBM`MSFT;\n",
    "    ex:`N`O`N`N`N;\n",
    "    time:12:10:00 12:30:00 12:45:00 12:50:00 13:30:00;\n",
    "    price:82.1 81.95 23.45 82.05 23.40)\n",
    "\n",
    "select from t where price=(max;price) fby ([]sym;ex)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9.4 The exec Template\n",
    "The syntax of the exec template is identical to that of select.\n",
    "\n",
    "exec <ps> <by pb> from texp <where pw>\n",
    "\n",
    "Whereas select always returns a table, the result type of exec depends on the number of columns in its select phrase. One column yields a list; more than one column yields a dictionary.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "name | `a`b`c`d`e\r\n",
       "state| `NY`FL`OH`HI\r\n"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "name\r\n",
       "----\r\n",
       "a   \r\n",
       "b   \r\n",
       "c   \r\n",
       "d   \r\n",
       "e   \r\n"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "`a`b`c`d`e\r\n"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t:([] name:`a`b`c`d`e; state:`NY`FL`OH`NY`HI)\n",
    "/select name, distinct state from t\n",
    "/'length\n",
    "exec name, distinct state from t\n",
    "/name | `a`b`c`d`e\n",
    "/state| `NY`FL`OH`HI\n",
    "\n",
    "select name from t\n",
    "exec name from t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9.5 The update Template¶\n",
    "The update template has identical syntax to select.\n",
    "\n",
    "update <pu> <by pb> from texp <where pw>\n",
    "\n",
    "The semantic difference is that colons in the update phrase pu identify modified or new columns instead of simply assigning column names. \n",
    "\n",
    "To modify the table in place, pass it by name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "`t\r\n"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c1 c2\r\n",
       "-----\r\n",
       "x  10\r\n",
       "y  20\r\n",
       "z  30\r\n"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "`t\r\n"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c1 c2 c3\r\n",
       "--------\r\n",
       "x  10 x \r\n",
       "y  20 y \r\n",
       "z  30 z \r\n"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t:([] c1:`a`b`c; c2:10 20 30)\n",
    "update c1:`x`y`z from `t / `t instead of t\n",
    "t\n",
    "update c3:`x`y`z from `t / `t instead of t\n",
    "t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9.5.2 update-by\n",
    "When the by phrase is present, the update operation is performed along groups. This is most useful with aggregate and uniform functions. For an aggregate function, the entire group gets the value of the aggregation on the group.\n",
    "\n",
    "update avg weight by city from p\n",
    "p | name  color weight city  \n",
    "--| -------------------------\n",
    "p1| nut   red   15     london\n",
    "p2| bolt  green 14.5   paris \n",
    "p3| screw blue  17     rome  \n",
    "p4| screw red   15     london\n",
    "p5| cam   blue  14.5   paris \n",
    "p6| cog   red   15     london"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9.6 The delete Template¶\n",
    "The final template, delete, allows either rows or columns to be deleted. Its syntax is a simplified form of select, with the restriction that either pcols or pw can be present but not both.\n",
    "\n",
    "delete <pcols> from texp <where pw>\n",
    "\n",
    "If pcols is present as a comma-separated list of columns, the result is texp with the specified columns removed. If pw is present, the result is texp after records meeting the criteria of pw are removed. Someone always asks, can you delete rows and column simultaneously? But the rest of us meditating on the Zen of q realize this makes no sense."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "c2\r\n",
       "--\r\n",
       "10\r\n",
       "20\r\n",
       "30\r\n"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c1 c2\r\n",
       "-----\r\n",
       "a  10\r\n"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c1 c2\r\n",
       "-----\r\n",
       "a  10\r\n",
       "b  20\r\n",
       "c  30\r\n"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t:([] c1:`a`b`c; c2:10 20 30)\n",
    "delete c1 from t\n",
    "delete from t where c2>15\n",
    "t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9.7 Sorting\n",
    "Recall that tables and keyed tables comprise lists of records and therefore have an inherent order. A table or keyed table can be reordered by sorting on any column(s). In contrast to SQL, there is no equivalent to ORDER BY in the select template. Instead, built-in functions that sort tables are applied after select."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "ename": "\u001b[0;31mlist\u001b[0m",
     "evalue": "\u001b[0;31mlist\u001b[0m",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31mevaluation error:\n\u001b[0m",
      "\u001b[0;31mlist\u001b[0m",
      "\u001b[0;31m\u001b[0m",
      "\u001b[0;31m  [0]  list `c*\r\n       ^\r\n\u001b[0m"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "c1 c2\r\n",
       "-----\r\n",
       "a  20\r\n",
       "a  30\r\n",
       "b  10\r\n",
       "c  40\r\n"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c1 c2\r\n",
       "-----\r\n",
       "a  20\r\n",
       "b  10\r\n",
       "c  40\r\n",
       "a  30\r\n"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "`t\r\n"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c1 c2\r\n",
       "-----\r\n",
       "a  20\r\n",
       "a  30\r\n",
       "b  10\r\n",
       "c  40\r\n"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t:([] c1:`a`b`c`a; c2:20 10 40 30)\n",
    "`c1`c2 xasc t\n",
    "t\n",
    "`c1`c2 xasc `t / inplace by `t instead of t\n",
    "t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "new1 new2 c3 \r\n",
       "-------------\r\n",
       "a    10   1.1\r\n",
       "b    20   2.2\r\n",
       "c    30   3.3\r\n"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c1 c2 c3 \r\n",
       "---------\r\n",
       "a  10 1.1\r\n",
       "b  20 2.2\r\n",
       "c  30 3.3\r\n"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c3  c1 c2\r\n",
       "---------\r\n",
       "1.1 a  10\r\n",
       "2.2 b  20\r\n",
       "3.3 c  30\r\n"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c3  c2 c1\r\n",
       "---------\r\n",
       "1.1 10 a \r\n",
       "2.2 20 b \r\n",
       "3.3 30 c \r\n"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t:([] c1:`a`b`c; c2:10 20 30; c3:1.1 2.2 3.3)\n",
    "`new1`new2 xcol t\n",
    "t /There is no pass-by-name version of xcol. To modify the source, reassign it.\n",
    "\n",
    "`c3 xcols t\n",
    "`c3`c2 xcols t\n",
    "/The source operand cannot be a keyed table.\n",
    "/There is no pass-by-name version of xcols. To modify the source, you must reassign it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9.9 Joins\n",
    "\n",
    "select sname:s.name, pname:p.name, qty from sp / implicit left join.\n",
    "\n",
    "### 9.9.2 Ad hoc Left Join (lj)\n",
    "To create an ad-hoc left outer join between tables that could have a foreign-key relationship, use the dyadic lj. When the foreign key exists, that linkage is used; otherwise, the linkage is constructed dynamically. The join is 2-3 times faster if the foreign key already exists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "c  v  \r\n",
       "------\r\n",
       "10    \r\n",
       "20 2.2\r\n",
       "30 3.3\r\n",
       "40 4.4\r\n"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "k v  \r\n",
       "-----\r\n",
       "2 2.2\r\n",
       "3 3.3\r\n",
       "4 4.4\r\n",
       "5 5.5\r\n"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c  v  \r\n",
       "------\r\n",
       "10    \r\n",
       "20 2.2\r\n",
       "30 3.3\r\n",
       "40 4.4\r\n"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t:([] k:1 2 3 4; c:10 20 30 40)\n",
    "kt:([k1:2 3 4 5]; v:2.2 3.3 4.4 5.5)\n",
    "select c, v:kt[([] k1:k); `v] from t\n",
    "\n",
    "select k:k1,v from kt\n",
    "\n",
    "select c,v from t lj `k xkey select k:k1,v from kt\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9.9.4 Ad Hoc Inner Join (ij)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t:([] k:1 2 3 4; v:10 20 30 40)\n",
    "kt:([k:2 3 4 5]; v:200 300 400 500)\n",
    "t ij kt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9.9.5 Equijoin ej\n",
    "The triadic equijoin operator ej corresponds to a SQL inner join between tables in the second and third parameters along specified column names in the first parameter. The right operand does not have to be a keyed table. Unlike ij, all matching records in the right table appear in the result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "k c   v  \r\n",
       "---------\r\n",
       "2 200 2.2\r\n",
       "3 300 3.3\r\n",
       "4 400 4.4\r\n"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "k c   v    \r\n",
       "-----------\r\n",
       "2 200 2.2  \r\n",
       "2 222 22.22\r\n",
       "3 300 3.3  \r\n",
       "4 400 4.4  \r\n"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t1:([] k:1 2 3 4; c:10 20 30 40)\n",
    "t2:([] k:2 2 3 4 5; c:200 222 300 400 500; v:2.2 22.22 3.3 4.4 5.5)\n",
    "t1 ij `k xkey t2\n",
    "ej[`k;t1;t2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9.9.7 Union Join"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "c1 c2\r\n",
       "-----\r\n",
       "a  1 \r\n",
       "b  2 \r\n",
       "c  3 \r\n",
       "d  4 \r\n"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t1:([] c1:`a`b; c2:1 2)\n",
    "t2:([] c1:`c`d; c2:3 4)\n",
    "t1,t2 / t1 uj t2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9.9.8 As-of Joins\n",
    "As-of joins are so-named because they most often join tables along time columns to obtain a value in one table that is current as of a time in another table. As-of joins are non-equijoins that match on less-than-or-equal. They are not restricted to time values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ti       sym  qty\r\n",
      "-----------------\r\n",
      "10:01:01 msft 100\r\n",
      "10:01:03 ibm  200\r\n",
      "10:01:04 ge   150\r\n",
      "ti       sym  px \r\n",
      "-----------------\r\n",
      "10:01:00 ibm  100\r\n",
      "10:01:01 msft 99 \r\n",
      "10:01:01 msft 101\r\n",
      "10:01:02 ibm  98 \r\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "ti       sym  qty px \r\n",
       "---------------------\r\n",
       "10:01:01 msft 100 101\r\n",
       "10:01:03 ibm  200 98 \r\n",
       "10:01:04 ge   150    \r\n"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "ti       sym  qty px \r\n",
       "---------------------\r\n",
       "10:01:01 msft 100 101\r\n",
       "10:01:02 ibm  200 98 \r\n",
       "10:01:04 ge   150    \r\n"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "qty| 200\r\n"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "show t:([] ti:10:01:01 10:01:03 10:01:04;sym:`msft`ibm`ge;qty:100 200 150)\n",
    "show q:([] ti:10:01:00 10:01:01 10:01:01 10:01:02;sym:`ibm`msft`msft`ibm;px:100 99 101 98)\n",
    "aj[`sym`ti;t;q]\n",
    "aj0[`sym`ti;t;q]\n",
    "/If you want the time of the matching quote in the result instead of the time of the trade, use aj0.\n",
    "\n",
    "t asof `sym`ti!(`ibm;10:01:04)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9.9.9 Window Join\n",
    "Window joins are a generalization of as-of joins and are specifically geared for analyzing the relationship between trades and quotes in finance. The idea is that you want to investigate the behavior of quotes in a neighborhood of each trade. For example, to determine how well a trade was executed, you need to examine the range of bid and ask prices that were prevalent around the trade time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sym  time     price\r\n",
      "-------------------\r\n",
      "aapl 09:30:01 100  \r\n",
      "aapl 09:30:04 103  \r\n",
      "aapl 09:30:08 101  \r\n",
      "sym  time     ask bid\r\n",
      "---------------------\r\n",
      "aapl 09:30:01 101 98 \r\n",
      "aapl 09:30:02 103 99 \r\n",
      "aapl 09:30:03 103 102\r\n",
      "aapl 09:30:04 104 103\r\n",
      "aapl 09:30:05 104 103\r\n",
      "aapl 09:30:08 103 100\r\n",
      "aapl 09:30:09 102 100\r\n",
      "aapl 09:30:10 100 99 \r\n",
      "09:29:59 09:30:02 09:30:06\r\n",
      "09:30:02 09:30:05 09:30:09\r\n",
      "`sym`time\r\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "sym  time     price ask             bid           \r\n",
       "--------------------------------------------------\r\n",
       "aapl 09:30:01 100   101 103         98 99         \r\n",
       "aapl 09:30:04 103   103 103 104 104 99 102 103 103\r\n",
       "aapl 09:30:08 101   104 103 102     103 100 100   \r\n"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "sym  time     price ask bid\r\n",
       "---------------------------\r\n",
       "aapl 09:30:01 100   103 98 \r\n",
       "aapl 09:30:04 103   104 99 \r\n",
       "aapl 09:30:08 101   104 100\r\n"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "show t:([]sym:3#`aapl;time:09:30:01 09:30:04 09:30:08;price:100 103 101)\n",
    "\n",
    "show q:([] sym:8#`aapl;\n",
    "    time:09:30:01+(til 5),7 8 9;\n",
    "    ask:101 103 103 104 104 103 102 100;\n",
    "    bid:98 99 102 103 103 100 100 99)\n",
    "show w:-2 1+\\:t `time\n",
    "show c:`sym`time\n",
    "wj[w;c;t;(q;(::;`ask);(::;`bid))] \n",
    "/To see all the values in each window, pass the identity function :: \n",
    "/in place of the aggregates. The result is similar to grouping without\n",
    "/aggregate in a query and is helpful to see what is happening within each window.\n",
    "\n",
    "wj[w;c;t;(q;(max;`ask);(min;`bid))]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9.10 Parameterized Queries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "c1 c2 c3 \r\n",
       "---------\r\n",
       "b  20 2.2\r\n",
       "c  30 3.3\r\n"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c1 c2 c3 \r\n",
       "---------\r\n",
       "b  20 2.2\r\n",
       "c  30 3.3\r\n"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c1 c2 c3 \r\n",
       "---------\r\n",
       "c  30 3.3\r\n"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t:([] c1:`a`b`c; c2:10 20 30; c3:1.1 2.2 3.3)\n",
    "select from t where c2>15\n",
    "proc:{[sc] select from t where c2>sc}\n",
    "proc 15\n",
    "proc2:{[nms;sc] select from t where c1 in nms, c2>sc}\n",
    "proc2[`a`c; 15]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "c1 c2  c3 \r\n",
       "----------\r\n",
       "a  110 1.1\r\n",
       "b  20  2.2\r\n",
       "c  130 3.3\r\n"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c1 c2 c3 \r\n",
       "---------\r\n",
       "a  10 1.1\r\n",
       "b  20 2.2\r\n",
       "c  30 3.3\r\n"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "`t\r\n"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c1 c2  c3 \r\n",
       "----------\r\n",
       "a  110 1.1\r\n",
       "b  20  2.2\r\n",
       "c  130 3.3\r\n"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t:([] c1:`a`b`c; c2:10 20 30; c3:1.1 2.2 3.3)\n",
    "proc3:{[t;nms;delta] update c2+delta from t where c1 in nms}\n",
    "proc3[t;`a`c;100]\n",
    "t\n",
    "proc3[`t;`a`c;100]\n",
    "t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9.11 Views\n",
    "A SQL view is effectively a query expression whose result set can be used like a table. Views are useful for encapsulating data – e.g., hiding columns, or simplifying complex queries.\n",
    "\n",
    "A q-sql view is a named table expression created as an alias with the double-colon operator ::. It is common to use the templates in views but this is not a limitation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "c1 c2\r\n",
       "-----\r\n",
       "b  20\r\n",
       "c  30\r\n"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c1 c2\r\n",
       "-----\r\n",
       "b  20\r\n",
       "c  30\r\n"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "`t\r\n"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c1 c2\r\n",
       "-----\r\n",
       "b  20\r\n",
       "c  30\r\n"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c1 c2\r\n",
       "-----\r\n",
       "c  30\r\n"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "\"select from t where c2>15 \"\r\n"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       ",\"a\"\r\n"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "`s#`b`v\r\n"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t:([] c1:`a`b`c; c2:10 20 30)\n",
    "u:select from t where c2>15\n",
    "v::select from t where c2>15 \n",
    "u\n",
    "v\n",
    "update c2:15 from `t where c1=`b\n",
    "u\n",
    "v\n",
    "\n",
    "/Observe that when the underlying table changed,\n",
    "/u did not change but the next reference to v does reflect the update.\n",
    "\n",
    "/ To find the underlying query of a view, or any alias, apply the function view to the symbol alias name.\n",
    "view `v /\"select from t where c2>15\"\n",
    "a:42\n",
    "b::a\n",
    "view `b /\"a\"\n",
    "\n",
    "views `."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9.12 Functional Forms\n",
    "In the experience of the author, functional form is the most difficult q topic for most qbies. \n",
    "\n",
    "The high level of abstraction and generalization\n",
    "There is nothing like it in SQL or other programming languages\n",
    "In vintage Arthurian fashion, information density is maximized\n",
    "Full disclosure: functional form is difficult. Along with adverbs and generalized application, it completes the Big Three aspects of q that separate q pretenders from contenders. Fortunately there is a cheat that can be helpful in most situations.\n",
    "\n",
    "The function parse can be applied to a string containing a template query to produce a parse tree whose items (nearly) work in the equivalent functional form. A complication is that the operators are displayed in k form instead of q.\n",
    "\n",
    "There are two functional forms, one for select and exec, the other for update and delete. The types of the arguments passed determine the overload. The forms are,\n",
    "\n",
    "?[t;c;b;a] / select and exec\n",
    "\n",
    "![t;c;b;a] / update and delete\n",
    "\n",
    "where\n",
    "\n",
    "t is a table or the name of a table\n",
    "a is a dictionary of aggregates\n",
    "b is a dictionary of groupbys or a flag controlling other aspects of the query\n",
    "c is a list of constraints.\n",
    "\n",
    "### 9.12.1 Functional select"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "c1 c2 c3 \r\n",
       "---------\r\n",
       "a  10 1.1\r\n",
       "b  20 2.2\r\n",
       "a  30 3.3\r\n",
       "c  40 4.4\r\n",
       "a  50 5.5\r\n",
       "b  60 6.6\r\n",
       "c  70 7.7\r\n"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c1 c2 c3 \r\n",
       "---------\r\n",
       "a  10 1.1\r\n",
       "b  20 2.2\r\n",
       "a  30 3.3\r\n",
       "c  40 4.4\r\n",
       "a  50 5.5\r\n",
       "b  60 6.6\r\n",
       "c  70 7.7\r\n"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c1 c2 c3 \r\n",
       "---------\r\n",
       "c  40 4.4\r\n",
       "b  60 6.6\r\n",
       "c  70 7.7\r\n"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c1 c2 c3 \r\n",
       "---------\r\n",
       "c  40 4.4\r\n",
       "b  60 6.6\r\n",
       "c  70 7.7\r\n"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c2 c3 \r\n",
       "------\r\n",
       "70 5.5\r\n"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "maxc2 wtavg\r\n",
       "-----------\r\n",
       "70    5.5  \r\n"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c1 c2\r\n",
       "-----\r\n",
       "a  1 \r\n",
       "b  1 \r\n",
       "c  2 \r\n",
       "b  2 \r\n"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c1 c2\r\n",
       "-----\r\n",
       "a  1 \r\n",
       "b  1 \r\n",
       "c  2 \r\n",
       "b  2 \r\n"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c1 c2\r\n",
       "-----\r\n",
       "a  10\r\n",
       "b  20\r\n"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c1 c2\r\n",
       "-----\r\n",
       "a  10\r\n",
       "b  20\r\n"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c1 c2\r\n",
       "-----\r\n",
       "c  30\r\n",
       "b  20\r\n",
       "a  10\r\n",
       "a  40\r\n"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c1 c2\r\n",
       "-----\r\n",
       "c  30\r\n",
       "b  20\r\n",
       "a  10\r\n",
       "a  40\r\n"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t:([] c1:`a`b`a`c`a`b`c; c2:10*1+til 7; c3:1.1*1+til 7)\n",
    "ft:{([] c1:`a`b`a`c`a`b`c; c2:10*1+til 7; c3:1.1*1+til 7)}\n",
    "\n",
    "select from t\n",
    "?[t; (); 0b; ()]\n",
    "\n",
    "select from t where c2>35,c1 in `b`c\n",
    "?[t; ((>;`c2;35); (in;`c1;enlist `b`c)); 0b; ()]\n",
    "\n",
    "select max c2, c2 wavg c3 from t\n",
    "?[t; (); 0b; `maxc2`wtavg!((max;`c2); (wavg;`c2;`c3))]\n",
    "\n",
    "t:([] c1:`a`b`a`c`b`c; c2:1 1 1 2 2 2; c3:10 20 30 40 50 60)\n",
    "select distinct c1,c2 from t\n",
    "?[t; (); 1b; `c1`c2!`c1`c2]\n",
    "\n",
    "t:([] c1:`a`b`c; c2:10 20 30)\n",
    "select[2] from t\n",
    "?[t;();0b;();2]\n",
    "\n",
    "t:([] c1:`a`b`c`a; c2:10 20 30 40)\n",
    "select[>c1] c1,c2 from t\n",
    "?[t;();0b;`c1`c2!`c1`c2; 0W; (>:;`c1)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9.12.1 Functional select\n",
    "The functional form for exec is nearly identical to that of select. Slight variations in the parameters indicate which is intended. Since the constraint parameter carries over unchanged, we omit its discussion in this section."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "`a`b`c\r\n"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "`a`b`c\r\n"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c1| a b c\r\n"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c1| a b c\r\n"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c1| `a`b`c\r\n",
       "c2| 10 20 30 40\r\n"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c1| `a`b`c\r\n",
       "c2| 10 20 30 40\r\n"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "a| 10 40\r\n",
       "b| ,20\r\n",
       "c| ,30\r\n"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "a| 10 40\r\n",
       "b| ,20\r\n",
       "c| ,30\r\n"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t:([] c1:`a`b`c`a; c2:10 20 30 40; c3:1.1 2.2 3.3 4.4)\n",
    "\n",
    "exec distinct c1 from t\n",
    "?[t; (); (); (distinct; `c1)]\n",
    "\n",
    "exec c1:distinct c1 from t\n",
    "?[t; (); (); (enlist `c1)!enlist (distinct; `c1)]\n",
    "\n",
    "exec distinct c1, c2 from t\n",
    "?[t; (); (); `c1`c2!((distinct; `c1); `c2)]\n",
    "\n",
    "exec c2 by c1 from t\n",
    "?[t; (); `c1; `c2]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9.12.3 Functional update¶\n",
    "The syntax of functional form of update is identical to that of select except that ! is used in place of ?. In the following examples you will need to keep track of the different uses of enlist:\n",
    "\n",
    "making a list of parse trees from a single parse expression\n",
    "creating singleton dictionaries\n",
    "distinguishing literal symbols from column names."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "c1 c2 \r\n",
       "------\r\n",
       "a  100\r\n",
       "b  20 \r\n",
       "c  30 \r\n",
       "a  100\r\n",
       "b  50 \r\n"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c1 c2 \r\n",
       "------\r\n",
       "a  100\r\n",
       "b  20 \r\n",
       "c  30 \r\n",
       "a  100\r\n",
       "b  50 \r\n"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c1 c2\r\n",
       "-----\r\n",
       "a  10\r\n",
       "b  20\r\n",
       "c  30\r\n",
       "a  50\r\n",
       "b  70\r\n"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "`t\r\n"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c1 c2\r\n",
       "-----\r\n",
       "a  10\r\n",
       "b  20\r\n",
       "c  30\r\n",
       "a  50\r\n",
       "b  70\r\n"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t:([] c1:`a`b`c`a`b; c2:10 20 30 40 50)\n",
    "update c2:100 from t where c1=`a\n",
    "\n",
    "c:enlist (=;`c1;enlist `a)\n",
    "b:0b\n",
    "a:(enlist `c2)!enlist 100\n",
    "![t;c;b;a]\n",
    "\n",
    "update c2:sums c2 by c1 from t\n",
    "![`t; (); (enlist `c1)!enlist `c1; (enlist `c2)!enlist(sums; `c2)]\n",
    "t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9.12.4 Functional delete¶\n",
    "The syntax of functional delete is a simplified form of functional update.\n",
    "\n",
    "![t;c;0b;a]\n",
    "\n",
    "where t is a table, or the name of a table, c is a list of parse trees for where subphrases and a is a list of column names. Either c or a, but not both, must be present. If c is present, it specifies which rows are to be deleted. If a is present it is a list of symbol column names to be deleted. In the former case you must specify a as an empty list of symbols.\n",
    "\n",
    "As before, distinguish the various uses of enlist in the examples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "c1 c2\r\n",
       "-----\r\n",
       "a  10\r\n",
       "c  30\r\n",
       "a  40\r\n"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c1 c2\r\n",
       "-----\r\n",
       "a  10\r\n",
       "c  30\r\n",
       "a  40\r\n"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c1\r\n",
       "--\r\n",
       "a \r\n",
       "b \r\n",
       "c \r\n",
       "a \r\n",
       "b \r\n"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "`t\r\n"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "c1\r\n",
       "--\r\n",
       "a \r\n",
       "b \r\n",
       "c \r\n",
       "a \r\n",
       "b \r\n"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t:([] c1:`a`b`c`a`b; c2:10 20 30 40 50)\n",
    "delete from t where c1=`b\n",
    "\n",
    "![t;enlist (=;`c1;enlist `b);0b;`symbol$()]\n",
    "\n",
    "delete c2 from t\n",
    "\n",
    "![`t;();0b;enlist `c2]\n",
    "t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Q (kdb+)",
   "language": "q",
   "name": "qpk"
  },
  "language_info": {
   "file_extension": ".q",
   "mimetype": "text/x-q",
   "name": "q",
   "version": "3.6.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}