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
« 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.
 Row^{r} EXP→Row^{r}
 Key:ZXmin
 Get or set the current cursor row.
 Col^{r} EXP→Col^{r}
 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▶Int^{r}
 Key:ZYmax
 Converts the number to an unsigned or signed integer respectively and returns the pointer to that string.
 EXP▶Fixed EXP▶Fixed^{r}
 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▶Token^{r}
 Key:ZXres
 Converts the 1 or 2 byte token that is pointed to to a string and returns a pointer to that string.
 PTR▶Token^{rr}
 Key:ZXres
 Returns the 1 or 2 byte token that is pointed to.

2
« on: May 23, 2012, 11:26:40 pm »
8xpfixlinkThis program fixes archived 8xp files made with TILP, so that they will work with other software (e.g. Wabbitemu, TI Connect). To use, just draganddrop 8xp files on 8xpfix.exe. Note: other 8x* files might work too.
3
« 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
« 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 copyandpasted directly into code tags in a post. It currently supports both TIBasic and Axe tokens.
5
« 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! :A→B
:#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. :A+B→C
:#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! :L₁∗A→L₂
:#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 42 ^{nd} number in L₁ you ask? Well, why not! :L₁(42)‒A→L₂(42)
:#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₁. :42→dim(L₁)
:#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! :{5,5}→dim([A]) :For(A,1,5) :For(B,1,5) :10A+B→[A](A,B) :End :End
:#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: :#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. :(B+√(B²‒4AC))/(2A)→C :(B‒√(B²‒4AC))/(2A)→D
:#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: :#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 .precalculate 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. :(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. :#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 .precalculate 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>) _{E}CE  _{E}CF  _{E}D0  _{E}D1  _{E}D2  _{E}D3  _{E}D4  _{E}D5  _{E}D6  _{E}D7  _{E}D8  _{E}D9  _{E}DA  _{E}DB  npv(  irr(  bal(  ∑Prn(  ∑Int  ➤Nom(  ➤Eff(  dbd(  lcm(  gcd(  randInt(  randBin(  sub(  stdDev(   _{E}DC  _{E}DD  _{E}DE  _{E}DF  _{E}E0  _{E}E1  _{E}E2  _{E}E3  _{E}E4  _{E}E5  _{E}E6  _{E}E7  _{E}E8  _{E}E9  variance(  inString(  normalcdf(  invNorm(  tcdf(  Χ²cdf(  Ϝcdf(  binompdf(  binomcdf(  poissonpdf(  poissoncdf(  geometpdf(  geometcdf(  normalpdf(   _{E}EA  _{E}EB  _{E}EC  _{E}ED  _{E}89  _{E}8A  _{E}8B  _{E}8C  _{E}8D  _{E}8E  _{E}8F  _{E}90  _{E}91  _{E}92  _{E}93  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]
