{"id":410,"date":"2004-09-17T23:03:00","date_gmt":"2004-09-17T23:03:00","guid":{"rendered":"http:\/\/www.dresan.com\/blog\/?p=410"},"modified":"2004-09-17T23:03:00","modified_gmt":"2004-09-17T23:03:00","slug":"my-first-apl-program","status":"publish","type":"post","link":"https:\/\/dresan.com\/blog\/2004\/09\/17\/my-first-apl-program\/","title":{"rendered":"My First APL Program"},"content":{"rendered":"

As a side project right now I’m investigating computer languages — not just experimenting with Perl vs. Python but trying to expose myself to different families<\/i> of languages, such as functional, logic, imperative, object oriented, and obfuscated.<\/p>\n

Most recently, someone mentioned that array<\/i> languages are the least
\n
widely known family — perhaps because the founding language in the group,
\n
APL, was written with a nonstandard character set. Perhaps the most terse
\n
of all programming languages, APL spawned a series of children, like J and K,
\n
which, even though they can be written in a normal alphabet, retain APL’s
\n
essential terseness — or, dare we say, obscurity?<\/p>\n

I plan to learn J. However, before I did so, I committed myself to learning
\n
at least a smidgen of the original APL, so I could see how the language was
\n
originally intended to work and look.<\/p>\n

Here’s my first APL program, designed to produce a Vigenere tableau:<\/p>\n

<\/p>\n

Note the code isn’t in the standard ASCII character set, so I had
\n
to represent it as an image file.<\/p>\n

The heart of the code is the central box of the next image. This should read as:<\/p>\n

\n<\/p>\n

\n
disclose (( -1 rotate (indexList (shapeOf Y)))\n
   (outerProduct rotate) (enclose Y))\n
<\/pre>\n
<\/p><\/blockquote>\n
and executes right to left:<\/p>\n
\n

\n

\n
Click for PDF<\/font>
\n
<\/a>
\n<\/div>\n
To translate into pseudocode:<\/p>\n
\n
\/\/ Assign the alphabet to the variable Y\n
Y = \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\"\n
 \n
\/\/ Now perform the following:\n
(unbox\n
 ((outerproduct rotate)\n
  (rotate -1 (enumerate (length y)))\n
  (box y)\n
  )\n
 )\n
 \n
\/\/ This is the moral equivalent of:\n
\/\/ (1). Treat array Y like a \"scalar\" variable\n
boxedY = box(y)\n
 \n
\/\/ (2) Find the length of Y - in this case,26\n
lengthOfY = length(y)\n
 \n
\/\/ (3) Get an array from 1 to the length of Y\n
\/\/     We will use this (1 2 ... 26) later to\n
\/\/     rotate the alphabet to the side\n
list1toY = enumerate(lengthOfY)\n
 \n
\/\/ (4) Rotate list by one so that the first\n
\/\/     row is a \"no-op\" rotation: (26 1 2 ... 25)\n
\/\/     (I should have just have subtracted one\n
\/\/     from each list to get (0 1 .. 25), but\n
\/\/     it's just my first APL program!)\n
rotateAmounts = rotate(-1, list1toY)\n
 \n
\/\/ (5) Create a \"mapping rotate\" function that takes\n
\/\/     a list of integers as its first argument and\n
\/\/     rotates each element of its second argument\n
\/\/     by the supplied integer.\n
\/\/     We had to \"box\" Y earlier because APL by\n
\/\/     default treat each of its elements as a one-element\n
\/\/     array.\n
mapRotate = outerproduct(rotate)\n
 \n
\/\/ Now create 26 copies of Y, each rotated by the amount\n
\/\/ specified in the rotateAmounts variable, and collect\n
\/\/ them all into a list.  This is morally equivalent to:\n
\/\/ list(\n
\/\/      rotate(26, boxedY),\n
\/\/      rotate( 1, boxedY),\n
\/\/      ...\n
\/\/      rotate(25, boxedY)\n
\/\/      )\n
rotatedY =  mapRotate(rotateAmounts, boxedY)\n
 \n
\/\/ Now \"unbox\" the rotated list, which takes the\n
\/\/ list of lists of rotated Ys and turns them into\n
\/\/ a matrix or grid rotation\n
return unbox(rotatedY)\n
<\/pre>\n
<\/p>\n
\n
The idea in my mind was to take an input array and print
\n
a diagonalized rectangle with it.  With the alphabet, this
\n
becomes a Vigenere table — once the “indecipherable cipher”,
\n
now a trivial matter for any modern computer.<\/p>\n
With a different string, like “01” or “_[]” (reading the two
\n
brackets as the APL Quad character), and a suitable change
\n
in length of the output, it becomes instead a checkerboard:<\/p>\n
<\/p>\n
Deciphering that is left as an exercise to you, dear fanu.<\/p>\n","protected":false},"excerpt":{"rendered":"
As a side project right now I’m investigating computer languages — not just experimenting with Perl vs. Python but trying to expose myself to different families of languages, such as…<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[11],"class_list":["post-410","post","type-post","status-publish","format-standard","hentry","category-uncategorized","tag-development","ratio-2-1","entry"],"_links":{"self":[{"href":"https:\/\/dresan.com\/blog\/wp-json\/wp\/v2\/posts\/410","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/dresan.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/dresan.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/dresan.com\/blog\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/dresan.com\/blog\/wp-json\/wp\/v2\/comments?post=410"}],"version-history":[{"count":0,"href":"https:\/\/dresan.com\/blog\/wp-json\/wp\/v2\/posts\/410\/revisions"}],"wp:attachment":[{"href":"https:\/\/dresan.com\/blog\/wp-json\/wp\/v2\/media?parent=410"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/dresan.com\/blog\/wp-json\/wp\/v2\/categories?post=410"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/dresan.com\/blog\/wp-json\/wp\/v2\/tags?post=410"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}