flat assembler
Message board for the users of flat assembler.

Index > Windows > Complex dynamic formulas

Author
Thread Post new topic Reply to topic
kasake36



Joined: 28 Mar 2006
Posts: 68
kasake36
Hello!

I am at the start of writing a program that reads in "complex" formulas from a textfile, e.g.:

"KO - ((150-A) * 2) - (40 - B) - ((180 -X) / 3)"

After the formula is read, the alphabetic variables get replaced with their character-values, so the result would be a string that needs to get calculated. Programming this calculation manually would be much work i believe, so i wanted to ask if anyone of you has some ideas for doing the calculation.
I thought about calling a extern library function if one does exist. Also: would a FASM macro be possible? (i've never written one)

Thanks in advance!

P.S.: I've not programmed anything yet, just starting to plan...
Post 06 Feb 2007, 14:44
View user's profile Send private message Reply with quote
Reverend



Joined: 24 Aug 2004
Posts: 408
Location: Poland
Reverend
Get some converting routines (ie. text -> number). Save all the converted alphabetic variables somewhere and do the calculations step by step (you have the formula nicely put inside braces, so no problem).

Code:
1 = 150-A
2 = [1] * 2
3 = 40 - B
4 = [2] - [3]
...
    

Code:
; 1 = 150-A
mov eax, 150
sub eax, [A]

; 2 = [1] * 2
shl eax, 1 ; this equals eax = eax*2

; 3 = 40 - B
mov ecx, 40
sub ecx, [B]

; 4 = [2] - [3]
sub eax, ecx
...
    
Post 06 Feb 2007, 20:35
View user's profile Send private message Visit poster's website Reply with quote
kasake36



Joined: 28 Mar 2006
Posts: 68
kasake36
That's what i didn't want to do first, because i still believe it ends up in a mess (at least for me) but anyways, i'll do it this way. Thanks.
Post 07 Feb 2007, 07:14
View user's profile Send private message Reply with quote
Reverend



Joined: 24 Aug 2004
Posts: 408
Location: Poland
Reverend
If you don't want mess than just put this code in a procedure like this:
Code:
proc formula A, B, K, O, X
...
endp    
Save this "messy" code in some diffferent file. And in your main application, include it. Then your main code will look like:
Code:
...
stdcall formula, [A], [B], [K], [O], [X]
...    


But generally my opinion is that sooner or later you will have to get used to the "messy" code if you choose assembly.
Post 07 Feb 2007, 11:55
View user's profile Send private message Visit poster's website Reply with quote
kasake36



Joined: 28 Mar 2006
Posts: 68
kasake36
With messy i meant the part of the program that divides the formula into simple calculations. I wanted to do something similar using C several years ago and i failed, but i do not know the reason for the failure at the moment. The only thing i have in mind is that the program was a mess. On the other side i'm a bit more experienced nowadays.
Post 07 Feb 2007, 13:27
View user's profile Send private message Reply with quote
PopeInnocent



Joined: 01 Jan 2004
Posts: 18
Location: USA
PopeInnocent
If I understand you correctly, it sounds like you want to read in a formula and calculate it. An LR(1) recursive-descent parser would probably work perfectly for you, and it would distinctly non-messy. Very Happy
Post 08 Feb 2007, 23:09
View user's profile Send private message Reply with quote
kasake36



Joined: 28 Mar 2006
Posts: 68
kasake36
Oh my gosh.... Shocked
Thanks for the keywords! I'll have to spent some thought on that!
Post 09 Feb 2007, 08:52
View user's profile Send private message Reply with quote
kandamun



Joined: 20 Jul 2005
Posts: 25
kandamun
What about "Reverse Polish Notation" Very Happy
It is another way of doing this.
Post 10 Feb 2007, 08:25
View user's profile Send private message ICQ Number Reply with quote
kasake36



Joined: 28 Mar 2006
Posts: 68
kasake36
RPN seems a bit more comfortable than the LR(1) stuff (for the calculation with assembler) and i believe the customer would appreciate to write down the formulas in that syntax - it looks more pro and he can brag around in front of his nice secretaries Smile
Post 12 Feb 2007, 07:41
View user's profile Send private message Reply with quote
donkey7



Joined: 31 Jan 2005
Posts: 127
Location: Poland, Malopolska
donkey7
you don't need the customer to write in rpn syntax. instead you can use algorithm to convert from classic notation to rpn.
Code:
repeat
  get_next_element;
  if element_is_a_value then
    write_it_to_output
  else
    if element_is_a_operator then
      while priority_of_first_operator_on_stack >= priority_of_element do
        move_first_operator_from_stack_to_output
      push_element_on_stack
    if element_equal_( then
      push_it_on_stack
    if element_equal_) then
      while first_element_on_stack_is_a_operator do ; ( remove_elements_util_( )
        move_it_from_stack_to_output
      delete_(_from_beginnig_of_stack
  end if
until end_of_data
while stack_non_empty do
  move_operator_from_stack_to_output
    


then you apply algorithm to evaluate it:
Code:
repeat
  get_next_element
  if element_is_a_value then
    push_it_onto_stack
  else
    pop_needed_values_from_stack
    do_operation
    push_the_result_onto_stack
  end if
until end_of_data
    


because the evaluation algorithm is stack based you can easily implement it for 80387 fpu (which is also stack based).

you can also look at:
http://en.wikipedia.org/wiki/Reverse_Polish_notation
http://en.wikipedia.org/wiki/Shunting_yard_algorithm

_________________
Keep coding!
Post 12 Feb 2007, 11:24
View user's profile Send private message Visit poster's website Reply with quote
kasake36



Joined: 28 Mar 2006
Posts: 68
kasake36
That is very helpful, thanks!
Post 12 Feb 2007, 11:35
View user's profile Send private message Reply with quote
Display posts from previous:
Post new topic Reply to topic

Jump to:  


< Last Thread | Next Thread >
Forum Rules:
You cannot post new topics in this forum
You cannot reply to topics in this forum
You cannot edit your posts in this forum
You cannot delete your posts in this forum
You cannot vote in polls in this forum
You cannot attach files in this forum
You can download files in this forum


Copyright © 1999-2020, Tomasz Grysztar. Also on GitHub, YouTube, Twitter.

Website powered by rwasa.