newRPL - Updated to build 1510 [official build remains at 1487]

[Gilles]

I spent some time tonight starting a ListExt library in newRPL.
For documentation and usage, see : https://www.hpcalc.org/details/7971 by David Mutter. It's a partial implementation for now. It's very fast because newRPL is very fast especially with the processing of lists. The rest will follow soon enough when I have time next week and will be integrated into a newRPL library with menu and on line help.

Code:

@================================================================
@  List Extension for newRPL  13/08/2023
@----------------------------------------------------------------
DIRECTORY
@---------------------------------------------------------------
'$LIBID' 'LstX' 
@---------------------------------------------------------------
'$TITLE' 
"List extended lib v1.01a Nemo59
Thanks to Claudio L. (newRPL)
and to D. Mutter (ListExt)" 
@================================================================
'LSEQ'   
  « → a  
   « CASE 
       a 1  ≥ THEN  1 a FOR 'n' n NEXT a →LIST END
       a -1 ≤ THEN -1 a FOR 'n' n -1 STEP a NEG →LIST END
      {} 
     END   
   » 
  »
@----------------------------------------------------------------
'LSEQR'   
  « → a b  
   « IF a b ≤  THEN 
      a b FOR 'n' n NEXT 
     ELSE 
      a b FOR 'n' n -1 STEP 
     END 
     a b - ABS 1 + →LIST
   »
  »
@----------------------------------------------------------------
'LASEQ'
  « → dep diff nbr 
   « 
    CASE 
     nbr NOT  THEN {} END
     nbr 1 == THEN dep 1 →LIST END
     dep 
     2 nbr START DUP diff + NEXT
     nbr →LIST
    END
   »
  » 
@----------------------------------------------------------------
'LMSEQ'   
  « → a b c 
   « CASE
       c 0 ≤ THEN {} END
       c 2 < THEN a 1 →LIST END
       a DUP     
       2 c START b * DUP NEXT
       DROP c →LIST
     END
   »
  »
@----------------------------------------------------------------
'LDSEQ' « SWAP INV SWAP LMSEQ »
@----------------------------------------------------------------
'LMRPT'
  « → List a  
   « {}
     IF a 1 ≥ THEN 1 a START List ADD NEXT END    
   » 
  »
  
@----------------------------------------------------------------
'LWHL'
  « DEPTH 3 - → LWHL.Pa LWHL.Pc LWHL.d
    « DO  
       DUP LWHL.Pa EVAL
      UNTIL DUP LWHL.Pc EVAL NOT END
      DROP
      DEPTH LWHL.d - →LIST
    »
  »
@----------------------------------------------------------------
'LDDUP'
  « 
   REVLIST OBJ→ {}
   1 ROT START
    IF SWAP DUP2 POS THEN DROP ELSE
      IF DUP TYPE 62 == THEN 1 →LIST END
      ADD 
    END
   NEXT 
  » 
@----------------------------------------------------------------
'LPOP' « DUP HEAD SWAP TAIL SWAP »
@----------------------------------------------------------------
'LPOPR' « DUPDUP SIZE 1 - LFRST SWAP 1 LLAST OBJ→ DROP »
@----------------------------------------------------------------
'LPUSH' « 1 →LIST SWAP ADD »
@----------------------------------------------------------------
'LPSHR' « 1 →LIST ADD »
@----------------------------------------------------------------
'LPICK' « SWAP → List « « List SWAP GET » MAP » »
@----------------------------------------------------------------
'LREPL' « ROT → List « 2 « 'List' UNROT REPL » DOLIST DROP List » »
@----------------------------------------------------------------
'LRMOV'
  « → List r 
   « IF r TYPE 10 == THEN
      @.........................................................
      @ Working with the stack in not significantly faster
      @ and more complicated than using two SUB. 
      @ Very different versus stock RPL
      @.........................................................
      List 1 r 1 - SUB
      List r 1 + List SIZE SUB
      ADD 
     ELSE
      IF r SIZE THEN 
       @.........................................................
       @ See to ameliorate? Not obvious because of // process
       @ For exemple { a b c d e } { 2 2 4 } LRMOV => { a c e }
       @ <=>  { a b c d e } 2 LRMOV 3 LRMOV  that is a lot faster
       @.........................................................
       r LDDUP SORT REVLIST
       1
       « → ri 
        « List 1 ri 1 - SUB 
          List ri 1 + List SIZE SUB
          ADD 'List' STO
        » 
       » 
       DOSUBS DROP List    
      END   
     END 
   » 
  »
@----------------------------------------------------------------
'LINSR'
  « → List n o
   « List n 1 - LFRST o ADD List DUP SIZE n - 1 + LLAST ADD »
  »
@----------------------------------------------------------------
'LFRST'  « 1 SWAP SUB »
@----------------------------------------------------------------
'LLAST' « OVER SIZE DUP ROT - 1 + SWAP SUB »
@----------------------------------------------------------------
'LDWHL'
  « OVER SIZE → LDWHL.List LDWHL.p LDWHL.s
   « IF LDWHL.s NOT THEN {} ELSE 
       0 'LDWHL.n' LSTO
       WHILE 'LDWHL.List' 'LDWHL.n' INCR GET LDWHL.p REPEAT END 
       LDWHL.List LDWHL.n LDWHL.s SUB
     END
   »
  »
@----------------------------------------------------------------
'LTWHL'
  « OVER SIZE → LTWHL.List LTWHL.p LTWHL.s
   « IF LTWHL.s NOT THEN {} ELSE 
       0 'LTWHL.n' LSTO
       WHILE 'LTWHL.List' 'LTWHL.n' INCR GET LTWHL.p REPEAT END 
       LTWHL.List 1 LTWHL.n 1 - SUB
     END
   »
  »
@----------------------------------------------------------------
'LDROP'
  « 0 RND → n
   « CASE
       n 0 > THEN DUP SIZE n 1 + SWAP SUB END
       n 0 < THEN DUP SIZE n + 1 SWAP SUB END
     END
   »
  »
@---------------------------------------------------------------
'LFILT'  
  « → LFILT.Filter 
    « 1 « IF DUP LFILT.Filter NOT THEN DROP END » DOSUBS »
  » 
@----------------------------------------------------------------
'LROLL' « DUP SIZE → List s « List 1 LLAST List s 1 - LFRST ADD » »
@----------------------------------------------------------------
'LRLLD' « DUP TAIL SWAP HEAD ADD »
@----------------------------------------------------------------
'LROT'
   « OVER SIZE → List a s  
    « CASE 
        a 0 > THEN List a LLAST List s a - LFRST  ADD END
        a 0 < THEN 'a' SNEG List s a - LLAST List a LFRST ADD END 
       List
      END   
    »
   »
@----------------------------------------------------------------
'LSWAP'  
   « →  a b 
    « DUP a GET
      OVER b GET
      UNROT b SWAP PUT
      SWAP a SWAP PUT
    »
   »
@---------------------------------------------------------------
'LSHUF'
   « IF DUP TYPE 10 == THEN LSEQ END 
     OBJ→ → s  
    « 
      1 s FOR n
        s n - 1 + RAND * IP n + ROLL
      NEXT
      s →LIST
     »
   »
@----------------------------------------------------------------
'DOPERM' 

@ DOPERM.L : Liste
@ DOPERM.P : Programme a éxécuter pour chaque permutation
@ DOPERM.T : Taille de de liste à permuter
@ DOPERM.B : Gestion du BREAK
@ DOPERM.S : Mémorise taille de la pile pour générer liste retour 
@ DOPERM.G : S/Prog récursif pour générer les permut successives
@................................................................

 « OVER SIZE 0 DEPTH 4 - → DOPERM.L DOPERM.P DOPERM.T DOPERM.B DOPERM.S
    «
       « 1 'DOPERM.B' STO »
  
       «  → DOPERM.K
         «
           IF DOPERM.B THEN 1 'LstX.Break?' LIBSTO EXIT END
           IF 'DOPERM.K==1' THEN DOPERM.L DOPERM.P  
           ELSE
             DOPERM.K 1 - DOPERM.G  
             1 DOPERM.K 1 - FOR 'DOPERM.I'
                IF DOPERM.K 2 MOD THEN
                 'DOPERM.L' 1 GET 'DOPERM.L' DOPERM.K GET
                 'DOPERM.L' 1 ROT PUT 'DOPERM.L' DOPERM.K ROT PUT
                ELSE
                 'DOPERM.L' DOPERM.I GET 'DOPERM.L' DOPERM.K GET
                 'DOPERM.L' DOPERM.I ROT PUT 'DOPERM.L' DOPERM.K ROT PUT
                END
                DOPERM.K 1 - DOPERM.G  
             NEXT
           END
         » 

       » → BREAK DOPERM.G
         « 
           0 'LstX.Break?' LIBSTO
           DOPERM.T DOPERM.G EVAL
           DEPTH DOPERM.S - →LIST
         »
    » 
  »
@---------------------------------------------------------------
'DOCOMB'

@ DOCOMB.L : Liste
@ DOCOMB.R : Nbr d'items à combiner
@ DOCOMB.P : Programme a éxécuter pour chaque combinaison
@ DOCOMB.E : Taille de de liste initiale
@ DOCOMB.B : Gestion du BREAK
@ DOCOMB.S : Mémorise taille de la pile pour générer liste retour 
@ DOCOMB.G : S/Prog récursif pour générer les combi successives
@................................................................

  « PICK3 SIZE PICK3 0 SWAP NDUPN →LIST 0 DEPTH 6 -
    → 'DOCOMB.L' 'DOCOMB.R' 'DOCOMB.P' 'DOCOMB.E' 'DOCOMB.D' 'DOCOMB.B' 'DOCOMB.S'
    « 
      « 1 'DOCOMB.B' STO » @ BREAK
  
      «  → DOCOMB.I DOCOMB.X 
        «
          IF DOCOMB.B 'LstX.Break?' LIBRCL OR THEN EXIT END
          IF  DOCOMB.X DOCOMB.R 1 + ==  THEN DOCOMB.D DOCOMB.P 
          ELSE
            IF DOCOMB.I DOCOMB.E ≤ THEN
              'DOCOMB.L' DOCOMB.I GET 'DOCOMB.D' DOCOMB.X ROT PUT
              DOCOMB.I 1 + DOCOMB.X 1 + DOCOMB.G
              DOCOMB.I 1 + DOCOMB.X DOCOMB.G
            END 
          END
        » 
      »
      → BREAK DOCOMB.G
      « 
        0 'LstX.Break?' LIBSTO
        1 1 DOCOMB.G EVAL
        DEPTH DOCOMB.S - →LIST
      »
   »
 »
@---------------------------------------------------------------
'DOCOPE'
 « → DOCOPE.P
   « « 'DOCOPE.P' RCL DOPERM IF DUP SIZE THEN OBJ→ END DROP » DOCOMB »
 »
@----------------------------------------------------------------
'NL→I' 
  « DUP SIZE 0 → s t
    « CASE 
        s NOT  THEN DROP 0 't' STO END
        s 1 == THEN 1 GET 't' STO END
        OBJ→  1 1 ROT  1 - START
          DUP UNROT * 't' STO+
          10 *
        NEXT
        * 't' STO+
      END
      t
    »
  »
@----------------------------------------------------------------
'I→NL'
  « ABS 0 RND DUP XPON → n s  
   « IF s 0 ≥ THEN s 0 FOR 'a' n a a DIGITS -1 STEP
     ELSE 0 0 's' STO END
     s 1 + →LIST     
   » 
  »  
@---------------------------------------------------------------
'LUNION' « ADD LDDUP »
@---------------------------------------------------------------
'LINTR'
  « → Lst2
    « 
      « IF DUP Lst2 SWAP POS NOT THEN DROP END » MAP 
      LDDUP
    »
  »
@---------------------------------------------------------------
'LMAX' « IF DUP SIZE 1 > THEN « MAX » STREAM ELSE 1 GET END »
@---------------------------------------------------------------
'LMIN' « IF DUP SIZE 1 > THEN « MIN » STREAM ELSE 1 GET END »
@---------------------------------------------------------------
'LCLLT' 
 « 
  { } → ri 
   « OBJ→ 
     « DEPTH →LIST 'ri' SWAP SADD » DOLIST
       DROP ri     
     »
   »
@---------------------------------------------------------------
'LDIST' 
  « OVER SIZE → List t s
   « IF t 0 < THEN s NEG 't' STO/ END
     IF s t IDIV2 THEN DROP List EXIT END
     'n' LSTO
     1 n FOR i
       0 s 1 - FOR j
         'List' i j + GET
         n STEP
         t →LIST
      NEXT
      n →LIST
   »
  »
@---------------------------------------------------------------
'LGRP' 
  «  DUP SIZE DEPTH 2 -  → List s d
    « IF s 2 < THEN List ELSE
        List 1 GET
        2 s FOR n
          IF List n GET DUP2 == THEN DROP END
        NEXT
        DEPTH d - →LIST
      END
    »
  »
@---------------------------------------------------------------
'LRPCT' 
  « DUP SIZE {} 1  → List s Count c
    « 
      CASE 
         s NOT THEN { { } { } } END
         s 1 == THEN List { 1 } 2 →LIST END
        DEPTH 'd' LSTO
        List 1 GET
        2 s FOR n
          IF List n GET DUP2 == THEN DROP 1 'c' STO+ 
          ELSE 'Count' c SADD 1 'c' STO 
          END
        NEXT
        'Count' c SADD
        DEPTH d - →LIST Count 2 →LIST 
      END
    »
   »
@---------------------------------------------------------------
'LRPC→' « OBJ→ « NDUPN DROP » DOLIST »
@---------------------------------------------------------------
'LSDIV'
  « OVER SIZE → List n s
    « IF s n IDIV2 s 0 == OR THEN DROP List EXIT ELSE ABS 't' LSTO END
      IF n 0 < THEN n ABS t 'n' STO 't' STO END
      1 s FOR 'i'
        List i i n + 1 - SUB
      n STEP
      t →LIST
    »
  »
@---------------------------------------------------------------
'SPLIT' « DUP2 1 SWAP SUB UNROT 1 + OVER SIZE SUB »
@---------------------------------------------------------------
'RSPLT' « OVER SIZE SWAP - SPLIT »
@---------------------------------------------------------------
'LSSR' « → List a b « List 1 a 1 - SUB List a b SUB REVLIST List b 1 + OVER SIZE SUB ADD ADD » »
@---------------------------------------------------------------
'LCNT' 
  « OVER SIZE 0 → List o s n 
    « IF s NOT THEN 0 ELSE
        1 s FOR 'i' 'List' i GET o SAME 'n' STO+ NEXT
        n
      END    
    » 
  »
@---------------------------------------------------------------
'LDUPL' 
  « DUP SIZE 0 → List s Exit
    « IF s 2 < THEN 0 'Exit' STO
      ELSE
        1 s 1 - FOR 'i'
         IF Exit THEN EXIT END
            'List' i GET 'o' LSTO
         i 1 + s FOR j
           IF 'List' j GET o SAME THEN 1 'Exit' STO EXIT END 
         NEXT
        NEXT
      END
      Exit
    » 
  »
@---------------------------------------------------------------
'MPOS' « → o « 1 « IF o SAME THEN NSUB END » DOSUBS » » 
@---------------------------------------------------------------
'LDIFF' 
  « → list2 
    « IF DUP SIZE THEN
        1 « IF list2 OVER POS THEN DROP END » 
        DOSUBS
      ELSE { } END
    » 
  » 
@---------------------------------------------------------------
'LXIL'  
  « 1
    « IF DUP TYPE 62 == THEN OBJ→ DROP END » DOSUBS
  »
@---------------------------------------------------------------  
'LXILR' « DO DUP LXIL UNTIL DUP ROT SAME END  »
@---------------------------------------------------------------
'FOOT' « DUP SIZE GET » 
@---------------------------------------------------------------
'MDIST' « SWAP LXILR SWAP LDIST » 
@---------------------------------------------------------------
'LMAP' 
  « → Pgm 
    « 1 « IF DUP TYPE 62 ≠ THEN Pgm END » DOSUBS » 
  »
@---------------------------------------------------------------
'DOLLST' « → Pgm « OBJ→ 'Pgm' DOLIST » »
@---------------------------------------------------------------
'LCPRD'
« 
  « OVER SIZE OVER SIZE → l1 l2 s1 s2
    «
      IF s1 s2 AND THEN
        1 s1 FOR i
          1 s2 FOR j
            l1 i GET l2 j GET ADD 
          NEXT
        NEXT
        s1 s2 * →LIST 
      ELSE
        { }
      END
    »
  »
  → List Recur
  «  
     IF List TYPE 62 == List SIZE AND THEN
       WHILE List SIZE 1 > REPEAT
         List 2 LFRST OBJ→ DROP Recur EVAL
         List 2 LDROP
         SWAP LPUSH 'List' STO
       END
       List LXIL
     ELSE {} END
  »
» 
  

@===============================================================
@ Library meta data
@---------------------------------------------------------------
'$VISIBLE' 
{
 { 'LSEQ'   1 0 "" }
 { 'LSEQR'  2 0 "" }
 { 'LASEQ'  2 0 "" }
 { 'LMSEQ'  3 0 "" }
 { 'LDSEQ'  3 0 "" }
 { 'LMRPT'  2 0 "" }
 { 'LWHL'   3 0 "" } 
 
 { 'LDDUP'  1 0 "" }
 { 'LPOP'   1 0 "" }
 { 'LPOPR'  1 0 "" }
 { 'LPUSH'  2 0 "" }
 { 'LPSHR'  2 0 "" } 
 { 'LPICK'  2 0 "" }
 { 'LREPL'  3 0 "" }
 { 'LRMOV'  2 0 "" }
 { 'LINSR'  2 0 "" }
 { 'LFRST'  2 0 "" }
 { 'LLAST'  2 0 "" }
 { 'LDROP'  1 0 "" }
 { 'LDWHL'  2 0 "" }
 { 'LTWHL'  2 0 "" }
 { 'LFILT'  1 0 "" }
 
 { 'LROLL'  1 0 "" }
 { 'LRLLD'  1 0 "" }
 { 'LROT'   2 0 "" }
 { 'LSWAP'  3 0 "" }
 { 'LSHUF'  1 0 "" }
 
 { 'LINTR'  2 0 "" }
 { 'DOPERM' 2 0 "" }
 { 'DOCOMB' 3 0 "" }
 { 'DOCOPE' 3 0 "" }
 
 { 'LMAX'   1 1 "" }
 { 'LMIN'   1 1 "" }
 { 'LUNION' 2 0 "" }
 { 'NL→I'   1 0 "" }
 { 'I→NL'   1 0 "" }
 { 'LCLLT'  1 0 "" }
 { 'LDIST'  2 0 "" }
 { 'LGRP'   2 0 "" }
 { 'LRPCT'  1 0 "" }
 { 'LRPC→'  1 0 "" }
 { 'LSDIV'  1 0 "" }
 { 'SPLIT'  2 0 "" }
 { 'RSPLT'  2 0 "" }
 { 'LSSR'   3 0 "" }
 { 'LCNT'   2 0 "" }
 { 'LDUPL'  1 0 "" }
 { 'MPOS'   2 0 "" } 
 { 'LDIFF'  2 0 "" } 
 { 'LXIL'   2 0 "" } 
 { 'LXILR'  2 0 "" } 
 { 'FOOT'   1 0 "" }  
 { 'MDIST'  2 0 "" } 
 { 'LMAP'   2 0 "" } 
 { 'DOLLST' 2 0 "" }
 { 'LCPRD'  1 0 "" }
}

@---------------------------------------------------------------
'$MENU'
@ ===============================================================
@  Menu, submenus and help definition
@ =============================================== Begin Main menu
{
@-------------- ---------------------------- Begin create submenu
{ { "Creat" 1 }  « {

{ "LSEQ" LSEQ
"Create a list from 1 to n
or from -1 to -n
I<a> → L<1..a>" }
 
{ "LSEQR" LSEQR 
"Create a list from a to b

I<a> I<b> → L<a..b>" }

{ "LASEQ" LASEQ
"Numeric sequence by repetitive
addition
I<start> I<inc> I<times> → L<i>" }
 
{ "LMSEQ" LMSEQ 
"List multiplicative sequence
Ex: 2 2 4 → {2 4 8 16}
R<start> R<mult> I<times> → L" } 
 
{ "LDSEQ" LDSEQ 
"List divide sequence
Ex: 2 2 4 → {2 1 0.5 0.25}
R<start> R<div> I<times> → L" } 

{ "LMRPT" LMRPT 
"Repeat a list n times

L<l> I<n> → L<n times l>..." }

{ "LWHL" LWHL 
"Execute action repeatedly until
check condition is false
O P<action> P<condition> → L<o>..." }

} TMENULST » "Creates list" } 
@ -------------------------------------------- End Create submenu

@ -------------------------------------------- Begin Edit submenu
{ { "Edit" 1 } « { 

{ "LDDUP" LDDUP 
"Deduplicate items of a list
Ex : {a b c b d} → {a b c d} 
L<o> → L<o>" }

{ "LPOP" LPOP
"Retrieves first elmt in a list
leaving the rest on the stack
L<o> → L<o> O" }

{ "LPOPR" LPOPR
"Retrieves last elmt in a list
leaving the rest on the stack
L<o> → L<o> O" }

{ "LPUSH" LPUSH
"Add object to front of list
Unlike ADD, list is add as list
L O → L" }

{ "LPSHR" LPSHR
"Add object to end of list
Unlike ADD, list is add as list
L O → L" }

{ "LPICK" LPICK 
"return list elmts in specific order
Ex:{a b c d} {2 4} → {b d}
L<o> L<i> → L<o>" }

{ "LREPL" LREPL 
"{a b c d} {2 4} {x y}
→ {a x c y}
L<o> L<i> L<o> → L<o>" }

{ "LRMOV" LRMOV
"Remove one or more elmts
from a list as indicated 
L<o> L<i> or I → L<o>" }

{ "LINSR" LINSR 
"Insert one or more elmts
in a list
L<o> I L<o> or I → L<o>" }

{ "LFRST" LFRST
"returns the first <n> elmts
of a list
L<o> I → L<o>" }

{ "LLAST" LLAST
"returns the last <n> elmts
of a list
L<o> I → L<o>" }

{ "FOOT" FOOT
"Returns the last elmt
of a list
L<o> → O" }

{ "LDROP" LDROP
"Drop the specified count of
obj from begin(+) or end(-) 
L<o> I<+-> → L<o>" }

{ "LDWHL" LDWHL
"Drops elmts from beginning 
while match the  condition
L<o> P<t/f> → L<o>" }

{ "LTWHL" LTWHL
"Takes elmts from beginning 
while match the  condition
L<o> P<t/f> → L<o>" }

{ "LFILT" LFILT 
"Returns a list for wich
the supplied prog is true
L<o> P → L<o> " }

} TMENULST » "" }


@ ---------------------------------------------- End Edit submenu

@ ------------------------------------- Begin Arrangement submenu
{ { "Arrng" 1 }  « {
 
{ "LROLL" LROLL 
"Roll the list. Equivalent
to 1 LROT
L<o> I → L<o>" }

{ "LRLLD" LRLLD 
"Roll down the list. 
Equivalent to -1 LROT
L<o> I → L<o>" } 

{ "LROT"  LROT
"Rotates list elements left or 
right as indicated by count
L<o> I → L<o>" }

{ "LSWAP" LSWAP 
"Swap the position of two
elements of the list
L<o> I I → L<o>" }

{ "LSHUF" LSHUF 
"Shuffles the content of 
a list
L<o> →  L<o>" }

{ "LSSR" LSSR 
"Reverse a subsequence of
a list between a and b
L<o> I<a> I<b> → L<o>" }
 
} TMENULST » "Arrangement" } 
@ --------------------------------------- End Arrangement submenu

@ ------------------------------------------- Begin Group submenu
{ { "Group" 1 }  « {
 
{ "LCLLT" LCLLT 
"Collates a list of sublist

L<l<o>> → L<o>" }

{ "LDIST" LDIST 
"Distributes list in sublist
of size I
L<o> I → L<o>" }

{ "MDIST" MDIST 
"Distributes list in sublist
of size I after explode inner
L<o> I → L<o>" }

{ "LGRP" LGRP 
"Replaces repeated elmts with
a signle instance
L<o> → L<o>" }

{ "LRPCT" LRPCT 
"Like LGRP and count each elements

L<o> → L<l<o>l<o>>" }

{ "LRPC→" LRPC→ 
"Restores a list that was grouped
with LRCPT
L<l<o>l<o>> → L<o>" }

{ "LSDIV" LSDIV 
"Subdivides a list in list of
n elmts (or n list if n<0)
L<o> → L<l<o>...l<o>>" }

{ "SPLIT" SPLIT 
"Split a list in two parts
First part is I items
L<o> I → L<o> L<o>" }

{ "RSPLT" RSPLT 
"Split a list in two parts
Right part is I items
L<o> I → L<o> L<o>" }

{ "LXIL" LXIL 
"Return a list with first level
inner list exploded
L<o> → L<o>" }

{ "LXILR" LXILR
"Return a list with all the
inner list exploded
L<o> → L<o>" }

} TMENULST » "Gouping lists" } 
@ --------------------------------------------- End Group submenu

@ -------------------------------------------- Begin Test submenu
{ { "Test"  1 } « {

{ "LCNT" LCNT 
"Count occurences of an object
in a list
L<o> O → I" }

{ "MPOS" MPOS 
"Find all positions of an
object in a list
L<o> O → L<i>" }

{ "LDUPL" LDUPL 
"Test if there is duplicate 
objects in a list
L<o> → I<t/f>" }


} TMENULST » "Tests" } 
@ ---------------------------------------------- End Test submenu

@ ------------------------------------- Begin Combination submenu
{ { "Comb"  1 } « {

{ "DOCOMB" DOCOMB 
"Apply a pgm to all combinations
of n elmt of list. BREAK to exit
L<o> I<n> P → L<o>" }

{ "DOPERM" DOPERM 
"Apply a pgm to all permutations
of a list. BREAK to exit
L<o> P → L<o>" }

{ "DOCOPE" DOCOPE 
"Apply a pgm to all combinations
and permutations. BREAK to exit
L<o> I<n> P → L<o>" }

{ "DOLLST" DOLLST 
"Like DOLIST but with list of lists.
{{a b}{c d}} «+» → {'a+c' 'b+d'}
L<l<o>..l<o>> P → L<<lo>..l<o>>" }

{ "LMAP" LMAP 
"Apply a pgm to all elmt but
whithout explore inner list
L<o> P → L<o>" }

{ "LCPRD" LCPRD 
"Returns list of sublists with
cartesian product of s/lists input
L<l<o>l<o>...> → L<l<o>l<o>...>" }


} TMENULST » "Combinatorics" } 
@ --------------------------------------- End Combination submenu

@ -------------------------------------------- Begin Math submenu
{ { "Math"  1 } « {

{ "I→NL" I→NL 
"Convert an integer to
a list of digits
I → L<I>" }

{ "NL→I" NL→I
"Convert a list of digits
to an integer
L<i> → I" }

{ "LMAX" LMAX "Max item of a list" }

{ "LMIN" LMIN "Min item of a list" }

{ "LINTR" LINTR 
"2 Lists intersection.
Deduplicate
L<o> L<o> → L<o> " }

{ "LUNION" LUNION 
"2 Lists union
Deduplicate
L<o> L<o> → L<o> " }
 
{ "LDIFF" LDIFF 
"List of object in list level2 that
don't match object list level 1
L<o> L<o> → L<o>" }

} TMENULST » "Math on lists" } 
@ ---------------------------------------------- End Math submenu
} 
@================================================================
ENDDIR

USAGE EXEMPLES :

returns the list of numbers from 1 to 1000 not divisible by 7 :

Code:

1000 LSEQ « 7 MOD » LFILT

List of the 69 numbers <1000 with sum on digits is 11 :

Code:

999 LSEQ « I→NL ΣLIST 11 == » LFILT

random shuffle from a list

Code:

49 LSEQ LSHUF

Sum of the 200 first decimals of PI (HP50g : 0.029 sec USB powered / 0.246 sec on battery)

Code:

GETPREC 202 SETPREC 
  π →NUM FP 1E200 * I→NL ΣLIST 
SWAP SETPREC

Permute letters of a string

Code:

{ "a" "b" "c" "d" } « ΣLIST » DOPERM 
-> { "abcd" "bacd" "cabd" "acbd" "bcad" "cbad" "dbac" "bdac" "adbc"
"dabc" "badc" "abdc" "acdb" "cadb" "dacb" "adcb" "cdab" "dcab"
"dcba" "cdba" "bdca" "dbca" "cbda" "bcda" }

List of numbers with all the 1,2,3,4,7 digits witch are primes

Code:

{ 1 2 3 4 7 } « NL→I IF DUP ISPRIME? NOT THEN DROP END » DOPERM
->  { 12347 21347 31247 24137 12437 14327 34127 34217 24317 23417
12473 12743 27143 47123 14723 74231 72431 27431 73421 43721 34721
24371 43271 23741 72341 }