Newsgroups: comp.lang.apl
Path: watmath!watserv2.uwaterloo.ca!mach1!torn!cs.utexas.edu!sdd.hp.com!news.cs.indiana.edu!nstn.ns.ca!news.ucs.mun.ca!csd.unb.ca!Gateway.UNB.ca
From: jupiter.sun.csd.unb.ca@unb.ca
Reply-To: apl-l@jupiter.sun.csd.unb.ca
Subject: apl-l UseNet batch for Fri Jan 29 23:59:05 AST 1993
Message-ID: <1993-01-30.000312.1106@jupiter.sun.csd.unb.ca>
Date: Fri, 29 Jan 1993 23:59:06 AST
Lines: 558

Contents of apl-l UseNet batch for Fri Jan 29 23:59:05 AST 1993:

  1. Subject: Need help with adverb
     From: mclean@futon.SFSU.EDU (Emmett Mclean)

  2. Subject: APL on the SUN (Results)
     From: roland@quadsys.com (Roland Besserer)

  3. Subject: Re: APL on the SUN (Results)
     From: wchang@phage.cshl.org (William Chang in Marr Lab - CSHL)

  4. Subject: Re: Selective assignment (was Re: J is NOT APL)
     From: sam@csi.jpl.nasa.gov (Sam Sirlin)

  5. Subject: Re: Selective assignment (was Re: J is NOT APL)
     From: rockwell@socrates.umd.edu (Raul Deluth Miller-Rockwell)

  6. Subject: Re: J is NOT APL (was Re: Interpreter advice sought.)
     From: 6035230@LMSC5.IS.LMSC.LOCKHEED.COM (Charles Schulz)

  7. Subject: Re: Selective assignment (was Re: J is NOT APL)
     From: rockwell@socrates.umd.edu (Raul Deluth Miller-Rockwell)

  8. Subject: Re: Weaning  myself from Matlab: is APL a viable alternative for
 scientific programming and signal processing?
     From: neitzel@ips.cs.tu-bs.de (Martin Neitzel)

  9. Subject: Re: Interpreter advice sought.
     From: volker@sfb256.iam.uni-bonn.de ( Volker A. Brandt )

 10. Subject: Re: Selective assignment (was Re: J is NOT APL)
     From: emclean@sfsuvax1.sfsu.edu (Emmett McLean)

===> Start of article 1

Path:
 csd.unb.ca!torn!spool.mu.edu!decwrl!csus.edu!nic.csu.net!futon.SFSU.EDU!mclean
Newsgroups: comp.lang.apl
Subject: Need help with adverb
Message-ID: <1993Jan28.235833.3968@nic.csu.net>
From: mclean@futon.SFSU.EDU (Emmett Mclean)
Date: 28 Jan 93 23:58:33 PST
Distribution: NA
Organization: San Francisco State University
Nntp-Posting-Host: futon.sfsu.edu
Lines: 45



   Is there a way to write an adverb returning a verb which
   returns the verb but also transparently prints it's
   left and right arguments?

   The adverb would be "something" like:

   print =. 1!:2&2
   t =. i. 0 0
   t =. t,'print ''entering  left argument is'' ; x.'
   t =. t,'print ''entering right argument is''; y.'
   t =. t,'y. =. x. generic_verb y.'
   t =. t,'print ''exiting value of right argument is''; y.'
   t =. t : 1

   For which :
   * t
   or perhaps
   '*' t
   Would return :

   t =. i. 0 0
   t =. t,'print ''entering  left argument is'' ; x.'
   t =. t,'print ''entering right argument is''; y.'
   t =. t,'y. =. x. * y.'
   t =. t,'print ''exiting value of right argument is''; y.'
   t =. t : 1

   In adverbs the left argument is a function. And here
   I am trying to force x. to refer to the left argument
   of the original function, instead of the left argument
   of the adverb. So I know what I've written doesn't make
   any sense but it communicates my question.

   Raul Rockwell's docify verb does this, but ].,[.,
   ]:, and [: have been introduced since he wrote it.
   And even without these new features it probably can be
   cleaned it up.

   BTW, I have a copy of Raul Rockwell's docify and undocify
   verbs which do not use read_block and can be loaded
   into any version of J.  Any one interested in a copy
   let me know.

   Thanks!, Emmett

===> Start of article 2

Newsgroups: comp.lang.apl
Path: csd.unb.ca!torn!cs.utexas.edu!uunet!portal!quadsys!roland
From: roland@quadsys.com (Roland Besserer)
Subject: APL on the SUN (Results)
Message-ID: <C1LMFG.4Ar@quadsys.com>
Organization: QUAD Systems
X-Newsreader: Tin 1.1 PL3
Date: Fri, 29 Jan 1993 04:42:52 GMT
Lines: 14


Well, from all the answers I got to my inquiry concerning APL interpreters for
SUN systems it seems that only Manugistics (formerly STSC*APL) has a
commercial implementation.

MicroAPL who - IMHO - have the best APL/APL2 with their APL.68000 product,
have ported only to the IBM R/6000 machines. Others, including SUN may
follow but no time schedule.

I will be looking into the Manugistics APL interpreter.

--

--------------------------------------------------------------------------------
Roland Besserer          QUAD Systems, Santa Cruz             roland@quadsys.com

===> Start of article 3

Newsgroups: comp.lang.apl
Path:
 csd.unb.ca!torn!cs.utexas.edu!qt.cs.utexas.edu!yale.edu!newsserver.jvnc.net!pha
 ge!wchang
From: wchang@phage.cshl.org (William Chang in Marr Lab - CSHL)
Subject: Re: APL on the SUN (Results)
Message-ID: <C1MIFz.5qL@phage.cshl.org>
Organization: Cold Spring Harbor Lab, Long Is New York
References: <C1LMFG.4Ar@quadsys.com>
Date: Fri, 29 Jan 1993 16:14:23 GMT
Lines: 8


For the sparc at least there is Dyalog APL, sold by MIPS
313-661-5000.  They used to have one for Sun 3's as well.

I paid $1700 educational a few years back for an older
version for the sparc 1 (Sunview).  Their glossy for the
new dyalog APL/X looks very, very impressive indeed.

-- Bill Chang (wchang@cshl.org)

===> Start of article 4

Newsgroups: comp.lang.apl
Path:
 csd.unb.ca!news.ucs.mun.ca!nstn.ns.ca!newsflash.concordia.ca!utcsri!rpi!gatech!
 emory!swrinde!sdd.hp.com!elroy.jpl.nasa.gov!jato!csi!sam
From: sam@csi.jpl.nasa.gov (Sam Sirlin)
Subject: Re: Selective assignment (was Re: J is NOT APL)
Message-ID: <1993Jan27.221845.11152@csi.jpl.nasa.gov>
Originator: sam@kalessin
Sender: usenet@csi.jpl.nasa.gov (Network Noise Transfer Service)
Nntp-Posting-Host: kalessin
Organization: Jet Propulsion Laboratory, Pasadena, CA
References: <1993Jan23.113019.23895@fid.morgan.com> <C1EIJn.I3@quadsys.com>
 <1993Jan26.184600.24394@csi.jpl.nasa.gov> <1993Jan27.094037.13820@csus.edu>
Date: Wed, 27 Jan 1993 22:18:45 GMT
Lines: 52



In article <1993Jan27.094037.13820@csus.edu>, emclean@sfsuvax1.sfsu.edu (Emmett
 McLean) writes:
|> NB. In article 1993Jan26.184600.24394@csi.jpl.nasa.gov sam@csi.jpl.nasa.gov
 (Sam Sirlin) writes:
|> NB. .... There's even lots
|> NB. of new ideas and functionality. The only thing that I still find
|> NB. missing is selective assignment...
|> NB.
|> NB.    Not sure what Sam means by missing but here is a nice verb
|> NB.    implementing selective assignment.  New Jer's might enjoy looking
|> NB.    at it.  Perhaps this will also touch on the thread of how readable
|> NB.    J can be. Apologies to bold APL enthusiasts tired of verbose
|> NB.    postings -:)

Good idea. What I meant is that there is no way to change a part of an
existing structure, though you can make an ammended copy. I've heard
functional justifications for the restriction, but still miss
reassignment. I use it all the time in APL, for setting up arrays
with a given simple pattern and then changing parts for special cases.

...
|>    selectiveAssign =. assign`errorMessage agenda errorCondition

Whew! I'll have to look this over. I use a much simpler indexing
function (that seems to use the same heart as yours):

   index=. ($@])#.[

that can be used with ammend for copy-with-selective-reassignment:
   x (i index y) } y
   x (i&index@]) } y

so I don't have to link the index (i in the above) and the array (y),
as you do. For example
   a selectiveAssign b

becomes
   b; (>1{b) ((>0{b)&index@]) } a

etc. It also works on more than one position:
   i=. 3 2$ 2 1  0 2  3 3
   (-1 2 3) (i&index@]) }a

I'd really like to build something that I could use without ammend:
   x i thing a

but haven't found a way to do this. Does ammend then violate the
gander principle?

--
Sam Sirlin
Jet Propulsion Laboratory         sam@kalessin.jpl.nasa.gov


===> Start of article 5

Newsgroups: comp.lang.apl
Path:
 csd.unb.ca!news.ucs.mun.ca!nstn.ns.ca!newsflash.concordia.ca!utcsri!rpi!zaphod.
 mps.ohio-state.edu!howland.reston.ans.net!bogus.sura.net!darwin.sura.net!haven.
 umd.edu!socrates!socrates!rockwell
From: rockwell@socrates.umd.edu (Raul Deluth Miller-Rockwell)
Subject: Re: Selective assignment (was Re: J is NOT APL)
In-Reply-To: sam@csi.jpl.nasa.gov's message of Wed, 27 Jan 1993 22:18:45 GMT
Message-ID: <ROCKWELL.93Jan29141307@socrates.umd.edu>
Sender: rockwell@socrates.umd.edu (Raul Deluth Miller-Rockwell)
Reply-To: moth@firefly.com
Organization: Traveller
References: <1993Jan23.113019.23895@fid.morgan.com> <C1EIJn.I3@quadsys.com>
        <1993Jan26.184600.24394@csi.jpl.nasa.gov>
        <1993Jan27.094037.13820@csus.edu>
        <1993Jan27.221845.11152@csi.jpl.nasa.gov>
Date: Fri, 29 Jan 1993 19:13:07 GMT
Lines: 15


Sam>   I'd really like to build something that I could use without ammend:
Sam>      x i thing a

What about
   gniht=. '':'(>1{.y.) (>{.y.) } x.'
used as
   a gniht i;x
?

If speed of explicit evaluation is a significant problem, you could
implement it as a 10!: customization.

No?

Raul

===> Start of article 6

Newsgroups: comp.lang.apl
Path:
 csd.unb.ca!news.ucs.mun.ca!nstn.ns.ca!newsflash.concordia.ca!utcsri!rpi!gatech!
 usenet.ins.cwru.edu!agate!ames!kronos.arc.nasa.gov!butch!LMSC5.IS.LMSC.LOCKHEED
 .COM!6035230
From: 6035230@LMSC5.IS.LMSC.LOCKHEED.COM (Charles Schulz)
Subject: Re: J is NOT APL (was Re: Interpreter advice sought.)
Message-ID: <93029.38923.6035230@LMSC5.IS.LMSC.LOCKHEED.COM>
Sender: news@butch.lmsc.lockheed.com
Organization: Lockheed Missiles & Space Company, Inc.
Date: Fri, 29 Jan 93 10:48:43 PST
Lines: 20


------------------------- Original Article -------------------------
From: cbbrowne@csi.uottawa.ca (Christopher Browne)
Newsgroups: comp.lang.apl
Subject: Re: J is NOT APL (was Re: Interpreter advice sought.)
Message-ID: <1993Jan28.194511.20795@csi.uottawa.ca>
Date: 28 Jan 93 19:45:11 GMT

 ...                             The fact that APL uses a different
order of operations than people are used to is also confusing.
Right-to-left evaluation isn't "normal."  ...
END---------------------- Original Article -------------------------

Most other languages besides APL and J DO use right-to-left evaluation --
consider assignment (=, :=, etc.):  the thing on the left gets everything
to the right.  Of course, those languages ALSO use left-to-right
evaluation, perhaps even in the same assignment line -- that may be
"normal" but I find that more confusing.

/Charles A. Schulz
cschulz@lmsc.lockheed.com

===> Start of article 7

Newsgroups: comp.lang.apl
Path:
 csd.unb.ca!news.ucs.mun.ca!nstn.ns.ca!newsflash.concordia.ca!utcsri!rpi!zaphod.
 mps.ohio-state.edu!cs.utexas.edu!uunet!haven.umd.edu!socrates!socrates!rockwell
From: rockwell@socrates.umd.edu (Raul Deluth Miller-Rockwell)
Subject: Re: Selective assignment (was Re: J is NOT APL)
In-Reply-To: rockwell@socrates.umd.edu's message of Fri, 29 Jan 1993 19:13:07
 GMT
Message-ID: <ROCKWELL.93Jan29150712@socrates.umd.edu>
Sender: rockwell@socrates.umd.edu (Raul Deluth Miller-Rockwell)
Reply-To: moth@firefly.com
Organization: Traveller
References: <1993Jan23.113019.23895@fid.morgan.com> <C1EIJn.I3@quadsys.com>
        <1993Jan26.184600.24394@csi.jpl.nasa.gov>
        <1993Jan27.094037.13820@csus.edu>
        <1993Jan27.221845.11152@csi.jpl.nasa.gov>
        <ROCKWELL.93Jan29141307@socrates.umd.edu>
Date: Fri, 29 Jan 1993 20:07:12 GMT
Lines: 21


More on the subject of doing "amend" without the restrictions of "}"
on index calculations.  [The restriction is: you are limited to
functions applying to global values and/or the amending data, or you
must use explicit evaluation.  In other words, it's akward using
tacitly expressed values.]

With numeric information, you can do quite a lot with 0, 1, addition,
and multiplication: arbitrary permutations, mix and match selectivity,
whatever.  In assembly language [and C, to a lesser extent], you could
get away with this sort of manipulation (multiplication by 0 and 1,
addition by 0 -- generally in the form of "and", "or", or "branch"
instructions) with arbitrary objects.  Unfortunately, these techniques
do not currently apply to character or boxed data.

However, there are a variety of selection and permutation techniques
that do apply to any class of data.  For example, I have gotten a lot
of mileage out of concatenating two lumps of data together, then
indexing from that intermediate result.

Raul


===> Start of article 8

Newsgroups: comp.lang.apl
Path:
 csd.unb.ca!news.ucs.mun.ca!nstn.ns.ca!newsflash.concordia.ca!utcsri!rpi!zaphod.
 mps.ohio-state.edu!howland.reston.ans.net!spool.mu.edu!yale.edu!ira.uka.de!Siri
 us.dfn.de!tubsibr!infbssys!neitzel
From: neitzel@ips.cs.tu-bs.de (Martin Neitzel)
Subject: Re: Weaning  myself from Matlab: is APL a viable alternative for
 scientific programming and signal processing?
Message-ID: <1993Jan29.133601.7385@ips.cs.tu-bs.de>
Sender: neitzel@ips.cs.tu-bs.de (Martin Neitzel)
Organization: Inst. f. Informatik, TU Braunschweig, FRG
References: <WEG.93Jan19140548@mace.cc.purdue.edu> <1502@kepler1.rentec.com>
 <WEG.93Jan26115205@mace.cc.purdue.edu>
Date: Fri, 29 Jan 1993 13:36:01 GMT
Lines: 22


> We read and write but do not pipe.  Is this an instance of
> J's insulation?

Yes.  Also the fact that the host execution verbs (0!:0 and 0!:1)
require that unix commands return exit state 0.  That is, you can't
invoke programs like "mail -e" which uses the exit state to indicate
the presence of mail and similar programs.  (The whole point of exit
codes is to support a functional style of program interconnection but
the J implementation prefers to ignore that.)

It's sad to see efforts wasted on things like built-in graphics
featurisms instead of much simpler and more general capabilities
like cooperation with external processes.  Looks like another instance
of the all-in-one approach.

I am very happy that ISI has made the source available.

                                                Martin Neitzel

[Hey, at least they *did* think along the right lines once.  Remember
the "gnuplot" example, eg. from "Programming in J", Chapter 1, "Host
facilities"?]

===> Start of article 9

Newsgroups: comp.lang.apl
Path:
 csd.unb.ca!news.ucs.mun.ca!nstn.ns.ca!newsflash.concordia.ca!utcsri!rpi!zaphod.
 mps.ohio-state.edu!howland.reston.ans.net!spool.mu.edu!yale.edu!ira.uka.de!Siri
 us.dfn.de!olymp!sfb256!volker
From: volker@sfb256.iam.uni-bonn.de ( Volker A. Brandt )
Subject: Re: Interpreter advice sought.
Message-ID: <1993Jan29.123607.10111@olymp.informatik.uni-bonn.de>
Sender: usenet@olymp.informatik.uni-bonn.de
Organization: Applied Math, University of Bonn, Germany
References: <1993Jan21.160604.7887@lth.se>
Date: Fri, 29 Jan 1993 12:36:07 GMT
Lines: 16


In article <1993Jan21.160604.7887@lth.se> kurt@dna.lth.se (Kurt Swanson) writes:
>Is there any "free" apl *interpreter* available for UNIX and/or MAC's???

For Unix, not that I know of.  I'm still dreaming of a GNU APL2 package.  It
cannot be that hard, but I have never written any interpreter.  I'm sure a
couple of knowledgeable people using gcc or even g++ could do it.  I'm willing
to help but have never found anyone who'd take the lead.

Free Unixes, free X Window implementations, free APL2 fonts, they're all there.

-- Volker
--
----------------------------------------------------------------------------
Bitnet:   UNM409@DBNRHRZ1                              Volker A. Brandt
UUCP:     ...!unido!DBNRHRZ1.bitnet!unm409             Angewandte Mathematik
Internet: volker@sfb256.iam.uni-bonn.de                (Bonn, Germany)

===> Start of article 10

Newsgroups: comp.lang.apl
Path:
 csd.unb.ca!news.ucs.mun.ca!nstn.ns.ca!newsflash.concordia.ca!utcsri!rpi!zaphod.
 mps.ohio-state.edu!sol.ctr.columbia.edu!The-Star.honeywell.com!umn.edu!csus.edu
 !sfsuvax1.sfsu.edu!emclean
From: emclean@sfsuvax1.sfsu.edu (Emmett McLean)
Subject: Re: Selective assignment (was Re: J is NOT APL)
Message-ID: <1993Jan29.233943.5662@csus.edu>
Sender: news@csus.edu
Organization: San Francisco State University
References: <1993Jan26.184600.24394@csi.jpl.nasa.gov>
 <1993Jan27.094037.13820@csus.edu> <1993Jan27.221845.11152@csi.jpl.nasa.gov>
Date: Fri, 29 Jan 1993 23:39:43 GMT
Lines: 122


 >
 >   Whew! I'll have to look this over. I use a much simpler indexing
 >   function (that seems to use the same heart as yours):
 >
 >   index=. ($@])#.[
 >
 >   that can be used with amendd for copy-with-selective-reassignment:
 >
 Lets look at two real cases :

   x0 =. 100
   i0 =. 0 2
   y0 =. i. 3 3
 So :
   x0 (i0 index y0) } y0
0 1 100
3 4   5
6 7   8
   x0 (i0&index@]) } y0
0 1 100
3 4   5
6 7   8

    And :

   x0 =. 100
   i1 =. 0 6
   y0 =. i. 3 3

   i1 =. 0 6
   x0 (i1 index y0) } y0
  0 1 2
  3 4 5
100 7 8
   x0 (i1&index@]) } y0
  0 1 2
  3 4 5
100 7 8

   For the example x0, i0, and y0 your method works nicely. Unfort-
   unately, for the example of x0, i1, and y0 it also works nicely!
   The index value (0 6) usually would mean that one wanted to amend
   the 0th row and 6st column of a table. But y0 is 3 by 3. By
   using selectiveAssign one can watch out for unusual indexing.
   Also using selectiveAssign may help one avoid instances
   where one believes a verb works properly (which it will for most
   values of the index) when really it doesn't.

   0!:3 <'A.js'

   y0 selectiveAssign i1;x0
index error (selectiveAssign)

   See.

>   so I don't have to link the index (i in the above) and the array (y),
>   as you do. For example

   The linking only occurs once and no variables are assigned as boxed.
   So  the additional computer time is marginal.  I estimate it about
   about 0.01 secs for a 1000 by 1000 table.

   a =. i. 3 3
   b =. 0 ; 10
   a selectiveAssign b
10 1 2
 3 4 5
 6 7 8

>   becomes
>   b; (>1{b) ((>0{b)&index@]) } a
+------+------+
|+-+--+|10 1 2|
||0|10|| 3 4 5|
|+-+--+| 6 7 8|
+------+------+
    I thought you said your method was easier -:)

>   etc. It also works on more than one position:
>   i=. 3 2$ 2 1  0 2  3 3
>   (-1 2 3) (i&index@]) }a

   I think you mean:  i =. 3 2 $ 2 1 0 2 2 2

   So does selectiveAssign.

   a selectiveAssign i ; -1 2 3


   As an aside, selectiveAssign also provides for nice 3D indexing
   allowing the programmer to make efficient use of the rank operator.

   For example :
   (y0,:y0) selectiveAssign"(2 1) 2 2 $ (0 0 ; 100 ; 2 2 ; 200)
100 1   2
  3 4   5
  6 7   8

  0 1   2
  3 4   5
  6 7 200

   Your method also allows 3D indexing, but again, the potential
   for incorrect indexing is just compounded .

>   I'd really like to build something that I could use without amend:
>   x i thing a
>   but haven't found a way to do this. Does amend then violate the
>   gander principle?

   Gees. Isn't
   (x;i) selectiveAssign~ a
   close enough? -:)

   selectiveAssign could easily be made part of the verb I've been
   working on (I've posted a preliminary version) for general assignment
   into a noun.  Thus one verb could handle row assignment, column
   assignment, and selective assignment.

   Regards,

   Emmett

===> End of articles for Fri Jan 29 23:59:05 AST 1993
