can anyone suggest me a command that talks about how matlab performed an arithmetic operation (its steps to give us the final result) ?

such a given operation (1/2+1/3)/456*789

[Steven Lord]

People have commented about potential ways to do what you've asked, but no one has yet asked why you want to know this information?

Answer 1

[Stephen23]

I suspect that you might mean this:

https://www.mathworks.com/help/matlab/matlab_prog/operator-precedence.html

[James Tursa]

... along with the fact that literal constant numbers in MATLAB are floating point doubles.

[diadalina]

yes Mr.stephen but how can i get wich operation was the first one ,i want to know if there is a command wich shows me these steps

[James Tursa]

That is in the link that Stephen showed you. Do operations inside parentheses first. Then higher precedence operations. If two operations next to each other are of equal precedence, then look to see if the particular operation is left-to-right or right-to-left to indicate which operation will be performed first (in MATLAB they are all left-to-right). For your particular example, it will be performed as:

( ( (1/2) + (1/3) ) / 456 ) * 789

[diadalina]

i know the operator precedance, but i want to confirm this, with a command !!

[Stephen23]

@diadalina: please show us what the output of this command would be like for your example calculation.

[diadalina]

Precedence levels determine the order in which MATLAB evaluates an expression, this is clear for me, but if i enter any expression, is there a matlab command that can give me the steps of calculating the final result ?

[James Tursa]

Sounds like you want an expression parser that could put the operands and operations into stacks for subsequent evaluation (like if you were programming a calculator from scratch, maybe using RPN). Is that what you are asking?

[diadalina]

yes, is this possible on Matlab ?, this exists on Maple

[James Tursa]

I don't know of anything in MATLAB. Maybe someone else does. This is not trivial unless you limit the syntax for how to enter constants and what operations and functions you are willing to cover.

[Stephen23]

I don't know of anything built in to MATLAB that does this. You could try writing your own parser for some limited set operators, e.g. using the shunting yard algorithm, but of course this would not necessarily reflect what MATLAB was doing...

I would argue that a command that knows a priori what will be evaluated cannot exist: because the MATLAB path can be changed dynamically and operators overloaded, it only when the code is evaluated that any code resolves to one specific set of operations. It is only really possible to know once the code has been / is being evaluated. Therefore I would suggest that the closest solution is to use the debugging tools.

[Bruno Luong]

You could implement the shunting yard algorithm with any the preceding order rule you specify (I have done it), that doesn't tell anything about MATLAB's rule.

[diadalina]

MR.Stephen if i want to use the the debugging tools.for this operation how can i do this ?

[Stephen23]

"if i want to use the the debugging tools.for this operation how can i do this"

I don't know if it is possible to do exactly what you want. I wrote that the closest solution might be to use the debugging tools (in particular the step in command). But how useful that would be depends on what commands in your code are functions and which ones are compiled/inbuilt. But there is nothing stopping you from giving it a try:

https://www.mathworks.com/help/matlab/matlab_prog/debugging-process-and-features.html

Answer 2

[Bruno Luong]

Here is an idea, replace the number of your expression by functions (that return a scalar) and print out the order

% (1/2+0/3)/456*789 
(f(1)/f(2)+f(0)/f(3))/f(456)*f(789)

   function x = f(x)
   disp(x)
   end

When run it you'll get

>> printorder

       1

       2

       0

       3

     456

     789

ans =

      0.8651

Insert the operator(s) (there is only one right way to do it) you'll get the polish-reverse notation of the expression

1; 2; /; 0; 3; /; +; 456; /; 789; *

Meaning the expected specified evaluation order we told you.

[Bruno Luong]

If you like (not necessary as explained earlier) you could also overload the operators by using double class folder @double

[Walter Roberson]

Notice that the output is the function calls from left to right, not according to operator precedence.

>> f(1)-f(2)/(f(3)^f(4))
     1
     2
     3
     4

If it were done according to operator precedence as suggested by James in https://www.mathworks.com/matlabcentral/answers/420691-can-anyone-suggest-me-a-command-that-talks-about-how-matlab-performed-an-arithmetic-operation-its-s#comment_614284 then either because f(3)^f(4) is in brackets and the rest are not, either f(3) or f(4) would be expected to be executed first, and then the other of the pair. Then with division being higher precedence than subtraction, f(2) would be expected to be executed first; then finally with subtraction being the lowest precedence, f(1) would be the last executed.

But that is not what we see at all. What we see from the output is that MATLAB must be starting from the left and executing each term as soon as all the arguments are available for it, pushing the results onto an internal stack if the right hand side involves terms with higher precedence.

Thus, f(1)-f(2)/(f(3)^f(4)) is not

f(3); f(4); mpower; f(2); swap; mrdivide; f(1); swap; minus

but rather

f(1); f(2); f(3); f(4); mpower; mrdivide; minus

[Bruno Luong]

either f(3) or f(4) would be expected to be executed first

Why? priority is not the same thing than evaluation order. f(3)^f(4) has higher priority meaning the "^" operator is perform before the rest, it does mean the operands f(3) and f(4) are evaluated before the other operands.

left->right rule applies only for same-priority level. The second way is the way MATLAB evaluates and not contradicts with MATLAB's documentation.

The swap thing, is inefficient in term of speed and complexity, no one implement such thing for the sake of respecting human left-to-right reading manner. For simple number operations, calculation is made with CPU registers, and swapping register is difficult even impossible on some HW.

[Walter Roberson]

James wrote, "Do operations inside parentheses first."

In the expression f(1)-f(2)/(f(3)^f(4)) f(3)^f(4) is an operation inside parentheses, so by his description, f(3)^f(4) would have to be done first, which would result in either 3 then 4 output or 4 and then 3 output, before anything outside the () was evaluated.

"swapping register is difficult even impossible on some HW"

Not very relevant these days, as MATLAB is currently only supported on x64 architectures, which have the XCHG instruction https://www.felixcloutier.com/x86/XCHG.html

[Bruno Luong]

But you have seen through the tracing that the evaluation order can be such that that swapping are not needed at all, and MATLAB parser (and virtual all modern computer language) does that.

[Walter Roberson]

MATLAB parses into a threaded code structure, not a postfix stack, so it does not use a swap operation.

It perhaps uses a tree and if so then it probably follows the left edge for execution order.

[James Tursa]

So, getting caught up on this thread. My comments were general comments about operator precedence, not about how MATLAB decides how to evaluate an expression, particularly one involving function calls. Bruno makes that point as well in his Answer. This entire thread about which order MATLAB evaluates functions in an expression is a related topic but is not the same thing as operator precedence, and my comments should not be taken to imply anything about which order function calls are evaluated.

[Bruno Luong]

From the order of the evaluation of the operands one can infer the order of the operations. Actually I have double checked the logic by hacking the operations as well to display something when it's invoked. The result just match well all the cases I tested with what I have expected and the documentation.

Answer 3

[Bruno Luong]

f(3)^f(4) would have to be done first

That's the case, the power is the first to be performed (among operators), but it's not saying the operands f(3) and f(4) are evaluated first.

[Bruno Luong]

sorry my reply should be in the comment, not a new answer