I meant more that since IRC is down, I cannot use it, but I wouldn't mind getting to help on that. However, if you have most of the commands already finished, I don't plan to add any more functions to BatLib...

Okay, I think it is bug hunting time I have fixed the graphing bug, and I have added more to dim(126) to make it even better.
Taken from the readme:

126-GroupHookMode dim(126.x,arg1,arg2)

This is used to control the GroupHook settings. Since BatLib automatically
installs all GroupHook apps on the calc in the order they appear in memory, this
command is very useful to manage conflicts. For example, Celtic 3 installed
before Omnicalc will render Omnicalc's real() commands useless (because Celtic 3
thinks they belong to it). You can use this command to swap the order in which
apps are checked.

• dim(126,#) returns the name of the nth app in the GroupHook.
• dim(126.1) will disable all grouphooks.
• dim(126.2) will enable all the apps in the grouphook.
• dim(126.3,#) will disable the nth app in the grouphook.
• dim(126.4,#) will enable the nth app in the grouphook.
• dim(126.5,#,"App") will allow you to rearrange the grouphook order. For

example, to make sure Celtic 3 is checked first, set it in slot 0:
:dim(126.5,"Celtic 3Notes:

• ".DNE" is returned with dim(126.4) and below if there is no nth app (meaning #

was too big).
When using dim(126.5), the hooks are swapped. In the example, the App
previously in position zero will now be in whatever position Celtic 3 was in.

• ".BAD NUMBER" is returned with dim(126.5) if there is no nth app.
• ".DNE" is returned with dim(126.5) if the app does not exist
• ".BAD NAME" is returned with dim(126.5) if the app exists, but is not a

grouphook app.

---

Basically, if you have a program that you want to run Celtic 3, Omnicalc, and BatLib routines in, you should include this at the start of your program:
dim(126.5,"Omnicalc      ;put Omnicalc first so that Celtic 3 doesn't conflict with Omnicalc's real() token.
dim(126.5,1,"Celtic 3
Oh, as another note, app names are usually 8 characters long, so they get padded with spaces at the end. However, since this is not always the case, BatLib does not automatically pad names.

I am thinking of getting this book for somebody. I just wish the campus book store had it in stock I'll probably have to order it online

So you'll no longer disappear during 2 months once in a while? Nice

precisely Now I can be on the evil interwebs all year round.

Hmm, the internet was finally hooked up at home. It got this:

xeactyl,wlel dnoe!me lkies ti.

See, that doesn't work You either said that you like TI or you like IT o.O

Or did you say both?! Talk about message compression!

I have some ideas!
-You can store source code to appvars and still be able to compile them
- If the user tries to execute source code, automatically compile the program if it has not yet been compiled. (Or ask the user)
basically, a Compile+Run option

In case anybody else wanted some arbitrary precision multiplication, here is a routine
;===============================================================
AP_Mul_AP:
;===============================================================
;Inputs:
;     HL points to the first number (little-endian, size prefix 2 bytes)
;     DE points to the second number (little-endian, size prefix 2 bytes)
;     BC points to the output location
;Output:
;     The RAM at HL contains the product (little-endian with
;     size prefix). Size is adjusted so there won't be zeroes
;     at the end.
;Notes:
;     This will erase bytes of RAM at (HL) equal to the
;     size of the first number plus the size of the second.
;     So if you use saveSScreen:
;         First number uses 2+M bytes
;        Second number uses 2+N bytes
;        Output number uses 2+M+N bytes
;     At most, 2+N+2+M+2+M+N=768.
;        2+N+2+M+2+M+N = 768
;              6+2M+2N = 768
;               2(M+N) = 762
;                  M+N = 381
;     In otherwords, you can multiply two, 190 byte numbers. In
;     Decimal, this comes out to roughly two 457 digit numbers
;     to get up to 915 digit number. It requires 14952 bytes of
;     RAM to use two numbers >9000 digits
;===============================================================
     di
;First, we get the size
     ld (output),bc   ;4 bytes, save the output location
     ld c,(hl)
     inc hl
     ld b,(hl)
     inc hl
     ld (Num1Loc),hl  ;3 bytes, save the location of the first number
     ld (Num1Size),bc ;4 bytes, save the size
     ex de,hl
     ld e,(hl)
     inc hl
     ld d,(hl)
     add hl,de
     ld (Num2Loc),hl  ;3 bytes, save the location
     ld (Num2Size),de ;4 bytes, save the size
     ex de,hl
     add hl,bc        ;size of the output RAM
;Now we clear out the bytes for the output
     ld b,h
     ld c,l
     ld hl,(output)
     ld (hl),c
     inc hl
     ld (hl),b
     inc hl
     ld (output),hl
     ld (Num3Size),bc
     xor a
       ld (hl),a
       cpi
       jp pe,$-3
;Now we start multiplying stuff
;We need to do:
;     hl=(Num2Loc)
;     de=(Num1Loc)
;     ix=(output)
;     bc=(Num2Size)
;(hl)_Times_(de)_To_(ix)
   exx
   ld bc,(Num3Size)
   exx
   ld bc,(Num2Size)
;   ld hl,(Num2Loc)
   ex de,hl
Loop1:
   push bc
   ld b,8
Loop2:
;===============================================================
;   rl (output)
;===============================================================
     exx
     ld hl,(output)
     ld d,b
     ld e,c
     dec de
     inc d
     inc e
     or a
       rl (hl)
       inc hl
       dec e
       jr nz,$-4
       dec d
       jr nz,$-7
     exx
;===============================================================


   rlc (hl)
   jr nc,NoAdd
;add (output),(Num1Loc)
     exx
     ld de,(Num1Loc)
     push bc
     ld bc,(Num1Size)
     dec bc
     inc c
     inc b
     ld hl,(output)
     or a
AddLoop:
       ld a,(de)
       adc a,(hl)
       ld (hl),a
       inc hl
       inc de
       dec c
       jr nz,AddLoop
       dec b
       jr nz,AddLoop
       jr nc,$+3
       inc (hl)
     pop bc
     exx
NoAdd:
   djnz Loop2
   pop bc
   cpd
   jp pe,Loop1
   ld hl,(output)
   ld bc,(Num3Size)
   add hl,bc
   dec hl
   inc bc
   xor a
     cpd
     jp po,$+5
     jr z,$-5
   ld hl,(output)
   dec hl
   ld (hl),b
   dec hl
   ld (hl),c
   ret
I used this in a test app and wrote a routine to multiply two base 10 integers in Str1 and Str2 respectively (I had to convert the base 10 string to hex data, then multiply, then convert back to base 10). I then used this routine in BatLib to make the routine for base conversion that handles large numbers (hundreds of digits). Feel free to supply other routines or optimisations, too! (I know some of you will find some )