Post Reply 
ListExtras: A teaser for Listextensions on the Prime
11-01-2018, 06:17 PM (This post was last modified: 11-02-2018 07:43 PM by StephenG1CMZ.)
Post: #1
ListExtras: A teaser for Listextensions on the Prime
Here is a teaser for List Extras...Totally untested.

I already have a collection of list routines in my List, Means and SortL programs.
ListExtras aims to eventually implement relevant functionality on the Prime comparable to DavidM's Listextensions for the HP48..HP50 family, to assist portability between the two platforms.

The current teaser should be considered untested pseudocode...
i wanted to put something online just in case.
Code:

 LOCAL CRID:="ListExtras API V0.01 © 2018";
 LOCAL MORETEXT:="ListExtras by StephenG1CMZ on HP Prime\nInspired by DavidM's Listext on HP48-50.";
 LOCAL MN:="ListExtras.";//Name

 //IMPORT({List});        //Required
 //IMPORT({Means,SortL}); //Required

 LOCAL TP;

 LOCAL ExBool:=0;//Request Exact//MEX

 LOCAL NOVALERR:=ListIsEmptyError;//LPOP
 LOCAL BADDIMERR:=ListIsEmptyError;

 //Forward
 LNMRL(LST);
 
 EXPORT ABOUT()
 BEGIN
  MSGBOX(CRID);
  MSGBOX(MORETEXT);
  MSGBOX("An early teaser...\nTotally untested");
 END;

 TBD()
 BEGIN
  MSGBOX(MN+"TBD");
 END;

 EXPORT ArrangeFunctions()
 BEGIN

 END;

 EXPORT LRLLD(LST)
 //INVERSE ROTATE (=−1 ROT)
 BEGIN
  LOCAL HD:=LST(1);
  RETURN CONCAT(ListAFTER(LST,1),HD);

 END;

 EXPORT LROLL(LST)
 //ROTATE (=1 ROT)
 BEGIN
  LOCAL LAST:=LST(0);
  RETURN CONCAT(LAST,ListBEFORE(LST,SIZE(LST)));
 END;

 EXPORT LROT(LST,ROTNUM)
 //ROTATE A LIST NUM POSITIONS (NUM SIGNED)
 //NEED -1 REPEATEDLY TBD
 BEGIN
  LOCAL II;
  IF ROTNUM THEN
   TBD();
   FOR II FROM 1 TO ABS(ROTNUM) DO
    IF ROTNUM>0 THEN
     RETURN LROLL(LST);
    ELSE
     RETURN LRLLD(LST);
    END; 
   END;
  END;
  RETURN LST; //NO ROT
 END;

 EXPORT LSWAP(LST,POSN1,POSN2)
 //SWAP 2 ELEMENTS
 BEGIN
  LOCAL TMP:=LST(POSN1);
  LST(POSN1):=LST(POSN2);
  LST(POSN2):=TMP;
 END;

 EXPORT LSSR(LST,POSN1,POSN2)
 //REVERSES PART OF A LIST, RETURNS WHOLE LST
 //EXT: POSN>0 INCLUDED (NULL=POSN=0)
 BEGIN
  LOCAL TMP:=REVERSE(ListSLICE(LST,POSN1,POSN2));
  LOCAL BEF:=ListBEFORE(LST,POSN1);
  LOCAL AFT:=ListAFTER(LST,POSN2);
  ListANS:=CONCAT(BEF,CONCAT(TMP,AFT));
  RETURN ListANS;
 END;

 EXPORT LSHUF(LSTNUM)
 //SHUFFLES LST
 BEGIN
  RETURN ListSHUFFLE(LSTNUM);
 END;

 EXPORT REV(LstStN)
 //EXT: REVERSE LISTS STRINGS N
 //THIS IMPLEMENT ALSO DOES SUBLISTS
 //QUERY DO WE NEED? DOES BUILTIN REVERSE SAME?
  BEGIN
    TP:=TYPE(LstStN);
    CASE
    IF TP==TYPELST THEN RETURN REVERSE(LstStN); END;
    IF TP==TYPESTR THEN TBD(); END;
    DEFAULT
    END; 
 END;

 EXPORT EditFunctions()
 BEGIN

 END;

 EXPORT LDDUP(LST)
 //EDIT:REMOVE DUPLICATES
 //EXT:SAME SEQ
 //X:NATIVE SEEMS TO
 BEGIN
  RETURN ListREMOVEDUPLICATES(LST);
 END;

 EXPORT LHDTL(LST)
 //EDIT: AKA LPOP. NULL=NOVAL ERR
 //X: Tail in ListANS. NULL=ListIsEmptyError
 BEGIN
  RETURN ListHEAD(LST);
 END;

 EXPORT LINSR(LST,POSN,ITEMS)
 //EDIT: INSERT ITEM(S) AKA LINSRT
 //INSERTS 1 ITEM OR A LIST OF ITEMS
 //QUERY: HOW TO INSERT 1 ITEM OF TYPE LST?
 //EXT: POSN<2 NEEDS HANDLING
 //X: EXT COMPATABILITY TBD
 BEGIN
  RETURN ListINSERT(LST,POSN,ITEMS);
 END;

 EXPORT LINSRT(LST,POSN,ITEMS)
 //AKA LINSR
 BEGIN
  RETURN LINSR(LST,POSN,ITEMS);
 END;

 EXPORT LFIRST(LST,NUM) 
 //EDIT: RETURN FIRST ITEMS AKA LFRST
 //GUARDS AND NEGATIVES TBD
 //EXT: N<0 UNK ERR N==0 NULL
 //X:NO ERROR YET
 BEGIN
  RETURN ListBEFORE(LST,NUM+1);
 END;

 EXPORT LFRST(LST,NUM)
 //AKA LFIRST
 BEGIN
  RETURN LFIRST(LST,NUM);
 END;

 EXPORT LLAST(LST,NUM)
 //EDIT: RETURN LAST ITEMS
 //EXT: N<0 UNK ERR 0 NULL N>LST LST
 //X: GUARDS AND NEGATIVES TBD
 BEGIN
  LOCAL POSN:=SIZE(LST)-NUM;
  RETURN ListAFTER(LST,POSN);
 END;

 EXPORT LPICK(LST,GETLST)
 //EXT:EMPTY GET=NULL
 BEGIN
  RETURN ListGETLIST(LST,GETLST);
 END;

 EXPORT LPOP(LST)
 //EDIT: AKA LHDTL
 BEGIN
  RETURN LHDTL(LST);
 END;

 EXPORT LPOPR(LST)
 //EDIT: POP LAST ITEM
 //EXT: NULL=NULL AND NOVAL ERR
 //X: ERR TBD
 BEGIN
  IF SIZE(LST) THEN
   ListANS:=ListBEFORE(LST,SIZE(LST));
   RETURN LST(0);
  END;
  ListANS:={};
  RETURN {};
 END;

 EXPORT LPSHR(LST,ITEM)
 //EDIT: PUSH ITEM TO RIGHT OF LST
 //EXT: ITEMTYPE=LST:PUSH 1 ITEM NULLNULL={{}} 
 //X: TBD NULL GUARDS CF LPUSH
 BEGIN
  LST(0):=ITEM;
 END;

 EXPORT LPUSH(LST,ITEM)
 //EDIT:ADD ITEM TO FRONT
 //EXT NULLNULL={{}}
 //TBD:NULL GUARDS DONT WORK
 //LATER:USE GUARDS IN LIST
 BEGIN
  IF LST=={} THEN 
   RETURN {ITEM};
  END;
  IF ITEM=={} THEN
   RETURN CONCAT({},LST);
  END;
  RETURN ListINSERT(LST,1,ITEM);
 END;

 EXPORT LRCL(LST)
 //EXT:({A}) -> 5 IF A IS 5 
 //X: ({"2+3"}) -> 5 ==> NOT THE SAME
 BEGIN
  LOCAL II;
  ListANS:={};
  FOR II FROM  1 TO  SIZE(LST) DO
   ListANS(0):=EXPR(LST(II));
  END;
  RETURN ListANS;
 END;

 EXPORT LREPL(LST,TARGETLST,REPLLST)
 //WHEN TARGETLSTn EXISTS IN LST
 //REPLACE IT WITH REPLLSTn
 //RETURN MODIFIED LST
 //Hint: CALL ListREPLACE FOR EACH n
 //QUERY: WHAT HAPPENS IF CHANGED TWICE
 BEGIN
  LOCAL II;
  ListANS:=LST;
  //Can this be more efIcient?
  FOR II FROM 1 TO SIZE(TARGETLST)  DO
   ListANS:=ListREPLACE(ListANS,TARGETLST(II),REPLLST(II)); 
  END;
  RETURN ListANS;
 END;

 EXPORT LRMOV(LST,POSNS)
 //EDIT: REMOVE ITEMS
 //EXT: REMOVE MULTIPLE POSNS IGNORING DUPLICATE POSNS
 //X: SINGLE POSN ONLY FOR NOW
 BEGIN
  IF TYPE(POSNS)==TYPELST THEN
   TBD();
  END;
  RETURN ListREMOVEX(LST,POSNS);
 END;

 EXPORT GroupFunctions()
 BEGIN

 END;

 EXPORT GrpLCLLT(LSTS)
 //List Collate. INVERSE OF LDIST
 BEGIN
   LOCAL II,JJ;
   LOCAL SIZE1:=SIZE(LSTS(1));
   ListANS:={};

   //REQUIRE ALL SIZES SAME
   FOR II FROM  1 TO SIZE(LSTS) DO
    IF SIZE1≠SIZE(LSTS(II)) THEN
     RETURN "BAD DIM";//UNK ERR
    END;
   END;
   //OK, COLLATE
   FOR JJ FROM  1 TO SIZE1 DO
    FOR II:=1 TO SIZE(LSTS) DO
     ListANS(0):=LSTS(II,JJ);
    END; 
   END;
 END;
 
 EXPORT LDIST(LST,NUM)
 //DISTRIBUTE ITEMS INTO NUM SUBLISTS.INVERSE OF LCLLT. CF LSDIV
 //EXT: NUM MUST EVENLY DIVIDE LISTSIZE. UNK ERR
 //HINT REPEATEDLY CALL ListBEFORE
 BEGIN
  TBD();
 END;

 EXPORT LGRP(LST)
 //GROUP REPEATED ELEMENTS IE NO DUPLICATS
 BEGIN
  RETURN ListREMOVEDUPLICATES(LST);
 END;

 EXPORT LRPCT(LST)
 //LIST LGRP ELEMENTS AND COUNTS
 //EXT: NULL={{},{}}
 //X:DITTO
 BEGIN
  RETURN ListCOUNTS(LST);
 END;

 EXPORT LRPCTo(LSTVLSTF)
 //INVERSE
 BEGIN
  LOCAL LSTV:=LSTVLSTF(1);
  LOCAL LSTF:=LSTVLSTF(2);
  RETURN ListUNCOUNTS(LSTV,LSTF);
 END;

 EXPORT LSDIV(LST,SUBSIZE)
 //SPLIT A LIST INTO LISTS OF SIZE SUBSIZE. CF LDIST
 //EXT: NO REMNANT. UNK ERR.
 //HINT REPEATEDLY CALL ListBEFORE 
 BEGIN
  TBD(); 
 END;

 EXPORT LXIL(LST)
 //FLATTEN TOP LISTS
 BEGIN
  RETURN ListFLATTENTOP(LST);
 END;

 EXPORT LXILR(LST)
 //FLATTEN LISTS RECURSIVELY
 BEGIN
  RETURN ListFLATTENALL(LST);
 END;

 EXPORT RSPLT(LstStN,RSIZE)
 //RIGHT SPLIT Lst St Or N. SZ=IP(RSIZE)
 //EXT:LST: RETURN 2 LISTS, RIGHT OF SIZE RSIZE
 //SIMILARLY FOR ST AND N 
 BEGIN
  TBD();
 END;

 EXPORT SPLIT(LstStN,LSIZE)
 //SPLIT A Lst St OR N. (IE LSPLT CF RSPLT) SZ=IP(LSIZE)
 BEGIN
  TBD();
 END;

 EXPORT SLISTTo(LST)
 //EXT:SAFE LST AVOIDING GARBAGE COLLECTION
 //X: IRRELEVANT?
 BEGIN
  RETURN LST;
 END;

 EXPORT MakeFunctions()
 BEGIN

 END;

 EXPORT MakeLASEQ(FRM,CHNG,NUM)
 BEGIN
  LOCAL XX;
  RETURN IFTE(NUM>0,MAKELIST(FRM+(CHNG*XX),XX,0,NUM-1),{});  
 END;

 EXPORT MakeLDSEQ(FRM,CHNG,NUM)
 BEGIN
   LOCAL XX;
   IF CHNG==0 THEN
    RETURN "NaN";//DIVBY0
   END;
   IF (TYPE(FRM)==TYPE(CHNG) AND TYPE(CHNG)==TYPEINT) OR ExBool THEN
    RETURN IFTE(NUM>0,MAKELIST(exact(FRM/(CHNG^XX)),XX,0,NUM-1),{}); 
   END;
    RETURN IFTE(NUM>0,MAKELIST(FRM/(CHNG^XX),XX,0,NUM-1),{}); 
 END;

 EXPORT MakeLMSEQ(FRM,CHNG,NUM)
 BEGIN
   LOCAL XX;
   RETURN IFTE(NUM>0,MAKELIST(FRM*(CHNG^XX),XX,0,NUM-1),{}); 
 END;

 EXPORT MakeLSEQ(CNT)
 //Create CNT REAL integers
 //Return Real integer (No N)
 BEGIN
  LOCAL XX;
  RETURN ListANS:=IFTE(CNT,MAKELIST(XX,XX,SIGN(CNT),CNT),{});
 END;

 EXPORT MakeLSEQR(FRM,TOO)
 //Create CNT REAL integers
 //Return Real integer (No N)
 BEGIN
  LOCAL XX;
  RETURN ListANS:=IFTE(TOO-FRM,MAKELIST(XX,XX,FRM,TOO),{});
 END;

 EXPORT MakeLMRPT(ITEMS,RPTCNT)
 BEGIN
  IF RPTCNT<0 THEN
   RETURN {};//OR NEGATE
  END;
  IF TYPE(ITEMS)≠TYPELST AND RPTCNT==1 THEN
   //GUARD AGAINST SINGLE ITEM ONCE NOT RETURNING A LIST
   RETURN MakeLMRPT({ITEMS},RPTCNT);
  END;

  IF RPTCNT>1 THEN
   RETURN CONCAT(ITEMS,MakeLMRPT(ITEMS,RPTCNT-1));
  END;
  RETURN IFTE(RPTCNT,ITEMS,{});
 END;

 EXPORT MathFunctions()
 BEGIN

 END;

 EXPORT LMAX(LST)
 //EXT: CAN ALSO MAX LISTS OF STRINGS
 //EXT: NULL=INVALID DIM
 //X: NUMERICS ONLY
 BEGIN
  //RETURN ListMAX(LST);
  RETURN MAX(LST);
 END;

 EXPORT LMIN(LST)
 //EXT: CAN ALSO MIN LISTS OF STRINGS
 //EXT: NULL=INVALID DIM
 //X: NUMERICS ONLY
 BEGIN
  //ListMIN NOT IMP?
  RETURN MIN(LST);
 END;

 EXPORT LSUM(LST)
 //HANDLES NULL
 BEGIN
  //RETURN ListΣLIST(LST);
 END;

 EXPORT LPROD(LST)
 //HANDLES NULL
 BEGIN
  //RETURN ListΠLIST(LST);
 END;

 EXPORT SortFunctions()
 BEGIN

 END;

 EXPORT KSORT(LST,KEYLST)
 //EXT:NULL KEY RETURNS TARGET UNCHANGED
 //EXT:NULL TARGET AND NON NULL KEY=BAD DIM
 //RETURN 2 LISTS
 BEGIN
  RETURN SortByKeyLST(LST,KEYLST);
 END;

 EXPORT KSORTFUN(LST,KEYLST,KEYFUNC)
 //Pysort implements sort functions
 //NB The ext list sequence is not implemented
 BEGIN
  MSGBOX("Use SORTL.Pysort");
 END;

 EXPORT StringFunctions()
 BEGIN

 END;

 EXPORT StringLOCASE(ST)
 //EXT:ST
 //X-ALSO LST
 BEGIN
  RETURN LOWER(ST);
 END;

 EXPORT StringUPCASE(ST)
 //EXT:ST
 //X-ALSO LST
 BEGIN
  RETURN UPPER(ST);
 END;

 EXPORT RPTCHR(ST,RPTCOUNT)
 //QUERY: IN EXT IF STRING IS >1 CHAR
 //IS THE COUNT THE NUMBER OF REPETITIONS OF STRING
 //OR NUMBER OF CHARACTERS
 //(REPETITIONS EASIER?)
 //HINT I HAVE IMPLEMENTED THIS RECURSIVELY IN A PROGRAM
 BEGIN
  TBD();//BUT WHERE 
 END;

 EXPORT TestFunctions()
 BEGIN
  
 END;

 EXPORT LCNT(LST,ITEM)
 //NB TO COUNT ITEM=LISTS SEE IMPLEMENT
 BEGIN
  RETURN ListCOUNTITEMS(LST,ITEM);
 END;

 EXPORT LEQ(LST)
 //TST ALL ITEMS IN 1 LST ARE SAME
 //EXT: NULL OR SIZE 1 RETURNS TRUE (NO NON-MATCHES)
 BEGIN
  LOCAL XX;
  LOCAL TMP:=LST(1);
  ListANS:=MAKELIST(TMP,XX,1,SIZE(LST));
  RETURN EQ(LST,TMP);
 END;

 EXPORT MPOS(LstSt,ITEM)
 //Find ITEM in Lst or St
 BEGIN
  IF TYPE(LstSt)==TYPELST THEN
   RETURN ListFIND(LstSt,ITEM);
  ELSE
   TBD();
  END;
 END;

 EXPORT MPOSL()
 //AS MPOS BUT IF LSTn IS A LIST, MATCH IN THERE TOO
 //BUT NOT FULLY RECURSIVEO JUST ONE LEVEL
 BEGIN
  TBD();
 END;
 
 EXPORT LNMRL(LST)
 //EXT:NORMALISE COMPRESSES LST
 //X:NOP 
 BEGIN
  RETURN LST; 
 END;

 EXPORT LSAME(LST1,LST2)
 //EXT: IMPLEMENTS LMRL SAME
 BEGIN
  RETURN EQ(LST1,LST2);
 END;

 EXPORT ThatsAllFunctions()
 BEGIN

 END;

 EXPORT LISTEXTRAS()
 BEGIN

 END;

Stephen Lewkowicz (G1CMZ)
Visit this user's website Find all posts by this user
Quote this message in a reply
11-02-2018, 12:41 PM
Post: #2
RE: List Extras: A teaser for Listextensions on the Prime
Nice, no time to test it but it is great that you put effort on it and shared it Smile

Wikis are great, Contribute :)
Find all posts by this user
Quote this message in a reply
Post Reply 




User(s) browsing this thread: 1 Guest(s)