fib2=: 13 :'0,%1+.(+%)/\y$1' fib2 9 0 1 1 2 3 5 8 13 21 34 fib2 0 , [: % 1 +. [: (+ %)/\ 1 $~ ]
This does not use $: Linda -----Original Message----- From: programming-boun...@forums.jsoftware.com [mailto:programming-boun...@forums.jsoftware.com] On Behalf Of Jose Mario Quintana Sent: Sunday, February 23, 2014 8:38 PM To: Programming forum Subject: [Jprogramming] Tacit recursion without $: Tacit recursion without $: Is there ever a case for tacit recursion without the use of the self-reference verb ($:)? One reason is if one wants to define and fix a tacit verb in terms of one or more tacit recursive verbs. The problem is that the official public version of J lacks the means to provide a direct scope for the recursion phrase containing the self-references. It is possible, but inefficient, to circumvent this problem by employing recursion without $:. This was the motivation for developing the recursion scope adverb (103!.0) extension [0,1]. Thus, this is no longer an issue when using a patched version of J. What about when writing mutually recursive anonymous verbs? One can even use $: to accomplish this using the recursion scope (103!.0). How? See, for example, hint/solution (a). A reasonably interesting test case is the implementation of the female and male sequences [7]. (See [1] to find where to get a suitable Windows J DDL version with recursion scope.) What about when writing recursive tacit adverbs since $: is only meant to self-refer verbs? The agenda form (@. N) where N is boxed is a fairly general, but often a cumbersome and only occasionally a convenient, scheme to write tacit adverbs. However, the (@. N) form is not necessary. An alternative way is via the adverb (Adv) in [2] that adverbializes a verb; see also the adverb (av) in [3] (or a similar adverb, for example, the permissive adverb (adv) defined in [1]). The generic defining sentence form is ((`'') (workhorse f.Adv) (`:6)) where workhorse is a tacit verb that takes the adverb's gerund as an argument and constructs the atomic representation of the desired word to be produced by the adverb (and any valid computable atomic representation can be produced, in principle, by a workhorse verb since tacit verbal programming is (Turing) complete). The burden of working with atomic representations can be mitigated by using heterodox wicked verbs that can take and produce any type of word (see, [1] and references there in) and the form is in this case simplified to (darkhorse f. Adv). There is one issue though, the agenda form (@. N) is used in the definition of the adverb (Adv)! However, the adverb (Adv) can be rewritten without using the agenda form. How? See, hint/solution (b). Thus, if a recursive method is well-advised, it could always be implemented in the definition of the workhorse, or the darkhorse, via $:. Therefore, there is never a case for recursion without the use of $: with just one type of exception (as far as I know). How come? The exception occurs when it is required because of syntactic reasons! What? Consider the following: One can write tacitly an adverb (Recursion) that reproduces the behavior of (`:4) described in [4]. (How? See hint/solution (c).) So that, fact=. *`1:`*`<: Recursion NB. Factorial fact 5 120 Fib=. >&1`(i.@>:)`(] , +/@(_2&{.)@])`<: Recursion NB. Fibonacci Fib 7 0 1 1 2 3 5 8 13 One can even produce an adverb (Recur) that that takes the arguments (Proposition, Basis, Combine, and Reduce) as a strand; this is a form pioneered by Dan (see, for example, [5,6]), fact=. * 1: * <: Recur NB. Factorial fact 5 120 Fib=. (>&1) (i.@>:) (] , +/@(_2&{.)@]) <: Recur NB. Fibonacci Fib 7 0 1 1 2 3 5 8 13 Furthermore, one can even write a fixed adverb (sna) that takes as a strand (of course!) the atomic representation of any adverb, which takes a gerund (in the form of an argument list), and (sna) also takes the tally (#) of that gerund and produces a corresponding (fixed) adverb, which takes the arguments as a strand. How? The subject of this message implies the answer: recursively (without $:)! For more details see the hint/solution (d). For instance, the adverb (Recur) was defined as, ar=. 5!:1@< Recur=. (ar'Recursion') 4 sna NB. Recur is fixed automatically (Incidentally, although Recursion and Recur can produce a wide variety of recursive verbs, more complex recursive verbs, such as the recursive definition of the Ackermann function, do not seem to fit the (Proposition, Basis, Combine, and Reduce) mold. Am I mistaken?) Is there any benefit for defining adverbs in strand form (apart from allowing one to write neat expressions)? I think so: these expressions are, or should be, right-associative and provide flexible means to refer to the argument of a derived adverb, the argument of the derived adverb of a derived adverb, and so on; thus, one can easily bond adverb arguments. For example, often the Reduce recursion part is decrement (<:), so one can easily write an adverb (rd) that would accommodate those cases, rd=. <: Recur NB. rd is fixed automatically fact=. * 1: * rd fact 5 120 Fib=. (>&1) (i.@>:) (] , +/@(_2&{.)@]) rd Fib 7 0 1 1 2 3 5 8 13 Sometimes the order of the arguments of the source adverb might not be convenient for bonding. For the typical adverbs taking a gerunds, it is quite easy to derive a target adverb with an arbitrary permutation of the arguments: just adverbialize a permutation verb first; for example, ((P&{ Adv) Recursion) where P is an arbitrary permutation. It is not as easy to permute the arguments of adverbs taking strands. Yet, one can write a generic adverb Permute to derive a target adverb, which takes a list of arguments as a gerund, from a permutation verb and the (atomic representation of the) source adverb, which takes its arguments as a strand. The derived verb can in turn be easily converted to take its arguments as a strand. For example, recur=. (3 2 1 0&{) (ar'Recur') Permute 4 sna <: * 1: * recur 5 120 <: (] , +/@(_2&{.)@]) (i.@>:) (>&1) recur 7 0 1 1 2 3 5 8 13 recur=. |. (ar'Recur') Permute 4 sna <: * 1: * recur 5 120 <: (] , +/@(_2&{.)@]) (i.@>:) (>&1) recur 7 0 1 1 2 3 5 8 13 * 1: * <: Recur 5 120 * 1: * <: |.(ar'recur') Permute 4 sna 5 120 (>&1) (i.@>:) (] , +/@(_2&{.)@]) <: Recur 7 0 1 1 2 3 5 8 13 (>&1) (i.@>:) (] , +/@(_2&{.)@]) <: |.(ar'recur') Permute 4 sna 7 0 1 1 2 3 5 8 13 How can one write Permute? See hint/solution (e). [0] J functional programming extensions http://www.jsoftware.com/pipermail/programming/2013-March/031835.html [1] J Functional Programming Extensions http://journalofj.com/index.php/vol-2-no-2-october-2013 [2] Recursion http://www.jsoftware.com/pipermail/programming/2013-November/034177.html [3] Tacit adverbial programming patterns http://www.jsoftware.com/pipermail/programming/2013-February/031673.html [4] Gerunds and Representations http://www.snakeisland.com/gerunds.htm [5] How to make this conjunction tacit http://www.jsoftware.com/pipermail/programming/2013-October/033639.html [6] How to make this conjunction tacit http://www.jsoftware.com/pipermail/programming/2013-October/033654.html [7] Hofstadter's female and male sequences http://en.wikipedia.org/wiki/Hofstadter_sequence#Hofstadter_Female_and_Male_sequences The hints/solutions follow after the countdown: ,. @: |. @: i. 43 42 41 40 39 38 37 36 35 34 33 32 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 NB. The following were referred as hints/solutions. They are solutions written using a NB. permissive extended version of J described in [1]; but, there are also hints because the NB. ideas could be applied to write solutions using an official version of J. Verbalized NB. primitive adverbs and conjunctions can be produced using an alternative definition for NB. Cloak (]:): Cloak=. (<(<,'4'),<(<(<,'4'),<;:'0:`'),<(<,'4'),<;:',^:') (0:`)(,^:). In NB. addition, tacit adverbs can replace derived tacit conjunctions which are not possible to NB. produce using the official version. Orthodox tacit solutions are, in principle, also NB. possible (with the virtual exception of (a)), but probably hard to write. As its name NB. implies, the orthodox solution to question (b) does not require any extensions. NB. NB. Moreover, for the law abiding explicit writers (if there are any still reading this far) NB. I do not see any reason why anonymous solutions could not be written explicitly; then NB. again, I do not write explicitly, what do I know? NB. The hints/solutions are presented slightly out of order ((a), (b), (d), (c) and (d)). NB. General preliminary pro-words... (ar=. 5!:1@<) (st=.7!:2@:] ; 6!:2) NB. Verbs 5!:1@< (7!:2@:] ; 6!:2) (o=. @:) NB. Conjunction @: (x=. o[) (y=. o]) (g=. "_1) (e=. &.>) (c=. "_) (f=. &{::) NB. Adverbs (((((o[)(o]))("_1))(&.>))("_))(&({::)) NB. (a) Mutual recursion.................................................................... pre=. o <: zip=. @.(0 = ]) NB. Odd/Even (first a classic simple example) NB. see http://en.wikipedia.org/wiki/Mutual_recursion NB. Using pro-verbs Even=. ( Odd pre)`1: zip Odd =. (Even pre)`0: zip (Even g ,: Odd g) o i. 11 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 NB. Anonymously using $: and recursion scope (103!:0) NB. The idea is to write the recursive verbs as agenda cases of a single encompassing NB. recursive verb. Even=. 0&oe Odd =. 1&oe ( oe=. ( ( Odd pre y)`1: zip)`((Even pre y)`0: zip) @. [ ) Odd@:<:@:]`1:@.(0 = ])`(Even@:<:@:]`0:@.(0 = ]))@.[ ( oe=. oe f. ) NB. Unfortunately, 1&oe@:<:@:]`1:@.(0 = ])`(0&oe@:<:@:]`0:@.(0 = ]))@.[ NB. Fixing oe manually, ( oe=. ( ( (1&$:) pre y)`1: zip)`(((0&$:) pre y)`0: zip) @. [ ) 1&$:@:<:@:]`1:@.(0 = ])`(0&$:@:<:@:]`0:@.(0 = ]))@.[ Even f. 0&(1&$:@:<:@:]`1:@.(0 = ])`(0&$:@:<:@:]`0:@.(0 = ]))@.[ (103!:0)) Odd f. 1&(1&$:@:<:@:]`1:@.(0 = ])`(0&$:@:<:@:]`0:@.(0 = ]))@.[ (103!:0)) (Even f.g ,: Odd f.g) o i. 11 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 NB. Female/Male sequences NB. http://en.wikipedia.org/wiki/Hofstadter_sequence#Hofstadter_Female_and_Male_sequences NB. Using pro-verbs female=. (] - male o (female pre))`1: zip M. male=. (] - female o (male pre))`0: zip M. (female f.g ,: male f.g) o i. 22 1 1 2 2 3 3 4 5 5 6 6 7 8 8 9 9 10 11 11 12 13 13 0 0 1 2 2 3 4 4 5 6 6 7 7 8 9 9 10 11 11 12 12 13 st'(female g ,: male g) o i. 222' ┌─────┬─────────┐ │19136│0.0159093│ └─────┴─────────┘ NB. Anonymously using $: and recursion scope (103!:0) NB. Again, the idea is to define the recursive verbs as agenda cases of a single NB. encompassing recursive verb. female=. 0&fm male=. 1&fm fm=. ((] - male o (female pre y))`1: zip)`((] - female o (male pre y))`0: zip) @. [ M. fm f. NB. Unfortunately, (] - 1&fm@:(0&fm@:<:@:]))`1:@.(0 = ])`((] - 0&fm@:(1&fm@:<:@:]))`0:@.(0 = ]))@.[M. NB. Fixing fm manually, fm=. ((] - (1&$:) o ((0&$:) pre y))`1: zip)`((] - (0&$:) o ((1&$:) pre y))`0: zip) @. [ M. male f. 1&((] - 1&$:@:(0&$:@:<:@:]))`1:@.(0 = ])`((] - 0&$:@:(1&$:@:<:@:]))`0:@.(0 = ]))@.[M. (103!:0)) female f. 0&((] - 1&$:@:(0&$:@:<:@:]))`1:@.(0 = ])`((] - 0&$:@:(1&$:@:<:@:]))`0:@.(0 = ]))@.[M. (103!:0)) (female f.g ,: male f.g) o i. 22 1 1 2 2 3 3 4 5 5 6 6 7 8 8 9 9 10 11 11 12 13 13 0 0 1 2 2 3 4 4 5 6 6 7 7 8 9 9 10 11 11 12 12 13 st'(female f.g ,: male f.g) o i. 222' ┌──────┬──────────┐ │155136│0.00219392│ └──────┴──────────┘ NB. There is a space-time tradeoff but the huge savings in space and time for NB. both versions come from the use of memoization (M.). NB. ........................................................................................ NB. Someone might think that in a permissive environment the rules for writing tacitly are NB. discarted. On the contrary, they are more relevant than ever and it is crucial to have NB. in mind one of my favorite generic rules, "Learn the rules so you know how to break them NB. properly." Why? Because the power emanating from the tacit rules of J is multiplied NB. when it is delivered at higher levels (where tacit rules were not supposed to operate). NB. General preliminary pro-words for programming wickedly... Cloak=. ]: NB. The monadic case is equivalent to, NB. Cloak=. (<(<,'4'),<(<(<,'4'),<;:'0:`'),<(<,'4'),<;:',^:') (0:`)(,^:) NB. Verbalizing all primitive adverbs and conjunctions (only a few are used in this session), ( (X=. 'power tilde dot even odd colon obverse adverse cut fit foreign slash slashdot back backdot trap brace rank tie knot evoke atop agenda at amper under dual appose') (;:x ,: ]) Y=. ;: '^: ~ . .. .: : :. :: ;. !. !: / /. \ \. ]. } " ` `. `: @ @. @: & &. &.: &:' ) ┌─────┬─────┬───┬────┬───┬─────┬───────┬───────┬───┬───┬───────┬─────┬────────┬────┬───────┬────┬─────┬────┬───┬────┬─────┬────┬──────┬──┬─────┬─────┬────┬──────┐ │power│tilde│dot│even│odd│colon│obverse│adverse│cut│fit│foreign│slash│slashdot│back│backdot│trap│brace│rank│tie│knot│evoke│atop│agenda│at│amper│under│dual│appose│ ├─────┼─────┼───┼────┼───┼─────┼───────┼───────┼───┼───┼───────┼─────┼────────┼────┼───────┼────┼─────┼────┼───┼────┼─────┼────┼──────┼──┼─────┼─────┼────┼──────┤ │^: │~ │. │.. │.: │: │:. │:: │;. │!. │!: │/ │/. │\ │\. │]. │} │" │` │`. │`: │@ │@. │@:│& │&. │&.: │&: │ └─────┴─────┴───┴────┴───┴─────┴───────┴───────┴───┴───┴───────┴─────┴────────┴────┴───────┴────┴─────┴────┴───┴────┴─────┴────┴──────┴──┴─────┴─────┴────┴──────┘ ( (X)=. ]: o < e Y ) NB. Verbalizing primitive adverbs and conjunctions ┌───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───... │(]:(<'^:'))│(]:(<,'~'))│(]:(<,'.'))│(]:(<'..'))│(]:(<'.:'))│(]:(<,':'))│(]:(<':.'))│(]:(<'::'))│(]:(<';.'))│(]:(<'!.'))│(]:(<'!:'))│(]:(<,'/'))│(]:(<'/.'))│(]:(<,'\'))│(]:(<'\.'))│(]:(<'].'))│(]:(<,'}'))│(]:(<,'"'))│(]:(<,'`'))│(]:(<'`.'))│(]:(<'`:'))│(]:... └───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───... ( (X=. 'bdot derivative Derivative secant fix hypergeometric LevelAt memo spread TaylorCoeff WeightedTaylor TaylorApprox') (;:x ,: ]) Y=. ;: 'b. d. D. D: f. H. L: M. S: t. t: T.' ) ┌────┬──────────┬──────────┬──────┬───┬──────────────┬───────┬────┬──────┬───────────┬──────────────┬────────────┐ │bdot│derivative│Derivative│secant│fix│hypergeometric│LevelAt│memo│spread│TaylorCoeff│WeightedTaylor│TaylorApprox│ ├────┼──────────┼──────────┼──────┼───┼──────────────┼───────┼────┼──────┼───────────┼──────────────┼────────────┤ │b. │d. │D. │D: │f. │H. │L: │M. │S: │t. │t: │T. │ └────┴──────────┴──────────┴──────┴───┴──────────────┴───────┴────┴──────┴───────────┴──────────────┴────────────┘ ( (X)=. ]: o < e Y ) NB. Verbalizing the rest of the primitive adverbs and conjunctions ┌───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┬───────────┐ │(]:(<'b.'))│(]:(<'d.'))│(]:(<'D.'))│(]:(<'D:'))│(]:(<'f.'))│(]:(<'H.'))│(]:(<'L:'))│(]:(<'M.'))│(]:(<'S:'))│(]:(<'t.'))│(]:(<'t:'))│(]:(<'T.'))│ └───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┴───────────┘ ( train=. evoke&6 ) NB. train evoke&6 NB. Preliminary wicked pro-words... box=. < o train g f. NB. Boxing verbs from gerund ( an=. <@:((":0) ,&< ]) ) NB. Atomizing a noun <@:((,'0') ,&< ]) ( ew=. adverb ]: (ar'an') ) NB. Encasing a word (adv) (1]:(<(<'@:'),<(<,'<'),<(<,'3'),<(<<;._1 ' 0 0'),(<(<,'&'),<;:',<'),<,']')) ( ew=. adverb ]: an (f.ew) ) (1]:(<(,'0');<@:((,'0') ,&< ]))) ( af=. an o fix f.) NB. Atomizing after fixing (an alternative to atomic representations) <@:((,'0') ,&< ])@:(]:(<'f.')) ( wl=. 104!:1 ) NB. Word from linear (similar to Dan's dont) 104!:1 NB. These (verbalized primitive adverbs and conjunctions) operate as brain surgeons, NB. borrowing Dan's analogy [8], on conscious patients (verbs and nouns). Neither there is NB. a need to knock the arguments out into atomic representations (via `'') nor to wake them NB. up via a culminating train (`:6). NB. (b) Adv without (@. N).................................................................. NB. An orthodox way... ( a0=. `'' ) ( a1=. (@:[) ((<'&')`) (`:6) ) ( a2=. (`(an _)) (`:6) ) ((`'')(((@:[)(&`))(`:6)))((`_)(`:6)) (('a0'f.) (u a1) ('a2'f.)) ((`'')(&(u@:[)))((`_)(`:6)) ( Adv0=. ((ar'a0')`) (`(ar'a1')) (`(ar'a2') ) (`:6) ) (((`''`)(`(((@:[)(&`))(`:6))))(`((`_)(`:6))))(`:6) u Adv0 ((`'')(&(u@:[)))((`_)(`:6)) 1 2 3 % Adv0 NB. Testing... 1 0.5 0.333333 NB. A wicked way... ( Adv=. ((af'a0')`) (`(af'a1')) (`(af'a2') ) (`:6) ) (((`''`)(`(((@:[)(&`))(`:6))))(`((`_)(`:6))))(`:6) u Adv ((`'')(&(u@:[)))((`_)(`:6)) 1 2 3 % Adv NB. Testing... 1 0.5 0.333333 st e '1 2 3 % Adv0' ; '1 2 3 % Adv' NB. They look the same but they are not, ┌─────────────────┬─────────────────┐ │┌────┬──────────┐│┌────┬──────────┐│ ││6272│3.80344e_5│││5120│1.38856e_5││ │└────┴──────────┘│└────┴──────────┘│ └─────────────────┴─────────────────┘ NB. ........................................................................................ NB. adv and conj adverbs... ( adv=. 'ew'f. (adverb ]: adverb ((&]:) ew)) ) ( conj=. 'ew'f. (adverb ]: conjunction ((&]:) ew)) ) ((1]:(<(,'0');<@:((,'0') ,&< ])))(1]:(<(,'0');1&]:)))((1]:(<(,'0');<@:((,'0') ,&< ])))(1]:(<(,'0');2&]:))) Fetch=. (] ([ amper train y)(({::`'')c))e o i. f.adv NB. Word mnemonics 5 Fetch NB. Example use (see (c) below), ┌───────┬───────┬───────┬───────┬───────┐ │0&({::)│1&({::)│2&({::)│3&({::)│4&({::)│ └───────┴───────┴───────┴───────┴───────┘ NB. Strand forms... NB. (d) Gerund to strand adverb converter................................................... NB. Writing the adverb (sna) is a lot easier that one might think at first glance because, NB. due to the right-associativity property, one only has to write one adverb (sna) that NB. (using the number of arguments) collects the rest of the strand as a list (the NB. arguments, and the adverb to be converted) and evaluates this list as a train formed by NB. the (atomic representation of the) curtail (}:) and the tail ({:). NB. sna... C=. _2 NB. Counter position last=. 1 >: C f NB. Is the last word in the queue? dec=. <@:(<: o (C f)) C} ] NB. Decrementing the counter next=. {: train o , an o dec NB. Producing the next adverb eval=. train o ((an o }:) ; {:) NB. Evaluating an adverb form ( [: (an o }:) {: Train ) main=. (next`(eval o (C&}.)) @. last) o knot f.conj NB. knoting and reproducing itself and finally evaluating sna=. (af'main')&(train o ([ ,(an o (>:y ; [)))f.) adv NB. The (main) conjunction is referring indirectly to itself sna NB. It is fixed... (1]:(<(,'0');(<(,'0');(2]:(<(,'0');({: (]:(<'`:'))&6@:, <@:((,'0') ,&< ])@:(<@:(<:@:(_2&({::))) _2} ]))`((]:(<'`:'))&6@:(<@:((,'0') ,&< ])@:}: ; {:)@:(_2&}.))@.(1 >: _2&({::))@:(]:(<'`.')))))&((]:(<'`:'))&6@:([ , <@:((,'0') ,&< ])@:(>:@:] ; [))))) NB. ........................................................................................ NB. Sometimes the number of arguments of an adverb is variable. This case can be handled NB. using a sentinel. Both, sna and particularly sa, were inspired by [9]. Their anonymous NB. (fixed) recursive implementation is based on the classic trick (Gödelian self-reference, NB. Quines, u/y combinators): self reference and reproduction via indirect reference to a NB. self-representation; see also [10,11,12] and references there in. NB. sa... cap=. (<'[:') (train x -: ]) [ NB. Using cap ([:) as a sentinel main=. ({:y train o , an o knot)`(eval o }:y) @. cap f.conj NB. knoting and reproducing itself and finally evaluating sa=. (fix'main') (af'main') NB. The (main) conjunction is referring indirectly to itself sa NB. It is fixed... (2]:(<(,'0');({:@:] (]:(<'`:'))&6@:, <@:((,'0') ,&< ])@:(]:(<'`.')))`((]:(<'`:'))&6@:(<@:((,'0') ,&< ])@:}: ; {:)@:}:@:])@.((<'[:') ((]:(<'`:'))&6@:[ -: ]) [)))(<(,'0');(2]:(<(,'0');({:@:] (]:(<'`:'))&6@:, <@:((,'0') ,&< ])@:(]:(<'`.')))`((]:(<'`:'))&6@:(<... NB. Train... darkhorse=. (('train'(wl ew) (train x at ]) train o (([ , (;`'') , ])/))) f. u0`u1`u2`u3 template=. darkhorse f. adv NB. Arguments as a gerund train@:(u0 ; u1 ; u2 ; u3) [: u0 u1 u2 u3 Train=. (af'template') sa NB. Arguments as a strand train@:(u0 ; u1 ; u2 ; u3) NB. (c) Recursion (reproduces the behavior of (`:4))........................................ ( 'v0 v1 v2 v3 self'=. 5 Fetch ) NB. Verbs mnemonics ┌───────┬───────┬───────┬───────┬───────┐ │0&({::)│1&({::)│2&({::)│3&({::)│4&({::)│ └───────┴───────┴───────┴───────┴───────┘ ( $:`'' ( items=. box o (,~) ) v0`v1`v2`v3 ) NB. Verbs ┌──┬──┬──┬──┬──┐ │v0│v1│v2│v3│$:│ └──┴──┴──┴──┴──┘ sentence=. (v1 tie ([: v2 (self at v3) Train)) agenda v0 NB. v1 ` ( v2 $: @: v3 ) @. v0 [: v2 (self at v3) Train NB. is just a convenient (and more meaningful) way to write, train@:(v2 ; self at v3) ( darkhorse=. sentence o ($:`''&items) )v0`v1`v2`v3 v1`(v2 $:@:v3)@.v0 ( Recursion=. darkhorse f.adv ) NB. Recursion as a fixed adverb (1]:(<(,'0');((1&({::) (]:(<,'`')) (]:(<'`:'))&6@:(2&({::) ; 4&({::) (]:(<'@:')) 3&({::))) (]:(<'@.')) 0&({::))@:((,<'$:')&(<@:((]:(<'`:'))&6)"_1@:(,~))))) ( fact=. *`1:`*`<: Recursion ) NB. Factorial 1:`(* $:@:<:)@.* fact 5 120 ( Fib=. >&1`(i.@>:)`(] , +/@(_2&{.)@])`<: Recursion ) NB. Fibonacci i.@>:`((] , +/@(_2&{.)@]) $:@:<:)@.(>&1) Fib 7 0 1 1 2 3 5 8 13 NB. ........................................................................................ Recur=. (ar'Recursion') 4 sna NB. Recur is fixed automatically fact=. * 1: * <: Recur NB. Factorial fact 5 120 Fib=. (>&1) (i.@>:) (] , +/@(_2&{.)@]) <: Recur NB. Fibonacci Fib 7 0 1 1 2 3 5 8 13 NB. Bonding... rd=. <: Recur NB. rd is fixed automatically fact=. * 1: * rd fact 5 120 Fib=. (>&1) (i.@>:) (] , +/@(_2&{.)@]) rd Fib 7 0 1 1 2 3 5 8 13 NB. (e) Permutations........................................................................ 'Proposition Basis Combine Reduction' (i."_ 0 &: ;:) 'Reduction Combine Basis Proposition' 3 2 1 0 NB. Typical adverb taking a gerund <:`*`1:`* (((3 2 1 0&{)Adv) Recursion) 5 120 tgv=. `:6 (*`1:`*`<:) (af'Recur') ga=. (af'tgv') 2 sna 1:`(* $:@:<:)@.* (<:`*`1:`*) (3 2 1 0&{adv) (af'Recur') ga 1:`(* $:@:<:)@.* afTemplate=. an o ([: an o ([: (0&{) ((af'adv')c) Train) ((an o (1&{))c) ((af'ga')c) Train) f.adv ( ( 3 2 1 0&{ adv ) (af'Recur' ) ( ga ) ) (1]:(<(,'0');3 2 1 0&{))((2]:(<(,'0');({: (]:(<'`:'))&6@:, <@:((,'0') ,&< ])@:(<@:(<:@:(_2&({::))) _2} ]))`((]:(<'`:'))&6@:(<@:((,'0') ,&< ])@:}: ; {:)@:(_2&}.))@.(1 >: _2&({::))@:(]:(<'`.'))))((<(,'0');(2]:(<(,'0');({: (]:(<'`:'))&6@:, <@:((,'0') ,&< ])@:... NB. template=. (3 2 1 0&{adv) (af'Recur') ga NB. recur=. (af'template') 4 sna NB. <: * 1: * recur 5 NB. <: (] , +/@(_2&{.)@]) (i.@>:) (>&1) recur 7 NB. NB. (3 2 1 0&{) ` (af'Recur') afTemplate NB. an o ([: an o ([: (0&{) ((af'adv')c) Train) ((an o (1&{))c) ((af'ga')c) Train) ((3 2 1 0&{)) ` (af'Recur') NB. recur=. (((3 2 1 0&{) ` (af'Recur')) afTemplate) 4 sna NB. recur=. ((3 2 1 0&{) (af'Recur') (af'afTemplate') 2 sna) 4 sna Permute=. (af'afTemplate') 2 sna recur=. (3 2 1 0&{) (ar'Recur') Permute 4 sna NB. Reversing the list os arguments, <: * 1: * recur 5 120 <: (] , +/@(_2&{.)@]) (i.@>:) (>&1) recur 7 0 1 1 2 3 5 8 13 recur=. |. (ar'Recur') Permute 4 sna NB. An equivalent direct way, <: * 1: * recur 5 120 <: (] , +/@(_2&{.)@]) (i.@>:) (>&1) recur 7 0 1 1 2 3 5 8 13 NB. Alternatively... recur=. (3 2 1 0&{) (af'Recur') Permute 4 sna <: * 1: * recur 5 120 <: (] , +/@(_2&{.)@]) (i.@>:) (>&1) recur 7 0 1 1 2 3 5 8 13 recur=. |. (af'Recur') Permute 4 sna <: * 1: * recur 5 120 <: (] , +/@(_2&{.)@]) (i.@>:) (>&1) recur 7 0 1 1 2 3 5 8 13 NB. Checking... * 1: * <: Recur 5 120 * 1: * <: |.(ar'recur') Permute 4 sna 5 120 (>&1) (i.@>:) (] , +/@(_2&{.)@]) <: Recur 7 0 1 1 2 3 5 8 13 (>&1) (i.@>:) (] , +/@(_2&{.)@]) <: |.(ar'recur') Permute 4 sna 7 0 1 1 2 3 5 8 13 NB. [8] making a 'first' adverb tacit NB. http://www.jsoftware.com/pipermail/programming/2013-November/033914.html NB. [9] Third argument (was: avoid boxing with fills - ?) NB. http://www.jsoftware.com/pipermail/programming/2009-July/015541.html NB. [10] J Myths Puzzles (Last Spoiler) NB. http://www.jsoftware.com/pipermail/programming/2008-March/009915.html NB. [11] Tacit Programming in Action: A Decade of Experience (Slides 99-111) NB. http://www.2bestsystems.com/j/J_Conference_2012. All NB. [12] Y Combinator -- "the J way" NB. http://www.jsoftware.com/pipermail/programming/2012-June/028335.html ---------------------------------------------------------------------- For information about J forums see http://www.jsoftware.com/forums.htm ---------------------------------------------------------------------- For information about J forums see http://www.jsoftware.com/forums.htm
