Here is another approach to simplifying J and meeting dyadic J goals without
verb definitions:
M =: @]
3 4 (+:M~ + -:M) 2 4
7 10
(+: M~ + -: M) 2 4
5 10
~ (swap) basically works like @[ on a monad that is defined to ignore x rather
than return error.
M or M~ is easier to type than @:] or @:[ too.
T =: &{(>@)
NB. double adverb version of @:
at =: 1 : 'u 1 :''2 : ''''u (v@:) '''' u'''
3 2 (1 T M~ + 0 1 T M +: at) 2 3 4
6 8
----- Original Message -----
From: Jose Mario Quintana <jose.mario.quint...@gmail.com>
To: Programming forum <programm...@jsoftware.com>
Sent: Thursday, December 3, 2015 11:04 AM
Subject: Re: [Jprogramming] dyadic J
Pascal wrote:
"There is a addon called general/primitives that provides shadow names for
everything."
However, trying to provide a shadow name for $: is futile.
Pascal wrote:
'A recent point of conversion of mine is that u@:v is both easier to read
and edit/expand and easier to see subresults by cutting out parts of an @
train "s@t@u@v" even if its u@:(v) compared to [: u v.'
Welcome to a very exclusive club ;)
Linda wrote:
"
Pascal and others. I am curious to know if you find tacit code easy to read.
cr=:([ = [: +/ [: |: #~ #: [: i. ^) #"2 #~ #: [: i. ^
divy=:([: ,. [: <"1 '*' $~ ] ,~ [: <. %) , [: < '*' $~ [ - ] * [: <. %
Those two tacit lines seem hard to translate for me. Instead I find the
expressions below are quite easy to follow.
cr=: 13 :'(x= +/ |:(y#x)#:i.x^y) #"2 (y#x)#:i.x^y'
divy=: 13 :'(,.<"1((<.x%y),y)$''*''),<(x-y*<.x%y)$''*'''
"
I submit that it is a matter of familiarity. Granted, forum members are
likely more familiar with explicit rather than tacit reading and writing
(then again, most programmers are more familiar with one element at a time
as opposed to array processing).
Personally, armed with the boxed representation of a verb, I can typically
see effortlessly how the data flows given a tacit verb and its
argument(s). This does not surprise me since the interpreter’s
representation of a verb is closely related to the boxed representation (if
I recall correctly).
Moreover, tacit forms facilitate the manual, or automatic, symbolic
manipulation and simplification of tacit forms. For example,
cr=:([ = [: +/ [: |: #~ #: [: i. ^) #"2 #~ #: [: i. ^
cr
([ = [: +/ [: |: #~ #: [: i. ^) #"2 #~ #: [: i. ^
┌─────────────────────────────────────────────┬───────┬────────────────────┐
│┌─┬─┬───────────────────────────────────────┐│┌─┬─┬─┐│┌─────┬──┬─────────┐│
││[│=│┌──┬─────┬────────────────────────────┐│││#│"│2│││┌─┬─┐│#:│┌──┬──┬─┐││
││ │ ││[:│┌─┬─┐│┌──┬──┬────────────────────┐│││└─┴─┴─┘│││#│~││ ││[:│i.│^│││
││ │ ││ ││+│/│││[:│|:│┌─────┬──┬─────────┐││││ ││└─┴─┘│ │└──┴──┴─┘││
││ │ ││ │└─┴─┘││ │ ││┌─┬─┐│#:│┌──┬──┬─┐│││││ │└─────┴──┴─────────┘│
││ │ ││ │ ││ │ │││#│~││ ││[:│i.│^││││││ │ │
││ │ ││ │ ││ │ ││└─┴─┘│ │└──┴──┴─┘│││││ │ │
││ │ ││ │ ││ │ │└─────┴──┴─────────┘││││ │ │
││ │ ││ │ │└──┴──┴────────────────────┘│││ │ │
││ │ │└──┴─────┴────────────────────────────┘││ │ │
│└─┴─┴───────────────────────────────────────┘│ │ │
└─────────────────────────────────────────────┴───────┴────────────────────┘
NB. Regardless of the nature of the arguments...
NB. Automatically,
cr f. decap ala NB. Wicked Jx adverbs for decapitating and associating
@:s to the left
([ = +/@:|:@:(#~ #: i.@:^)) #"2 #~ #: i.@:^
┌─────────────────────────────────────────────┬───────┬────────────────────┐
│┌─┬─┬───────────────────────────────────────┐│┌─┬─┬─┐│┌─────┬──┬─────────┐│
││[│=│┌─────────────┬──┬────────────────────┐│││#│"│2│││┌─┬─┐│#:│┌──┬──┬─┐││
││ │ ││┌─────┬──┬──┐│@:│┌─────┬──┬─────────┐│││└─┴─┴─┘│││#│~││ ││i.│@:│^│││
││ │ │││┌─┬─┐│@:│|:││ ││┌─┬─┐│#:│┌──┬──┬─┐││││ ││└─┴─┘│ │└──┴──┴─┘││
││ │ ││││+│/││ │ ││ │││#│~││ ││i.│@:│^│││││ │└─────┴──┴─────────┘│
││ │ │││└─┴─┘│ │ ││ ││└─┴─┘│ │└──┴──┴─┘││││ │ │
││ │ ││└─────┴──┴──┘│ │└─────┴──┴─────────┘│││ │ │
││ │ │└─────────────┴──┴────────────────────┘││ │ │
│└─┴─┴───────────────────────────────────────┘│ │ │
└─────────────────────────────────────────────┴───────┴────────────────────┘
NB. Manually,
[ (([ = +/@:|:@:]) #"2 ]) #~ #: i.@:^ NB. Distributing (#~ #: i.@:^)
[ (([ = +/@:|:@:]) #"2 ]) #~ #: i.@:^
┌─┬──────────────────────────────────────┬────────────────────┐
│[│┌──────────────────────────┬───────┬─┐│┌─────┬──┬─────────┐│
│ ││┌─┬─┬────────────────────┐│┌─┬─┬─┐│]│││┌─┬─┐│#:│┌──┬──┬─┐││
│ │││[│=│┌─────────────┬──┬─┐│││#│"│2││ ││││#│~││ ││i.│@:│^│││
│ │││ │ ││┌─────┬──┬──┐│@:│]│││└─┴─┴─┘│ │││└─┴─┘│ │└──┴──┴─┘││
│ │││ │ │││┌─┬─┐│@:│|:││ │ │││ │ ││└─────┴──┴─────────┘│
│ │││ │ ││││+│/││ │ ││ │ │││ │ ││ │
│ │││ │ │││└─┴─┘│ │ ││ │ │││ │ ││ │
│ │││ │ ││└─────┴──┴──┘│ │ │││ │ ││ │
│ │││ │ │└─────────────┴──┴─┘││ │ ││ │
│ ││└─┴─┴────────────────────┘│ │ ││ │
│ │└──────────────────────────┴───────┴─┘│ │
└─┴──────────────────────────────────────┴────────────────────┘
[ (( = +/@:|: ) #"2 ]) #~ #: i.@:^ NB. Hook form
[ ((= +/@:|:) #"2 ]) #~ #: i.@:^
┌─┬─────────────────────────────┬────────────────────┐
│[│┌─────────────────┬───────┬─┐│┌─────┬──┬─────────┐│
│ ││┌─┬─────────────┐│┌─┬─┬─┐│]│││┌─┬─┐│#:│┌──┬──┬─┐││
│ │││=│┌─────┬──┬──┐│││#│"│2││ ││││#│~││ ││i.│@:│^│││
│ │││ ││┌─┬─┐│@:│|:│││└─┴─┴─┘│ │││└─┴─┘│ │└──┴──┴─┘││
│ │││ │││+│/││ │ │││ │ ││└─────┴──┴─────────┘│
│ │││ ││└─┴─┘│ │ │││ │ ││ │
│ │││ │└─────┴──┴──┘││ │ ││ │
│ ││└─┴─────────────┘│ │ ││ │
│ │└─────────────────┴───────┴─┘│ │
└─┴─────────────────────────────┴────────────────────┘
NB. Given the nature of the arguments...
[ (( = +/@:|: ) # ]) #~ #: i.@:^ NB. Redundant "2
[ ((= +/@:|:) # ]) #~ #: i.@:^
┌─┬───────────────────────┬────────────────────┐
│[│┌─────────────────┬─┬─┐│┌─────┬──┬─────────┐│
│ ││┌─┬─────────────┐│#│]│││┌─┬─┐│#:│┌──┬──┬─┐││
│ │││=│┌─────┬──┬──┐││ │ ││││#│~││ ││i.│@:│^│││
│ │││ ││┌─┬─┐│@:│|:│││ │ │││└─┴─┘│ │└──┴──┴─┘││
│ │││ │││+│/││ │ │││ │ ││└─────┴──┴─────────┘│
│ │││ ││└─┴─┘│ │ │││ │ ││ │
│ │││ │└─────┴──┴──┘││ │ ││ │
│ ││└─┴─────────────┘│ │ ││ │
│ │└─────────────────┴─┴─┘│ │
└─┴───────────────────────┴────────────────────┘
[ (( = +/"1 ) # ]) #~ #: i.@:^ NB. Summing the rows of a matrix
[ ((= +/"1) # ]) #~ #: i.@:^
┌─┬─────────────────────┬────────────────────┐
│[│┌───────────────┬─┬─┐│┌─────┬──┬─────────┐│
│ ││┌─┬───────────┐│#│]│││┌─┬─┐│#:│┌──┬──┬─┐││
│ │││=│┌─────┬─┬─┐││ │ ││││#│~││ ││i.│@:│^│││
│ │││ ││┌─┬─┐│"│1│││ │ │││└─┴─┘│ │└──┴──┴─┘││
│ │││ │││+│/││ │ │││ │ ││└─────┴──┴─────────┘│
│ │││ ││└─┴─┘│ │ │││ │ ││ │
│ │││ │└─────┴─┴─┘││ │ ││ │
│ ││└─┴───────────┘│ │ ││ │
│ │└───────────────┴─┴─┘│ │
└─┴─────────────────────┴────────────────────┘
This latter form is the capless counterpart of the version provided by
Lippu Esa.
On Sat, Nov 28, 2015 at 2:27 AM, Linda A Alvord <lindaalv...@verizon.net>
wrote:
> Pascal and others. I am curious to know if you find tacit code easy to
> read.
>
> cr=:([ = [: +/ [: |: #~ #: [: i. ^) #"2 #~ #: [: i. ^
> divy=:([: ,. [: <"1 '*' $~ ] ,~ [: <. %) , [: < '*' $~ [ - ] * [: <. %
>
> Those two tacit lines seem hard to translate for me. Instead I find the
> expressions below are quite easy to follow.
>
> cr=: 13 :'(x= +/ |:(y#x)#:i.x^y) #"2 (y#x)#:i.x^y'
> divy=: 13 :'(,.<"1((<.x%y),y)$''*''),<(x-y*<.x%y)$''*'''
>
> In most cases, with examples there is little documentation that is
> necessary.
>
> 2 cr 5
> 0 0 0 1 1
> 0 0 1 0 1
> 0 0 1 1 0
> 0 1 0 0 1
> 0 1 0 1 0
> 0 1 1 0 0
> 1 0 0 0 1
> 1 0 0 1 0
> 1 0 1 0 0
> 1 1 0 0 0
> 18 divy 5
> ------┐
> │*****│
> +-----+
> │*****│
> +-----+
> │*****│
> +-----+
> │*** │
> L------
> Maybe it is just that the explicit code looks like mathematics. It might be
> interesting and useful to hear how programmers and J users read code most
> easily.
>
> Linda
> -----Original Message-----
> From: programming-boun...@forums.jsoftware.com
> [mailto:programming-boun...@forums.jsoftware.com] On Behalf Of Don Kelly
> Sent: Friday, November 27, 2015 10:37 PM
> To: programm...@jsoftware.com
> Subject: Re: [Jprogramming] dyadic J
>
> there is nothing wrong with saying something like plus =: + conjugate =:+
> and knowing that plus is intended to be monadic (although +(real
> number) is the real number in either case. If you want one to work as
> monadic onlyand the other as dyadic only-then you have to dress them up a
> bit with some test and error message.
> you can do mean=: sum divideby count in any language.
> J has 2 meanings for + -which are dependent on the context. English also
> is
> like that in that some words have two unrelated meanings (e.g bow , can,
> twig, butt ) as well as having some with related meanings (e.g rise, level)
> and a lot of other things that depend on context It would be possible to
> build up a long list of names so that all uses of the primitives have
> different names and do just what the names indicate but is that of any more
> than limited use?
>
>
>
> On 11/27/2015 1:08 PM, 'Pascal Jasmin' via Programming wrote:
> > Are you saying that if I define
> >
> > floor =: (<. : (<.@]))"0 _ 0
> >
> > that it does not have integrated rank support?
> >
> > The criticism about english and documentation seems hollow to me. I
> don't
> say that Nuvoc is useless because it hasn't been implemented in 150
> languages. An ability to read the dictionary in English is essential to
> learn J, and code typically uses english shaddows from profile.ijs. Making
> foreign language cover verbs including autotranslating the english ones is
> straightforward, and answers that part of the criticism. Using the exact
> names from the dictionary (what I'm refering to as autodocumentation
> because
> the exact same place you would look up i. is where iota will be explained.)
> seems like an elegant way to ease a shallow learning curve on the process.
> >
> > The entire criticism could be applied to "you should never assign a verb
> to any name"
> >
> >
> >
> >
> > ----- Original Message -----
> > From: Raul Miller <rauldmil...@gmail.com>
> > To: Programming forum <programm...@jsoftware.com>
> > Sent: Friday, November 27, 2015 3:27 PM
> > Subject: Re: [Jprogramming] dyadic J
> >
> > On Thu, Nov 26, 2015 at 4:12 PM, 'Pascal Jasmin' via Programming
> > <programm...@jsoftware.com> wrote:
> >> The only disadvantage I recognize is the point about special code.
> > It would be interesting to go over the reasons you do not recognize
> > the other disadvantages.
> >
> >> As to your other points, because the primitives are tacit, I believe
> there is integrated rank support.
> >>
> >> floor b. 0
> >> 0 _ _
> > You might want to read
> > http://www.jsoftware.com/pipermail/general/1998-October/000041.html
> >
> > All verbs have rank support, even verbs which contain explicit
> > definitions. However, for some combinations of primitives, the
> > interpreter takes special steps - bypassing the default implementation
> > of rank support with something more efficient.
> >
> >> English is needed to read dictionary, and all of the primitives are the
> monad dictionary entries, so everything is autodocumented.
> > In my experience, documentation is difficult and autodocumentation
> > quickly falls victim to entropy. It sounds great, but most examples I
> > have seen become incredibly useless in practice. It's possible to work
> > around this with manual effort, but the effort involved often seems to
> > be greater than the effort of simply doing it manually in the first
> > place. Where automation shines is replicating the useful manual
> > efforts.
> >
> >> The advantage bigger than the one you mentioned is better seeing the
> intent of code.
> > Agreed.
> >
> > Thanks,
> >
>
> ----------------------------------------------------------------------
> For information about J forums see http://www.jsoftware.com/forums.htm
>
> ----------------------------------------------------------------------
> For information about J forums see http://www.jsoftware.com/forums.htm
>
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
