Not easily. That said, I'm not sure I agree that the should give a DOMAIN
ERROR:
* ∘.+/ ⍬*
DOMAIN ERROR
∘.+/⍬
^ ^
Regards,
Elias
On 2 March 2016 at 17:38, Jay Foad <[email protected]> wrote:
> Cool! For bonus marks can you make it work in the degenerate case:
>
> ⍳⍬ ←→ ⊂⍬
>
> ?
>
> Jay.
>
> On 2 March 2016 at 02:23, Elias Mårtenson <[email protected]> wrote:
> > Looking at it further, I realise you need do disclose the result in
> order to
> > make them equivalent:
> >
> > IOTA ← {⊃∘.,/⍳¨⍵}
> >
> > Regards,
> > Elias
> >
> > On 2 March 2016 at 10:19, Elias Mårtenson <[email protected]> wrote:
> >>
> >> I don't know about a loop, but wouldn't this do the same thing?
> >>
> >> IOTA ← {∘.,/⍳¨⍵}
> >>
> >> Regards,
> >> Elias
> >>
> >> On 2 March 2016 at 09:57, Christian Robert <[email protected]
> >
> >> wrote:
> >>>
> >>> I have this function,
> >>>
> >>> ∇IOTA[⎕]∇
> >>> ∇
> >>> [0] z←IOTA v
> >>> [1] z←⍳↑v
> >>> [2] v←1↓,v
> >>> [3] Loop: →(0=⍴v)/0
> >>> [4] z←z∘.,⍳↑v
> >>> [5] v←1↓v
> >>> [6] →Loop
> >>> ∇
> >>>
> >>> ]boxing 24
> >>>
> >>> IOTA 0
> >>> ┌⊖┐
> >>> │0│
> >>> └─┘
> >>> IOTA 10
> >>> ┌10──────────────────┐
> >>> │1 2 3 4 5 6 7 8 9 10│
> >>> └────────────────────┘
> >>> IOTA 2 3
> >>> ┌3────────────────┐
> >>> 2┌2──┐ ┌2──┐ ┌2──┐│
> >>> ││1 1│ │1 2│ │1 3││
> >>> │└───┘ └───┘ └───┘│
> >>> │┌2──┐ ┌2──┐ ┌2──┐│
> >>> ││2 1│ │2 2│ │2 3││
> >>> │└───┘ └───┘ └───┘│
> >>> └∊────────────────┘
> >>> IOTA 2 3 5
> >>> ┌5──────────────────────────────────────┐
> >>> 2┌3────┐ ┌3────┐ ┌3────┐ ┌3────┐ ┌3────┐│
> >>> ││1 1 1│ │1 1 2│ │1 1 3│ │1 1 4│ │1 1 5││
> >>> 3└─────┘ └─────┘ └─────┘ └─────┘ └─────┘│
> >>> │┌3────┐ ┌3────┐ ┌3────┐ ┌3────┐ ┌3────┐│
> >>> ││1 2 1│ │1 2 2│ │1 2 3│ │1 2 4│ │1 2 5││
> >>> │└─────┘ └─────┘ └─────┘ └─────┘ └─────┘│
> >>> │┌3────┐ ┌3────┐ ┌3────┐ ┌3────┐ ┌3────┐│
> >>> ││1 3 1│ │1 3 2│ │1 3 3│ │1 3 4│ │1 3 5││
> >>> │└─────┘ └─────┘ └─────┘ └─────┘ └─────┘│
> >>> │ │
> >>> │┌3────┐ ┌3────┐ ┌3────┐ ┌3────┐ ┌3────┐│
> >>> ││2 1 1│ │2 1 2│ │2 1 3│ │2 1 4│ │2 1 5││
> >>> │└─────┘ └─────┘ └─────┘ └─────┘ └─────┘│
> >>> │┌3────┐ ┌3────┐ ┌3────┐ ┌3────┐ ┌3────┐│
> >>> ││2 2 1│ │2 2 2│ │2 2 3│ │2 2 4│ │2 2 5││
> >>> │└─────┘ └─────┘ └─────┘ └─────┘ └─────┘│
> >>> │┌3────┐ ┌3────┐ ┌3────┐ ┌3────┐ ┌3────┐│
> >>> ││2 3 1│ │2 3 2│ │2 3 3│ │2 3 4│ │2 3 5││
> >>> │└─────┘ └─────┘ └─────┘ └─────┘ └─────┘│
> >>> └∊──────────────────────────────────────┘
> >>>
> >>>
> >>>
> >>> my question is: can such a function can be written in Lambda style ?
> >>> (especially in gnuapl)
> >>>
> >>> eg:
> >>>
> >>> IOTA ← { ... }
> >>>
> >>> That IOTA function simulate the behavior of "⍳" on "Dyalog APL" and
> >>> NARS2000 and more interpretors when the argument is a vector.
> >>>
> >>>
> >>> thanks,
> >>>
> >>> Xtian.
> >>>
> >>>
> >>>
> >>
> >
>
