J does not have an explicit scope for $: (other than using an explicit verb for that purpose), but often you can use induction instead of recursion.
(And, also - generally speaking - we can use analytic techniques - for example, sometimes recursive algorithms can be replaced with arithmetic.) Thanks, -- Raul On Thu, Oct 5, 2017 at 7:57 PM, Jose Mario Quintana <[email protected]> wrote: > " > If the first example was in an equivalent to tacit code, it could not > call f. It would have to be like this: > 4 (.x).`(.y (. y , x + {: y ). x $: <: y). at .(.x < y). 8 > It would be impossible to use in a larger tacit program and you'd need > Jx to solve that, as far as I understand. > Same problem as in tacit J today. > I didn't manage to use $: from explicit J. > /Erling > > On 2017-09-30 18:28, Erling Hellenäs wrote: >> Hi all ! >> >> 4(f=. 4 : 'x (4 : ''x'')`(4 : ''s,y +{: s=.x f <: y'')@.(4 :''x < >> y'') y' )8 >> >> 4 9 15 22 30 > " > > Beware of line-wrapping... > > One can always produce, in principle, for any explicit verb a corresponding > tacit verb. Ocasionally, this might be a difficult task; this is not in > this case, > > 4 (f=. 4 : 'x (4 : ''x'')`(4 : ''s,y +{: s=.x f <: y'')@.(4 :''x < y'') > y' ) 8 > 4 9 15 22 30 > > 4 (f=. [`(] (] , [ + {:@:]) [ $: <:@:])@.<) 8 > 4 9 15 22 30 > > After I rewrote f tacitly I realized that this explicit verb was the > transcription of a tacit verb :D (although I suspect the original tacit > verb itself was a transcription of an explicit version). > > " > 4 (.x).`(.y (. y , x + {: y ). x $: <: y). at .(.x < y). 8 > It would be impossible to use in a larger tacit program and you'd need > " > > At any rate, it is very easy, in Jx, to embed a tacit version of the verb f > within a larger tacit verb and fix it, for instance, > > 4 (1 + f) 8 > 5 10 16 23 31 > > 4 (1 + f)f. 8 > 5 10 16 23 31 > > The reason is Jx's recursive scope O.0, > > (1 + f)f. > 1 + [`(] (] , [ + {:@:]) [ $: <:@:])@.<O.0 > > One cannot do that in J, > > JVERSION > Engine: j806/j64avx/windows > Beta-6: commercial/2017-09-26T14:05:48 > Library: 8.06.07 > Qt IDE: 1.6.1/5.6.3 > Platform: Win 64 > Installer: J806 install > InstallPath: c:/program files/j64-806 > Contact: www.jsoftware.com > > 4 (f=. [`(] (] , [ + {:@:]) [ $: <:@:])@.<) 8 > 4 9 15 22 30 > > 4 (1 + f) 8 > 5 10 16 23 31 > > 4 (1 + f)f. 8 > 5 10 16 23 31 > > (1 + f)f. NB. The larger verb in not a (pure) tacit verb anymore... > 1 + 3 : '[`(] (] , [ + {:@:]) [ $: <:@:])@.< y' :(4 : 'x [`(] (] , [ + > {:@:]) [ $: <:@:])@.< y') > > unless, one is prepared to use the darkest side of the force (which Jx > promotes), see [0, 1] > > 4 (1 + (f f.)dRS) 8 > 5 10 16 23 31 > > (1 + (f f.)dRS) > 1 + ,^:(0:``:)&6 :.(<@:((,'0') ,&:< ]))@:([ , (<[`(] (] , [ + {:@:]) [ $: > <:@:])@.<) , ])&:(<@:((,'0') ,&:< ])) > > This is just one of the otherwise apparently impossible feats for those who > choose to always obey the Dictionary's sacred commandments ;) > > References > > [0] [Jprogramming] Adverbial Tacit Jym Jose Mario Quintana > http://www.jsoftware.com/pipermail/programming/2016-May/045156.html > > [1] J Wicked Toolkit > http://www.2bestsystems.com/foundation/j/Jx.zip > \Jx\J\J Wicked Toolkit.ijs > > > On Sat, Sep 30, 2017 at 12:57 PM, Erling Hellenäs <[email protected]> > wrote: > >> If the first example was in an equivalent to tacit code, it could not call >> f. It would have to be like this: >> 4 (.x).`(.y (. y , x + {: y ). x $: <: y).@.(.x < y). 8 >> It would be impossible to use in a larger tacit program and you'd need Jx >> to solve that, as far as I understand. >> Same problem as in tacit J today. >> I didn't manage to use $: from explicit J. >> /Erling >> >> >> On 2017-09-30 18:28, Erling Hellenäs wrote: >> >>> Hi all ! >>> >>> 4(f=. 4 : 'x (4 : ''x'')`(4 : ''s,y +{: s=.x f <: y'')@.(4 :''x < >>> y'') y' )8 >>> >>> 4 9 15 22 30 >>> >>> Here we have another example of the Henry syntax: >>> >>> 4(f=.(.x (.x).`(.y (. y , x + {: y ). x f <: y).@.(.x < y). y).)8 >>> >>> s is here the right unnamed operand of (. y , x + {: y ). . As long as >>> you have variables, like in explicit code, you can keep s if you want. Like >>> this: >>> >>> 4(f=.(.x (.x).`(. s , y + {: s=. x f <: y).@.(.x < y). y).)8 >>> >>> >>> Cheers, >>> >>> Erling >>> >>> >>> On 2017-09-30 16:24, Erling Hellenäs wrote: >>> >>>> Hi all! >>>> >>>> Yes, well, I wanted to measure differences between tacit and explicit >>>> expressions as such, so I tried to avoid unrelated processing time. In >>>> case you have significant operations, these differences disappear, of >>>> course, and the processing time in these operations dominate over >>>> interpretation time or small differences in the code generated. >>>> It seems better to create an internal loop then to have ts loop a big >>>> number of times over a very small load, since the measurement process as >>>> such might dominate in the latter case. >>>> The way you measure, you have to set v low and n high to avoid >>>> processing time, and it seems you didn't. >>>> I understand that these differences might not be important in practice. >>>> Thanks for your judgement on that. >>>> Any other opinions about performance differences between tacit and >>>> explicit code? Are there any cases when they are big? >>>> >>>> ts=: 6!:2 , 7!:2@] NB. Time and space >>>> v=.1 >>>> n=.5000000 >>>> n ts'(3 :''-y'')@:- v' >>>> 3.03253e_6 6784 >>>> n ts'(-)@:- v' >>>> 4.83682e_7 1152 >>>> v=.?~n >>>> ts'(3 :''-y'')@- v' >>>> 1.8912 1.34712e9 >>>> ts'(-)@- v' >>>> 0.93178 1.34711e9 >>>> >>>> Cheers, >>>> Erling >>>> >>>> > ---------------------------------------------------------------------- > For information about J forums see http://www.jsoftware.com/forums.htm ---------------------------------------------------------------------- For information about J forums see http://www.jsoftware.com/forums.htm
