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

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