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 <christian.rob...@polymtl.ca>
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.
>
>
>
>
