Show Posts

This section allows you to view all posts made by this member. Note that you can only see posts made in areas you currently have access to.


Topics - jacobly

Pages: [1]
1
The Axe Parser Project / [Axiom] Text routines
« on: July 03, 2012, 06:17:39 am »
#Axiom(TEXT)
(All commands are in the Vars → Zoom menu.)
Row
EXP→Row

Key:ZXmin
Get or set the current pen row.
Col
EXP→Col

Key:ZXmax
Get or set the current pen column.
Rowr
EXP→Rowr

Key:ZXmin
Get or set the current cursor row.
Colr
EXP→Colr

Key:ZXmax
Get or set the current cursor column.
Str(PTR)
Str(PTR)r
Str(PTR,BUF)


Key:ZXscl
The string that is pointed to is drawn at the current pen location to the main buffer, back buffer, or specified buffer respectively. See Fix 0 and Fix 1 commands for drawing details.
Char(CHAR)
Char(CHAR)r
Char(CHAR,BUF)


Key:ZYmin
The ASCII character is drawn at the current pen location to the main buffer, back buffer, or specified buffer respectively. See Fix 0 and Fix 1 commands for drawing details.
EXP▶Int
EXP▶Intr

Key:ZYmax
Converts the number to an unsigned or signed integer respectively and returns the pointer to that string.
EXP▶Fixed
EXP▶Fixedr

Key:ZYscl
Converts the number to an unsigned or signed 8.8 fixed point number respectively and returns the pointer to that string.
EXP▶Token
Key:ZXres
Converts the 1 or 2 byte token to a string and returns a pointer to that string.
PTR▶Tokenr
Key:ZXres
Converts the 1 or 2 byte token that is pointed to to a string and returns a pointer to that string.
PTR▶Tokenrr
Key:ZXres
Returns the 1 or 2 byte token that is pointed to.

2
Other Calculators / 8xpfix
« on: May 23, 2012, 11:26:40 pm »
8xpfix

link

This program fixes archived 8xp files made with TILP, so that they will work with other software (e.g. Wabbitemu, TI Connect).  To use, just drag-and-drop 8xp files on 8xpfix.exe.  Note: other 8x* files might work too.

3
TI Z80 / Axe Emulator
« on: April 19, 2012, 01:25:17 am »
I have been working on a program that interprets Axe source code.  Currently, I am able to compile it to computer assembly code, which I can link with a program that emulates a calculator screen.  At some point, it should be able to run Axe programs directly (using JIT compilation).

So far, I have implemented enough of the commands to be able to compile most of the example programs that come with Axe.  The compiler itself is not ready yet, but I do have some examples of the executables produced.

4
TI Z80 / Online TI Token to Unicode Converter
« on: October 30, 2011, 10:46:53 pm »
I created a webpage here that converts 8xp files to unicode. The output was designed to be able to be copy-and-pasted directly into code tags in a post. It currently supports both TIBasic and Axe tokens.

5
The Axe Parser Project / [Axiom] Floating Point Math (and other stuff)
« on: October 25, 2011, 07:18:09 pm »
This axiom allows you to access the os variables and do floating point math with them!
Feel free to ask questions instead of trying to read and understand this entire post.

Did you ever want to store the value of the real/complex variable A into the real/complex variable B inside of an axe program? Now it is easier than ever!
Code: [Select]
:A→B
Code: [Select]
:#Axiom(CPLXMATH) .varA could be complex
:Select("varA")→Select("varB") .Select( is in the 2nd List Ops menu
:solve() .optional but suggested, frees used memory

But maybe you wanted to store A + B to C.  Well that is almost as simple.
Code: [Select]
:A+B→C
Code: [Select]
:#Axiom(CPLXMATH) .varA or varB could be complex
:solve(ᵀ+,Select("varA"),Select("varB"))→Select("varC") .solve( is on the Math Math menu
:solve() .optional, but suggested - frees used memory
In general, solve(ᵀ<op>,<args>) applies <op> to <args>. <op> can be be almost anything from ^, dim( to inString(!
Note: even though Axe changes inString( to inData(, it still does its original function when used in this command. Also, don't close the ( in <op>!

Well that's cool, but can I use Lists you ask? Of course!
Code: [Select]
:L₁∗A→L₂
Code: [Select]
:#Axiom(CPLXMATH) .L₁ or L₂ could be complex lists
:solve(ᵀ∗,Select("L₁"),Select("varA"))→Select("L₂")
:solve() .optional but suggested, frees used memory

But I only wanted to used the 42nd number in L₁ you ask? Well, why not!
Code: [Select]
:L₁(42)‒A→L₂(42)
Code: [Select]
:#Axiom(CPLXMATH) ... see above
:solve(ᵀ‒,Select("L₁",42),Select("varA"))→Select("L₂",42)
:solve() ... see above
Notice how Select( loads or saves to a variable, and solve( applies an operation to loaded variables.

The above code doesn't work if L₁ is too small, you say? Well why don't we resize L₁.
Code: [Select]
:42→dim(L₁)
Code: [Select]
:#Axiom(CPLXMATH) ...you know
:dim("L₁",42) .notice the slight difference in syntax
Note that solve() is unnecessary because dim does not currently use any memory.

I'll bet you forgot about matricies, you say... Nope!
Code: [Select]
:{5,5}→dim([A])
:For(A,1,5)
:For(B,1,5)
:10A+B→[A](A,B)
:End
:End
Code: [Select]
:#Axiom(REALMATH) .only real numbers used AND no arbitrary variable access
:Buff(9)→GDB1 .a temp floating point - they are 9 bytes large
:dim("[A]",5,5)
:For(A,1,5) .remember, A and B are still Axe variables
:For(B,1,5)
:A∗10+B→float{GDB1} .load temp with A∗10+B converted to a floating point
:GDB1→Select("[A]",A,B) .see, I didn't forget matrix support
:solve() .especially important inside loops
:End
:End
Or, if you are familiar with the format of floating point numbers:
Code: [Select]
:#Axiom(REALMATH) .see above
:"[A]"→Str1
:[008100000000000000]→GDB1 .floating point zero, prepared for 2 digit numbers
:dim(Str1,5,5)
:For(A,1,5)
:For(B,1,5)
:A∗16+B→{GDB1+2} .A and B are between 0 and 10 exclusive, treat as bcd digits
:GDB1→Select(Str1,A,B)
:End
:solve() .delete temp memory at least moderately often (~100 bytes at this point!)
:End

Now for an example that actually does something useful.
Code: [Select]
:(-B+√(B²‒4AC))/(2A)→C
:(-B‒√(B²‒4AC))/(2A)→D
Code: [Select]
:#Axiom(CPLXMATH) .obviously
:Buff(9)→GDB2 .declare constants
:Buff(9)→GDB4
:2→float{GDB2} .initialize constants
:4→float{GDB4}
:solve(ᵀ/,solve(ᵀ+,solve(ᵀ-,Select("varB")),solve(ᵀ√(,solve(ᵀ‒,solve(ᵀ²,Select("varB")),solve(ᵀ∗,GDB4,solve(ᵀ∗,Select("varA"),Select("varB")))))),solve(ᵀ∗,GDB2,Select("varA")))→Select("varC")
:solve()
:solve(ᵀ/,solve(ᵀ‒,solve(ᵀ-,Select("varB")),solve(ᵀ√(,solve(ᵀ‒,solve(ᵀ²,Select("varB")),solve(ᵀ∗,GDB4,solve(ᵀ∗,Select("varA"),Select("varB")))))),solve(ᵀ∗,GDB2,Select("varA")))→Select("varC")
:solve()
JK, it doesn't have to be that unreadable. I just wanted to show what you could do if you really wanted to. (Yes, that means you can nest as much as you want, limited only by the amount of memory available.) A normal person might do something more like this:
Code: [Select]
:#Axiom(CPLXMATH) .obviously
:Buff(9)→GDB2 .declare constants
:Buff(9)→GDB4
:2→float{GDB2} .initialize constants
:4→float{GDB4}
:Select("varA")→A .yes you can do that
:Select("varB")→B
:Select("varC")→C
:solve(ᵀ√(,solve(ᵀ‒,solve(ᵀ²,B),solve(ᵀ∗,GDB4,solve(ᵀ∗,A,C))))→D
:solve(ᵀ-,B)→B .pre-calculate stuff
:solve(ᵀ∗,GDB2,A)→A
:solve(ᵀ/,solve(ᵀ+,B,D),A)→Select("varD")
:solve(ᵀ/,solve(ᵀ‒,B,D),A)→Select("varE")
:solve()

Let's return the result in Ans instead of D and E.
Code: [Select]
:(-B+{1,-1}√(B²+i²4AC))/(2A)
i²=-1, but it allows the result to be complex regardless of mode. Similarly, complex constants are used below, with no i component, in order to allow complex answers in any mode.
Code: [Select]
:#Axiom(CPLXMATH)
:[015D]"TEMP"→Str1LT .[015D] must be used instead of the ᴸ before a list in the current version of Axe
:[0C80200000000000000C8000000000000000]→GDB2 .still 2, but complex
:[0C80400000000000000C8000000000000000]→GDB4 .complex floating point 4
:Select("varA")→A
:Select("varB")→B
:Select("varC")→C
:solve(ᵀ√(,solve(ᵀ‒,solve(ᵀ²,B),solve(ᵀ∗,GDB4,solve(ᵀ∗,A,C))))→C .we don't need C anymore
:solve(ᵀ-,B)→B .pre-calculate stuff
:solve(ᵀ∗,GDB2,A)→A
:DelVar Str1LT .Delete ᴸTemp in case it already exists
:solve(ᵀ/,solve(ᵀ+,B,C),A)→Select(Str1LT,1)
:solve(ᵀ/,solve(ᵀ‒,B,C),A)→Select(Str1LT,2)
:Select(Str1LT)→Select("varAns") .yep, that's right
:DelVar Str1LT .no one needs ᴸTemp anymore
:solve() .we are done

Strange OP codes (used instead of ᵀ<token>)
ECEECFED0ED1ED2ED3ED4ED5ED6ED7ED8ED9EDAEDB
npv(irr(bal(∑Prn(∑Int➤Nom(➤Eff(dbd(lcm(gcd(randInt(randBin(sub(stdDev(
EDCEDDEDEEDFEE0EE1EE2EE3EE4EE5EE6EE7EE8EE9
variance(inString(normalcdf(invNorm(tcdf(Χ²cdf(Ϝcdf(binompdf(binomcdf(poissonpdf(poissoncdf(geometpdf(geometcdf(normalpdf(
EEAEEBEECEEDE89E8AE8BE8CE8DE8EE8FE90E91E92E93
tpdf(Χ²pdf(Ϝpdf(randNorm(conj(real(imag(angle(cumSum(expr(length(ΔList(ref(rref(Fill(

Update 0.1: Tutorial added.
Update 0.2: Major bugfix.
Update 0.3: Select( is replaced with get(. Key: seq(

*Warning: Please do not use RealMath unless you are absolutely sure that your code will never see anything that could posibly be complex. (unless you want corrupted mem, etc.) However, use it if you can, since it is smaller and faster.

Pages: [1]