J Notes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction\n",
    "This is the electronic version of hand written notes collected on the J programming language. Many of the idioms have come from searching the J mailing lists and support documentation from the J Software website: http://www.jsoftware.com \n",
    "\n",
    "J is an array processing language and inherits much of the functionality of APL. Both were developed by Ken Iverson. J encompasses much of the functionality of APL without the need for a new type font. APL invented new symbols to represent the basic functionality of array processing. Dr. Iverson introduces an ASCII only symbol set while firming up the grammar with analogies to English language parts of speech. This provides the language with a framework of familiarity for anyone with a rudementary understanding of English grammar."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Arrays\n",
    "Arrays are the implicit data structure of J. They can be thought of as lists of numbers or characters. To define them a space delimited list of numbers is all that is required. If you type in a list of numbers the J interpreter will respond with the same list of numbers back indicating it is a valid list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4\n"
     ]
    }
   ],
   "source": [
    "1 2 3 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 3 4 5\n"
     ]
    }
   ],
   "source": [
    "1 + 1 2 3 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables\n",
    "values and arrays can be assigned to variables. Assignment is accomplished by the =: or =. operators. The =: creates a global variable, where =. creates a local variable (useful inside function definitions). One other operator useful is to use ]. This will ouput the contents of the variable assignment (It's normally suppressed)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "myvar =: 1 2 3 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4\n"
     ]
    }
   ],
   "source": [
    "myvar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 3 4 5\n"
     ]
    }
   ],
   "source": [
    "]myvar =: 2 3 4 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## i. - iota\n",
    "This function allows you to create a list of consequtive integers starting at 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 2 3 4 5 6 7 8 9\n"
     ]
    }
   ],
   "source": [
    "i. 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 2 3 4 5 6 7 8 9\n"
     ]
    }
   ],
   "source": [
    "]myvar =: i. 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1  2  3\n",
      "4 5  6  7\n",
      "8 9 10 11\n"
     ]
    }
   ],
   "source": [
    "i. 3 4     NB. iota can create multidimensional lists too"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Negative Numbers and the subtraction function\n",
    "The subtraction function - has its normal mathmatical meaning when used with 2 operands. But when used in front of a number alone (monadic use) it works as a function and not as negative sign for a negative number. J uses the underscore to precede the digits as a negative number sign. Examples will show the functionality quite clearly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_12\n"
     ]
    }
   ],
   "source": [
    "_12    NB. negative 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_12\n"
     ]
    }
   ],
   "source": [
    "- 12   NB. negate 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_2 3 4 5\n"
     ]
    }
   ],
   "source": [
    "_2 3 4 5  NB. array with negative number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_2 _3 _4 _5\n"
     ]
    }
   ],
   "source": [
    "]V =: -2 3 4 5    NB. negate all the digits of the array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mathematical Operations\n",
    "### Exponentiation (raising to a power)  ^"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "2^3    NB. 2 cubed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 10 100 1000\n"
     ]
    }
   ],
   "source": [
    "] U =: 10 ^ i. 4   NB. i. 4 creates the list 0 1 2 3 and it raises 10 by those powers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Concatenate  ,\n",
    "Join to lists together with a comma operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 10 100 1000 _2 _3 _4 _5\n"
     ]
    }
   ],
   "source": [
    "U,V"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Size '#'\n",
    "The number of elements in the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "# U,V"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Shape $\n",
    "Gives the number of elements if a single list or if there is dimensionality to the list it returns the dimensions of the list. In diatic form it will reformat the list to the dimensions provided."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "$ U,V"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 1 10 100 1000\n",
      "_2 _3  _4   _5\n"
     ]
    }
   ],
   "source": [
    "2 4$ U,V"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  1   10\n",
      "100 1000\n",
      " _2   _3\n",
      " _4   _5\n"
     ]
    }
   ],
   "source": [
    "4 2$ U,V"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0 0 0\n",
      "0 0 0 0\n",
      "0 0 0 0\n"
     ]
    }
   ],
   "source": [
    "NB. Shape is also good for creating intialized arrays\n",
    "3 4$0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 1 1 1 1 1 1 1 1 1\n"
     ]
    }
   ],
   "source": [
    "10 $ 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Laminate ,:\n",
    "This will layer the lists on top of each other forming a multidimensional list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 1 10 100 1000\n",
      "_2 _3  _4   _5\n"
     ]
    }
   ],
   "source": [
    "U,:V"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 4\n"
     ]
    }
   ],
   "source": [
    "$ U,:V  NB. gives us a 2 row 4 col matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Stitch ,.\n",
    "Similar to laminate but this will produce side by side arrangement as follows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   1 _2\n",
      "  10 _3\n",
      " 100 _4\n",
      "1000 _5\n"
     ]
    }
   ],
   "source": [
    "U,.V"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4 2\n"
     ]
    }
   ],
   "source": [
    "$ U,.V   NB. produces a 4 row 2 col matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 4\n"
     ]
    }
   ],
   "source": [
    "NB. in case you were wondering about size\n",
    "(# U,:V), (#U,.V)  NB. concatenate the sizes of the 2 methods of combining same sized lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Interestingly size came back with the number of rows as the size. This gives an indication to how J considers objects within it's hierarchy. Our matrix is really a list of lists and J is reporting only on the highest level list."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Select {\n",
    "J follows it's infix notation when selecting elements from arrays. There isn't a square bracket deliniation. Where in most languages you would do something like A[2] to get a specific element from an array. In J: 2 { A \n",
    "\n",
    "Also J assumes an index origin of 0 and there is no way to change it except for creating your own functions to manipulate arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_2\n"
     ]
    }
   ],
   "source": [
    "0 { V  NB. Select the first element of V"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_4 _5 _2 _3\n"
     ]
    }
   ],
   "source": [
    "2 3 0 1 { V   NB. give a vector list of indexes get a rearranged list back accordingly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "aaabbcddeee\n"
     ]
    }
   ],
   "source": [
    "NB. strings are arrays that are not space delimited when output\n",
    "0 0 0 1 1 2 3 3 4 4 4{ 'abcde'   NB. over specify indexes in a selection vector is OK"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Amend }\n",
    "Amend allows you to replace specific elements of an array (aka vector or list). Given a value and an index. This is not a verb in the strict sense. Providing an index value with the symbol is the actual verb. Keeping with the functional style of J no changes are made on the operands. To permanently effect the change an assignment back to the variable would have to be made.\n",
    "\n",
    "to do: explain the grammar of this"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_2 3 _4 _5\n"
     ]
    }
   ],
   "source": [
    "3 (1)} V      NB. replace position 1 with 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_2 _3 _4 _5\n"
     ]
    }
   ],
   "source": [
    "V   NB. however V remains unchanged"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_2 3 _4 _5\n"
     ]
    }
   ],
   "source": [
    "V =: 3 (1)} V      NB. to make the change in V you must assign\n",
    "V"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Boxing\n",
    "Boxing is a meta structuring of data that J allows. It's a nice way to group differing objects and store them into a single variable. It's also a nice way to group elements so they can be worked on sequentially. There are 3 operators associated with boxing: < ; and >  \n",
    "\n",
    "- < boxes its right argument (if there's a left argument it becomes the less than operator)\n",
    "- ; boxes its left and right argument and concatenates them together\n",
    "- > unboxes its right arguement (becomes greater than if left and right arguments are present)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "┌─┬─┬─┐\n",
      "│a│a│a│\n",
      "└─┴─┴─┘\n"
     ]
    }
   ],
   "source": [
    "]mybox =: 'a';'a';'a'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "┌─┐\n",
      "│a│\n",
      "└─┘\n"
     ]
    }
   ],
   "source": [
    "<'a'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "┌─┬─┬─┬─┐\n",
      "│a│a│a│a│\n",
      "└─┴─┴─┴─┘\n"
     ]
    }
   ],
   "source": [
    "mybox,<'a'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1\n",
      "2 3\n",
      "4 5\n"
     ]
    }
   ],
   "source": [
    "NB. Box rows of a matrix\n",
    "] mymatrix =: i. 3 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "┌───┐\n",
      "│0 1│\n",
      "│2 3│\n",
      "│4 5│\n",
      "└───┘\n"
     ]
    }
   ],
   "source": [
    "<  mymatrix         NB. this operated on the whole matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "┌───┬───┬───┐\n",
      "│0 1│2 3│4 5│\n",
      "└───┴───┴───┘\n"
     ]
    }
   ],
   "source": [
    "<\"1 mymatrix   NB. the \"1 after the operator causes it to operate on another axis (rows) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Identity Matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 0 0\n",
      "0 1 0\n",
      "0 0 1\n"
     ]
    }
   ],
   "source": [
    "= i. 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 0 0 0 0\n",
      "0 1 0 0 0\n",
      "0 0 1 0 0\n",
      "0 0 0 1 0\n",
      "0 0 0 0 1\n"
     ]
    }
   ],
   "source": [
    "= i. 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Debug\n",
    "- Ctrl-k\n",
    "- dbstop function_name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Linear Regression\n",
    "Fit a line to over specified data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5\n"
     ]
    }
   ],
   "source": [
    "]y1 =: 1 2 3 4 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 4 6 8 10\n"
     ]
    }
   ],
   "source": [
    "]x1 =: 2 4 6 8 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_1.33227e_15 0.5\n"
     ]
    }
   ],
   "source": [
    "y1 %. 1,. x1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Counting Repeats\n",
    "#/.~  will count the total number of repeated numbers in a list (ie vector)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 5 2\n"
     ]
    }
   ],
   "source": [
    "#/.~ 1 1 1 3 3 3 3 0 0 1 1 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Local Repeats\n",
    "Possibly a little more usable is counting local repeats. Local repeats are separated consequitive runs of a number. A number may have runs that are separated by other numbers and they will be counted separately. This produces a list of counts that can be matched up to the original list (with a little bit of work). This uses a Tacit function. Tacit is a fancy name for stringing verbs (operators) togther into one function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "f =: (1:, }. ~: }:)#;. 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 3 2 2 1\n"
     ]
    }
   ],
   "source": [
    "f 1 1 1 3 3 3 0 0 1 1 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Occurances\n",
    "Another method that matches each member of the list to the total count of each item in the list. This uses =/ which produces an outer product of the operands comparing every item on the left to each itme on the right. By then summing the rows of the resulting table you get the corresponding total count for each item in the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 0 0 0 0\n",
      "0 1 0 1 0\n",
      "0 0 1 0 0\n",
      "0 1 0 1 0\n",
      "0 0 0 0 1\n"
     ]
    }
   ],
   "source": [
    "1 2 3 2 4 =/ 1 2 3 2 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 1 2 1\n"
     ]
    }
   ],
   "source": [
    "+/ 1 2 3 2 4 =/ 1 2 3 2 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So there is 1 \"1\", 2 \"2's\", 1 \"3\", 2 \"2's\", 1 \"4\"\n",
    "\n",
    "The length of the lists match so this is a nice way of creating a look up table to find out the quantity of that item given the position of the item of interest."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Selecting Rows and Columns (use of { )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1  2  3\n",
      "4 5  6  7\n",
      "8 9 10 11\n"
     ]
    }
   ],
   "source": [
    "] matrix =: i. 3 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4 5 6 7\n"
     ]
    }
   ],
   "source": [
    "1 { matrix    NB. selects the second row, remember the index starts at 0 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 5 9\n"
     ]
    }
   ],
   "source": [
    "NB. the \"1 below changes which dimension the operator will work switching it to cols\n",
    "1 {\"1 matrix  NB. select the second column"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mask Select  (dyadic # )\n",
    "Use a mask of 1's and 0's to select elements from a list.\n",
    "\n",
    "Many times elements are tested for certain properites and a list of true or false are obtained. In J true and false are represented by 1's and 0's respectively. This is a nice way to pull out elements from a list that meet certain criteria at runtime."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 3\n"
     ]
    }
   ],
   "source": [
    "0 1 0 1 # 0 1 2 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Copy  (further extension of dyadic #)\n",
    "A further extension of Mask select is to let values be the number of copies of an item you want in the new list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 1 1 3 3\n"
     ]
    }
   ],
   "source": [
    "0 3 0 2 # 0 1 2 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Grade Up  /:\n",
    "\"Grade Up\" is a verb that will produce a list of indexes that when applied to the original array will result in its elements being in ascending order"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 0 3 2 6 5 4\n"
     ]
    }
   ],
   "source": [
    "/: 10 9 20 19 25 24 23"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sorting\n",
    "using the select operator { you can place the original list in ascending order"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 9 20 19 25 24 23\n"
     ]
    }
   ],
   "source": [
    "]ascend =: 10 9 20 19 25 24 23"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9 10 19 20 23 24 25\n"
     ]
    }
   ],
   "source": [
    "(/: ascend) { ascend"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## dyadic /:\n",
    "the dyadic use of grade up will produce the sorted list without the use of the select operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9 10 19 20 23 24 25\n"
     ]
    }
   ],
   "source": [
    "ascend /: ascend"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reflexive operator ~\n",
    "The reflexive operator uses the right hand operand as both the left and right operand to the operator it's applied to. Therefore /:~ is a shorthand for the dyadic use above"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9 10 19 20 23 24 25\n"
     ]
    }
   ],
   "source": [
    "/:~ ascend     NB. The interpreter will use the dyadic /: definition and apply operand to both"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Verbs from other verbs\n",
    "The simplest way to create a new verb is to assign it to a variable. Technically we create anything new but it does allow you to save a symbolic operator and give it a word based name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "┌─┬─┐\n",
      "│7│7│\n",
      "└─┴─┘\n"
     ]
    }
   ],
   "source": [
    "add =: +\n",
    "(5 add 2);5 + 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Every operator or function in J is considered a verb. These verbs can be strung together to perform combined operations in a single line. It is a strength of J to be able to do this. It is a weakness of the programmer if he or she forgets how J handles multiple verbs placed in a row (called a verb \"train\" in J).\n",
    "\n",
    "As an example \n",
    "5 (+ * -) 3\n",
    "\n",
    "will be interpreted by J as follows\n",
    "(5+3)*(5-3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "┌──┬──┐\n",
      "│16│16│\n",
      "└──┴──┘\n"
     ]
    }
   ],
   "source": [
    "((5 +3) * (5-3));5 (+ * -) 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In general the fork: x (f g h) y in dyadic form (takes 2 operands left and right) has this tree based structure:\n",
    "     g\n",
    "    / \\\n",
    "   /   \\\n",
    "  f     h\n",
    " / \\   / \\\n",
    "z   y x   y\n",
    "\n",
    "Monadic form (f g h) y has this structure\n",
    "\n",
    "   g\n",
    "  / \\\n",
    " f   h\n",
    " |   |\n",
    " y   y\n",
    " \n",
    " ## Mean \n",
    " The prototypical use of fork is to get the mean of a list of numbers. In J terms you need to sum the list of numbers and then divide by the number of numbers present in the list (ie. the length of the list of numbers. Lets look at it by hand storing calculations in variables then take a look at the fork methodology"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5 6\n"
     ]
    }
   ],
   "source": [
    "NB. create a list of numbers from 1 to 6\n",
    "]nums =: 1 + i.6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.5\n"
     ]
    }
   ],
   "source": [
    "NB. Sum numbers \n",
    "s =: +/nums\n",
    "NB. divide by the length of the list of numbers (# - is the length operator)\n",
    "s % #nums"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.5\n"
     ]
    }
   ],
   "source": [
    "NB. now do it as a fork\n",
    "(+/ % #) nums"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Comma Separated Values Files\n",
    "CSV handling is available in the addons for J. Just require 'tables/csv' and the readcsv function is now available. It takes a file path name as a parameter and returns a boxed table or list of the elements in the file. Then you can use J functionality to convert numbers in table to their J numerical form (using the do operator \".) or you can make use of the makenum script in the same addon. \n",
    "\n",
    "There is also a dsv addon which generalizes to any character separating values in a regular way in a file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "┌─────┬───┬───┬─┬──┐\n",
      "│hello│1.0│5.2│6│-1│\n",
      "└─────┴───┴───┴─┴──┘\n"
     ]
    }
   ],
   "source": [
    "require 'tables/csv'\n",
    "'\"hello\",\"1.0\",\"5.2\",\"6\",\"-1\"' fwrites 'tempcsv.csv'\n",
    "]csvdat =: readcsv 'tempcsv.csv'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 5.2 6 _1\n"
     ]
    }
   ],
   "source": [
    "NB. now drop the string from the list above and use makenum to convert to numbers\n",
    "NB. csvdat has dimensions 1 5 to process appropriately use ravel ,  to make a simple list\n",
    "]numdat =: makenum }. ,csvdat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11.2\n"
     ]
    }
   ],
   "source": [
    "+/ numdat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "┌─────┬───┬───┬─┬──┐\n",
      "│hello│1.0│5.2│6│-1│\n",
      "└─────┴───┴───┴─┴──┘\n"
     ]
    }
   ],
   "source": [
    "NB. fixcsv function takes a string of csv data and converts it into a boxed table\n",
    "NB. useful if you already have the data in memory and not in a file\n",
    "NB. creating our own string you need to add a linefeed as that is part of the\n",
    "NB. delimiters expected\n",
    "fixcsv '\"hello\",\"1.0\",\"5.2\",\"6\",\"-1\"',LF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"hello\",\"1.0\",\"5.2\",\"6\",\"-1\"\n",
      "\n"
     ]
    }
   ],
   "source": [
    "NB. makecsv will take an appropriately formated boxed list or table and make a csv string\n",
    "makecsv csvdat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Oblique  /.\n",
    "This function produces the regular diagonals of a matrix.\n",
    "If proceeded by a verb (function) it will apply the verb to the diagonals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 0  1  2  3  4\n",
      " 5  6  7  8  9\n",
      "10 11 12 13 14\n",
      "15 16 17 18 19\n",
      "20 21 22 23 24\n"
     ]
    }
   ],
   "source": [
    "]M =: i. 5 5 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "┌─┬───┬──────┬─────────┬────────────┬──────────┬────────┬─────┬──┐\n",
      "│0│1 5│2 6 10│3 7 11 15│4 8 12 16 20│9 13 17 21│14 18 22│19 23│24│\n",
      "└─┴───┴──────┴─────────┴────────────┴──────────┴────────┴─────┴──┘\n"
     ]
    }
   ],
   "source": [
    "NB. to display the diagonals as boxed elements use the box operator < (monadic less than) \n",
    "NB. with the oblique operator\n",
    "]oM =: < /. M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 0  1  2  3  4\n",
      " 5  6  7  8  9\n",
      "10 11 12 13 14\n",
      "15 16 17 18 19\n",
      "20 21 22 23 24\n"
     ]
    }
   ],
   "source": [
    "NB. to turn the boxed oblique back into a matrix use the following\n",
    "deoblique =: ($:~ [: (( 1+i. , i:)>./) #@>) : ([$ (/:&; </.@: i.)~)\n",
    "deoblique oM"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bibliography\n",
    "1. J Software http://www.jsoftware.com\n",
    "2. Reiter, Cliff Visualization in J 3rd edition\n",
    "3. Gilman, Rose APL An Interactive Approach Wiley"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Prefix \\  and Infix   x u\\ y\n",
    "The back slash used monadically creates prefixes of a list, meaning groupings of elements starting with the first element. then the first and second, 1st, 2nd, and 3rd etc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "i.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "J",
   "language": "J",
   "name": "jkernel"
  },
  "language_info": {
   "file_extension": "ijs",
   "mimetype": "text/x-J",
   "name": "J"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}