The inability of determining the locale of the calling context (to
qualify non-locative names with it) has bothered me for some time
(many years).
However, I did not have a convincing use case where it was significant
(I was trying to work with trace, and that apparently was not
important enough to warrant addressing this issue).
I think something should be done about it, but I'll leave the details
of that to the ISI folks.
Thanks,
--
Raul
On Wed, Apr 5, 2017 at 11:40 AM, Xiao-Yong Jin <jinxiaoy...@gmail.com> wrote:
>
>> On Apr 5, 2017, at 3:32 AM, Raul Miller <rauldmil...@gmail.com> wrote:
>>
>> I get:
>> (-~&(^&3%3:)/ -: *:qromb_nr_) 1 2
>> |domain error
>> | PolyInterpY=:PolyInterpY (j-1)}~u trapzdNext ab
>>
> That was because your code has some issues. You can see what's going on by
> checking the output of *trapzdNext_nr_
> I did some fixing to it.
>
>> But the locale is right, which is all I was concerned with.
>>
>> That said, there's another issue - we are working with an anonymous
>> verb, so we must manually set the locale back to what it was before we
>> exit. (The automatic locale switching only happens with named verbs.)
>>
> And there's another. u and v has to run in their own respective locales,
> which my little code snippet of aa_t_ failed to address correctly.
>
>> Meanwhile... conjunctions are a bit trickier.
>>
>> However, you can write an adverb or conjunction which returns an
>> adverb or a conjunction. The adverb which returns an adverb is
>> probably the easiest to reason about syntactically (because adverbs
>> and conjunctions have a long left scope). Anyways, you can use this to
>> bring in arbitrarily many arguments. (Though you do need to think
>> about how you terminate the mess, if you are getting overly
>> ambitious.)
>>
>> Still, you wind up building a gerund to pass multiple verbs where they
>> need to be. Which is basically what you were suggesting, and I think
>> that that's all that's needed here.
>>
>> So, for example (being a bit verbose, but this is a verbose issue...):
>>
>> conj_example_=: 2 :0
>> u`v conj_implementation_example_ (coname '')
>> )
> I don't know how to get the correct locale of u and v here.
> They could be 1) named verb, 2) primitives, 3) anonymous verb.
> How do I make them run in their correct locales?
>
>>
>> conj_implementation_example_=: 2 :0
>> return_locale=. coname''
>> cocurrent v
>> '`u v'=. u
>> NB. code goes here
> We actually need another level of wrapping because of early 'return.'s.
>
>> return_value=. expression y NB. fix this expression
>> cocurrent return_locale
>> return_value
>> )
>>
>> I hope this helps,
>>
>> --
>> Raul
>>
>>
>>
>>
>> On Wed, Apr 5, 2017 at 2:29 AM, Xiao-Yong Jin <jinxiaoy...@gmail.com> wrote:
>>> Hi Pascal, Henry, and Raul,
>>>
>>> First, thank you for giving me suggestions. Allow me to reply you all in
>>> this one message.
>>>
>>> Raul, 'qromb' does a numerical integration, so
>>> (-~&(^&3%3:)/ -: *:qromb) 1 2
>>> returns 1, meaning integrating *: from 1 to 2 is the same as 2-&(^&3%3:)1
>>> or 2-&(*:d._1)1
>>> I got your code to work by putting back 'u' in those adverbs.
>>> But the code changes the current locale to nr after calling qromb_nr_ once,
>>> and I don't see an easy
>>> way to get back to the calling locale.
>>> I also don't like rewriting the adverb into a conjunction. What would I do
>>> with a conjunction?
>>> Maybe I can rewrite it into a verb accepting gerunds. I'll try looking
>>> into this direction.
>>>
>>> Pascal, it really takes some time to wrap my head around your code. I want
>>> to have a generic method
>>> that would work for both adverb and conjunction, and have an interface that
>>> works like a normal J adverb
>>> or conjunction. Inspired by your verb and ti, I found the following work
>>> around satisfying.
>>>
>>> NB.for a simple object/locale, with a monadic adverb a_t_ waiting to be
>>> wrapped
>>> a_t_=:1 : 'echo (u y);(5!:1<''u'');''a_t_'';y;(coname'''')label_.d'
>>> d_t_=:'d_t_'
>>> NB.create an interface adverb aa_t_ for a_t_ and hide the data d_t_ via a
>>> verb av_t_
>>> aa_t_=:1 : '(cofullname&.>u`'''') av_t_ y'
>>> av_t_=:4 : 'x`:6 a y'
>>>
>>> Henry, I see the complication.
>>> Assuming all names are fully qualified with locales (otherwise we stick the
>>> current locale to it like cofullname does)
>>> What about letting 'v_lv_ a_la_' executes: switch to la, run 'v_lv_ a',
>>> switch back? Similar behavior for conjunctions. Does the locale has to be
>>> tied to anonymous verbs?
>>> I may have some misunderstanding, but my impression of the execution model
>>> is that 'v_lv_ y' executes
>>> 1. get the value of 'y'
>>> 2. switch to 'lv'
>>> 3. get the value of 'v_lv_'
>>> 4. run 'v_lv_ y' by following the definition of 'v_lv_'
>>> 5. switch back
>>>
>>>
>>>
>>>
>>>> On Apr 4, 2017, at 9:01 PM, 'Pascal Jasmin' via Programming
>>>> <programm...@jsoftware.com> wrote:
>>>>
>>>>
>>>>> should the anonymous verb created by
>>>>
>>>>
>>>> verb adv_locale_
>>>>
>>>> automatically be executed in (locale)?
>>>>
>>>>
>>>> The existing behaviour can be leveraged with duck typing in mind.
>>>>
>>>> One easy workaround I didn't get too deep in is based on this magic fork
>>>>
>>>> inl_z_ =: ((cocurrent@] ".@] [)"1 0 boxopen)
>>>>
>>>>
>>>> executes string x in every locale y
>>>>
>>>> A conjunction version lets you access local parameters,
>>>>
>>>> lr_z_ =: 3 : '5!:5 < ''y'''
>>>> inlC_z_ =: 2 : ' (([: <^:(0=L.) v"_) inl~ m ,"1 '' '',"1 lr@:]) : (([:
>>>> <^:(0=L.) v"_) inl~ (lr@:[),"1 '' '' ,"1 m ,"1 '' '',"1 lr@:] )'
>>>>
>>>> inlA =: 1 : 'u inlC (18!:5 '''')'
>>>>
>>>> ab_far_ =: 1 : (':';'x + a u y')
>>>> a_far_ =: 3
>>>>
>>>> a_base_ =: 33
>>>>
>>>> a ' + ab ' inlA_far_ 3
>>>> 39
>>>>
>>>> b =: 4 : 'x + a + y'
>>>>
>>>> 2 ' b_base_ ab ' inlA_far_ 3
>>>> 41
>>>>
>>>> in jpp, this can be
>>>>
>>>>
>>>> 2 ( b_base_ ab inlC.: far) 3
>>>> ________________________________
>>>> From: Henry Rich <henryhr...@gmail.com>
>>>> To: programm...@jsoftware.com
>>>> Sent: Tuesday, April 4, 2017 8:12 PM
>>>> Subject: Re: [Jprogramming] locales with adverbs and conjunctions?
>>>>
>>>>
>>>>
>>>> I have been thinking about this & I don't see a better solution than
>>>> Raul's. @Raul: think about putting something in NuVoc explaining this.
>>>>
>>>> I thought at first: should the anonymous verb created by
>>>>
>>>> verb adv_locale_
>>>>
>>>> automatically be executed in (locale)? That would solve the immediate
>>>> problem.
>>>>
>>>> But it leaves us with the responsibility of defining a locale for every
>>>> anonymous verb. What locale should we assign to:
>>>>
>>>> (V0 V1_locale_ V2)
>>>>
>>>> (V0_locale0_ V1_locale1_ V2_locale2_)
>>>>
>>>> (V0_locale0_ V1)
>>>>
>>>> ?
>>>>
>>>> I haven't been able to come up with something I would be willing to
>>>> suggest to Roger & Ken.
>>>>
>>>> Unless someone does, I guess we will leave it as is. The locale suffix
>>>> gives an easy way to specify the locale of a verb - 98% of the cases -
>>>> and for the rest you need Raul's Device.
>>>>
>>>> Henry Rich
>>>>
>>>>
>>>>
>>>> On 4/4/2017 4:03 AM, Raul Miller wrote:
>>>>> I am not sure how to test this (I do not know what values to use for f
>>>>> a and b in 'f qromb a b' and do not feel like studying your code
>>>>> enough to deduce such values), but I think this is what you are asking
>>>>> for:
>>>>>
>>>>> ---------- 8< ------ cut here ------ 8< ----------
>>>>>
>>>>> coclass'nr'
>>>>>
>>>>> qromb=:1 :0
>>>>> qromb_implementation (coname '')
>>>>> )
>>>>>
>>>>> qromb_implementation=:2 :0
>>>>> NB.Returns the integral of the function from a to b. NR P.166 Ch.4.3
>>>>> NB.Uses Romberg's method of order 2*K, where, e.g. K=2 is Simpson's rule.
>>>>> NB.u function
>>>>> NB.y a,b,eps integration bounds(a,b), and accuracy(eps,
>>>>> default 1e_10)
>>>>> NB.eps is the fraction error from extrapolation error estimate
>>>>> NB.PolyInterpX stores successive trapezoidal relative stepsizes
>>>>> NB.PolyInterpY stores their approximations
>>>>> NB.K is the number of points used in the extrapolation
>>>>> cocurrent v
>>>>> ab=.2{.y [ eps=.2{y,1e_10
>>>>> PolyInterpY=:20#0 [ PolyInterpX=:21#0 [ PolyInterpM=:K=.5
>>>>> PolyInterpX=:PolyInterpX 0}~1
>>>>> TrapzdNextN=:0
>>>>> j=.1 while.j<:#PolyInterpX do.
>>>>> PolyInterpY=:PolyInterpY(j-1)}~u trapzdNext ab
>>>>> if.j>:K do.'ss dy'=.0 polyInterpRawinterp j-K
>>>>> if.(|dy)<:eps*|ss do.ss return.end.end.
>>>>> NB.This is key. The factor 0.25 allows h^2 extrapolation. See NR
>>>>> equation 4.2.1.
>>>>> PolyInterpX=:PolyInterpX j}~0.25*PolyInterpX{~j-1
>>>>> j=.>:j end.
>>>>> 'Too many steps in routine qromb'assert 0
>>>>> )
>>>>>
>>>>> polyInterpRawinterp=:4 :0
>>>>> NB.Polynomial interpolation. NR P.119 Ch.3.2
>>>>> NB.x the point of interpolation
>>>>> NB.y j subrange j+i.PolyInterpM is used for the
>>>>> interpolation
>>>>> NB.Must initialize
>>>>> NB.PolyInterpM=:5
>>>>> NB.PolyInterpX=:21#0
>>>>> NB.PolyInterpY=:20#0
>>>>> j=.y
>>>>> dif=.|x-j{PolyInterpX
>>>>> i=.0 while.i<PolyInterpM do.
>>>>> if.dif>dift=.|x-PolyInterpX{~j+i do.ns=.i [ dif=.dift end.
>>>>> i=.>:i end.
>>>>> d=.c=.PolyInterpY ];.0~ j,:PolyInterpM
>>>>> ns=.<:ns [ y=.PolyInterpY{~j+ns
>>>>> m=.1 while.m<PolyInterpM do.
>>>>> i=.0 while.i<PolyInterpM-m do.
>>>>> ho=.x-~PolyInterpX{~j+i
>>>>> hp=.x-~PolyInterpX{~j+i+m
>>>>> w=.(c{~i+1)-i{d
>>>>> 'PolyInterp error'assert 0~:den=.ho-hp
>>>>> den=.w%den
>>>>> d=.d i}~hp*den
>>>>> c=.c i}~ho*den
>>>>> i=.>:i end.
>>>>> if.(PolyInterpM-m)>2*ns+1 do.dy=.c{~ns+1
>>>>> else.ns=.<:ns [ dy=.ns{d
>>>>> end.
>>>>> y=.y+dy
>>>>> m=.>:m end.
>>>>> y,dy
>>>>> )
>>>>>
>>>>> trapzdNext=:1 :0
>>>>> trapzdNext_implementation (coname '')
>>>>> )
>>>>>
>>>>> trapzdNext_implementation=:2 :0
>>>>> NB.Returns the nth stage of refinement of the extended trapezoidal
>>>>> rule. NR P.163 Ch.4.2
>>>>> NB.u function must accept list
>>>>> NB.y a,b range
>>>>> NB.Must initialize TrapzdNextN=:0 before using.
>>>>> cocurrent v
>>>>> ba=.-~/y
>>>>> TrapzdNextN=:>:TrapzdNextN
>>>>> if.1=TrapzdNextN do.TrapzdNextS=:-:ba*+/u y return.
>>>>>
>>>>> else.TrapzdNextS=:-:TrapzdNextS+ba*t%~+/u({.y)+(0.5+i.t)*ba%t=.2^TrapzdNextN-2
>>>>> return.
>>>>> end.
>>>>> )
>>>>>
>>>>> ---------- 8< ------ cut here ------ 8< ----------
>>>>>
>>>>> This is a rather bulky example, if there are problems with this
>>>>> approach it might be better to define a more concise (and complete -
>>>>> with a test case which illustrates the problem) example?
>>>>>
>>>>> 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
>
> ----------------------------------------------------------------------
> For information about J forums see http://www.jsoftware.com/forums.htm
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
