Re: [Bug-apl] A couple of bugs, and a question on the power operator

[Christian Robert]

Look at this

      {1+÷⍵}⍣= 256
1.618033989
      {1+÷⍵}⍣{⍺=⍵} 256
1.618033989
      {1+÷⍵}⍣{⍺=⍵⊣⎕←⍺ ⍵ (⍵-⍺)} 256
1.00390625 256 254.9960938
1.996108949 1.00390625 ¯0.9922026994
1.500974659 1.996108949 0.4951342905
1.666233766 1.500974659 ¯0.1652591074
1.600155885 1.666233766 0.06607788159
1.624939113 1.600155885 ¯0.02478322885
1.615407674 1.624939113 0.009531439632
1.619038783 1.615407674 ¯0.003631108845
1.61765043 1.619038783 0.001388352906
1.61818053 1.61765043 ¯0.0005301001708
1.61797802 1.61818053 0.0002025099168
1.618055368 1.61797802 ¯0.00007734757573
1.618025823 1.618055368 0.00002954477659
1.618037108 1.618025823 ¯0.00001128500832
1.618032797 1.618037108 0.000004310503058
1.618034444 1.618032797 ¯0.000001646463698
1.618033815 1.618034444 6.288934578E¯7
1.618034055 1.618033815 ¯2.402158839E¯7
1.618033963 1.618034055 9.175430926E¯8
1.618033998 1.618033963 ¯3.504702684E¯8
1.618033985 1.618033998 1.338677325E¯8
1.61803399 1.618033985 ¯5.113292456E¯9
1.618033988 1.61803399 1.953103901E¯9
1.618033989 1.618033988 ¯7.460192464E¯10
1.618033989 1.618033989 2.849540603E¯10
1.618033989 1.618033989 ¯1.088429347E¯10
1.618033989 1.618033989 4.157429956E¯11
1.618033989 1.618033989 ¯1.587974197E¯11
1.618033989 1.618033989 6.065370428E¯12
1.618033989 1.618033989 ¯2.316813408E¯12
1.618033989 1.618033989 8.850697952E¯13
1.618033989 1.618033989 ¯3.379518887E¯13
1.618033989 1.618033989 1.290079155E¯13
1.618033989

power is always diadic on the function it call.

> Its right argument then is _always_ the result of the previous iteration. Is 
that correct?

I really hope so. That was my understanding since several months. I may still 
be wrong.

Xtian.

On 2016-08-15 21:54, Louis de Forcrand wrote:
> I'm sorry, _I_ misunderstood the manual. I did not know that Dyalog dfns were 
> always dyadic / ambivalent.
>
> If I understand correctly then, in F {pow} G, G's left argument is _always_ the 
> result of the power operator if G is true. Its right argument then is _always_ 
> the result of the previous iteration. Is that correct?
>
> If it is, I believe always ambivalent lambdas would be convenient (aside from 
> possible implementation problems), but not at all essential; it's probably rare 
> to check something about the previous iteration without comparing it to the 
> current one. But wouldn't have been simpler to model them as ambivalent from 
> the ground up?
>
> Louis
>
> On 15 Aug 2016, at 08:22, Jay Foad <address@hidden <mailto:address@hidden>> 
> wrote:
>
> > The manual is here, see page 145: 
> > http://docs.dyalog.com/15.0/Dyalog%20APL%20Language%20Reference%20Guide.pdf
> >
> > I'm not sure where Louis got the information about monadic G. I assure you that 
> > Dyalog APL does not examine G to see if it's monadic or dyadic. It always tries 
> > to apply G dyadically.
> >
> > Jay.
> >
> > On 15 August 2016 at 12:30, Juergen Sauermann <address@hidden 
> > <mailto:address@hidden>> wrote:
> >
> >     Hi Jay,
> >
> >     I see. Maybe I misunderstood Louis,s email from last Saturday completely?
> >     The way I read this email was that in Dyalog APL version 15 you can have
> >     a monadic condition function G in F⍣G . Quote from the email:
> >
> >
> >     ///The Dyalog 15.0 manual states that the power operator can take a/
> >     ///function right argument. In this case, that function can be/
> >     ///either monadic or dyadic, and can be a lambda./
> >     ///If it’s monadic:/
> >     /
> >     /
> >     ///  (F⍣G) ⍵  ←→  ⍵ ←   F ⍵  until          G ⍵/
> >     ///⍺ (F⍣G) ⍵  ←→  ⍵ ← ⍺ F ⍵  until          G ⍵/
> >     /
> >     /
> >     ///If it’s dyadic:/
> >     /
> >     /
> >     ///  (F⍣G) ⍵  ←→  ⍵ ←   F ⍵  until  (  F ⍵) G ⍵/
> >     ///⍺ (F⍣G) ⍵  ←→  ⍵ ← ⍺ F ⍵  until  (⍺ F ⍵) G ⍵/
> >     /
> >     /
> >     ///(Note that G is checked before the first time F is executed.)/
> >
> >     I don't know if that statement is correct or not, but if it is then I would 
> > prefer to not
> >     introduce this "monadic case" in GNU APL for the reasons explained earlier.
> >
> >     Thanks,
> >     Jürgen
> >
> >
> >     On 08/15/2016 10:16 AM, Jay Foad wrote:
> > >     On 13 August 2016 at 13:05, Juergen Sauermann <address@hidden 
> > > <mailto:address@hidden>> wrote:
> > >
> > >         In "Mastering Dyalog APL" I haven't found the monadic case for the 
> > > right function argument
> > >         G of the power operator. In that book G seems to be always dyadic. So 
> > > the monadic case looks
> > >         like a new Dyalog invention. And, if it is defined like you say, IMHO 
> > > not the ultimate wisdom.
> > >
> > >
> > >     There is no "monadic case". G is always applied dyadically, and if it 
> > > happens to be a strictly monadic function then you'll get a SYNTAX ERROR:
> > >
> > >           ⎕FX'r←g y' 'r←g>10' ⍝ g is strictly monadic
> > >           2 g 4 ⍝ applying it dyadically gives an error
> > >     SYNTAX ERROR
> > >           (+⍨⍣g)1 ⍝ power operator tries to apply g dyadically
> > >     SYNTAX ERROR
> > >
> > >     In general, Dyalog APL /never/ examines a function operand to see whether 
> > > it is monadic or dyadic, in order to treat them differently.
> > >
> > >     Jay.