The Museum of HP Calculators

HP Forum Archive 21

[ Return to Index | Top of Index ]

DOCOMB
Message #1 Posted by Werner on 5 Oct 2012, 7:47 a.m.

DOCOMB will evaluate <ob> for every combination of <n> elements from list <L>. Usage is similar to DOLIST and DOSUBS: 

Input:
3: L   list of objects
2: n   number of elements to be taken each time
1: ob  object to be evaluated
Output: ob evaluated for each of the COMB(s,n) combinations of n elements of L

@ DOCOMB 230.5_Bytes # 1997h (48G)
\<<
  ROT DUP SIZE 1 + 0
  \-> ob L s DoC
  \<<
    {}
    { OVER 1 -
      \-> t n
      \<<
        s 1 -
        IF n
        THEN FOR s n L s GET 1 \->LIST t + DoC EVAL NEXT 
        ELSE FOR s L s GET t LIST\-> DROP ob EVAL NEXT
        END
      \>>
    } DUP 'DoC' STO EVAL
  \>>
\>>

examples:

{ 11 22 33 44 }
 3
 \<< 3 \->LIST \>>
 DOCOMB
 results in
{ 11 22 33 }
{ 11 22 44 }
{ 11 33 44 }
{ 22 33 44 }

  0
 { (0,3) (0,0) (4,0) (3,4) (4,3) }
  2
  \<< - ABS MAX \>>
  DOCOMB

 results in 5

Cheers, Werner

Edited: 6 Oct 2012, 1:38 p.m. after one or more responses were posted

      
Re: DOCOMB
Message #2 Posted by Gilles Carpentier on 5 Oct 2012, 5:30 p.m.,
in response to message #1 by Werner

Hi Werner,

Well done ! The problem is that recursivity is very slow in User RPL. Perhaps is there a way to avoid recursivity ?

It would be great to have such a thing in SysRPL (why not in the Gofer List Library) but a will prefer an output in _one_ list of list. I think it s not a good idea to have program wich return a variable number of items on the stack

Ex : 

{ 11 22 33 44 }
 3 << >>
 DOCOMB
 results in
{{ 11 22 33 }
 { 11 22 44 }
 { 11 33 44 }
 { 22 33 44 }}

PS : I never understood why RPL creators did not DOSUBS with n parameters to work like this :

{ 1 2 3 4 } 2 << R->C >> DOSUBS

{ (1 2) (3 4)}

Edited: 5 Oct 2012, 5:42 p.m.

            
Re: DOCOMB
Message #3 Posted by C.Ret on 6 Oct 2012, 2:24 a.m.,
in response to message #2 by Gilles Carpentier

RE: P.S.

Or at least propose a multidimentional version of DOSUB as done with DUP or DROP :

{ 1 2 3 4 5 6 } « SQ »  DOSUB            returns  { 1 4 9 16 25 36 }

{ 1 2 3 4 5 6 } « R->C » DOSUB2          returns  { (1 2) (3 4) (5 6) }

{ 1 2 3 4 5 6 } « 3 ->ARRY » 3 DOSUBN    returns  { [ 1 2 3 ] [ 4 5 6 ] }

Edited: 6 Oct 2012, 2:28 a.m.

            
Re: DOCOMB
Message #4 Posted by Werner on 6 Oct 2012, 2:24 p.m.,
in response to message #2 by Gilles Carpentier

Hello Gilles,
you are right that, to correspond to how DOSUBS works, the result should be wrapped up in a list.
The inputs to the object being evaluated however, should not, just like DOSUBS does.
So,
{ 11 22 33 44 }
3
\<< 3 \->LIST \>>
DOCOMB
should return
{ { 11 22 33 } { 11 22 44 } { 11 33 44 } { 22 33 44 } }

My other example remains the same, as it doesn't add a stack level.
BTW this version is not my first, and the fastest I've been able to come up with. 
I too, tried to circumvent recursion (and failed) and the creation of the temporary environment 
at each recursive call - that is possible, but turned out to be much slower.
My SysRPL is very rusty I'm afraid, that will take me a lot of time to get in to again. 
There's some nice tricks to be played with recursion though.
So the RPL version of DOCOMB becomes:
265.5 bytes
\<<
  ROT DUP SIZE 1 + 0
  \-> ob L s DoC
  \<<
    DEPTH DEPTH ROLLD
    {}
    { OVER 1 -
      \-> t n
      \<<
        s 1 -
        IF n
        THEN FOR s n L s GET 1 \->LIST t + DoC EVAL NEXT 
        ELSE FOR s L s GET t LIST\-> DROP ob EVAL NEXT
        END
      \>>
    } DUP 'DoC' STO EVAL
    DEPTH DEPTH ROLL -
    IF DUP THEN \->LIST ELSE DROP END
  \>>
\>>
Cheers, Werner

[ Return to Index | Top of Index ]

Go back to the main exhibit hall