Here is the code v1.0d, without google drive :
Code:
@================================================================
@ List Extension for newRPL Août 2023
@----------------------------------------------------------------
DIRECTORY
@---------------------------------------------------------------
'$LIBID' 'LstX'
@---------------------------------------------------------------
'$TITLE'
"List extended lib v1.01d 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'
«
IF DUP SIZE 1 > THEN
REVLIST LIST→ {}
1 ROT START
IF SWAP DUP2 POS THEN DROP ELSE
IF DUP TYPE 62 == THEN 1 →LIST END ADD
END
NEXT
END
»
@----------------------------------------------------------------
'LPOP' « DUP HEAD SWAP TAIL SWAP »
@----------------------------------------------------------------
'LPOPR' « DUPDUP SIZE 1 - LFRST SWAP 1 LLAST LIST→ 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'
« PICK3 TYPE → a b t
« CASE
t 62 == THEN @ it's a list { ... }
DUP a GET OVER b GET
UNROT b SWAP PUT SWAP a SWAP PUT
END
t 32 == THEN @ It's a variable containing a list
DUPDUP a GET OVER b GET
UNROT b SWAP PUT a SWAP PUT
END
END
»
»
@---------------------------------------------------------------
'LSHUF'
« IF DUP TYPE 10 == THEN LSEQ END
LIST→ → 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 LIST→ 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
LIST→ 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
«
1 « IF Lst2 OVER POS NOT THEN DROP END » DOSUBS
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
« LIST→
« 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→' « LIST→ « 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 LIST→ DROP END » DOSUBS
»
@---------------------------------------------------------------
'LXILR' « DO DUP LXIL UNTIL DUP ROT SAME END »
@---------------------------------------------------------------
'MDIST' « SWAP LXILR SWAP LDIST »
@---------------------------------------------------------------
'LMAP'
« → Pgm
« 1 « IF DUP TYPE 62 ≠ THEN Pgm END » DOSUBS »
»
@---------------------------------------------------------------
'DOLLST' « → Pgm « LIST→ '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 LIST→ DROP Recur EVAL
List 2 LDROP
SWAP LPUSH 'List' STO
END
List LXIL
ELSE {} END
»
»
@==============================================================
'DOSORT'
« 0 → List KSORT.Order Pivot
«
« 'List' Pivot Dernier LSWAP
Premier 'j' LSTO
Premier Dernier 1 - FOR 'i'
IF 'List' i GET 'List' Dernier GET KSORT.Order THEN
'List' i j LSWAP
1 'j' STO+
END
NEXT
'List' Dernier j LSWAP
j
»
« → Premier Dernier
« IF Premier Dernier < THEN
Dernier Premier - RAND * 0 RND Premier + 'Pivot' STO
Part 'Pivot' STO
Premier Pivot 1 - Tri
Pivot 1 + Dernier Tri
END
»
»
→ Part Tri
« 1 List SIZE Tri EVAL List »
»
»
@================================================================
'SGE'
« OVER SIZE OVER SIZE → s1 s2 t1 t2
« 1 @ True (great or equal) by default
IF s1 s2 SAME THEN EXIT DROP END
IF t2 NOT THEN EXIT END
IF t1 NOT THEN NOT EXIT END
1 t1 FOR 'i'
s1 i i SUB UTF8→ 1 GET
s2 i i SUB UTF8→ 1 GET - 'n' LSTO
IF n 0 > THEN EXIT END
IF n 0 < THEN NOT EXIT END
IF i t2 == THEN EXIT END
IF i t1 == THEN NOT EXIT END
NEXT
»
»
@---------------------------------------------------------------
'SLT' « SGE NOT »
@---------------------------------------------------------------
'SLE' « DUP2 IF SAME THEN DROP2 1 ELSE SGE NOT END »
@---------------------------------------------------------------
'SGT' « DUP2 IF SAME THEN DROP2 0 ELSE SGE END »
@---------------------------------------------------------------
'LCASE'
« IF DUP SIZE THEN
UTF8→
« IF DUPDUP #41h ≥ SWAP #5Ah ≤ AND THEN #20h + END » MAP
→UTF8
END »
@---------------------------------------------------------------
'UCASE'
« IF DUP SIZE THEN
UTF8→
« IF DUPDUP #61h ≥ SWAP #7Ah ≤ AND THEN #20h - END » MAP
→UTF8
END »
@---------------------------------------------------------------
'S→SL' « IF DUP SIZE THEN UTF8→ « →UTF8 » MAP END »
@---------------------------------------------------------------
'ALL?'
« OVER SIZE → 'ALL?.L' 'ALL?.P' 'ALL?.S'
«
IF ALL?.S NOT THEN 0 EXIT END
1 @ True by default
1 ALL?.S FOR 'i'
IF 'ALL?.L' i GET ALL?.P EVAL NOT THEN
NOT EXIT @ returns FALSE (0)
END
NEXT
»
»
@---------------------------------------------------------------
'VL→I' « RCL NL→I »
@---------------------------------------------------------------
'ISEVEN?' « 2 MOD NOT »
@---------------------------------------------------------------
'ISODD?' « 2 MOD »
@---------------------------------------------------------------
'LINCL'
« → list2
« IF DUP SIZE THEN
1 « IF list2 OVER POS DUP THEN list2 SWAP LRMOV 'list2' STO ELSE DROP2 END »
DOSUBS
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 "" }
{ 'MDIST' 2 0 "" }
{ 'LMAP' 2 0 "" }
{ 'DOLLST' 2 0 "" }
{ 'LCPRD' 1 0 "" }
{ 'DOSORT' 1 0 "" }
{ 'SGE' 2 0 "" }
{ 'SLE' 2 0 "" }
{ 'SGT' 2 0 "" }
{ 'SLT' 2 0 "" }
{ 'LCASE' 1 0 "" }
{ 'UCASE' 1 0 "" }
{ 'S→SL' 1 0 "" }
{ 'ALL?' 2 0 "" }
{ 'VL→I' 1 0 "" }
{ 'ISEVEN?' 1 0 "" }
{ 'ISODD?' 1 0 "" }
{ 'LINCL' 1 0 "" }
}
@---------------------------------------------------------------
'$MENU'
@ ===============================================================
@ Menu, submenus and help definition
@ =============================================== Begin Main menu
{
@-------------- ---------------------------- Begin create submenu
{ { "Creat" 1 } « {
{ "LSEQ" LSEQ
"Creates a list of int from
1 to n or from -1 to -n
I<a> → L<1..a>" }
{ "LSEQR" LSEQR
"Creates a list of integer
from a to b
I<a> I<b> → L<a..b>" }
{ "LASEQ" LASEQ
"Integer sequence by repetitive
addition
I<start> I<inc> I<times> → L<i>" }
{ "LMSEQ" LMSEQ
"Int multiplicative sequence
Ex: 2 2 4 → {2 4 8 16}
R<start> R<mult> I<times> → L" }
{ "LDSEQ" LDSEQ
"Int divide sequence
Ex: 2 2 4 → {2 1 0.5 0.25}
R<start> R<div> I<times> → L" }
{ "LMRPT" LMRPT
"Repeat a list or object
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>" }
{ "LSHUF" LSHUF
"Shuffles the content of a list
of create a random list of int
L<o> or I → L<o> or L<i>" }
} TMENULST » "Commands to create new lists" }
@ -------------------------------------------- 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>" }
{ "RHEAD" RHEAD
"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 »
"Get, put, swap, insert,
delete etc objects in list" }
@ ---------------------------------------------- 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>" }
{ "DOSORT" DOSORT
"Sort a list with an order given
by a program
L<o> P → 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>" }
{ "ALL?" ALL?
"Test if all the objects
of the list checks prog P
L<o> P → I<t/f>" }
} TMENULST » "Tests on lists or items of list" }
@ ---------------------------------------------- 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 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 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 on lists" }
@ --------------------------------------- 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" }
{ "VL→I" VL→I
"Convert a list of variables
that store a digit to an integer
L<v> → I" }
{ "LMAX" LMAX "Max item in a list" }
{ "LMIN" LMIN "Min item in 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 objects in list lvl2 that
don't match objects list level 1
L<o> L<o> → L<o>" }
{ "LINCL" LINCL
"List of objects in list level2
includes in objects list level1
L<o> L<o> → L<o>" }
{ "ISEVEN?" ISEVEN?
" is the number even ?
I → 0/1 " }
{ "ISODD?" ISODD?
" is the number odd ?
I → 0/1 " }
} TMENULST » "Math on lists" }
@ ---------------------------------------------- End Math submenu
@ ------------------------------------------ Begin String submenu
{ { "String" 1 } « {
{ "SGT" SGT
"Test if a string is
strictly greater to another
S S → 0/1" }
{ "SLT" SLT
"Test if a string is strictly
less to another
S S → 0/1" }
{ "SGE" SGE
"Test if a string is
greater or equal to another
S S → 0/1" }
{ "SLE" SLE
"Test if a string is less
than or equal to another
S S → 0/1" }
{ "LCASE" LCASE
"Upper to lower cases
S → S" }
{ "UCASE" UCASE
"Lower to upper cases
S → S" }
{ "S→SL" S→SL
"String to chars list
S → L<c>" }
} TMENULST » "String manupulation" }
@ ---------------------------------------------- End String submenu
}
@================================================================
ENDDIR