cbbrowne@csi.uottawa.ca (Christopher Browne (055908)) (02/24/91)
I'm in the process of trying to assimilate some sort of understanding of the J language. It looks like it has distinct advantages over APL, notably in that it doesn't use "funny characters." That makes it: a) Easier to port to multiple machines i.e. - it's MUCH LESS hardware dependent. One APL solution is to have a standard "character set generator" for each machine - but you still have to put together SOMETHING that's massively machine dependent when you use classical APL. b) Nicer to use with foreign file systems. It uses "standard ASCII" (and EBCDIC support wouldn't be too hard to add...) so that files will be far easier to move between different machines & versions of the language. I don't know how "classical APL" put together workspaces, but I'm pretty sure that the ONLY sensible way to edit it was by using APL (or some customized version of XEDIT...). This adds Yet Another Improvement: c) You can use ANY editor to edit programs/data. Old APL workspaces were ugly in MANY ways... Being able to load vars/ functions from files is a NICE improvement. I can use Emacs, you can use Brief, someone else can use WordPerfect (ick!)... Others may use vi... BUT --- There seem to be a few downsides. Related to one of them, I have a public question... a) Doesn't use the "funny characters" That special character set WAS good in that it was easy to tell the various operations apart. Now, instead of looking like strange-character gibberish, the code looks like punctuation gibberish... It'll take some work with the system to be able to figure out the operator set, especially since MANY have characters in common. This is a lose-lose situation. There are both advantages and disadvantages to using either a) Special APL characters or b) Combinations of standard punctuation characters. I think that the benefits of moving to ASCII outweigh the costs, but there IS certainly a cost... b) Documentation at FTP archives This isn't a language issue - just a distribution issue. All I could find on watserv1 was a document entitled "J Implementation Status," showing the various verbs, adverbs, conjunctions, pronouns, copulae, and conjunctions, with (in most cases) not much explanation of what they're about. T'would be nice to have some sort of brief documenting describing: I) What is J? How did APL work lead to J? II) What are the major differences? III)What are the operators? What do they do? (e.g. - giving a little more than just the operators' names.) I've been able to figure out many of my confusions by looking at the sundry tutorial files, but it would be nice to have some sort of overview of the system. I realize that there's a $24 J Reference Manual available, but I'm a poor grad. student who can't really afford every manual that comes available... If I start using J really extensively, then maybe... c) Matrix Referencing (the "" operation) This shouldn't be TOO hard... In original APL, one could grab part of a matrix by doing something like the following: (I'll add a little J in to substitute for those operators that are not in ASCII...) EXPENDITURES=. 2 3 6 $ 161 161 161 164 164 164 9 3 11 6 4 4 10 17 22 9 11 20 130 132 184 197 163 0 1 7 9 10 5 6 21 24 8 11 17 161 EXPENDITURES 161 161 161 164 164 164 9 3 11 6 4 4 10 17 22 9 11 20 130 132 184 197 163 0 1 7 9 10 5 6 21 24 8 11 17 161 I'd then like to add things up with respect to the second index. I'd use the operation: +/[2]EXPENDITURES getting: 180 181 194 179 179 188 152 163 201 218 185 167 In J, it's something annoying like +/ {Ugliesomitted{MoreUglies{EXPENDITURES Question 1) What should those two sets of uglies be? Question 2) There must be some general J idiom for doing this sort of thing. What might it be? Question 3) Why was this operation changed? I can see that the new way is far more explicit (and may be able to do things the old way couldn't). The square braces aren't used for anything in J now - they could have been used for the old operation. Why not? (I'm sure there are good reasons for these things. I'd just like to know why...) -- Christopher Browne cbbrowne@csi.uofottawa.ca University of Ottawa Master of System Science Program
mjab@godot.think.com (Michael J. A. Berry) (02/26/91)
Newsgroups: comp.lang.apl From: cbbrowne@csi.uottawa.ca (Christopher Browne (055908)) Keywords: n Nntp-Posting-Host: prgc Organization: CSI Dept., University of Ottawa Date: Sat, 23 Feb 91 23:45:05 GMT I'm in the process of trying to assimilate some sort of understanding of the J language. . . . c) Matrix Referencing (the "" operation) This shouldn't be TOO hard... I'm not too sure what you mean by the "" operation. In original APL, one could grab part of a matrix by doing something like the following: (I'll add a little J in to substitute for those operators that are not in ASCII...) EXPENDITURES=. 2 3 6 $ 161 161 161 164 164 164 9 3 11 6 4 4 10 17 22 9 11 20 130 132 184 197 163 0 1 7 9 10 5 6 21 24 8 11 17 161 EXPENDITURES 161 161 161 164 164 164 9 3 11 6 4 4 10 17 22 9 11 20 130 132 184 197 163 0 1 7 9 10 5 6 21 24 8 11 17 161 I'd then like to add things up with respect to the second index. I'd use the operation: +/[2]EXPENDITURES getting: 180 181 194 179 179 188 152 163 201 218 185 167 Actually, assuming an index origin of 0 as in J, that expression would be +/[1]EXPENDITURES In J, it's something annoying like +/ {Ugliesomitted{MoreUglies{EXPENDITURES Question 1) What should those two sets of uglies be? These are not the "uglies" you want. In both traditional APL and J what you are doing is not a selection of elements or "grabbing part of a matrix" (what { does) but rather, specifying how to carve up EXPENDITURES for +/. The confusion probably comes from the fact that square brackets were used for both selection and axis specification in APL. The two uses are unrelated. Question 2) There must be some general J idiom for doing this sort of thing. What might it be? In J, one would write +/"2 EXPENDITURES. This is read "sum rank two of EXPENDITURES" or "apply summation to the rank-2 cells of EXPENDITURES." The rank operator is not new with J. It was in Dictionary APL and Sharp APL (and maybe others as well). The [] notation was used for several different things in APL. In all cases, the syntax was anomalous since a pair of symbols was used where other APL functions and operators use a single symbol. Even the $24 documentation of J may not tell you all you want to know. If you want to read more about the rank operator, I suggest: Berneky, Robert "An Introduction to Function Rank" in the Proceedings of APL 88 (ACM). To understand more of the roots of J, I suggest: Iverson, Kenneth E. "A Dictionary of APL" APL Quote-Quad Vol. 18, Number 1, September 1987. The J distribution includes a file "references" with pointers to articles on J itself. Here is a sample J session illustrating the use of the rank operator to solve your problem: $ /public/j/sun4/j J Version 2.9 Copyright (c) 1990 1991, Iverson Software Inc. EXPENDITURES=. 2 3 6 $ 161 161 161 164 164 164 9 3 11 6 4 4 10 17 22 9 11 20 130 132 184 197 163 0 1 7 9 10 5 6 21 24 8 11 17 161 EXPENDITURES 161 161 161 164 164 164 9 3 11 6 4 4 10 17 22 9 11 20 130 132 184 197 163 0 1 7 9 10 5 6 21 24 8 11 17 161 +/"2 EXPENDITURES 180 181 194 179 179 188 152 163 201 218 185 167 Question 3) Why was this operation changed? I can see that the new way is far more explicit (and may be able to do things the old way couldn't). The square braces aren't used for anything in J now - they could have been used for the old operation. Why not? All the various things which [] used to do are done in J in different ways. The primary use of [] in APL was subscripting. Unlike {, however, it was impossible to write a rank-independent selection expression with the [] notation because you had to know how many semicolons to put in. (I'm sure there are good reasons for these things. I'd just like to know why...) -- Christopher Browne cbbrowne@csi.uofottawa.ca University of Ottawa Master of System Science Program -- ============================================== Michael J. A. Berry Internet: mjab@think.com uucp: {harvard, uunet}!think!mjab telephone: (617) 234-2056 FAX: (617) 234-4444 ==============================================
rbe@yrloc.ipsa.reuter.COM (Robert Bernecky) (02/27/91)
I won't try to deal with all your concerns about J vs apl, but here are two comments: a. character set: The apl character set is an ONGOING problem: Every new editor, printer, keyboard, etc., would need special tinkering to support it. Ergo, we give up and go ascii. b. hard-to-read squiggles: You get used to them, just as you got used to apl squiggles. For example, x#y is replicate or compression. $ is reshape (with slightly different semantics due to "item" orientation of J. c. (ok, so I can't count- that's why I use computers). how do I do reductions along specific axes, etc? Like this. Assume T is your rank 3 array: +/t gives you first axis summation +/"3 t would be the same. +/"2 t gives you second axis summation. Basically, it says: "apply plus reduction to the rank-2 objects of t". +/"1 t gives last axis reduction (sum each row of t). There are two reasons for abandoning the +/[k] approach of apl: a. brackets are syntactically anomalous, and are not functions, operators, or anything else that is generally applicable to apl. b. brackets have special and unique meanings for EACH primitive. You can't tell someone: foo[k] means thus and such. In J, the rank adverb ("k) has a specific and CONSISTENT meaning for all verbs, including user defined ones: Apply the verb/function to the rank k objects of the argument. Simple, straightforward, and consistent. See my paper on "An Introduction to Function Rank" in the acm sigapl apl88 conference proceedings (apl quote quad vol 18, no 2) for discussion of function rank in an apl environment. Bob Bernecky Snake Island Research Inc.
hui@yrloc.ipsa.reuter.COM (Roger Hui) (02/27/91)
a. The special symbols APL are elegant, but they are very expensive. You yourself outlined some of the costs, by pointing out things made possible by eschewing the special symbols. As to the possible disadvantages of the ASCII spelling, anything new will look strange at first. The Language Summary in the dictionary is worthy of study. You may come to appreciate that the ASCII spelling is no less mnemonic than the special symbols. b. Documentation. "status.doc" is not meant to be sufficient for learning J. It just tells you what's been implemented and what has not. $24 buys you a printed manual called "Tangible Math and the ISI Dictionary of J" (author: K.E. Iverson). If you feel that you can not afford the cost, there are alternatives: - Hui/Iverson/McDonnell/Whitney, APL\?, APL90 Conference Proceedings. [Introduced J, "philosophic" discussions, reasons behind design]. - K.E. Iverson, Dictionary of J, Vector (Journal of the British APL Association), October 1990. [This version of dictionary now slightly out-of-date.] - K.E. Iverson, J, Vector, July 1990. - The tutorial frames in the distribution package. c. The bracket axis "operator" has been superseded by the rank (") conjunction. See the msg from Bob Bernecky filed 1991 2 26 21 05 GMT. Roger Hui Iverson Software Inc. 33 Major Street, Toronto, Ontario M5S 2K9 (416) 925 6096
mjab@nanna.think.com (Michael J. A. Berry) (03/01/91)
In article <1991Feb26.162714.28837@csrd.uiuc.edu> jaxon@sp27.csrd.uiuc.edu (Greg P. Jaxon) writes:
.
.
.
I was sure I understood the rank operator until I read Mike Berry's reply. What I can't
understand now is how the summation chose the `middle' axis. Am I right that there are
2 `rank-2 cells' in EXPENDITURES, and they are 3x6 arrays? If so shouldn't summing them
yield a 3x6 result? Or is J's rank operator asking sum to produce a rank-2 result?, in
which case I want to know how it picked the axis to reduce.
I'm just guessing here, but has +/ been changed to work by default on the leading axis
of its argument? Applying +/[#IO] to the rank-2 cells of EXPENDITURES would give 2
6-element results.
Yes, that is what happened. In J, *everything* favors the first axis. /
does what slash-bar used to do, comma does what comma-bar used to do. This
(I assume) is to make the rank operator more convenient to use.
Regards,
Greg Jaxon Univ. of Ill. Center for Supercomputing R&D
jaxon@csrd.uiuc.edu
-Michael
--
==============================================
Michael J. A. Berry
Internet: mjab@think.com
uucp: {harvard, uunet}!think!mjab
telephone: (617) 234-2056 FAX: (617) 234-4444
==============================================
rbe@yrloc.ipsa.reuter.COM (Robert Bernecky) (03/02/91)
<... first axis operations were done... to make use of the rank operator easier...> There's more to it than that. Consider that traditional APL had 3 (count 'em, three!) flavors of many operations. For reduction, there was reduction along the first axis, written as slash overstruck with minus. There was reduction along the last axis, written as slash. And, there was reduction along axis k written as slash leftbracket k rightbracket. J unifies all those into a single reduction, written with slash, in which you achieve the other axes via the rank adverb. Because the rank adverb has consistent semantics, you only have to learn how it works once. Because reduction has consistent semantics, ditto. But you end up with a whole family of reductions, and REDUCE the number of symbols required to express the notation. So, it' it's not just to make rank easier. Function rank is the key to simplifying APL, and the first axis is its prophet. Oopsie. Apologies to Asimiv. Asimov. ... the first axis enables those simplifications. Bob Bernecky
Edward_M_Cherlin@cup.portal.com (03/03/91)
cbbrowne asked for help in understanding J and its rationale. He can find some of the answers in the article "The Principles of J" in APL News, 22,3 (1990). The article explains most J features with examples for the more confusing new features, and shows the development from Sharp (or Reuter:file) APL to J, starting from before nested arrays and including Dictionary APL. Back issues are available from the publisher, Springer-Verlag New York, at 800- SPRINGER or 212/460-1500. To answer one particular question: instead of using the axis operator to do reductions in a particular direction, J uses the rank operator. By default, reduction in J applies along the first axis rather than the last. The rank operator partitions an array by selecting a specified number of dimensions from the end. So +/"n applied to an m-dimensional array reduces the (m-n)th dimension, counting in origin 0.