f=:2 2 $*:,%:,+:,^ f 4 16 2 8 54.5982 Linda -----Original Message----- From: [email protected] [mailto:[email protected]] On Behalf Of Jon Hough Sent: Sunday, April 19, 2015 10:16 AM To: [email protected] Subject: Re: [Jprogramming] Evaluating a Gerund Array
Raul, Thanks for replying. Yes, you are correct about the first issue. Your verb solved the issue. I apologize for misunderstanding / misusing your previous advice. I am still reading through your answer to my second point. Thanks,Jon > From: [email protected] > Date: Sun, 19 Apr 2015 09:56:16 -0400 > To: [email protected] > Subject: Re: [Jprogramming] Evaluating a Gerund Array > > On Sun, Apr 19, 2015 at 4:13 AM, Jon Hough <[email protected]> wrote: > > I am still unsure about a few things, hopefully someone can clear > > these > up. > > 1. If I have my nxn gerund array and I want to evaluate it on a list > > of n > items, > > such that the first row takes the first item, the second row takes > > the > second > > item etc. > > e.g. (*:`%: ,. +:`^) VRB 1 2 > > I guess I am mildly dismayed that the following was not obvious: > > VRB=: 4 :'x`:6 y'"0 > (*:`%: ,. +:`^) VRB 1 2 > 1 2 > 1.41421 7.38906 > > The behavior you describe ("I want to evaluate it on a list of n > items, such that the first row takes the first item, the second row > takes the second item etc.") is exactly the behavior of a rank zero > verb (given those argument ranks). > > I do understand that learning, education, and humans in general need > repetition of ideas to get them to stick, but I also am getting the > idea that I am not very good at conveying concepts. And I do not know > what to do about that. > > I guess I should keep trying. > > > 2. This problem is a little bit more abstract. > > If I have a list of gerunds (1D this time), and I want to modify > > each > verb in the gerund in some way, and then return the sum of the verbs, > I am not sure how to do this. > > For example, if G =: *:`+:`^ and list =. 3 4 5 I want an adverb or > > conjunction that returns a verb of the form (3&*@:*:) > + (4&*@:+:) + (5&*@:^) > > For this, first you need to figure out how to deal with one item on > each side. That's relatively simple - since there is no repetition > involved you can use a conjunction: > > *:2 :'n&*u'3 > 3&* *: > > Once you have that, you need to figure out how to combine them. The > natural way of combining them would involve a verb (since repetition is involved). > But, in the absence of taking advantage of a quirk which can be found > using a forum search on the phrase: absolute power corrupt (except put > an 's' on the end of the word 'corrupt' - I am leaving that off here > so this message will not show up for that search), the result of a verb is a noun. > > So... we need to understand what the gerund form of your result looks > like (and then we can plan on using `:6 on that noun, to turn it into a verb). > > So that means inspecting > ((3&*@:*:) + (4&*@:+:) + (5&*@:^))`'' > > But that result is a bit too large for an email message (long lines > get mangled), so let's look at a simpler but similar verb here, and > focus on its high level structure: > > (1:+2:+3:)`'' > +------------------------+ > |+-+--------------------+| > ||3|+--+-+-------------+|| > || ||1:|+|+-+---------+||| > || || | ||3|+--+-+--+|||| > || || | || ||2:|+|3:||||| > || || | || |+--+-+--+|||| > || || | |+-+---------+||| > || |+--+-+-------------+|| > |+-+--------------------+| > +------------------------+ > > Or if that gets mangled by your email reader's font handling (you > should be reading this with a fixed width font), go evaluate either of > the above expressions for yourself. > > But you should be able to see a pattern there - let's take an even > simpler > case: > > (1:+2:)`'' > +-------------+ > |+-+---------+| > ||3|+--+-+--+|| > || ||1:|+|2:||| > || |+--+-+--+|| > |+-+---------+| > +-------------+ > > Now we just need to figure out the types and the shapes of each of > these things and we can build the result "manually": > > Here's the shapes: > > $L:0 (1:+2:)`'' > +-----------+ > |+-+-------+| > ||1|+-+-+-+|| > || ||2|1|2||| > || |+-+-+-+|| > |+-+-------+| > +-----------+ > $L:1 (1:+2:)`'' > +-----+ > |+-+-+| > ||1|3|| > |+-+-+| > +-----+ > $L:2 (1:+2:)`'' > +-+ > |2| > +-+ > $ (1:+2:)`'' > 1 > > As for the types, except at the level 0 "leaves", all of the types > here are boxed. So what are the leaves ? > > (1 {. 0 # ])L:0 (1:+2:)`'' > +-----------+ > |+-+-------+| > || |+-+-+-+|| > || || | | ||| > || |+-+-+-+|| > |+-+-------+| > +-----------+ > > All leaves in this example have the space character for fill, so all > leaves are characters. Though of course two of those leaves will be > externally supplied gerunds. But do we really need the one element lists to be lists? > It would be so much easier if we could just use rank 0 nouns there. A > little experiment suggests that that simplification would be fine: > > (<'3';<'1:';'+';'2:')`:6 > 1: + 2: > (<'3';<'1:';'+';'2:')`:6'' > 3 > > So, we want a verb like that, but replacing '1:' with x and replacing '2:' > with y > > (Is anyone even reading at this point? Or is this kind of description > too boring? I suppose that you have to perform some experiments or the > ideas will not actually make sense - even though they might look like > they make > sense...) > > So here's the verb: > 4 :'<''3'';<x;''+'';y' > > No, that's not actually right. Because x and y are going to already be > boxed - so we don't want to box them again. But that's a simple fix: > 4 :'<''3'';<x,''+'';y' > > But those doubled quotes are annoying, so let's make this tacit instead: > '3' <@; [ <@, '+' ; ] > > And here, I'd like to pause for a moment and call out a similarity > between this tacit verb and explicit verb definitions. If you squint, > you can sort of see the similarity. The notation is, of course, > different, but the similarity is an intentional part of the design of the language. > > So we are going to want to use something like ('3' <@; [ <@, '+' ; ])/ ... > where ... is the result of our earlier conjunction (2 :'n&*u') on each > of elements from x and y of the verb which ... ahh ... that's getting > too hard to describe. Here's what we are going to reduce: > > *:`+:`^ 4 :'{.((x`:6) 2 :''n&*u''y)`'''''"0 (3 4 5) > > That just kind of rolls off the tongue, doesn't it? > > Er... actually, it's probably an unreadable mess, since you didn't > write it yourself. So let's break it apart and give things names: > > term=: '3' <@; [ <@, '+' ; ] > Factor=: 2 :'n&*u' > Ing=: `'' > Er=: `:6 > factoring=:4 :'{. (x Er Factor y)Ing' > G =: *:`+:`^ > list =. 3 4 5 > > You should recognize the last two names, from earlier... > > The name 'Ing' is because in english we form gerunds by using the > suffix -ing on a verb. Similarly, the name 'Er' is because I needed a > word that conveyed action, and the suffix -er is used in english to > indicate one who does something. Not ideal, but maybe a little evocative? > > Likewise, 'Factor' is because I needed a name and I decided that the > multiplication involved was the important thing. (By the way, you'll > probably not actually be wanting that expression - you'll probably > really be wanting to eliminate the & from that definition.) Same thing for 'term' > - I'm sort of borrowing from the mathematical vocabulary sometimes > used to describe polynomial-like algebraic equations. > > Anyways, with this out of the way, the expression you said you wanted > looks like this: > > (term/G factoring"0 list)`:6 > (3&* *:) + (4&* +:) + (5&* ^) > > Simple, no? > > Well, when you consider that writing this kind of program in another > language would take considerable thought and/or a lot of code, it > actually is rather simple. But it's not entirely trivial, either. > Also, note that the parenthesized expressions are hooks, and that's > probably not going to do what you want. What you really want is probably more like: > > Factor=: 2 :'n*u' > (term/G factoring"0 list)`:6 > (3 * *:) + (4 * +:) + 5 * ^ > > So that might actually be a little scary - it suggests that you have > not been performing experiments on your sentences to ensure that they > do what you want. This is a problem I also often have - I think I know > what I am talking about but until I try it out and see how bad it > gets, I don't really understand. > > Still to get here I also imagine you would need to have spent some > time working with J's grammar rules (the Parsing and Execution > appendix in the dictionary and the j's trace facility are both good > resources - but you also need to pace yourself, so you can come back > to it on multiple different days). A formal computer science class on > parsing might also be useful background. > > Finally, I'll point out that I included a {. in the above lump of > code, without any explanation. Do you see why I did that? (There's no > error if it is omitted, so it's really a matter of personal taste. But > I imagine - perhaps incorrectly - that if you are performing > experiments to see what intermediate results are like that you'll see why I included it. > > Anyways, I hope this helps. > > And, even if this turns out to not be helpful, it was an entertaining > exercise for me. > > Thanks, > > -- > Raul > ---------------------------------------------------------------------- > 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
