AutoHotkey Community

[Laszlo]

Until AHK will have dynamic expressions, here is a simple script for evaluating arithmetic expressions in a variable or literal string. It handles +-*/ from left to right with the right precedence, but no unary minus (like -1*2 has to be written as 0-1*2), parentheses or functions, so there is plenty of room for extensions (left to the reader as an easy exercise ). It can be used to build a calculator or replace selected arithmetic expressions in texts.

[Laszlo]

The following version is longer, but can handle mod (%) and power (** or @) as well as unary - and unary + (-2*3, +5). Two constants, pi and e are replaced by their numerical values. Add your favorite ones, like currency exchange ratios, Kg to Lbs, miles to Km, Fahrenheit to centigrade conversion values, and life will get a little easier.

Choose this one if you need this extra functionality. Still no parentheses, because they are harder. Having parentheses, function calls, like sqrt(2) or sin(pi/3) will be easier.

[Chris]

I always enjoy posts like this where you apply your extensive algorithm expertise to create elegant, efficient scripts and functions.

Thanks for providing another solution for something AutoHotkey lacks.

[Nemroth]

Thanks a lot, Laszlo.
Of course a brillant script, as every time.
I will try to understand it and if I can, to implement parentheses and functions call !!!
thanks again for all you very clever contribution for AHK.

[Laszlo]

Here is a still larger version with parenthesis, function and variable handling. There could be a problem with expressions like 2*(1-2), which is reduced to 2*-1, an invalid expression. To combat that the subtraction operator is changed internally to # (so it could not be used in function names, as @ is forbidden, used as the power operator). After the replacement the negative sign is not considered an operator but part of a number.

The script also recognizes 3 functions, abs(), sqrt() and floor(), as examples. You can add as many to the list as you wish, even your private functions of one parameter. (If a function name contains another, it has to be listed first, like abs0, MyAbs, ABS.)

Constants might conflict with function names, like e is in Ceil(). To avoid problems, constants have to be in [ ], like [e] or [pi]. Now these can be any variable name, defined in the function Eval(). (Some vars are used, like x, i, j, L,and R. If you want to use them in expression, rename the ones used by the function to some obscure string, like appending a $ sign to them.)

Bitwise operators (~,&,|,^,<<,>>) can be easily added, just follow the pattern of the other operators. Still missing is multi parameter functions, like round([pi],3). It would require handling the "," as operator, which is not hard, but seldom needed.

[Nemroth]

Laszlo, you're very fast !!!
Of course I will try it, and if I can extend it I will post.
But I need first to carrefully read and study the script.
Thanks Laszlo for that superb work.
Why didn't like too mutch maths at school ?

[Laszlo]

I am sure you got a bad teacher. A good one can make all the kids just love math.

[Nemroth]

May be there are some problems, may be my understanding is not OK :
My first tests :

-1+45/2 = 21.500
I think it is equivalent to -1+45 = 44 then 44/2 = 22
but
(-1+45)/2 = 22.000 OK

45-1/2 = 44.500
but
(45-1)/2 = 22.000 OK

-1+45*2 = 89
but
(-1+45)*2 = 88 OK

45-1*2 = 43
but
(45-1)*2 = 88 OK

abs(12.6) = 12.600

may be I made mistakes.

Thanks for your time.

[Nemroth]

[Laszlo]

These come from the differences between how a cheap calculator reacts to keystrokes and how a computer language handles operator precedence: First the power is calculated, then *,/ and %, from left to right, then +,- also fro left to right. In case -1+45/2 first 45/2 is computed (22.5) then -1 is added to it, so the right answer is 21.500. Also, in 45-1/2 first 1/2 is computed (0.5) and then it is subtracted form 45, giving 44.500. Similarly with multiplication: in 45-1*2 first 1*2 is computed (2) and it gets subtracted from 45, giving 43 as the result.

The cheap calculator order of operations is easier, but confusing. If you want that, make the search flat in the Eval@() function, that is, find out the rightmost operator, any of the +-*/% or **, and perform that.

[Nemroth]

Thanks for your answer, Laszlo.
I understand the operator precedence topic but in fact I thought that the analysis of the entered calculation would be "naturally'" parsed from left to right, like in cheap calculators.
I thought that the calculation is similar in its behaviour as the one of the Windows Calc : an operation, then the other witch modify the prefious result and so on, but on one line...
I think that the parenthesis (in this way to do the things) allow to change the order of the calculations, if it is what the user wants to do.
I will try when I can to make modifications in ths way, as I think that for the use I have of this functionnality, this basic behaviour is better.
Thanks again for the fabulous work

[Laszlo]

Actually, if you use the Windows Calculator, you don't need all these (unless you need your own functions or constants). The calculator buttons all have keyboard shortcuts, so you only have to write the expressions conform to the AHK send command, that is, {F4}, ^p, `% etc. For the XP calculator:

[Nemroth]

Hi Lazslo.
I use the Calculator to do the calculations, and I "borrowed" you an other of your scripts to do that. But I'd like to do the calculations internally, as
1) I can't launch the calc hidden
2) the Windows calculator doesn't support function calls.
Here is the script :

[Invalid User]

Laszlo, do you plan on making a Evaluation function for handling undefined variables or irrationals, or 'solve for...' equations? or fractions
_________________
my lame sig

[Laszlo]

You could add yourself checking for undefined functions or variables, that is easy. On the other hand, making it a full blown math package is hard. AHK was not made for that. For example, numbers are practically fix point ([pi]/10000000000*10000000000 <> [pi]), and if you work with large or small numbers the precision of the intermediate results ruin the accuracy. Maybe the best is to interface AHK to GMP, the GNU multi precision numerical library, compiled to a Windows DLL.

Keeping fractions unevaluated to get rational results can be done, like complex number handling, but I don't know how you want to handle irrationals, especially transcendent numbers (pi, e), which are not roots of integer coefficient polynomials. Symbolic math packages keep expressions unevaluated, and manipulate them symbolically. It is hard.

Symbolic solution of general equations is also hard. Numerical root finding with an iterative method, like Regula Falsi, can be done for a single variable, otherwise it is hard. But then you could ask for optimization, too: finding the minimum. In the multivariate case, you guessed, is hard, too.