[Axiom] Floating Point Math (and other stuff)

[jacobly]

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 All | Copy To Clipboard

1 2

:A→B

Code: Select All | Copy To Clipboard

1 2 3 4

:#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 All | Copy To Clipboard

1 2

:A+B→C

Code: Select All | Copy To Clipboard

1 2 3 4

:#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 All | Copy To Clipboard

1 2

:L₁∗A→L₂

Code: Select All | Copy To Clipboard

1 2 3 4

:#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!

Code: Select All | Copy To Clipboard

1 2	:L₁(42)‒A→L₂(42)

Code: Select All | Copy To Clipboard

1 2 3 4

:#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 All | Copy To Clipboard

1 2	:42→dim(L₁)

Code: Select All | Copy To Clipboard

1 2 3

:#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 All | Copy To Clipboard

1 2 3 4 5 6 7

:{5,5}→dim([A]) :For(A,1,5) :For(B,1,5) :10A+B→[A](A,B) :End :End

Code: Select All | Copy To Clipboard

1 2 3 4 5 6 7 8 9 10 11

:#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 All | Copy To Clipboard

1 2 3 4 5 6 7 8 9 10 11 12

:#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 All | Copy To Clipboard

1 2 3

:(-B+√(B²‒4AC))/(2A)→C :(-B‒√(B²‒4AC))/(2A)→D

Code: Select All | Copy To Clipboard

1 2 3 4 5 6 7 8 9 10

:#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 All | Copy To Clipboard

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

:#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 All | Copy To Clipboard

1 2	:(-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 All | Copy To Clipboard

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

:#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>)

ECE

ECF

ED0

ED1

ED2

ED3

ED4

ED5

ED6

ED7

ED8

ED9

EDA

EDB

npv(

irr(

bal(

∑Prn(

∑Int

➤Nom(

➤Eff(

dbd(

lcm(

gcd(

randInt(

randBin(

sub(

stdDev(

EDC

EDD

EDE

EDF

EE0

EE1

EE2

EE3

EE4

EE5

EE6

EE7

EE8

EE9

variance(

inString(

normalcdf(

invNorm(

tcdf(

Χ²cdf(

Ϝcdf(

binompdf(

binomcdf(

poissonpdf(

poissoncdf(

geometpdf(

geometcdf(

normalpdf(

EEA

EEB

EEC

EED

E89

E8A

E8B

E8C

E8D

E8E

E8F

E90

E91

E92

E93

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.

[Deep Thought]

I personally haven't had a use for it yet, but good work Using ^T to grab operations is genius!

[Yeong]

it looks awesome!
So Quad solver in Axe finally?

[Deep Thought]

Oh, I have a suggestion. Not sure how this would work, but why not merge Select() with float{} somehow, seeing as the latter's already used natively by Axe? Again, I have no idea how that would work, but if it could work that'd be awesome. It would mean one fewer token used up by an Axiom.

yeong, oh dear

[Yeong]

did we already had one?

[jacobly]

According the the almighty Quigibo , that doesn't work yet.

Unfortunately, you cannot re-define current Axe tokens in Axioms which is why you're getting that error, you can only overwrite unused tokens.

EDIT:
Oh, and I originally did use solve( for everything instead of Select(. The code may have been slightly unreadable.
Besides, Select( takes a string and float{ takes a pointer...

[FinaleTI]

Intriguing. Now, people really can write a CAS in Axe.

Perhaps I should release the routine I made to convert a string to a real and store it in a real var, so it would make this even easier to use this library, as it doesn't require knowledge of the FP format.

[Deep Thought]

Perhaps I should release the routine I made to convert a string to a real and store it in a real var, so it would make this even easier to use this library, as it doesn't require knowledge of the FP format.

This Axiom doesn't either, does it?

[FinaleTI]

Perhaps I should release the routine I made to convert a string to a real and store it in a real var, so it would make this even easier to use this library, as it doesn't require knowledge of the FP format.

This Axiom doesn't either, does it?

If you want to create an FP number like -0.145 in the program, I believe you have to create it using hex.
I believe the Axiom only adds math functions, not creating or displaying non-integer FP numbers.

[ztrumpet]

This is really awesome!  Thanks for making this wonderful library.

[AngelFish]

* Qwerty.55 checks the posting date

I was planning on asking for help with floating point in Axe tonight. Awesome timing.

[alberthrocks]

That is.... AMAZING! O_O The impossible is now done! (Well, not impossible, just hard.)
I guess this is a good time to revive the Z80 CAS topic?

Also, I agree with the above suggestions of making the numbers easy to parse - we should use relatively simple syntax to make it work.

Before a CAS could be made, the following needs to occur:
1) String -> FP number
2) FP number -> String
3) Display FP number on arbitrary display buffer at certain position (pref. #2)
4)

I might still have code to print FP numbers, but it's in BASIC and requires... FP functions? (Specifically, log, int(), fPart(), and iPart().) If you would like to use it, tell me and I'll try to dig it out of a calc backup that is in a dead HDD backup...

[Keoni29]

* Qwerty.55 checks the posting date

I was planning on asking for help with floating point in Axe tonight. Awesome timing.

Maybe he learned how to make axioms elsewhere? Maybe he has another account?

[Xeda112358]

Some assembly code can be whipped up to convert between string and FP, but I am not going to commit myself to that task

[Keoni29]

I have seen some AXE programmes using strings to export images or tilemaps. How is that possible?