Evaluate a created equation

[mortdiggiddy]

I am new to z80. I created a program in BASIC to plot the root locus of a transfer function, but the algorithm to find the roots of a n-degree polynomial is slow (it's basic, duh). I need to be able to get a function from the user input from a getkey loop or w/e, then translate this to a y= function (using rom calls I assume to create an equation), and then have the ability to vary the value of the independent variable x and have the equation solved for that value. The algorithm to solve for the roots of a polynomial needs this operation.

I'm not sure if this is a dumb question, or if it isn't possible. So far in every tutorial or system routine explanation, I have only seen how to create a new equation, not actually how to make the equation's contents what you need it to be.

Thanks for the help.

[DarkerLine]

What's wrong with using Basic to store to a Y= equation? You can do this by storing a string to it:
Input "Eqn?",Str1
Str1→Y1

Doing this in assembly is more complicated. Equations are internally stored as strings, which themselves are made up of tokens. If you just had a fixed equation to create, you might do something like this:


ld hl, Y1Name
rst 20h ; _Mov9ToOP1
ld hl, EquationEnd - Equation
bcall(_CreateEqu)
inc de
inc de
ld hl, Equation
ld bc, EquationEnd - Equation
ldir
ret
Y1Name:
.db EquObj,tVarEqu,tY1,0,0
Equation:
.db tX,tSqr,tAdd,t2,tX,tAdd,t1
EquationEnd:

If you wanted the user to input an equation, you'd need to be able to convert keypresses to tokens, and possibly simulate built-in menus as well... There's some sort of bcall for this maybe, but I don't remember it... it's just ugly. Some things Basic just does better.

[mortdiggiddy]

BASIC for input of equations would be way easier yeah. Is it possible to use BASIC commands like input and prompt imbedded in a z80 file? Once the Y1 function is saved, how do I access it and get the output of it evaluated for a value of x?

[magicdanw]

One way to get input from the user is to make a basic program with the Input command in it, and then run the basic program using assembly code. This is done with the ParseInp bcall, which will run the basic program named in OP1. After that, you can use the bcall UnOpExec to run the expr( command, which will return the value of the equation at X. Finally, to change the value of X, you can write the number (in Real Floating Point number format, which is how the Os stores numbers internally) to X, which you can find using FindSym.

Hope that helped. If you have any questions (I suspect you will have a couple) just ask!

[brandonw]

I dug up some old code from that calcg.org RPN contest which lets you input a string/equation from assembly:

[magicdanw]

**Eyes glaze over** Dear Lord!!!!!

[thornahawk]

[OFF-TOPIC]

What algorithm are you using to solve for polynomial roots? As I recall, this is one particular application where you do need all the roots of a polynomial.

thornahawk

[mortdiggiddy]

http://en.wikipedia.org/wiki/Durand-Kerner_method

That is basically the algorithm, and encoded its actually a really simple double for() loop. Translate this BASIC code to assembly is what I am trying to do

~A is just an arbitrary variable to count the for() loop, same with B

~D is the degree of the polynomial, ex) 3x^3 + 2x^2 + 5x + 10 is degree 3

~two temp Lists are created, LROOT and LTEST. LROOT contains the new values for the roots of the polynomial, LTEST contains the "old" roots that you are comparing LROOT to to see if there was any change.

~R is the user set round, for accuracy, once you get beyond degree 4 polynomials, you can pretty much set this to zero, because getting 5+ roots to not change from one iteration to the next already ensures pretty good accuracy.

;-------------------------------------------------
;Initialize the roots at a "guess" value, can be virtually anything as long as ;x=a+bi where x is not a root of 1

:-0.9 + 0.9i ---> X
:For(A, 1, D, 1)
:X^(A-1)--->LROOT(A)
:0--->LTEST(A)
:end
:
:
:
:1--->T
:While round(Real(LROOT-LTEST), R) != 0
:LROOT--->LTEST
:For(A, 1, D, 1)
:For(B, 1, D, 1)
:If A!=B
:T*(LROOT(A)-LROOT(B))--->T
:end
:LROOT(A)--->X
:LROOT(A) - Y1(X)/T--->LROOT(A)
:end
:end

[thornahawk]

You might want to look into the Ehrlich-Aberth method; it performs similarly to Durand-Kerner and oftentimes yields more accurate answers in less iterations, only at the expense of having to evaluate the polynomial's derivative along with the polynomial itself. I had written an implementation of it a while back. The wrinkle in mine is that I had chosen to have the polynomial input as a list of coefficients rather than as an explicit Y= function. You will have to adapt the code to your purposes if you're interested.

There's a pretty wide literature on "simultaneous methods", as they are called. I'll be happy to answer questions.

thornahawk

[mortdiggiddy]

One quick question about complex floating point math.

If I have multiple complex FP's on the FP stack, when I do an operation that uses OP1/OP2 with FPS1/FPST, does the stack move down one so that the the next complex FP's that WERE on the stack below FPS1/FPST move up?

[DarkerLine]

That sort of question could be resolved very simply by, I don't know, trying it to see what happens?